Try to handle 'dla' in PIC mode for N64.

[bsdjhb]

Summary

[MIPS] Handle PIC load address macro instructions in N64.

In particular, use CALL16 (similar to O32) for address loads into T9 for certain
cases. Otherwise use a %got_disp relocation to load the address of a symbol.
Small offsets (small enough to fit in a 16-bit signed immediate) can be used and
are added to the symbol address after it is loaded from the GOT. Larger offsets
are currently unsupported and result in an error from the assembler.

[bsdjhb]

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2955

This comment is now stale and needs updating, I'm just not quite sure what the correct new comment is.

[sdardis]

I do not yet have test cases written (I'm not familiar with writing those for llvm),

If you look in test/MC/Mips/macro-la-pic.s , you'll find the test for the O32 'la' macro.

Copy that file to test/MC/Mips/macro-dla-pic.s, and modify the RUN: lines that mention -mtriple=mips-unknown-linux to -mtriple=mips64-unknown-linux and modify the -mcpu=mips32rX to -mcpu=mips64r6.

You'll need change the CHECK: lines to account for the change in instructions, as the encoding will be different due to using 'ld' instead of 'lw'. See http://llvm.org/docs/CommandGuide/FileCheck.html for more details on how FileCheck works.

You can run a single test by invoking llvm-lit from the build directory. e.g:

./bin/llvm-lit test/MC/Mips/macro-la-pic.s -a

Will run just that test and be verbose (the '-a') about it. You'll also see the commands use to run the test and use that to find the encodings for the different instructions.

I'll take a longer look at this tomorrow.

Thanks for doing this,
Simon

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2928

The '&& isGP64bit()' is unnecessary, ArePtrs64bit() should be sufficient to cover N64.

2955

I'm not wholly sure right now myself, but if you grab a recent copy of binutils and experiment (you'll want to see what GCC produces for PIC code as a reference), you'll get something.

2966–2968

XXX -> FIXME. LLVM uses "FIXME"s over XXX or ???.

[sdardis]

Can you split out the change of choosing CALL16 vs GOT for O32 at least? It's not wholly relevant to this patch and IIRC correctly, there may be deficiency in the assembly parser regarding forward declared local symbols. I have a patch floating around that addresses that.

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2849

Can you add "FIXME: These expansions do not respect -mxgot."

2867–2872

This change should be submitted seperately.

2966–2968

N64 and N32 both use GOT_DISP, so the bottom FIXME can be removed.

2971

While the O32 ABI produces a R_MIPS_LO16 for symbols that are temporary or located in the current section, N64/ N32 produce a R_MIPS_GOT16 only.

2972–2976

This hunk and the addition when LoExpr != nullptr is incorrect when the constant is < -0x8000 || >0x7fff as the symbol offset is truncated. Furthermore, GAS indicates that the offset for a symbol is 32 bits are most.

[bsdjhb]

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2972–2976

To be clear, does this mean that LoExpr should just be dropped entirely here? In the specific use cases I've seen this with FreeBSD there isn't an offset so I've not exercised this case (and am not sure what the right thing to do is)

[bsdjhb]

• Rebase on top of D33999
• A few fixes suggested by Simon Dardis.
• Add initial tests.
• Start on updating the comments, though I don't think this is quite right still.

[bsdjhb]

• Don't include the symbol offset in the %got_disp relocation.
• Add missing daddui's for symbol offsets to the test.
• Update comments and punt on large offsets for now.

[sdardis]

Some small changes requested, but otherwise this looks good.

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2866–2867

Can you remove that change?

The expansion for 'la' and 'dla' in the PIC case are very similar. I'd like both chunks of code to be as similar as possible so that the refactoring is as easy as possible.

2942–2947

Formatting. See my comment on D33999.

2962–2963

Formatting. This should be:

const MipsMCExpr *GotExpr = MipsMCExpr::create(MipsMCExpr::MEK_GOT_DISP,
                                               Res.getSymA(), getContext());

2971

FIXME: Offsets greater than 16 bits are not yet implemented.
FIXME: The correct range is a 32 bit sign-extended number.

2972–2976

The handling of of a constant and a symbol here is correct for the case of a sign extended 16 bit number.

