[mips] [IAS] Fix expansion of LASym with positive offset.

[tomatabacu]

Summary

Instead of creating the MCSymbolRefExpr's manually, we can use evaluateRelocExpr().
This gives us the ability to correctly handle MCBinaryExpr's for LASym.

[tomatabacu]

Rebased.

[dsanders]

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2506–2507

Despite it's name, I don't think this is really evaluating expressions. It seems to be simplifying them.

2506–2565

This code seems suspicious. For example, the MCBinaryExpr path tries to apply the RelocStr to both sides of the operator but it's easy to think of cases where this is incorrect. For example %hi(symbol+1) is not equivalent to %hi(symbol) + %hi(1) when symbol==0. The former results in %hi(1) = 0 while the latter results in %hi(0) + %hi(1) = 1.

test/MC/Mips/mips-expansions.s

26–42

These look wrong to me. I'd expect the same expression inside both the %hi and %lo's like so:
lui $8, %hi(symbol+1)
ori $8, $8, %lo(symbol+1)
lui $8, %hi(symbol+32770)
ori $8, $8, %lo(symbol+32770)
lui $8, %hi(symbol+65538)
ori $8, $8, %lo(symbol+65538)
lui $8, %hi(symbol+1118481)
ori $8, $8, %lo(symbol+1118481)

[tomatabacu]

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

2506–2565

It's true that this function needs to be revised a bit, but I don't think it should be a blocker for this patch, as long as the output is semantically equivalent to GAS' (see my reply to the comment below).

test/MC/Mips/mips-expansions.s

26–42

AFAICT the examples you give do not match GAS' output.
The expansions from the patch are closer to the ones from GAS, the only difference being that GAS uses ADDiu and we use ORi.

[tomatabacu]

Rebased (for Sean's convenience).

[tomatabacu]

Abandoned due to existing problems with evaluateRelocExpr().

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

void MipsAsmParser::expandLoadAddressSym(
     const MCOperand *DstRegOp, const MCOperand *SymOp, bool Is32BitSym,
     SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
   if (Is32BitSym && isGP64bit())
     Warning(IDLoc,
             "instruction loads a 32-bit address on a 64-bit architecture");
 
   MCInst tmpInst;
   unsigned RegNo = DstRegOp->getReg();
-  const MCSymbolRefExpr *Symbol = cast<MCSymbolRefExpr>(SymOp->getExpr());
-  const MCSymbolRefExpr *HiExpr =
-      MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
-                              MCSymbolRefExpr::VK_Mips_ABS_HI, getContext());
-  const MCSymbolRefExpr *LoExpr =
-      MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
-                              MCSymbolRefExpr::VK_Mips_ABS_LO, getContext());
+
+  const MCExpr *HiExpr = evaluateRelocExpr(SymOp->getExpr(), "hi");
+  const MCExpr *LoExpr = evaluateRelocExpr(SymOp->getExpr(), "lo");
+
   if (!Is32BitSym) {
     // If it's a 64-bit architecture, expand to:
     // la d,sym => lui  d,highest(sym)
     //             ori  d,d,higher(sym)
     //             dsll d,d,16
     //             ori  d,d,hi16(sym)
     //             dsll d,d,16
     //             ori  d,d,lo16(sym)
-    const MCSymbolRefExpr *HighestExpr =
-        MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
-                                MCSymbolRefExpr::VK_Mips_HIGHEST, getContext());
-    const MCSymbolRefExpr *HigherExpr =
-        MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
-                                MCSymbolRefExpr::VK_Mips_HIGHER, getContext());
+    const MCExpr *HighestExpr = evaluateRelocExpr(SymOp->getExpr(), "highest");
+    const MCExpr *HigherExpr = evaluateRelocExpr(SymOp->getExpr(), "higher");
 
     tmpInst.setOpcode(Mips::LUi);
     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
     tmpInst.addOperand(MCOperand::CreateExpr(HighestExpr));
     Instructions.push_back(tmpInst);
 
     createLShiftOri<0>(MCOperand::CreateExpr(HigherExpr), RegNo, SMLoc(),
                          Instructions);
