forked from OSchip/llvm-project
				
			Merge the SystemZ subreg_even32 SubRegIndex into subreg_32bit. The SubRegIndices
were overspecified when inheriting sub-subregisters, for instance: R0Q:subreg_even32 = R0Q:subreg_32bit = R0Q:subreg_even:subreg_32bit. This meant that composeSubRegIndices(subreg_even, subreg_32bit) was ambiguous. llvm-svn: 105063
This commit is contained in:
		
							parent
							
								
									f7bcc81213
								
							
						
					
					
						commit
						e02996ca8f
					
				| 
						 | 
				
			
			@ -124,7 +124,7 @@ void SystemZAsmPrinter::printOperand(const MachineInstr *MI, int OpNum,
 | 
			
		|||
    unsigned Reg = MO.getReg();
 | 
			
		||||
    if (Modifier && strncmp(Modifier, "subreg", 6) == 0) {
 | 
			
		||||
      if (strncmp(Modifier + 7, "even", 4) == 0)
 | 
			
		||||
        Reg = TM.getRegisterInfo()->getSubReg(Reg, SystemZ::subreg_even32);
 | 
			
		||||
        Reg = TM.getRegisterInfo()->getSubReg(Reg, SystemZ::subreg_32bit);
 | 
			
		||||
      else if (strncmp(Modifier + 7, "odd", 3) == 0)
 | 
			
		||||
        Reg = TM.getRegisterInfo()->getSubReg(Reg, SystemZ::subreg_odd32);
 | 
			
		||||
      else
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -670,7 +670,7 @@ SDNode *SystemZDAGToDAGISel::Select(SDNode *Node) {
 | 
			
		|||
    // Copy the remainder (even subreg) result, if it is needed.
 | 
			
		||||
    if (!SDValue(Node, 1).use_empty()) {
 | 
			
		||||
      unsigned SubRegIdx = (is32Bit ?
 | 
			
		||||
                            SystemZ::subreg_even32 : SystemZ::subreg_even);
 | 
			
		||||
                            SystemZ::subreg_32bit : SystemZ::subreg_even);
 | 
			
		||||
      SDNode *Rem = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
 | 
			
		||||
                                           dl, NVT,
 | 
			
		||||
                                           SDValue(Result, 0),
 | 
			
		||||
| 
						 | 
				
			
			@ -754,7 +754,7 @@ SDNode *SystemZDAGToDAGISel::Select(SDNode *Node) {
 | 
			
		|||
    // Copy the remainder (even subreg) result, if it is needed.
 | 
			
		||||
    if (!SDValue(Node, 1).use_empty()) {
 | 
			
		||||
      unsigned SubRegIdx = (is32Bit ?
 | 
			
		||||
                            SystemZ::subreg_even32 : SystemZ::subreg_even);
 | 
			
		||||
                            SystemZ::subreg_32bit : SystemZ::subreg_even);
 | 
			
		||||
      SDNode *Rem = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
 | 
			
		||||
                                           dl, NVT,
 | 
			
		||||
                                           SDValue(Result, 0),
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -1129,13 +1129,13 @@ def : Pat<(mulhs GR32:$src1, GR32:$src2),
 | 
			
		|||
          (EXTRACT_SUBREG (MUL64rrP (INSERT_SUBREG (v2i32 (IMPLICIT_DEF)),
 | 
			
		||||
                                                   GR32:$src1, subreg_odd32),
 | 
			
		||||
                                    GR32:$src2),
 | 
			
		||||
                          subreg_even32)>;
 | 
			
		||||
                          subreg_32bit)>;
 | 
			
		||||
 | 
			
		||||
def : Pat<(mulhu GR32:$src1, GR32:$src2),
 | 
			
		||||
          (EXTRACT_SUBREG (UMUL64rrP (INSERT_SUBREG (v2i32 (IMPLICIT_DEF)),
 | 
			
		||||
                                                    GR32:$src1, subreg_odd32),
 | 
			
		||||
                                     GR32:$src2),
 | 
			
		||||
                          subreg_even32)>;
 | 
			
		||||
                          subreg_32bit)>;
 | 
			
		||||
def : Pat<(mulhu GR64:$src1, GR64:$src2),
 | 
			
		||||
          (EXTRACT_SUBREG (UMUL128rrP (INSERT_SUBREG (v2i64 (IMPLICIT_DEF)),
 | 
			
		||||
                                                     GR64:$src1, subreg_odd),
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -55,7 +55,6 @@ class FPRL<bits<4> num, string n, list<Register> subregs>
 | 
			
		|||
 | 
			
		||||
let Namespace = "SystemZ" in {
 | 
			
		||||
def subreg_32bit  : SubRegIndex;
 | 
			
		||||
def subreg_even32 : SubRegIndex;
 | 
			
		||||
def subreg_odd32  : SubRegIndex;
 | 
			
		||||
def subreg_even   : SubRegIndex;
 | 
			
		||||
def subreg_odd    : SubRegIndex;
 | 
			
		||||
| 
						 | 
				
			
			@ -99,7 +98,7 @@ def R15D : GPR64<15, "r15", [R15W]>, DwarfRegNum<[15]>;
 | 
			
		|||
}
 | 
			
		||||
 | 
			
		||||
// Register pairs
 | 
			
		||||
let SubRegIndices = [subreg_even32, subreg_odd32] in {
 | 
			
		||||
let SubRegIndices = [subreg_32bit, subreg_odd32] in {
 | 
			
		||||
def R0P  : GPR64< 0,  "r0", [R0W,  R1W],  [R0D,  R1D]>,  DwarfRegNum<[0]>;
 | 
			
		||||
def R2P  : GPR64< 2,  "r2", [R2W,  R3W],  [R2D,  R3D]>,  DwarfRegNum<[2]>;
 | 
			
		||||
def R4P  : GPR64< 4,  "r4", [R4W,  R5W],  [R4D,  R5D]>,  DwarfRegNum<[4]>;
 | 
			
		||||
| 
						 | 
				
			
			@ -111,8 +110,7 @@ def R14P : GPR64<14, "r14", [R14W, R15W], [R14D, R15D]>, DwarfRegNum<[14]>;
 | 
			
		|||
}
 | 
			
		||||
 | 
			
		||||
let SubRegIndices = [subreg_even, subreg_odd],
 | 
			
		||||
 CompositeIndices = [(subreg_even32 subreg_even, subreg_32bit),
 | 
			
		||||
                     (subreg_odd32  subreg_odd,  subreg_32bit)] in {
 | 
			
		||||
 CompositeIndices = [(subreg_odd32  subreg_odd,  subreg_32bit)] in {
 | 
			
		||||
def R0Q  : GPR128< 0,  "r0", [R0D,  R1D],  [R0P]>,  DwarfRegNum<[0]>;
 | 
			
		||||
def R2Q  : GPR128< 2,  "r2", [R2D,  R3D],  [R2P]>,  DwarfRegNum<[2]>;
 | 
			
		||||
def R4Q  : GPR128< 4,  "r4", [R4D,  R5D],  [R4P]>,  DwarfRegNum<[4]>;
 | 
			
		||||
| 
						 | 
				
			
			@ -355,7 +353,7 @@ def ADDR64 : RegisterClass<"SystemZ", [i64], 64,
 | 
			
		|||
def GR64P : RegisterClass<"SystemZ", [v2i32], 64,
 | 
			
		||||
  [R0P, R2P, R4P, R6P, R8P, R10P, R12P, R14P]>
 | 
			
		||||
{
 | 
			
		||||
  let SubRegClasses = [(GR32 subreg_even32, subreg_odd32)];
 | 
			
		||||
  let SubRegClasses = [(GR32 subreg_32bit, subreg_odd32)];
 | 
			
		||||
  let MethodProtos = [{
 | 
			
		||||
    iterator allocation_order_begin(const MachineFunction &MF) const;
 | 
			
		||||
    iterator allocation_order_end(const MachineFunction &MF) const;
 | 
			
		||||
| 
						 | 
				
			
			@ -391,7 +389,7 @@ def GR64P : RegisterClass<"SystemZ", [v2i32], 64,
 | 
			
		|||
def GR128 : RegisterClass<"SystemZ", [v2i64], 128,
 | 
			
		||||
  [R0Q, R2Q, R4Q, R6Q, R8Q, R10Q, R12Q, R14Q]>
 | 
			
		||||
{
 | 
			
		||||
  let SubRegClasses = [(GR32 subreg_even32, subreg_odd32),
 | 
			
		||||
  let SubRegClasses = [(GR32 subreg_32bit, subreg_odd32),
 | 
			
		||||
                         (GR64 subreg_even, subreg_odd)];
 | 
			
		||||
  let MethodProtos = [{
 | 
			
		||||
    iterator allocation_order_begin(const MachineFunction &MF) const;
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
		Loading…
	
		Reference in New Issue