[MIPS] Modify LongBranch expansion to work with sandboxing

lib/Target/Mips/MCTargetDesc/MipsAsmBackend.cpp

 //===-- MipsASMBackend.cpp - Mips Asm Backend  ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the MipsAsmBackend and MipsELFObjectWriter classes.
 //
 //===----------------------------------------------------------------------===//
 //
 
 #include "MipsFixupKinds.h"
 #include "MCTargetDesc/MipsMCTargetDesc.h"
-#include "MCTargetDesc/MipsMCNaCl.h" // @LOCALMOD
+// @LOCALMOD-START
+#include "MCTargetDesc/MipsMCNaCl.h"
+#include "llvm/MC/MCAsmLayout.h"
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCValue.h"
+// @LOCALMOD-END
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ skipping 63 matching lines @@
 public:
   MipsAsmBackend(const Target &T,  Triple::OSType _OSType,
                  bool _isLittle, bool _is64Bit)
     :MCAsmBackend(), OSType(_OSType), IsLittle(_isLittle), Is64Bit(_is64Bit) {}
 
   MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
     return createMipsELFObjectWriter(OS,
       MCELFObjectTargetWriter::getOSABI(OSType), IsLittle, Is64Bit);
   }
 
+  // @LOCALMOD-START
+  /// processFixupValue - Target hook to process the literal value of a fixup
+  /// if necessary.
+  void processFixupValue(const MCAssembler &Asm, const MCAsmLayout &Layout,

[Mark Seaborn, 2013/11/28 03:37:02]

Can you send this part to upstream LLVM?  You can post it to llvm-commits and CC
me to review it.  This part is generally useful and not
NaCl-sandboxing-specific, so I'd like to minimise the number of localmods in our
branch.

When you do that, can you add an MC-level test for this relocation handling?

+                         const MCFixup &Fixup, const MCFragment *DF,
+                         MCValue &Target, uint64_t &Value,
+                         bool &IsResolved) {
+    if ((unsigned)Fixup.getKind() == Mips::fixup_Mips_HI16
+        || (unsigned)Fixup.getKind() == Mips::fixup_Mips_LO16) {
+
+      // Check for expressions %hi(tmp) and %lo(tmp), where tmp = sym1-sym2.

[Mark Seaborn, 2013/11/28 03:37:02]

This part isn't MIPS specific, so I wonder if you can reuse some existing
arch-independent code for doing this subtraction?

MIPS MC can already handle assembly code like this:
  .4byte sym1 - sym2
which occurs in C++ exception info.  Presumably that is handled by an
arch-independent part of MC?

+      if (Target.getSymA() != NULL && Target.getSymA()->getSymbol().isVariable()
+          && Target.getSymB() == NULL && Target.getConstant() == 0) {
+        const MCExpr *SymValue = Target.getSymA()->getSymbol()
+                                       .getVariableValue();
+        const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(SymValue);
+        if (BE && BE->getOpcode() == MCBinaryExpr::Sub) {
+          const MCSymbolRefExpr *LHS = dyn_cast<MCSymbolRefExpr>(BE->getLHS());
+          const MCSymbolRefExpr *RHS = dyn_cast<MCSymbolRefExpr>(BE->getRHS());
+          if (LHS != NULL && LHS->getSymbol().isDefined()
+              && RHS != NULL && RHS->getSymbol().isDefined()) {
+            // Don't emit relocation for expressions %hi(tmp) and %lo(tmp),
+            // where tmp = sym1-sym2.
+            IsResolved = true;
+
+            // Calculate symbol value.
+            uint64_t Value1 =
+              Layout.getSymbolOffset(&Asm.getSymbolData(LHS->getSymbol()));
+            uint64_t Value2 =
+              Layout.getSymbolOffset(&Asm.getSymbolData(RHS->getSymbol()));
+            Value = Value1 - Value2;
+          }
+        }
+      }
+    }
+  }
+  // @LOCALMOD-END
+
   /// ApplyFixup - Apply the \p Value for given \p Fixup into the provided
   /// data fragment, at the offset specified by the fixup and following the
   /// fixup kind as appropriate.
   void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
                   uint64_t Value) const {
     MCFixupKind Kind = Fixup.getKind();
     Value = adjustFixupValue((unsigned)Kind, Value);
 
     if (!Value)
       return; // Doesn't change encoding.
@@ skipping 179 matching lines @@
   // @LOCALMOD-END
   return new MipsAsmBackend(T, Triple(TT).getOS(),
                             /*IsLittle*/true, /*Is64Bit*/true);
 }
 
 MCAsmBackend *llvm::createMipsAsmBackendEB64(const Target &T, StringRef TT,
                                              StringRef CPU) {
   return new MipsAsmBackend(T, Triple(TT).getOS(),
                             /*IsLittle*/false, /*Is64Bit*/true);
 }