2974

"macro instruction uses large offset, which is not currently supported", also add test for this error.

See test/MC/Mips/macro-la-bad.s for an example of how to write a test that tests an error.

test/MC/Mips/macro-dla-pic.s

1 ↗

(On Diff #103541)

The cpu here should be mips3.

[bsdjhb]

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2866–2867

Do you want me to check for both T9 and T9_64 in the new 64-bit block as well?

[sdardis]

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2866–2867

Please. I'll sit down and refactor this code after it's been committed.

[bsdjhb]

• Revert change to remove T9_64 from O32 CALL16 condition.
• Formatting and other fixes from Simon.
• Add tests for errors for large symbol offsets with dla.
• Check for both T9's in the 64-bit case.

[bsdjhb]

• Wrap long line per clang-format.

[bsdjhb]

test/MC/Mips/macro-dla-pic.s

3 ↗

(On Diff #104399)

Not sure if this comment is really accurate. It was a cut and paste from macro-la-pic.s.

[sdardis]

test/MC/Mips/macro-dla-pic.s

3 ↗

(On Diff #104399)

Yes, it incorrect. Instead of erroring out, a static relocation sequence is written out. Also we don't warn + transform to 'la' instead like GAS does.

[bsdjhb]

• Drop N32 comment from dla-pic test.

[sdardis]

LGTM with a summary update.

[bsdjhb]

I've taken a stab at a new summary. Simon, can you refine that further and commit this change as I do not have commit access?

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

return loadImmediate(Offset.getImm(), DstReg, BaseReg, Is32BitAddress, true,
                        IDLoc, Out, STI);
 }
 
 bool MipsAsmParser::loadAndAddSymbolAddress(const MCExpr *SymExpr,
                                             unsigned DstReg, unsigned SrcReg,
                                             bool Is32BitSym, SMLoc IDLoc,
                                             MCStreamer &Out,
                                             const MCSubtargetInfo *STI) {
   MipsTargetStreamer &TOut = getTargetStreamer();
   bool UseSrcReg = SrcReg != Mips::NoRegister;
   warnIfNoMacro(IDLoc);
 
   if (inPicMode() && ABI.IsO32()) {
     MCValue Res;
     if (!SymExpr->evaluateAsRelocatable(Res, nullptr, nullptr)) {
       Error(IDLoc, "expected relocatable expression");
       return true;
     }
     if (Res.getSymB() != nullptr) {
       Error(IDLoc, "expected relocatable expression with only one symbol");
       return true;
     }
 
     // The case where the result register is $25 is somewhat special. If the
     // symbol in the final relocation is external and not modified with a
     // constant then we must use R_MIPS_CALL16 instead of R_MIPS_GOT16.
-    if ((DstReg == Mips::T9 || DstReg == Mips::T9_64) && !UseSrcReg &&
-        Res.getConstant() == 0 && !Res.getSymA()->getSymbol().isInSection() &&
-        !Res.getSymA()->getSymbol().isTemporary()) {
+    if (DstReg == Mips::T9 && !UseSrcReg &&
+        Res.getConstant() == 0 && !(Res.getSymA()->getSymbol().isInSection() ||
+        Res.getSymA()->getSymbol().isTemporary() ||
+        (Res.getSymA()->getSymbol().isELF() &&
+        cast<MCSymbolELF>(Res.getSymA()->getSymbol()).getBinding() ==
+        ELF::STB_LOCAL))) {
       const MCExpr *CallExpr =
           MipsMCExpr::create(MipsMCExpr::MEK_GOT_CALL, SymExpr, getContext());
       TOut.emitRRX(Mips::LW, DstReg, ABI.GetGlobalPtr(),
                    MCOperand::createExpr(CallExpr), IDLoc, STI);
       return false;
     }
 
     // The remaining cases are:
if (LoExpr)
                    IDLoc, STI);
 
     if (UseSrcReg)
       TOut.emitRRR(Mips::ADDu, DstReg, TmpReg, SrcReg, IDLoc, STI);
 
     return false;
   }
 
+  if (inPicMode() && ABI.ArePtrs64bit() && isGP64bit()) {
+    MCValue Res;
+    if (!SymExpr->evaluateAsRelocatable(Res, nullptr, nullptr)) {
+      Error(IDLoc, "expected relocatable expression");
+      return true;
+    }
+    if (Res.getSymB() != nullptr) {
+      Error(IDLoc, "expected relocatable expression with only one symbol");
+      return true;
+    }
+
+    // The case where the result register is $25 is somewhat special. If the
+    // symbol in the final relocation is external and not modified with a
+    // constant then we must use R_MIPS_CALL16 instead of R_MIPS_GOT16.
+    if (DstReg == Mips::T9_64 && !UseSrcReg &&
+        Res.getConstant() == 0 && !(Res.getSymA()->getSymbol().isInSection() ||
+        Res.getSymA()->getSymbol().isTemporary() ||
+        (Res.getSymA()->getSymbol().isELF() &&
+        cast<MCSymbolELF>(Res.getSymA()->getSymbol()).getBinding() ==
+        ELF::STB_LOCAL))) {
+      const MCExpr *CallExpr =
+          MipsMCExpr::create(MipsMCExpr::MEK_GOT_CALL, SymExpr, getContext());
+      TOut.emitRRX(Mips::LD, DstReg, ABI.GetGlobalPtr(),
+                   MCOperand::createExpr(CallExpr), IDLoc, STI);
+      return false;
+    }
+
+    // The remaining cases are:
+    //   External GOT: ld $tmp, %got(symbol+offset)($gp)
+    //                >daddiu $tmp, $tmp, %lo(offset)
+    //                >daddiu $rd, $tmp, $rs
+    //   Local GOT:    ld $tmp, %got(symbol+offset)($gp)
+    //                 daddiu $tmp, $tmp, %lo(symbol+offset)($gp)
+    //                >daddiu $rd, $tmp, $rs
+    // The daddiu's marked with a '>' may be omitted if they are redundant. If
+    // this happens then the last instruction must use $rd as the result
+    // register.
+    //
+    // XXX: This is just copied from O32 above.  No idea if a single
+    // loExpr is sufficient for N64 as well?
+    // XXX: Use GOT_DISP instead of GOT?
+    const MipsMCExpr *GotExpr =
+        MipsMCExpr::create(MipsMCExpr::MEK_GOT_DISP, SymExpr, getContext());
+    const MCExpr *LoExpr = nullptr;
+    if (Res.getConstant() != 0) {
+      // External symbols fully resolve the symbol with just the %got(symbol)
+      // but we must still account for any offset to the symbol for expressions
+      // like symbol+8.
+      LoExpr = MCConstantExpr::create(Res.getConstant(), getContext());
+    }
+
+    unsigned TmpReg = DstReg;
+    if (UseSrcReg &&
+        getContext().getRegisterInfo()->isSuperOrSubRegisterEq(DstReg,
+                                                               SrcReg)) {
+      // If $rs is the same as $rd, we need to use AT.
+      // If it is not available we exit.
+      unsigned ATReg = getATReg(IDLoc);
+      if (!ATReg)
+        return true;
+      TmpReg = ATReg;
+    }
+
+    TOut.emitRRX(Mips::LD, TmpReg, ABI.GetGlobalPtr(),
+                 MCOperand::createExpr(GotExpr), IDLoc, STI);
+
+    if (LoExpr)
+      TOut.emitRRX(Mips::DADDiu, TmpReg, TmpReg, MCOperand::createExpr(LoExpr),
+                   IDLoc, STI);
+
+    if (UseSrcReg)
+      TOut.emitRRR(Mips::DADDu, DstReg, TmpReg, SrcReg, IDLoc, STI);
+
+    return false;
+  }
+
   const MipsMCExpr *HiExpr =
       MipsMCExpr::create(MipsMCExpr::MEK_HI, SymExpr, getContext());
   const MipsMCExpr *LoExpr =
       MipsMCExpr::create(MipsMCExpr::MEK_LO, SymExpr, getContext());
 
   // This is the 64-bit symbol address expansion.
   if (ABI.ArePtrs64bit() && isGP64bit()) {
     // We need AT for the 64-bit expansion in the cases where the optional