CbC/CbC_llvm: lib/MC/MCExpr.cpp comparison

comparison lib/MC/MCExpr.cpp @ 77:54457678186b LLVM3.6

LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Mon, 08 Sep 2014 22:06:00 +0900
parents	e4204d083e25
children	60c9769439b8

comparison

equal deleted inserted replaced

-:e874dbf0ad9d
+:54457678186b
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#define DEBUG_TYPE "mcexpr"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
+#define DEBUG_TYPE "mcexpr"
 namespace {
 namespace stats {
 STATISTIC(MCExprEvaluate, "Number of MCExpr evaluations");
 }
 case VK_TLSLD: return "TLSLD";
 case VK_TLSLDM: return "TLSLDM";
 case VK_TPOFF: return "TPOFF";
 case VK_DTPOFF: return "DTPOFF";
 case VK_TLVP: return "TLVP";
+case VK_TLVPPAGE: return "TLVPPAGE";
+case VK_TLVPPAGEOFF: return "TLVPPAGEOFF";
+case VK_PAGE: return "PAGE";
+case VK_PAGEOFF: return "PAGEOFF";
+case VK_GOTPAGE: return "GOTPAGE";
+case VK_GOTPAGEOFF: return "GOTPAGEOFF";
 case VK_SECREL: return "SECREL32";
+case VK_WEAKREF: return "WEAKREF";
 case VK_ARM_NONE: return "none";
 case VK_ARM_TARGET1: return "target1";
 case VK_ARM_TARGET2: return "target2";
 case VK_ARM_PREL31: return "prel31";
+case VK_ARM_TLSLDO: return "tlsldo";
+case VK_ARM_TLSCALL: return "tlscall";
+case VK_ARM_TLSDESC: return "tlsdesc";
+case VK_ARM_TLSDESCSEQ: return "tlsdescseq";
 case VK_PPC_LO: return "l";
 case VK_PPC_HI: return "h";
 case VK_PPC_HA: return "ha";
 case VK_PPC_HIGHER: return "higher";
 case VK_PPC_HIGHERA: return "highera";
 case VK_Mips_HIGHEST:  return "HIGHEST";
 case VK_Mips_GOT_HI16: return "GOT_HI16";
 case VK_Mips_GOT_LO16: return "GOT_LO16";
 case VK_Mips_CALL_HI16: return "CALL_HI16";
 case VK_Mips_CALL_LO16: return "CALL_LO16";
+case VK_Mips_PCREL_HI16: return "PCREL_HI16";
+case VK_Mips_PCREL_LO16: return "PCREL_LO16";
 case VK_COFF_IMGREL32: return "IMGREL32";
 }
 llvm_unreachable("Invalid variant kind");
 }
 .Case("got", VK_GOT)
 .Case("GOTOFF", VK_GOTOFF)
 .Case("gotoff", VK_GOTOFF)
 .Case("GOTPCREL", VK_GOTPCREL)
 .Case("gotpcrel", VK_GOTPCREL)
+.Case("GOT_PREL", VK_GOTPCREL)
+.Case("got_prel", VK_GOTPCREL)
 .Case("GOTTPOFF", VK_GOTTPOFF)
 .Case("gottpoff", VK_GOTTPOFF)
 .Case("INDNTPOFF", VK_INDNTPOFF)
 .Case("indntpoff", VK_INDNTPOFF)
 .Case("NTPOFF", VK_NTPOFF)
 .Case("tpoff", VK_TPOFF)
 .Case("DTPOFF", VK_DTPOFF)
 .Case("dtpoff", VK_DTPOFF)
 .Case("TLVP", VK_TLVP)
 .Case("tlvp", VK_TLVP)
+.Case("TLVPPAGE", VK_TLVPPAGE)
+.Case("tlvppage", VK_TLVPPAGE)
+.Case("TLVPPAGEOFF", VK_TLVPPAGEOFF)
+.Case("tlvppageoff", VK_TLVPPAGEOFF)
+.Case("PAGE", VK_PAGE)
+.Case("page", VK_PAGE)
+.Case("PAGEOFF", VK_PAGEOFF)
+.Case("pageoff", VK_PAGEOFF)
+.Case("GOTPAGE", VK_GOTPAGE)
+.Case("gotpage", VK_GOTPAGE)
+.Case("GOTPAGEOFF", VK_GOTPAGEOFF)
+.Case("gotpageoff", VK_GOTPAGEOFF)
 .Case("IMGREL", VK_COFF_IMGREL32)
 .Case("imgrel", VK_COFF_IMGREL32)
 .Case("SECREL32", VK_SECREL)
 .Case("secrel32", VK_SECREL)
 .Case("L", VK_PPC_LO)
 .Case("target1", VK_ARM_TARGET1)
 .Case("TARGET2", VK_ARM_TARGET2)
 .Case("target2", VK_ARM_TARGET2)
 .Case("PREL31", VK_ARM_PREL31)
 .Case("prel31", VK_ARM_PREL31)
