[Sparc] Support calls to absolute addresses

[dcederman]

Summary

I will split it out the printout related code if the patch gets accepted.

[jyknight]

The current behavior is definitely wrong...but I think this isn't a correct fix either.

Per the behavior of both GNU as and Solaris as, "call NUM" should actually be an alias for "jmpl NUM, %o7", so I think isImm shouldn't be supported in getCallTargetOpValue at all -- and the tabledefs should be modified so that it's impossible to get into that code with an immediate.

(While I look at this, though, I notice that the *disassembly* is bogus in both gnu "objdump" and solaris "dis". They both output a relative call using the text "call NUM" -- they print a relative call using syntax which is parsed on input as an absolute call. Ugh. llvm-objdump at least prints the two differently and basically consistent with the assembler, but its assembler is wrong.)

Given a test file test.s:

call 1
call 4
call 0x1232
call . + 1
call . + 4
call . + 0x1232

With GNU as: "as -o test.o test.s". Note the difference in instruction encodings for the first 3 vs last 3. (I note also that "call . + 1" should really be an error, since it's unencodable, but that's a different issue.)

"objdump -d test.o":

00000000 <.text>:
   0:   9f c0 20 01     call  1
   4:   9f c0 20 04     call  4
   8:   9f c0 24 d2     call  0x4d0
   c:   40 00 00 00     call  0xc
  10:   40 00 00 01     call  0x14
  14:   40 00 01 34     call  0x4e4

"llvm-objdump -d test.o":

.text:
       0:       9f c0 20 01     call %g0+1
       4:       9f c0 20 04     call %g0+4
       8:       9f c0 24 d2     call %g0+1232
       c:       40 00 00 00     call 0
      10:       40 00 00 01     call 4
      14:       40 00 01 34     call 1232

With "clang -fintegrated-as -c -target sparc-unknown-unknown -o test.o test.s", note that we incorrectly encoded everything as relative calls.

"objdump -d test.o":

00000000 <.text>:
   0:   40 00 00 01     call  0x4
   4:   40 00 00 04     call  0x14
   8:   40 00 04 d2     call  0x1350
   c:   40 00 00 00     call  0xc
  10:   40 00 00 01     call  0x14
  14:   40 00 01 34     call  0x4e4

[dcederman]

Sorry for the very late reply, I missed that you had commented.

It seems GNU as generates a "jmpl %g0 + imm, %o7" when the target address value is small enough, and a call with a R_SPARC_WDISP30 and the target address as a constant when it is too big. To avoid having to modify parseMEMOperand() we could use the latter method in both cases. It generates the same number of instructions and it is not commonly used.

lib/Target/Sparc/InstPrinter/SparcInstPrinter.cpp

