MC: Add missing forward in MCLoggingStreamer.

[oota-llvm.git] / lib / MC / ELFObjectWriter.cpp

diff --git a/lib/MC/ELFObjectWriter.cpp b/lib/MC/ELFObjectWriter.cpp
index 72a6cbd5ef44171b4ac04031cacef4740dc6cb90..ac8c250a8337fede05b5fdd92ccda563c7f2f687 100644 (file)
--- a/lib/MC/ELFObjectWriter.cpp
+++ b/lib/MC/ELFObjectWriter.cpp
@@ -445,12 +445,22 @@ void ELFObjectWriterImpl::WriteSymbol(MCDataFragment *F, ELFSymbolData &MSD,
       const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(ESize);
 
       if (BE->EvaluateAsRelocatable(Res, &Layout)) {
-        MCSymbolData &A =
-          Layout.getAssembler().getSymbolData(Res.getSymA()->getSymbol());
-        MCSymbolData &B =
-          Layout.getAssembler().getSymbolData(Res.getSymB()->getSymbol());
+        uint64_t AddressA = 0;
+        uint64_t AddressB = 0;
+        const MCSymbol &SymA = Res.getSymA()->getSymbol();
+        const MCSymbol &SymB = Res.getSymB()->getSymbol();
+
+        if (SymA.isDefined()) {
+          MCSymbolData &A = Layout.getAssembler().getSymbolData(SymA);
+          AddressA = Layout.getSymbolAddress(&A);
+        }
+
+        if (SymB.isDefined()) {
+          MCSymbolData &B = Layout.getAssembler().getSymbolData(SymB);
+          AddressB = Layout.getSymbolAddress(&B);
+        }
 
-        Size = Layout.getSymbolAddress(&A) - Layout.getSymbolAddress(&B);
+        Size = AddressA - AddressB;
       }
     } else if (ESize->getKind() == MCExpr::Constant) {
       Size = static_cast<const MCConstantExpr *>(ESize)->getValue();
@@ -502,8 +512,9 @@ void ELFObjectWriterImpl::WriteSymbolTable(MCDataFragment *F,
   for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i) {
     ELFSymbolData &MSD = ExternalSymbolData[i];
     MCSymbolData &Data = *MSD.SymbolData;
-    assert((Data.getFlags() & ELF_STB_Global) &&
-           "External symbol requires STB_GLOBAL flag");
+    assert(((Data.getFlags() & ELF_STB_Global) ||
+            (Data.getFlags() & ELF_STB_Weak)) &&
+           "External symbol requires STB_GLOBAL or STB_WEAK flag");
     WriteSymbol(F, MSD, Layout);
     if (GetBinding(Data) == ELF::STB_LOCAL)
       LastLocalSymbolIndex++;
@@ -519,7 +530,8 @@ void ELFObjectWriterImpl::WriteSymbolTable(MCDataFragment *F,
 }
 
 static bool ShouldRelocOnSymbol(const MCSymbolData &SD,
-                                const MCValue &Target) {
+                                const MCValue &Target,
+                                const MCFragment &F) {
   const MCSymbol &Symbol = SD.getSymbol();
   if (Symbol.isUndefined())
     return true;
@@ -527,10 +539,18 @@ static bool ShouldRelocOnSymbol(const MCSymbolData &SD,
   const MCSectionELF &Section =
     static_cast<const MCSectionELF&>(Symbol.getSection());
 
+  if (SD.isExternal())
+    return true;
+
   if (Section.getFlags() & MCSectionELF::SHF_MERGE)
     return Target.getConstant() != 0;
 
-  if (SD.isExternal())
+  MCSymbolRefExpr::VariantKind Kind = Target.getSymA()->getKind();
+  const MCSectionELF &Sec2 =
+    static_cast<const MCSectionELF&>(F.getParent()->getSection());
+
+  if (&Sec2 != &Section &&
+      (Kind == MCSymbolRefExpr::VK_PLT || Kind == MCSymbolRefExpr::VK_GOTPCREL))
     return true;
 
   return false;
@@ -577,7 +597,7 @@ void ELFObjectWriterImpl::RecordRelocation(const MCAssembler &Asm,
       return;
     }
 
-    bool RelocOnSymbol = ShouldRelocOnSymbol(SD, Target);
+    bool RelocOnSymbol = ShouldRelocOnSymbol(SD, Target, *Fragment);
     if (!RelocOnSymbol) {
       Index = F->getParent()->getOrdinal();
 
@@ -629,6 +649,9 @@ void ELFObjectWriterImpl::RecordRelocation(const MCAssembler &Asm,
         case MCSymbolRefExpr::VK_GOT:
           Type = ELF::R_X86_64_GOT32;
           break;
+        case llvm::MCSymbolRefExpr::VK_GOTPCREL:
+          Type = ELF::R_X86_64_GOTPCREL;
+          break;
         default:
           llvm_unreachable("Unimplemented");
         }
@@ -726,7 +749,7 @@ void ELFObjectWriterImpl::ComputeSymbolTable(MCAssembler &Asm) {
 
   // Build section lookup table.
   NumRegularSections = Asm.size();
-  DenseMap<const MCSection*, uint8_t> SectionIndexMap;
+  DenseMap<const MCSection*, uint32_t> SectionIndexMap;
   unsigned Index = 1;
   for (MCAssembler::iterator it = Asm.begin(),
          ie = Asm.end(); it != ie; ++it, ++Index)
@@ -797,9 +820,20 @@ void ELFObjectWriterImpl::ComputeSymbolTable(MCAssembler &Asm) {
     MSD.SymbolData = it;
     MSD.StringIndex = Entry;
 
+    // FIXME: There is duplicated code with the local case.
     if (it->isCommon()) {
       MSD.SectionIndex = ELF::SHN_COMMON;
       ExternalSymbolData.push_back(MSD);
+    } else if (Symbol.isVariable()) {
+      const MCExpr *Value = Symbol.getVariableValue();
+      assert (Value->getKind() == MCExpr::SymbolRef && "Unimplemented");
+      const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr*>(Value);
+      const MCSymbol &RefSymbol = Ref->getSymbol();
+      if (RefSymbol.isDefined()) {
+        MSD.SectionIndex = SectionIndexMap.lookup(&RefSymbol.getSection());
+        assert(MSD.SectionIndex && "Invalid section index!");
+        ExternalSymbolData.push_back(MSD);
+      }
     } else if (Symbol.isUndefined()) {
       MSD.SectionIndex = ELF::SHN_UNDEF;
       // FIXME: Undefined symbols are global, but this is the first place we