[NDS32 37/46] Add 16-bit SP/FP Base Imply Load/Store Instructions

[shiva0217]

Summary

Add 16-bit SP/FP Base Imply Load/Store Instructions

lib/Target/NDS32/InstPrinter/NDS32InstPrinter.h

public:
 
     void printAddrRegShift(const MCInst *MI, unsigned OpNum, raw_ostream &O);
 
     void printAddrRegOperand(const MCInst *MI, unsigned OpNum, raw_ostream &O);
     void printAddrImmOffsetOperand(const MCInst *MI, unsigned OpNum,
                                    raw_ostream &O);
     void printAddrRegOffsetOperand(const MCInst *MI, unsigned OpNum,
                                    raw_ostream &O);
+
+    void printSPImplyAddrImmOperand(const MCInst *MI, unsigned OpNum,
+                                    raw_ostream &O);
   };
 }
 
 #endif

lib/Target/NDS32/InstPrinter/NDS32InstPrinter.cpp

 void NDS32InstPrinter::printAddrRegOffsetOperand(const MCInst *MI,
                                                  unsigned OpNum,
                                                  raw_ostream &O) {
   const MCOperand &MO1 = MI->getOperand(OpNum);
 
   O << '$';
   printRegName(O, MO1.getReg());
 }
+
+// print sp base imply [+ Imm] addressing mode
+void NDS32InstPrinter::printSPImplyAddrImmOperand(const MCInst *MI,
+                                                  unsigned OpNum,
+                                                  raw_ostream &O) {
+  const MCOperand &MO2 = MI->getOperand(OpNum + 1);
+
+  O << markup("<mem:") << "[";
+  int32_t OffImm = (int32_t)MO2.getImm();
+
+  // Special value for #-0. All others are normal.
+  if (OffImm == INT32_MIN)
+    OffImm = 0;
+
+  O << "+ " << markup("<imm:") << "(" << formatImm(OffImm) << ")";
+  O << markup(">") << "]" << markup(">");
+}

lib/Target/NDS32/NDS32Instr16Bit.td

def LHI333: LHI333Form<(outs lGPR:$Rt), (ins addr_imm3u_half:$addr),
                        "lhi333\t$Rt, $addr",
                        [(set lGPR:$Rt, (zextloadi16 addr_imm3u_half:$addr))]>,
                        Requires<[Has16Bit]>;
 
 def LWI333: LWI333Form<(outs lGPR:$Rt), (ins addr_imm3u_word:$addr),
                        "lwi333\t$Rt, $addr",
                        [(set lGPR:$Rt, (load addr_imm3u_word:$addr))]>,
                        Requires<[Has16Bit]>;
+
+def LWI37: XWI37Form<(outs lGPR:$Rt), (ins addr_fp_base_offset_imm7u_word:$addr),
+                     "lwi37\t$Rt, $addr", [], 0>,
+                     Requires<[Has16Bit]>;
+
+def LWI37SP: XWI37SPForm<(outs lGPR:$Rt), (ins addr_sp_base_offset_imm7u_word:$addr),
+                         "lwi37.sp\t$Rt, $addr", [], 0>,
+                         Requires<[Has16Bit]>;
 }
 
 let AddedComplexity = 4, mayStore = 1 in {
 def SBI333: SBI333Form<(outs), (ins lGPR:$Rt, addr_imm3u_byte:$addr),
                        "sbi333\t$Rt, $addr",
                        [(truncstorei8 lGPR:$Rt, addr_imm3u_byte:$addr)]>,
                        Requires<[Has16Bit]>;
 
 def SHI333: SHI333Form<(outs), (ins lGPR:$Rt, addr_imm3u_half:$addr),
                        "shi333\t$Rt, $addr",
                        [(truncstorei16 lGPR:$Rt, addr_imm3u_half:$addr)]>,
                        Requires<[Has16Bit]>;
 
 def SWI333: SWI333Form<(outs), (ins lGPR:$Rt, addr_imm3u_word:$addr),
                        "swi333\t$Rt, $addr",
                        [(store lGPR:$Rt, addr_imm3u_word:$addr)]>,
                        Requires<[Has16Bit]>;
+
+def SWI37: XWI37Form<(outs), (ins lGPR:$Rt, addr_fp_base_offset_imm7u_word:$addr),
+                     "swi37\t$Rt, $addr", [], 1>,
+                     Requires<[Has16Bit]>;
+
+def SWI37SP: XWI37SPForm<(outs), (ins lGPR:$Rt, addr_sp_base_offset_imm7u_word:$addr),
+                         "swi37.sp\t$Rt, $addr", [], 1>,
+                         Requires<[Has16Bit]>;
 }
 
 
 //===----------------------------------------------------------------------===//
 //  Control Flow Instructions
 //
 
 def BEQZ38 : BEQZ38Form<(outs), (ins lGPR:$Rt, brtargetImm8s:$offset),