+.Case("TLSLDO", VK_ARM_TLSLDO)
+.Case("tlsldo", VK_ARM_TLSLDO)
+.Case("TLSCALL", VK_ARM_TLSCALL)
+.Case("tlscall", VK_ARM_TLSCALL)
+.Case("TLSDESC", VK_ARM_TLSDESC)
+.Case("tlsdesc", VK_ARM_TLSDESC)
 .Default(VK_Invalid);
 }
 /* *** */
 void MCTargetExpr::anchor() {}
 /* *** */
 bool MCExpr::EvaluateAsAbsolute(int64_t &Res) const {
-return EvaluateAsAbsolute(Res, 0, 0, 0);
+return EvaluateAsAbsolute(Res, nullptr, nullptr, nullptr);
 }
 bool MCExpr::EvaluateAsAbsolute(int64_t &Res,
 const MCAsmLayout &Layout) const {
-return EvaluateAsAbsolute(Res, &Layout.getAssembler(), &Layout, 0);
+return EvaluateAsAbsolute(Res, &Layout.getAssembler(), &Layout, nullptr);
 }
 bool MCExpr::EvaluateAsAbsolute(int64_t &Res,
 const MCAsmLayout &Layout,
 const SectionAddrMap &Addrs) const {
 return EvaluateAsAbsolute(Res, &Layout.getAssembler(), &Layout, &Addrs);
 }
 bool MCExpr::EvaluateAsAbsolute(int64_t &Res, const MCAssembler &Asm) const {
-return EvaluateAsAbsolute(Res, &Asm, 0, 0);
+return EvaluateAsAbsolute(Res, &Asm, nullptr, nullptr);
+}
+int64_t MCExpr::evaluateKnownAbsolute(const MCAsmLayout &Layout) const {
+int64_t Res;
+bool Abs =
+evaluateAsAbsolute(Res, &Layout.getAssembler(), &Layout, nullptr, true);
+(void)Abs;
+assert(Abs && "Not actually absolute");
+return Res;
 }
 bool MCExpr::EvaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
 const MCAsmLayout *Layout,
 const SectionAddrMap *Addrs) const {
+// FIXME: The use if InSet = Addrs is a hack. Setting InSet causes us
+// absolutize differences across sections and that is what the MachO writer
+// uses Addrs for.
+return evaluateAsAbsolute(Res, Asm, Layout, Addrs, Addrs);
+}
+bool MCExpr::evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
+const MCAsmLayout *Layout,
+const SectionAddrMap *Addrs, bool InSet) const {
 MCValue Value;
 // Fast path constants.
 if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(this)) {
 Res = CE->getValue();
 return true;
 }
-// FIXME: The use if InSet = Addrs is a hack. Setting InSet causes us
+bool IsRelocatable = EvaluateAsRelocatableImpl(
-// absolutize differences across sections and that is what the MachO writer
+Value, Asm, Layout, nullptr, Addrs, InSet, /*ForceVarExpansion*/ false);
-// uses Addrs for.
-bool IsRelocatable =
-EvaluateAsRelocatableImpl(Value, Asm, Layout, Addrs, /*InSet*/ Addrs);
 // Record the current value.
 Res = Value.getConstant();
 return IsRelocatable && Value.isAbsolute();
 return;
 if (!Asm->getWriter().IsSymbolRefDifferenceFullyResolved(*Asm, A, B, InSet))
 return;
-MCSymbolData &AD = Asm->getSymbolData(SA);
+const MCSymbolData &AD = Asm->getSymbolData(SA);
-MCSymbolData &BD = Asm->getSymbolData(SB);
+const MCSymbolData &BD = Asm->getSymbolData(SB);
 if (AD.getFragment() == BD.getFragment()) {
 Addend += (AD.getOffset() - BD.getOffset());
 // Pointers to Thumb symbols need to have their low-bit set to allow
 if (Asm->isThumbFunc(&SA))
 Addend |= 1;
 // Clear the symbol expr pointers to indicate we have folded these
 // operands.
-A = B = 0;
+A = B = nullptr;
 return;
 }
 if (!Layout)
 return;
 if (Asm->isThumbFunc(&SA))
 Addend |= 1;
 // Clear the symbol expr pointers to indicate we have folded these
 // operands.