case AsmToken::Percent: {
 
     Operands.push_back(MipsOperand::CreateImm(IdVal, S, E, *this));
     return false;
   } // case AsmToken::Percent
   } // switch(getLexer().getKind())
   return true;
 }
 
 const MCExpr *MipsAsmParser::evaluateRelocExpr(const MCExpr *Expr,
                                                StringRef RelocStr) {
   const MCExpr *Res;
   // Check the type of the expression.
   if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Expr)) {
     // It's a constant, evaluate reloc value.
     int16_t Val;
     switch (getVariantKind(RelocStr)) {
     case MCSymbolRefExpr::VK_Mips_ABS_LO:
       // Get the 1st 16-bits.
       Val = MCE->getValue() & 0xffff;
       break;
     case MCSymbolRefExpr::VK_Mips_ABS_HI:
       // Get the 2nd 16-bits. Also add 1 if bit 15 is 1, to compensate for low
       // 16 bits being negative.
       Val = ((MCE->getValue() + 0x8000) >> 16) & 0xffff;
       break;
     case MCSymbolRefExpr::VK_Mips_HIGHER:
       // Get the 3rd 16-bits.
       Val = ((MCE->getValue() + 0x80008000LL) >> 32) & 0xffff;
       break;
     case MCSymbolRefExpr::VK_Mips_HIGHEST:
       // Get the 4th 16-bits.
       Val = ((MCE->getValue() + 0x800080008000LL) >> 48) & 0xffff;
       break;
     default:
       report_fatal_error("unsupported reloc value");
     }
     return MCConstantExpr::Create(Val, getContext());
   }
 
   if (const MCSymbolRefExpr *MSRE = dyn_cast<MCSymbolRefExpr>(Expr)) {
     // It's a symbol, create a symbolic expression from the symbol.
     StringRef Symbol = MSRE->getSymbol().getName();
     MCSymbolRefExpr::VariantKind VK = getVariantKind(RelocStr);
     Res = MCSymbolRefExpr::Create(Symbol, VK, getContext());
     return Res;
   }
 
   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr)) {
     MCSymbolRefExpr::VariantKind VK = getVariantKind(RelocStr);
 
     // Try to create target expression.
     if (MipsMCExpr::isSupportedBinaryExpr(VK, BE))
       return MipsMCExpr::Create(VK, Expr, getContext());
 
     const MCExpr *LExp = evaluateRelocExpr(BE->getLHS(), RelocStr);
     const MCExpr *RExp = evaluateRelocExpr(BE->getRHS(), RelocStr);
     Res = MCBinaryExpr::Create(BE->getOpcode(), LExp, RExp, getContext());
     return Res;
   }
 
   if (const MCUnaryExpr *UN = dyn_cast<MCUnaryExpr>(Expr)) {
     const MCExpr *UnExp = evaluateRelocExpr(UN->getSubExpr(), RelocStr);
     Res = MCUnaryExpr::Create(UN->getOpcode(), UnExp, getContext());
     return Res;
   }
   // Just return the original expression.
   return Expr;
 }
 
 bool MipsAsmParser::isEvaluated(const MCExpr *Expr) {
 
   switch (Expr->getKind()) {
   case MCExpr::Constant:
     return true;
   case MCExpr::SymbolRef:
     return (cast<MCSymbolRefExpr>(Expr)->getKind() != MCSymbolRefExpr::VK_None);

test/MC/Mips/mips-expansions.s

 # CHECK: ori     $4, $5, 20          # encoding: [0x14,0x00,0xa4,0x34]
 # CHECK: lui     $7, 1               # encoding: [0x01,0x00,0x07,0x3c]
 # CHECK: ori     $7, $7, 2           # encoding: [0x02,0x00,0xe7,0x34]
 # CHECK: addu    $7, $7, $8          # encoding: [0x21,0x38,0xe8,0x00]
 # CHECK: lui     $8, %hi(symbol)     # encoding: [A,A,0x08,0x3c]
                                      #   fixup A - offset: 0, value: symbol@ABS_HI, kind: fixup_Mips_HI16
 # CHECK: ori     $8, $8, %lo(symbol) # encoding: [A,A,0x08,0x35]
                                      #   fixup A - offset: 0, value: symbol@ABS_LO, kind: fixup_Mips_LO16
+# CHECK: lui $8, %hi(symbol)           # encoding: [A,A,0x08,0x3c]
+# CHECK:                               #   fixup A - offset: 0, value: symbol@ABS_HI, kind: fixup_Mips_HI16
+# CHECK: ori $8, $8, %lo(symbol+1)     # encoding: [0x01'A',A,0x08,0x35]
+# CHECK:                               #   fixup A - offset: 0, value: symbol@ABS_LO, kind: fixup_Mips_LO16
+# CHECK: lui $8, %hi(symbol+1)         # encoding: [0x01'A',A,0x08,0x3c]
+# CHECK:                               #   fixup A - offset: 0, value: symbol@ABS_HI, kind: fixup_Mips_HI16
+# CHECK: ori $8, $8, %lo(symbol-32766) # encoding: [0x02'A',0x80'A',0x08,0x35]
+# CHECK:                               #   fixup A - offset: 0, value: symbol@ABS_LO, kind: fixup_Mips_LO16
+# CHECK: lui $8, %hi(symbol+1)         # encoding: [0x01'A',A,0x08,0x3c]
+# CHECK:                               #   fixup A - offset: 0, value: symbol@ABS_HI, kind: fixup_Mips_HI16
+# CHECK: ori $8, $8, %lo(symbol+2)     # encoding: [0x02'A',A,0x08,0x35]
+# CHECK:                               #   fixup A - offset: 0, value: symbol@ABS_LO, kind: fixup_Mips_LO16
+# CHECK: lui $8, %hi(symbol+1)         # encoding: [0x01'A',A,0x08,0x3c]
+# CHECK:                               #   fixup A - offset: 0, value: symbol@ABS_HI, kind: fixup_Mips_HI16
+# CHECK: ori $8, $8, %lo(symbol+4369)  # encoding: [0x11'A',0x11'A',0x08,0x35]
+# CHECK:                               #   fixup A - offset: 0, value: symbol@ABS_LO, kind: fixup_Mips_LO16
+
 # CHECK: lui     $10, %hi(symbol)        # encoding: [A,A,0x0a,0x3c]
 # CHECK:                                 #   fixup A - offset: 0, value: symbol@ABS_HI, kind: fixup_Mips_HI16
 # CHECK: addu    $10, $10, $4            # encoding: [0x21,0x50,0x44,0x01]
 # CHECK: lw      $10, %lo(symbol)($10)   # encoding: [A,A,0x4a,0x8d]
 # CHECK:                                 #   fixup A - offset: 0, value: symbol@ABS_LO, kind: fixup_Mips_LO16
 # CHECK: lui     $1, %hi(symbol)         # encoding: [A,A,0x01,0x3c]
 # CHECK:                                 #   fixup A - offset: 0, value: symbol@ABS_HI, kind: fixup_Mips_HI16
 # CHECK: addu    $1, $1, $9              # encoding: [0x21,0x08,0x29,0x00]
# CHECK: sdc1    $f0, %lo(symbol)($1)
     li $8, ~7
     li $9, 0x10000
 
     la $a0, 20
     la $7,65538
     la $a0, 20($a1)
     la $7,65538($8)
     la $t0, symbol
+    la $8, symbol+1
+    la $8, symbol+32770
+    la $8, symbol+65538
+    la $8, symbol+0x11111
 
     .set noat
     lw  $t2, symbol($a0)
     .set at
     sw  $t2, symbol($t1)
 
     lw  $t2, 655483($a0)
     sw  $t2, 123456($t1)
 
     lw  $8, symbol
     sw  $8, symbol
 
     ldc1 $f0, symbol
     sdc1 $f0, symbol