lib/Target/NDS32/NDS32Instr16Formats.td

class SWI333Form<dag outs, dag ins, string asmstr, list<dag> pattern>
   : 16BitInst6BitOpcode<0b010100, outs, ins, asmstr, pattern> {
   bits<3> Rt;
   bits<6> addr;
   let Inst{8-6} = Rt;
   let Inst{5-3} = addr{5-3};  // Ra
   let Inst{2-0} = addr{2-0};  // imm3u
 }
 
+class XWI37Form<dag outs, dag ins, string asmstr, list<dag> pattern,
+      bit store>
+  : 16BitInst4BitOpcode<0b0111, outs, ins, asmstr, pattern> {
+  bits<3> Rt;
+  bits<7> addr;
+  let Inst{10-8} = Rt;
+  let Inst{7} = store;
+  let Inst{6-0} = addr;
+}
+
+class XWI37SPForm<dag outs, dag ins, string asmstr, list<dag> pattern,
+      bit store>
+  : 16BitInst4BitOpcode<0b1110, outs, ins, asmstr, pattern> {
+  bits<3> Rt;
+  bits<7> addr;
+  let Inst{10-8} = Rt;
+  let Inst{7} = store;
+  let Inst{6-0} = addr;
+}
+
 class BEQZ38Form<dag outs, dag ins, string asmstr, list<dag> pattern>
   : 16BitInst4BitOpcode<0b1000, outs, ins, asmstr, pattern> {
   bits<3> Rt;
   bits<8> offset;
   let Inst{10-8} = Rt;
   let Inst{7-0} = offset;
 }
 

lib/Target/NDS32/NDS32Predicate.td

 def addr_imm3u_byte : MemOperand,
     ComplexPattern<i32, 2, "SelectAddrImm3uByte", []> {
   // 3-bit unsigned immediate operand. Note that for byte size load/store
   // immediate access range would be + (imm3u).
 
   let MIOperandInfo = (ops lGPR:$base, i32imm:$offsimm);
   let PrintMethod = "printAddrImmOperand";
 }
+
+// addr_sp_base_offset_imm7u_word := [+ imm7u << 2]
+def AddrSPImm7uWordAsmOperand : AsmOperandClass { let Name = "AddrSPImm7uWord"; }
+def addr_sp_base_offset_imm7u_word : MemOperand {
+  let MIOperandInfo = (ops SPReg:$base, i32imm:$offsimm);
+  let PrintMethod = "printSPImplyAddrImmOperand";
+}
+
+// addr_fp_base_offset_imm7u_word := [$fp + imm7u << 2]
+def AddrFPImm7uWordAsmOperand : AsmOperandClass { let Name = "AddrFPImm7uWord"; }
+def addr_fp_base_offset_imm7u_word : MemOperand {
+  let MIOperandInfo = (ops FPReg:$base, i32imm:$offsimm);
+  let PrintMethod = "printAddrImmOperand";
+}

lib/Target/NDS32/NDS32RegisterInfo.cpp

 }
 
 const TargetRegisterClass *
 NDS32RegisterInfo::getPointerRegClass(const MachineFunction &MF, unsigned Kind)
                                                                         const {
   return &NDS32::GPRRegClass;
 }
 