-A = B = 0;
+A = B = nullptr;
 }
 /// \brief Evaluate the result of an add between (conceptually) two MCValues.
 ///
 /// This routine conceptually attempts to construct an MCValue:
 Res = MCValue::get(A, B, Result_Cst);
 return true;
 }
 bool MCExpr::EvaluateAsRelocatable(MCValue &Res,
-const MCAsmLayout &Layout) const {
+const MCAsmLayout *Layout,
-return EvaluateAsRelocatableImpl(Res, &Layout.getAssembler(), &Layout,
+const MCFixup *Fixup) const {
-0, false);
+MCAssembler *Assembler = Layout ? &Layout->getAssembler() : nullptr;
-}
+return EvaluateAsRelocatableImpl(Res, Assembler, Layout, Fixup, nullptr,
+false, /*ForceVarExpansion*/ false);
-bool MCExpr::EvaluateAsRelocatableImpl(MCValue &Res,
+}
-const MCAssembler *Asm,
+bool MCExpr::EvaluateAsValue(MCValue &Res, const MCAsmLayout *Layout,
+const MCFixup *Fixup) const {
+MCAssembler *Assembler = Layout ? &Layout->getAssembler() : nullptr;
+return EvaluateAsRelocatableImpl(Res, Assembler, Layout, Fixup, nullptr,
+false, /*ForceVarExpansion*/ true);
+}
+bool MCExpr::EvaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
 const MCAsmLayout *Layout,
-const SectionAddrMap *Addrs,
+const MCFixup *Fixup,
-bool InSet) const {
+const SectionAddrMap *Addrs, bool InSet,
+bool ForceVarExpansion) const {
 ++stats::MCExprEvaluate;
 switch (getKind()) {
 case Target:
-return cast<MCTargetExpr>(this)->EvaluateAsRelocatableImpl(Res, Layout);
+return cast<MCTargetExpr>(this)->EvaluateAsRelocatableImpl(Res, Layout,
+Fixup);
 case Constant:
 Res = MCValue::get(cast<MCConstantExpr>(this)->getValue());
 return true;
 case SymbolRef: {
 const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(this);
 const MCSymbol &Sym = SRE->getSymbol();
+const MCAsmInfo &MCAsmInfo = SRE->getMCAsmInfo();
 // Evaluate recursively if this is a variable.
 if (Sym.isVariable() && SRE->getKind() == MCSymbolRefExpr::VK_None) {
-bool Ret = Sym.getVariableValue()->EvaluateAsRelocatableImpl(Res, Asm,
+if (Sym.getVariableValue()->EvaluateAsRelocatableImpl(
-Layout,
+Res, Asm, Layout, Fixup, Addrs, true, ForceVarExpansion)) {
-Addrs,
+const MCSymbolRefExpr *A = Res.getSymA();
-true);
+const MCSymbolRefExpr *B = Res.getSymB();
-// If we failed to simplify this to a constant, let the target
-// handle it.
+if (MCAsmInfo.hasSubsectionsViaSymbols()) {
-if (Ret && !Res.getSymA() && !Res.getSymB())
+// FIXME: This is small hack. Given
-return true;
+// a = b + 4
+// .long a
+// the OS X assembler will completely drop the 4. We should probably
+// include it in the relocation or produce an error if that is not
+// possible.
+if (!A && !B)
+return true;
+} else {
+if (ForceVarExpansion)
+return true;
+bool IsSymbol = A && A->getSymbol().isDefined();
+if (!IsSymbol)
+return true;
+}
+}
 }
-Res = MCValue::get(SRE, 0, 0);
+Res = MCValue::get(SRE, nullptr, 0);
 return true;
 }
 case Unary: {
 const MCUnaryExpr *AUE = cast<MCUnaryExpr>(this);
 MCValue Value;
 if (!AUE->getSubExpr()->EvaluateAsRelocatableImpl(Value, Asm, Layout,
-Addrs, InSet))
+Fixup, Addrs, InSet,
+ForceVarExpansion))
 return false;
 switch (AUE->getOpcode()) {
 case MCUnaryExpr::LNot:
 if (!Value.isAbsolute())
 case Binary: {
 const MCBinaryExpr *ABE = cast<MCBinaryExpr>(this);
 MCValue LHSValue, RHSValue;
 if (!ABE->getLHS()->EvaluateAsRelocatableImpl(LHSValue, Asm, Layout,
-Addrs, InSet) ||
+Fixup, Addrs, InSet,
+ForceVarExpansion) ||
 !ABE->getRHS()->EvaluateAsRelocatableImpl(RHSValue, Asm, Layout,
-Addrs, InSet))
+Fixup, Addrs, InSet,
+ForceVarExpansion))
 return false;
 // We only support a few operations on non-constant expressions, handle
 // those first.
 if (!LHSValue.isAbsolute() || !RHSValue.isAbsolute()) {
 const MCSymbol &Sym = SRE->getSymbol();
 if (Sym.isDefined())
 return &Sym.getSection();
-return 0;
+return nullptr;
 }
 case Unary:
 return cast<MCUnaryExpr>(this)->getSubExpr()->FindAssociatedSection();

Mercurial > hg > CbC > CbC_llvm

comparison lib/MC/MCExpr.cpp @ 77:54457678186b LLVM3.6