if (MO.isReg()) {
     return ;
   }
 
   if (MO.isImm()) {
     switch (MI->getOpcode()) {
       default:
         O << (int)MO.getImm(); 
         return;
-        
+      case SP::CALL:
+        O << "0x";
+        O.write_hex(MO.getImm());
+        return;
       case SP::TICCri: // Fall through
       case SP::TICCrr: // Fall through
       case SP::TRAPri: // Fall through
       case SP::TRAPrr: // Fall through
       case SP::TXCCri: // Fall through
       case SP::TXCCrr: // Fall through
         // Only seven-bit values up to 127.
         O << ((int) MO.getImm() & 0x7f);  

lib/Target/Sparc/MCTargetDesc/SparcMCCodeEmitter.cpp

getMachineOpValue(const MCInst &MI, const MCOperand &MO,
   return 0;
 }
 
 unsigned SparcMCCodeEmitter::
 getCallTargetOpValue(const MCInst &MI, unsigned OpNo,
                      SmallVectorImpl<MCFixup> &Fixups,
                      const MCSubtargetInfo &STI) const {
   const MCOperand &MO = MI.getOperand(OpNo);
-  if (MO.isReg() || MO.isImm())
+  if (MO.isReg())
     return getMachineOpValue(MI, MO, Fixups, STI);
 
   if (MI.getOpcode() == SP::TLS_CALL) {
     // No fixups for __tls_get_addr. Will emit for fixups for tls_symbol in
     // encodeInstruction.
 #ifndef NDEBUG
     // Verify that the callee is actually __tls_get_addr.
     const SparcMCExpr *SExpr = dyn_cast<SparcMCExpr>(MO.getExpr());
     assert(SExpr && SExpr->getSubExpr()->getKind() == MCExpr::SymbolRef &&
            "Unexpected expression in TLS_CALL");
     const MCSymbolRefExpr *SymExpr = cast<MCSymbolRefExpr>(SExpr->getSubExpr());
     assert(SymExpr->getSymbol().getName() == "__tls_get_addr" &&
            "Unexpected function for TLS_CALL");
 #endif
     return 0;
   }
 
   MCFixupKind fixupKind = (MCFixupKind)Sparc::fixup_sparc_call30;
 
+  if (MO.isImm()) {
+    Fixups.push_back(MCFixup::create(
+        0, MCConstantExpr::create(MO.getImm(), Ctx), fixupKind));
+    return 0;
+  }
+
   if (const SparcMCExpr *SExpr = dyn_cast<SparcMCExpr>(MO.getExpr())) {
     if (SExpr->getKind() == SparcMCExpr::VK_Sparc_WPLT30)
       fixupKind = (MCFixupKind)Sparc::fixup_sparc_wplt30;
   }
 
   Fixups.push_back(MCFixup::create(0, MO.getExpr(), fixupKind));
 
   return 0;

test/MC/Disassembler/Sparc/sparc.txt

 0x1d 0xff 0xff 0xff
 
 # CHECK: cb012 4194303
 0x1f 0xff 0xff 0xff
 
 # CHECK: restore
 0x81 0xe8 0x00 0x00
 
-# CHECK: call 16
+# CHECK: call 0x10
 0x40 0x00 0x00 0x04
 
 # CHECK: add %g1, -10, %g2
 0x84 0x00 0x7f 0xf6
 
 # CHECK: save %sp, -196, %sp
 0x9d 0xe3 0xbf 0x3c
 

test/MC/Sparc/sparc-ctrl-instructions.s

 ! RUN: llvm-mc %s -arch=sparc   -show-encoding | FileCheck %s
 ! RUN: llvm-mc %s -arch=sparcv9 -show-encoding | FileCheck %s
 
         ! CHECK: call foo     ! encoding: [0b01AAAAAA,A,A,A]
         ! CHECK:              !   fixup A - offset: 0, value: foo, kind: fixup_sparc_call30
         call foo
 
         ! CHECK: call %g1+%i2 ! encoding: [0x9f,0xc0,0x40,0x1a]
         call %g1 + %i2
 
         ! CHECK: call %o1+8   ! encoding: [0x9f,0xc2,0x60,0x08]
         call %o1 + 8
 
         ! CHECK: call %g1     ! encoding: [0x9f,0xc0,0x40,0x00]
         call %g1
 
+        ! CHECK: call 0x40000000   ! encoding: [0b01AAAAAA,A,A,A]
+              ! fixup A - offset: 0, value: 1073741824, kind: fixup_sparc_call30
+        call 0x40000000
+
         ! CHECK: call %g1+%lo(sym)   ! encoding: [0x9f,0xc0,0b011000AA,A]
         ! CHECK-NEXT:                ! fixup A - offset: 0, value: %lo(sym), kind: fixup_sparc_lo10
         call %g1+%lo(sym)
 
         ! CHECK: jmp %g1+%i2  ! encoding: [0x81,0xc0,0x40,0x1a]
         jmp %g1 + %i2
 
         ! CHECK: jmp %o1+8    ! encoding: [0x81,0xc2,0x60,0x08]