+// Return true if the instruction fit
+// swi37.sp/lwi37.sp/swi37/lwi37 limitation.
+static bool FitFrameBase16BitLoadStore (MachineInstr &MI, unsigned BaseReg,
+                                        int64_t Offset) {
+  unsigned Opc = MI.getOpcode();
+
+  // BaseReg must be SP or FP
+  if (BaseReg != NDS32::SP && BaseReg != NDS32::FP)
+    return false;
+
+  // Offset limitation is (imm7u << 2)
+  if (!isUInt<9>(Offset))
+    return false;
+  if (Offset % 4 != 0)
+    return false;
+
+  if (Opc != NDS32::SWI && Opc != NDS32::LWI)
+    return false;
+
+  // Operand 0 must be low register
+  unsigned Reg = MI.getOperand(0).getReg();
+  if (!isNDS32LowRegister (Reg))
+    return false;
+
+  return true;
+}
+
 void
 NDS32RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
                                        int SPAdj, unsigned FIOperandNum,
                                        RegScavenger *RS) const {
   assert(SPAdj == 0 && "Unexpected");
 
   MachineInstr &MI = *II;
   MachineBasicBlock &MBB = *MI.getParent();
   MachineFunction &MF = *MBB.getParent();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const NDS32FrameLowering *TFI = getFrameLowering(MF);
   const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
   DebugLoc DL = MI.getDebugLoc();
   int FrameIndex = MI.getOperand(FIOperandNum).getIndex();
   uint64_t stackSize = MF.getFrameInfo().getStackSize();
   int64_t Offset = MF.getFrameInfo().getObjectOffset(FrameIndex);
+  const NDS32Subtarget &Subtarget = MF.getSubtarget<NDS32Subtarget>();
 
   DEBUG(errs() << "\nFunction : " << MF.getName() << "\n";
         errs() << "<--------->\n" << MI);
   DEBUG(errs() << "FrameIndex : " << FrameIndex << "\n"
                << "spOffset   : " << Offset << "\n"
                << "stackSize  : " << stackSize << "\n");
 
   unsigned BasePtr = (TFI->hasFP(MF) ? NDS32::FP : NDS32::SP);
NDS32RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
   Offset += stackSize;
 
   // Fold imm into offset
   Offset += MI.getOperand(FIOperandNum + 1).getImm();
 
   // Use R15 as temp register
   unsigned Reg = NDS32::R15;
 
-  if (isInt<15>(Offset)) {
+  // Transfer to 16 bit format
+  // if the instruction fit swi37.sp/lwi37.sp/swi37/lwi37 limitation
+  if (FitFrameBase16BitLoadStore (MI, BasePtr, Offset)
+      && Subtarget.has16Bit()) {
+    unsigned OpcNew;
+    if (MI.getOpcode() == NDS32::LWI)
+      OpcNew = (BasePtr == NDS32::SP) ? NDS32::LWI37SP : NDS32::LWI37;
+    else
+      OpcNew = (BasePtr == NDS32::SP) ? NDS32::SWI37SP : NDS32::SWI37;
+
+    MI.setDesc(TII.get(OpcNew));
+    MI.getOperand(FIOperandNum).ChangeToRegister(BasePtr, false);
+    MI.getOperand(FIOperandNum + 1).ChangeToImmediate(Offset);
+    return;
+  } else if (isInt<15>(Offset)) {
     MI.getOperand(FIOperandNum).ChangeToRegister(BasePtr, false);
     MI.getOperand(FIOperandNum + 1).ChangeToImmediate(Offset);
     return;
   } else if (isInt<20>(Offset)) {
     // movi r15, Offset
     BuildMI(MBB, II, DL, TII.get(NDS32::MOVI), Reg)
       .addImm(Offset);
   } else {

test/CodeGen/NDS32/by-val.ll

entry:
   store i32 10, i32* %c, align 4
   %arrayidx1 = getelementptr inbounds [3 x %struct.tiny], [3 x %struct.tiny]* %x, i32 0, i32 1
   %c2 = getelementptr inbounds %struct.tiny, %struct.tiny* %arrayidx1, i32 0, i32 0
   store i32 11, i32* %c2, align 4
   %arrayidx3 = getelementptr inbounds [3 x %struct.tiny], [3 x %struct.tiny]* %x, i32 0, i32 2
   %c4 = getelementptr inbounds %struct.tiny, %struct.tiny* %arrayidx3, i32 0, i32 0
   store i32 12, i32* %c4, align 4
 ; CHECK: movi55  $r0, 10
-; CHECK: swi     $r0, [$sp + (0)]
+; CHECK: swi37.sp        $r0, [+ (0)]
 ; CHECK: movi55  $r1, 4
 ; CHECK: movi55  $r2, 11
 ; CHECK: sw      $r2, [$r1 + $r0]
 ; CHECK: movi55  $r2, 8
 ; CHECK: movi55  $r3, 12
 ; CHECK: sw      $r3, [$r2 + $r0]
 ; CHECK: lw      $r3, [$r2 + $r0]
 ; CHECK: lw      $r2, [$r1 + $r0]
-; CHECK: lwi     $r1, [$sp + (0)]
+; CHECK: lwi37.sp        $r1, [+ (0)]
   %call = call i32 @f(i32 undef, %struct.tiny* byval nonnull align 4 %arrayidx, %struct.tiny* byval align 4 %arrayidx1, %struct.tiny* byval align 4 %arrayidx3)
   tail call void @exit(i32 0) #4
   unreachable
 }
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.lifetime.start(i64, i8* nocapture) #3
 
 ; Function Attrs: noreturn
 declare void @exit(i32) local_unnamed_addr #1

test/CodeGen/NDS32/prolog-endprolog.ll

 ; Function Attrs: noreturn
 declare void @abort() local_unnamed_addr #3
 
 ; Function Attrs: nounwind
 define i32 @foo(i8* nocapture readnone %a, i32 %b, i32 %c) local_unnamed_addr #2 {
 entry:
 ; CHECK: addi    $sp, $sp, -16
 ; CHECK: swi     $lp, [$sp + (12)]
-; CHECK: swi     $r7, [$sp + (8)]
-; CHECK: swi     $r6, [$sp + (4)]
+; CHECK: swi37.sp        $r7, [+ (8)]
+; CHECK: swi37.sp        $r6, [+ (4)]
   %0 = load i32, i32* @baz1.l, align 4
   %inc.i97 = add nsw i32 %0, 1
   store i32 %inc.i97, i32* @baz1.l, align 4
   %cmp98 = icmp slt i32 %0, %b
   br i1 %cmp98, label %if.then.lr.ph, label %while.end
 
 if.then.lr.ph:                                    ; preds = %entry
   %and = and i32 %c, 16
while.end.loopexit166:                            ; preds = %if.then
   store i32 %inc.i, i32* @baz1.l, align 4
   br label %while.end
 
 while.end.loopexit168:                            ; preds = %while.cond.backedge.us130
   br label %while.end
 
 while.end:                                        ; preds = %while.end.loopexit168, %while.end.loopexit166, %while.end.loopexit, %entry
 ; CHECK: lwi     $lp, [$sp + (12)]
-; CHECK: lwi     $r7, [$sp + (8)]
-; CHECK: lwi     $r6, [$sp + (4)]
+; CHECK: lwi37.sp        $r7, [+ (8)]
+; CHECK: lwi37.sp        $r6, [+ (4)]
 ; CHECK: addi    $sp, $sp, 16
   ret i32 0
 }
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.lifetime.start(i64, i8* nocapture) #4
 
 ; Function Attrs: noreturn nounwind

test/CodeGen/NDS32/va-arg.ll

 ; RUN: llc < %s | FileCheck %s
 target datalayout = "e-m:e-p:32:32-i64:64-a:0:32-n32-S64"
 target triple = "nds32le---elf"
 
 ; Function Attrs: nounwind
 define i32 @f(i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %p4, i32 %p5, i32 %p6, i32 %p7, i32 %p8, ...) local_unnamed_addr #0 {
 entry:
   %select = alloca i8*, align 4
   %0 = bitcast i8** %select to i8*
   call void @llvm.lifetime.start(i64 4, i8* nonnull %0) #2
   call void @llvm.va_start(i8* nonnull %0)
 ; CHECK: addi    $r0, $sp, 20
-; CHECK: swi     $r0, [$sp + (0)]
+; CHECK: swi37.sp        $r0, [+ (0)]
   %argp.cur = load i8*, i8** %select, align 4
   %argp.next = getelementptr inbounds i8, i8* %argp.cur, i32 4
   store i8* %argp.next, i8** %select, align 4
   %1 = bitcast i8* %argp.cur to i32*
   %2 = load i32, i32* %1, align 4
   %cmp = icmp eq i32 %2, 10
   br i1 %cmp, label %if.end, label %if.then