[mips] Expand 'lw/sw' instructions for 32-bit GOT

[atanasyan]

Summary

In case of using 32-bit GOT access to the table requires two instructions with attached %got_hi and %got_lo relocations. This patch implements correct expansion of 'lw/sw' instructions in that case.

[Petar.Avramovic]

LGTM.

llvm/test/MC/Mips/mips64-expansions.s

3

Missing run line with -mattr=+xgot.

506

Do symbols have different handling in assembly file based on something, like getAddrLocal and getAddrGlobal/getAddrGlobalLargeGOT in MipsISelLowering.cpp ?

[atanasyan]

llvm/test/MC/Mips/mips64-expansions.s

3

Good catch. I'll fix that.

506

Yes. The xgot flag does not affect taking address of local symbol. For global symbols with xgot flag we generate a pair of %got_hi/%got_lo relocations like the getAddrGlobalLargeGOT does. Without xgot flag we generate %got_disp in 64-bit case and %got in 32-bit case like the getAddrGlobal does.

[Petar.Avramovic]

llvm/trunk/test/MC/Mips/mips64-expansions.s

91 ↗

(On Diff #220726)

Do symbols have different handling in assembly ...

Missed that sym is local.

llvm/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) {
-  // FIXME: These expansions do not respect -mxgot.
   MipsTargetStreamer &TOut = getTargetStreamer();
   bool UseSrcReg = SrcReg != Mips::NoRegister && SrcReg != Mips::ZERO &&
                    SrcReg != Mips::ZERO_64;
   warnIfNoMacro(IDLoc);
 
   if (inPicMode()) {
     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;
     }
 
     bool IsPtr64 = ABI.ArePtrs64bit();
     bool IsLocalSym =
         Res.getSymA()->getSymbol().isInSection() ||
         Res.getSymA()->getSymbol().isTemporary() ||
         (Res.getSymA()->getSymbol().isELF() &&
          cast<MCSymbolELF>(Res.getSymA()->getSymbol()).getBinding() ==
              ELF::STB_LOCAL);
+    bool UseXGOT = STI->getFeatureBits()[Mips::FeatureXGOT] && !IsLocalSym;
 
     // 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
     // or R_MIPS_CALL16 instead of R_MIPS_GOT_DISP in 64-bit case.
     if ((DstReg == Mips::T9 || DstReg == Mips::T9_64) && !UseSrcReg &&
         Res.getConstant() == 0 && !IsLocalSym) {
+      if (UseXGOT) {
+        const MCExpr *CallHiExpr = MipsMCExpr::create(MipsMCExpr::MEK_CALL_HI16,
+                                                      SymExpr, getContext());
+        const MCExpr *CallLoExpr = MipsMCExpr::create(MipsMCExpr::MEK_CALL_LO16,
+                                                      SymExpr, getContext());
+        TOut.emitRX(Mips::LUi, DstReg, MCOperand::createExpr(CallHiExpr), IDLoc,
+                    STI);
+        TOut.emitRRR(IsPtr64 ? Mips::DADDu : Mips::ADDu, DstReg, DstReg, GPReg,
+                     IDLoc, STI);
+        TOut.emitRRX(IsPtr64 ? Mips::LD : Mips::LW, DstReg, DstReg,
+                     MCOperand::createExpr(CallLoExpr), IDLoc, STI);
+      } else {
         const MCExpr *CallExpr =
             MipsMCExpr::create(MipsMCExpr::MEK_GOT_CALL, SymExpr, getContext());
         TOut.emitRRX(IsPtr64 ? Mips::LD : Mips::LW, DstReg, GPReg,
                      MCOperand::createExpr(CallExpr), IDLoc, STI);
+      }
+      return false;
+    }
+
+    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;
+    }
+
+    if (UseXGOT) {
+      // Loading address from XGOT
+      //   External GOT: lui $tmp, %got_hi(symbol)($gp)
+      //                 addu $tmp, $tmp, $gp
+      //                 lw $tmp, %got_lo(symbol)($tmp)
+      //                >addiu $tmp, $tmp, offset
+      //                >addiu $rd, $tmp, $rs
+      // The addiu'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.
+      const MCExpr *CallHiExpr =
+          MipsMCExpr::create(MipsMCExpr::MEK_GOT_HI16, SymExpr, getContext());
+      const MCExpr *CallLoExpr = MipsMCExpr::create(
+          MipsMCExpr::MEK_GOT_LO16, Res.getSymA(), getContext());
+
+      TOut.emitRX(Mips::LUi, TmpReg, MCOperand::createExpr(CallHiExpr), IDLoc,
+                  STI);
+      TOut.emitRRR(IsPtr64 ? Mips::DADDu : Mips::ADDu, TmpReg, TmpReg, GPReg,
+                   IDLoc, STI);
+      TOut.emitRRX(IsPtr64 ? Mips::LD : Mips::LW, TmpReg, TmpReg,
+                   MCOperand::createExpr(CallLoExpr), IDLoc, STI);
+
+      if (Res.getConstant() != 0)
+        TOut.emitRRX(IsPtr64 ? Mips::DADDiu : Mips::ADDiu, TmpReg, TmpReg,
+                     MCOperand::createExpr(MCConstantExpr::create(
+                         Res.getConstant(), getContext())),
+                     IDLoc, STI);
+
+      if (UseSrcReg)
+        TOut.emitRRR(IsPtr64 ? Mips::DADDu : Mips::ADDu, DstReg, TmpReg, SrcReg,
+                     IDLoc, STI);
       return false;
     }
 
     const MipsMCExpr *GotExpr = nullptr;
     const MCExpr *LoExpr = nullptr;
     if (IsPtr64) {
       // The remaining cases are:
       //   Small offset: ld $tmp, %got_disp(symbol)($gp)
if (IsPtr64) {
         // expressions like symbol+8.
         GotExpr = MipsMCExpr::create(MipsMCExpr::MEK_GOT, Res.getSymA(),
                                      getContext());
         if (Res.getConstant() != 0)
           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(IsPtr64 ? Mips::LD : Mips::LW, TmpReg, GPReg,
                  MCOperand::createExpr(GotExpr), IDLoc, STI);
 
     if (LoExpr)
       TOut.emitRRX(IsPtr64 ? Mips::DADDiu : Mips::ADDiu, TmpReg, TmpReg,
                    MCOperand::createExpr(LoExpr), IDLoc, STI);
 
     if (UseSrcReg)

llvm/test/MC/Mips/mips-expansions.s

-# RUN: llvm-mc %s -triple=mipsel-unknown-linux -mcpu=mips32r2 \
+# RUN: llvm-mc %s -triple=mipsel-unknown-linux -mcpu=mips32r2 -mattr=-xgot \
 # RUN:            -show-encoding | FileCheck %s --check-prefixes=CHECK,CHECK-LE,GOT
+# RUN: llvm-mc %s -triple=mipsel-unknown-linux -mcpu=mips32r2 -mattr=+xgot \
+# RUN:            -show-encoding | FileCheck %s --check-prefixes=CHECK,CHECK-LE,XGOT
 # RUN: llvm-mc %s -triple=mips-unknown-linux -mcpu=mips32r2 \
 # RUN:            -show-encoding | FileCheck %s --check-prefixes=CHECK,CHECK-BE
 
 # Check that the IAS expands macro instructions in the same way as GAS.
 
 # Load address, done by MipsAsmParser::expandLoadAddressReg()
 # and MipsAsmParser::expandLoadAddressImm():
   la $8, 1f

 # PIC code
   .option pic2
   .set noat
   lw $10, symbol($4)
 # GOT:      lw      $10, %got(symbol)($gp)  # encoding: [A,A,0x8a,0x8f]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %got(symbol), kind: fixup_Mips_GOT
 # GOT-NEXT: addu    $10, $10, $4            # encoding: [0x21,0x50,0x44,0x01]
 # GOT-NEXT: lw      $10, 0($10)             # encoding: [0x00,0x00,0x4a,0x8d]
+
+# XGOT:      lui    $10, %got_hi(symbol)     # encoding: [A,A,0x0a,0x3c]
+# XGOT-NEXT:                                 #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: addu   $10, $10, $gp            # encoding: [0x21,0x50,0x5c,0x01]
+# XGOT-NEXT: lw     $10, %got_lo(symbol)($10) # encoding: [A,A,0x4a,0x8d]
+# XGOT-NEXT:                                 #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: addu   $10, $10, $4             # encoding: [0x21,0x50,0x44,0x01]
+# XGOT-NEXT: lw     $10, 0($10)              # encoding: [0x00,0x00,0x4a,0x8d]
   .set at
   sw $10, symbol($9)
 # GOT:      lw      $1, %got(symbol)($gp)   # encoding: [A,A,0x81,0x8f]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %got(symbol), kind: fixup_Mips_GOT
 # GOT-NEXT: addu    $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
 # GOT-NEXT: sw      $10, 0($1)              # encoding: [0x00,0x00,0x2a,0xac]
 
+# XGOT:      lui    $1, %got_hi(symbol)     # encoding: [A,A,0x01,0x3c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: addu   $1, $1, $gp             # encoding: [0x21,0x08,0x3c,0x00]
+# XGOT-NEXT: lw     $1, %got_lo(symbol)($1) # encoding: [A,A,0x21,0x8c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: addu   $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+# XGOT-NEXT: sw     $10, 0($1)              # encoding: [0x00,0x00,0x2a,0xac]
+
   lw $8, 1f+8
 # GOT:      lw      $8, %got($tmp0)($gp)    # encoding: [A,A,0x88,0x8f]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %got($tmp0), kind: fixup_Mips_GOT
 # GOT-NEXT: addiu   $8, $8, %lo($tmp0)      # encoding: [A,A,0x08,0x25]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %lo($tmp0), kind: fixup_Mips_LO16
 # GOT-NEXT: lw      $8, 8($8)               # encoding: [0x08,0x00,0x08,0x8d]
+
+# XGOT:      lw     $8, %got($tmp0)($gp)    # encoding: [A,A,0x88,0x8f]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got($tmp0), kind: fixup_Mips_GOT
+# XGOT-NEXT: addiu  $8, $8, %lo($tmp0)      # encoding: [A,A,0x08,0x25]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %lo($tmp0), kind: fixup_Mips_LO16
+# XGOT-NEXT: lw     $8, 8($8)               # encoding: [0x08,0x00,0x08,0x8d]
   sw $8, 1f+8
 # GOT:      lw      $1, %got($tmp0)($gp)    # encoding: [A,A,0x81,0x8f]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %got($tmp0), kind: fixup_Mips_GOT
 # GOT-NEXT: addiu   $1, $1, %lo($tmp0)      # encoding: [A,A,0x21,0x24]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %lo($tmp0), kind: fixup_Mips_LO16
 # GOT-NEXT: sw      $8, 8($1)               # encoding: [0x08,0x00,0x28,0xac]
 
+# XGOT:      lw     $1, %got($tmp0)($gp)    # encoding: [A,A,0x81,0x8f]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got($tmp0), kind: fixup_Mips_GOT
+# XGOT-NEXT: addiu  $1, $1, %lo($tmp0)      # encoding: [A,A,0x21,0x24]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %lo($tmp0), kind: fixup_Mips_LO16
+# XGOT-NEXT: sw     $8, 8($1)               # encoding: [0x08,0x00,0x28,0xac]
+
   lw $10, 655483($4)
 # GOT:      lui     $10, 10                 # encoding: [0x0a,0x00,0x0a,0x3c]
 # GOT-NEXT: addu    $10, $10, $4            # encoding: [0x21,0x50,0x44,0x01]
 # GOT-NEXT: lw      $10, 123($10)           # encoding: [0x7b,0x00,0x4a,0x8d]
+
+# XGOT:      lui    $10, 10                 # encoding: [0x0a,0x00,0x0a,0x3c]
+# XGOT-NEXT: addu   $10, $10, $4            # encoding: [0x21,0x50,0x44,0x01]
+# XGOT-NEXT: lw     $10, 123($10)           # encoding: [0x7b,0x00,0x4a,0x8d]
   sw $10, 123456($9)
 # GOT:      lui     $1, 2                   # encoding: [0x02,0x00,0x01,0x3c]
 # GOT-NEXT: addu    $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
 # GOT-NEXT: sw      $10, -7616($1)          # encoding: [0x40,0xe2,0x2a,0xac]
 
+# XGOT:      lui    $1, 2                   # encoding: [0x02,0x00,0x01,0x3c]
+# XGOT-NEXT: addu   $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
+# XGOT-NEXT: sw     $10, -7616($1)          # encoding: [0x40,0xe2,0x2a,0xac]
+
   lw $8, symbol+8
 # GOT:      lw      $8, %got(symbol)($gp)   # encoding: [A,A,0x88,0x8f]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %got(symbol), kind: fixup_Mips_GOT
 # GOT-NEXT: lw      $8, 8($8)               # encoding: [0x08,0x00,0x08,0x8d]
+
+# XGOT:      lui    $8, %got_hi(symbol)     # encoding: [A,A,0x08,0x3c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: addu   $8, $8, $gp             # encoding: [0x21,0x40,0x1c,0x01]
+# XGOT-NEXT: lw     $8, %got_lo(symbol)($8) # encoding: [A,A,0x08,0x8d]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: lw     $8, 8($8)               # encoding: [0x08,0x00,0x08,0x8d]
   sw $8, symbol+8
 # GOT:      lw      $1, %got(symbol)($gp)   # encoding: [A,A,0x81,0x8f]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %got(symbol), kind: fixup_Mips_GOT
 # GOT-NEXT: sw $8, 8($1)                    # encoding: [0x08,0x00,0x28,0xac]
 
+# XGOT:      lui    $1, %got_hi(symbol)     # encoding: [A,A,0x01,0x3c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: addu   $1, $1, $gp             # encoding: [0x21,0x08,0x3c,0x00]
+# XGOT-NEXT: lw     $1, %got_lo(symbol)($1) # encoding: [A,A,0x21,0x8c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: sw     $8, 8($1)               # encoding: [0x08,0x00,0x28,0xac]
+
   ldc1 $f0, symbol
 # GOT:      lw      $1, %got(symbol)($gp)   # encoding: [A,A,0x81,0x8f]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %got(symbol), kind: fixup_Mips_GOT
 # GOT-NEXT: ldc1    $f0, 0($1)              # encoding: [0x00,0x00,0x20,0xd4]
+
+# XGOT:      lui    $1, %got_hi(symbol)     # encoding: [A,A,0x01,0x3c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: addu   $1, $1, $gp             # encoding: [0x21,0x08,0x3c,0x00]
+# XGOT-NEXT: lw     $1, %got_lo(symbol)($1) # encoding: [A,A,0x21,0x8c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: ldc1   $f0, 0($1)              # encoding: [0x00,0x00,0x20,0xd4]
   sdc1 $f0, symbol
 # GOT:      lw      $1, %got(symbol)($gp)   # encoding: [A,A,0x81,0x8f]
 # GOT-NEXT:                                 #   fixup A - offset: 0, value: %got(symbol), kind: fixup_Mips_GOT
 # GOT-NEXT: sdc1    $f0, 0($1)              # encoding: [0x00,0x00,0x20,0xf4]
+
+# XGOT:      lui    $1, %got_hi(symbol)     # encoding: [A,A,0x01,0x3c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: addu   $1, $1, $gp             # encoding: [0x21,0x08,0x3c,0x00]
+# XGOT-NEXT: lw     $1, %got_lo(symbol)($1) # encoding: [A,A,0x21,0x8c]
+# XGOT-NEXT:                                #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: sdc1   $f0, 0($1)              # encoding: [0x00,0x00,0x20,0xf4]
   .option pic0
 
 # Test BNE with an immediate as the 2nd operand.
   bne $2, 0, 1332
 # CHECK-LE: bnez  $2, 1332          # encoding: [0x4d,0x01,0x40,0x14]
 # CHECK-LE: nop                     # encoding: [0x00,0x00,0x00,0x00]
 
   bne $2, 123, 1332

llvm/test/MC/Mips/mips64-expansions.s

 # RUN: llvm-mc %s -triple=mips64el-unknown-linux -mcpu=mips64r2 \
 # RUN:            -show-encoding | FileCheck --check-prefixes=CHECK,GOT %s
 
 # Check that signed negative 32-bit immediates are loaded correctly:
   li $10, ~(0x101010)
 # CHECK: lui $10, 65519        # encoding: [0xef,0xff,0x0a,0x3c]
 # CHECK: ori $10, $10, 61423   # encoding: [0xef,0xef,0x4a,0x35]
 # CHECK-NOT: dsll
 
 # Test bne with an immediate as the 2nd operand.
   bne $2, 0x100010001, 1332

 
 # LW/SW and LDC1/SDC1 of symbol address, done by MipsAsmParser::expandMemInst():
   .option pic2
   lw $10, symbol($4)
 # GOT:      ld      $10, %got_disp(symbol)($gp) # encoding: [A,A,0x8a,0xdf]
 # GOT-NEXT:                                     #   fixup A - offset: 0, value: %got_disp(symbol), kind: fixup_Mips_GOT_DISP
 # GOT-NEXT: daddu   $10, $10, $4                # encoding: [0x2d,0x50,0x44,0x01]
 # GOT-NEXT: lw      $10, 0($10)                 # encoding: [0x00,0x00,0x4a,0x8d]
+
+# XGOT:      lui    $10, %got_hi(symbol)        # encoding: [A,A,0x0a,0x3c]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: daddu  $10, $10, $gp               # encoding: [0x2d,0x50,0x5c,0x01]
+# XGOT-NEXT: ld     $10, %got_lo(symbol)($10)   # encoding: [A,A,0x4a,0xdd]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: daddu  $10, $10, $4                # encoding: [0x2d,0x50,0x44,0x01]
+# XGOT-NEXT: lw     $10, 0($10)                 # encoding: [0x00,0x00,0x4a,0x8d]
+
   sw $10, symbol($9)
 # GOT:      ld      $1, %got_disp(symbol)($gp)  # encoding: [A,A,0x81,0xdf]
 # GOT-NEXT:                                     #   fixup A - offset: 0, value: %got_disp(symbol), kind: fixup_Mips_GOT_DISP
 # GOT-NEXT: daddu   $1, $1, $9                  # encoding: [0x2d,0x08,0x29,0x00]
 # GOT-NEXT: sw      $10, 0($1)                  # encoding: [0x00,0x00,0x2a,0xac]
 
+# XGOT:      lui    $1, %got_hi(symbol)         # encoding: [A,A,0x01,0x3c]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: daddu  $1, $1, $gp                 # encoding: [0x2d,0x08,0x3c,0x00]
+# XGOT-NEXT: ld     $1, %got_lo(symbol)($1)     # encoding: [A,A,0x21,0xdc]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: daddu  $1, $1, $9                  # encoding: [0x2d,0x08,0x29,0x00]
+# XGOT-NEXT: sw     $10, 0($1)                  # encoding: [0x00,0x00,0x2a,0xac]
+
   lw $8, sym+8
 # GOT:      ld      $8, %got_disp(sym)($gp)     # encoding: [A,A,0x88,0xdf]
 # GOT-NEXT:                                     #   fixup A - offset: 0, value: %got_disp(sym), kind: fixup_Mips_GOT_DISP
 # GOT-NEXT: lw      $8, 8($8)                   # encoding: [0x08,0x00,0x08,0x8d]
+
+# XGOT:      ld     $8, %got_disp(sym)($gp)     # encoding: [A,A,0x88,0xdf]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_disp(sym), kind: fixup_Mips_GOT_DISP
+# XGOT-NEXT: lw     $8, 8($8)                   # encoding: [0x08,0x00,0x08,0x8d]
+
   sw $8, sym+8
 # GOT:      ld      $1, %got_disp(sym)($gp)     # encoding: [A,A,0x81,0xdf]
 # GOT-NEXT:                                     #   fixup A - offset: 0, value: %got_disp(sym), kind: fixup_Mips_GOT_DISP
 # GOT-NEXT: sw      $8, 8($1)                   # encoding: [0x08,0x00,0x28,0xac]
 
+# XGOT:      ld     $1, %got_disp(sym)($gp)     # encoding: [A,A,0x81,0xdf]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_disp(sym), kind: fixup_Mips_GOT_DISP
+# XGOT-NEXT: sw     $8, 8($1)                   # encoding: [0x08,0x00,0x28,0xac]
+
   lw $10, 655483($4)
 # GOT:      lui     $10, 10                     # encoding: [0x0a,0x00,0x0a,0x3c]
 # GOT-NEXT: daddu   $10, $10, $4                # encoding: [0x2d,0x50,0x44,0x01]
 # GOT-NEXT: lw      $10, 123($10)               # encoding: [0x7b,0x00,0x4a,0x8d]
+
+# XGOT:      lui    $10, 10                     # encoding: [0x0a,0x00,0x0a,0x3c]
+# XGOT-NEXT: daddu  $10, $10, $4                # encoding: [0x2d,0x50,0x44,0x01]
+# XGOT-NEXT: lw     $10, 123($10)               # encoding: [0x7b,0x00,0x4a,0x8d]
   sw $10, 123456($9)
 # GOT:      lui     $1, 2                       # encoding: [0x02,0x00,0x01,0x3c]
 # GOT-NEXT: daddu   $1, $1, $9                  # encoding: [0x2d,0x08,0x29,0x00]
 # GOT-NEXT: sw      $10, -7616($1)              # encoding: [0x40,0xe2,0x2a,0xac]
 
+# XGOT:      lui    $1, 2                       # encoding: [0x02,0x00,0x01,0x3c]
+# XGOT-NEXT: daddu  $1, $1, $9                  # encoding: [0x2d,0x08,0x29,0x00]
+# XGOT-NEXT: sw     $10, -7616($1)              # encoding: [0x40,0xe2,0x2a,0xac]
+
   lw $8, symbol+8
 # GOT:      ld      $8, %got_disp(symbol)($gp)  # encoding: [A,A,0x88,0xdf]
 # GOT-NEXT:                                     #   fixup A - offset: 0, value: %got_disp(symbol), kind: fixup_Mips_GOT_DISP
 # GOT-NEXT: lw      $8, 8($8)                   # encoding: [0x08,0x00,0x08,0x8d]
+
+# XGOT:      lui    $8, %got_hi(symbol)         # encoding: [A,A,0x08,0x3c]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: daddu  $8, $8, $gp                 # encoding: [0x2d,0x40,0x1c,0x01]
+# XGOT-NEXT: ld     $8, %got_lo(symbol)($8)     # encoding: [A,A,0x08,0xdd]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: lw     $8, 8($8)                   # encoding: [0x08,0x00,0x08,0x8d]
+
   sw $8, symbol+8
 # GOT:      ld      $1, %got_disp(symbol)($gp)  # encoding: [A,A,0x81,0xdf]
 # GOT-NEXT:                                     #   fixup A - offset: 0, value: %got_disp(symbol), kind: fixup_Mips_GOT_DISP
 # GOT-NEXT: sw $8, 8($1)                        # encoding: [0x08,0x00,0x28,0xac]
 
+# XGOT:      lui    $1, %got_hi(symbol)         # encoding: [A,A,0x01,0x3c]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: daddu  $1, $1, $gp                 # encoding: [0x2d,0x08,0x3c,0x00]
+# XGOT-NEXT: ld     $1, %got_lo(symbol)($1)     # encoding: [A,A,0x21,0xdc]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: sw     $8, 8($1)                   # encoding: [0x08,0x00,0x28,0xac]
+
   ldc1 $f0, symbol
 # GOT:      ld      $1, %got_disp(symbol)($gp) # encoding: [A,A,0x81,0xdf]
 # GOT-NEXT:                                    #   fixup A - offset: 0, value: %got_disp(symbol), kind: fixup_Mips_GOT_DISP
 # GOT-NEXT: ldc1    $f0, 0($1)                 # encoding: [0x00,0x00,0x20,0xd4]
+
+# XGOT:      lui    $1, %got_hi(symbol)         # encoding: [A,A,0x01,0x3c]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: daddu  $1, $1, $gp                 # encoding: [0x2d,0x08,0x3c,0x00]
+# XGOT-NEXT: ld     $1, %got_lo(symbol)($1)     # encoding: [A,A,0x21,0xdc]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: ldc1   $f0, 0($1)                  # encoding: [0x00,0x00,0x20,0xd4]
+
   sdc1 $f0, symbol
 # GOT:      ld      $1, %got_disp(symbol)($gp) # encoding: [A,A,0x81,0xdf]
 # GOT-NEXT:                                    #   fixup A - offset: 0, value: %got_disp(symbol), kind: fixup_Mips_GOT_DISP
 # GOT-NEXT: sdc1    $f0, 0($1)                 # encoding: [0x00,0x00,0x20,0xf4]
+
+# XGOT:      lui    $1, %got_hi(symbol)         # encoding: [A,A,0x01,0x3c]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_hi(symbol), kind: fixup_Mips_GOT_HI16
+# XGOT-NEXT: daddu  $1, $1, $gp                 # encoding: [0x2d,0x08,0x3c,0x00]
+# XGOT-NEXT: ld     $1, %got_lo(symbol)($1)     # encoding: [A,A,0x21,0xdc]
+# XGOT-NEXT:                                    #   fixup A - offset: 0, value: %got_lo(symbol), kind: fixup_Mips_GOT_LO16
+# XGOT-NEXT: sdc1   $f0, 0($1)                  # encoding: [0x00,0x00,0x20,0xf4]