Index: lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
===================================================================
--- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp	(revision 152265)
+++ lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp	(working copy)
@@ -24,7 +24,8 @@
 bool RuntimeDyldMachO::
 resolveRelocation(uint8_t *LocalAddress,
                   uint64_t FinalAddress,
-                  uint64_t Value,
+                  uint64_t FinalSource1,
+                  uint64_t FinalSource2,
                   bool isPCRel,
                   unsigned Type,
                   unsigned Size,
@@ -32,10 +33,20 @@
   // This just dispatches to the proper target specific routine.
   switch (CPUType) {
   default: llvm_unreachable("Unsupported CPU type!");
+  case mach::CTM_i386:
+    return resolveI386Relocation(LocalAddress,
+                                 FinalAddress,
+                                 FinalSource1,
+                                 FinalSource2,
+                                 isPCRel,
+                                 Type,
+                                 Size,
+                                 Addend);
   case mach::CTM_x86_64:
     return resolveX86_64Relocation(LocalAddress,
                                    FinalAddress,
-                                   (uintptr_t)Value,
+                                   FinalSource1,
+                                   FinalSource2,
                                    isPCRel,
                                    Type,
                                    Size,
@@ -43,7 +54,8 @@
   case mach::CTM_ARM:
     return resolveARMRelocation(LocalAddress,
                                 FinalAddress,
-                                (uintptr_t)Value,
+                                FinalSource1,
+                                FinalSource2,
                                 isPCRel,
                                 Type,
                                 Size,
@@ -52,19 +64,52 @@
 }
 
 bool RuntimeDyldMachO::
+resolveI386Relocation(uint8_t *LocalAddress,
+                      uint64_t FinalAddress,
+                      uint64_t FinalSource1,
+                      uint64_t FinalSource2,
+                      bool isPCRel,
+                      unsigned Type,
+                      unsigned Size,
+                      int64_t Addend) {
+  int64_t ValueToWrite = Addend;
+
+  switch (Type) {
+  default:
+    llvm_unreachable("Invalid relocation type!");
+  case macho::RIT_Vanilla:
+    ValueToWrite += FinalSource1;
+    break;
+  case macho::RIT_Difference:
+  case macho::RIT_Generic_LocalDifference:
+  case macho::RIT_Generic_PreboundLazyPointer:
+    ValueToWrite += FinalSource1;
+    ValueToWrite -= FinalSource2;
+    break;
+  }
+
+  if (isPCRel)
+    ValueToWrite -= FinalAddress + 4; // see resolveX86_64Relocation
+
+  uint8_t *p = LocalAddress;
+  for (unsigned i = 0; i < Size; ++i) {
+    *p++ = (uint8_t)(ValueToWrite & 0xff);
+    ValueToWrite >>= 8;
+  }
+
+  return false;
+}
+
+bool RuntimeDyldMachO::
 resolveX86_64Relocation(uint8_t *LocalAddress,
                         uint64_t FinalAddress,
-                        uint64_t Value,
+                        uint64_t FinalSource1,
+                        uint64_t FinalSource2,
                         bool isPCRel,
                         unsigned Type,
                         unsigned Size,
                         int64_t Addend) {
-  // If the relocation is PC-relative, the value to be encoded is the
-  // pointer difference.
-  if (isPCRel)
-    // FIXME: It seems this value needs to be adjusted by 4 for an effective PC
-    // address. Is that expected? Only for branches, perhaps?
-    Value -= FinalAddress + 4;
+  int64_t ValueToWrite = Addend;
 
   switch(Type) {
   default:
@@ -74,41 +119,53 @@
   case macho::RIT_X86_64_Signed4:
   case macho::RIT_X86_64_Signed:
   case macho::RIT_X86_64_Unsigned:
-  case macho::RIT_X86_64_Branch: {
-    Value += Addend;
-    // Mask in the target value a byte at a time (we don't have an alignment
-    // guarantee for the target address, so this is safest).
-    uint8_t *p = (uint8_t*)LocalAddress;
-    for (unsigned i = 0; i < Size; ++i) {
-      *p++ = (uint8_t)Value;
-      Value >>= 8;
-    }
-    return false;
-  }
+  case macho::RIT_X86_64_Branch:
+    ValueToWrite += FinalSource1;
+    break;
   case macho::RIT_X86_64_GOTLoad:
   case macho::RIT_X86_64_GOT:
   case macho::RIT_X86_64_Subtractor:
   case macho::RIT_X86_64_TLV:
     return Error("Relocation type not implemented yet!");
   }
+
+  // If the relocation is PC-relative, the value to be encoded is the
+  // pointer difference.
+  if (isPCRel)
+    // FIXME: It seems this value needs to be adjusted by 4 for an effective PC
+    // address. Is that expected? Only for branches, perhaps?
+    ValueToWrite -= FinalAddress + 4;
+
+  // Mask in the target value a byte at a time (we don't have an alignment
+  // guarantee for the target address, so this is safest).
+  uint8_t *p = (uint8_t*)LocalAddress;
+  for (unsigned i = 0; i < Size; ++i) {
+    *p++ = (uint8_t)(ValueToWrite & 0xff);
+    ValueToWrite >>= 8;
+  }
+
+  return false;
 }
 
 bool RuntimeDyldMachO::
 resolveARMRelocation(uint8_t *LocalAddress,
                      uint64_t FinalAddress,
-                     uint64_t Value,
+                     uint64_t FinalSource1,
+                     uint64_t FinalSource2,
                      bool isPCRel,
                      unsigned Type,
                      unsigned Size,
                      int64_t Addend) {
+  int64_t ValueToWrite = Addend;
+
   // If the relocation is PC-relative, the value to be encoded is the
   // pointer difference.
   if (isPCRel) {
-    Value -= FinalAddress;
+    ValueToWrite -= FinalAddress;
     // ARM PCRel relocations have an effective-PC offset of two instructions
     // (four bytes in Thumb mode, 8 bytes in ARM mode).
     // FIXME: For now, assume ARM mode.
-    Value -= 8;
+    ValueToWrite -= 8;
   }
 
   switch(Type) {
@@ -119,8 +176,8 @@
     // guarantee for the target address, so this is safest).
     uint8_t *p = (uint8_t*)LocalAddress;
     for (unsigned i = 0; i < Size; ++i) {
-      *p++ = (uint8_t)Value;
-      Value >>= 8;
+      *p++ = (uint8_t)(ValueToWrite & 0xff);
+      ValueToWrite >>= 8;
     }
     break;
   }
@@ -129,15 +186,15 @@
     // 32-bit aligned, so we can do it all at once.
     uint32_t *p = (uint32_t*)LocalAddress;
     // The low two bits of the value are not encoded.
-    Value >>= 2;
+    ValueToWrite >>= 2;
     // Mask the value to 24 bits.
-    Value &= 0xffffff;
+    ValueToWrite &= 0xffffff;
     // FIXME: If the destination is a Thumb function (and the instruction
     // is a non-predicated BL instruction), we need to change it to a BLX
     // instruction instead.
 
     // Insert the value into the instruction.
-    *p = (*p & ~0xffffff) | Value;
+    *p = (*p & ~0xffffff) | ValueToWrite;
     break;
   }
   case macho::RIT_ARM_ThumbBranch22Bit:
@@ -153,6 +210,29 @@
   return false;
 }
 
+static bool
+ResolveSectionAndOffset(const MachOObject *Obj,
+                        SmallVectorImpl<unsigned> &SectionMap,
+                        const MachOObject::LoadCommandInfo *SegmentLCI,
+                        InMemoryStruct<macho::SegmentLoadCommand> &SegmentLC,
+                        uint64_t Address,
+                        unsigned &SectionID,
+                        uint64_t &Offset)
+{
+  for (unsigned SI = 0, SE = SegmentLC->NumSections; SI < SE; ++SI) {
+    InMemoryStruct<macho::Section> CandidateSection;
+    Obj->ReadSection(*SegmentLCI, SI, CandidateSection);
+    if (Address >= CandidateSection->Address &&
+        Address < CandidateSection->Address + CandidateSection->Size) {
+      SectionID = SectionMap[SI];
+      Offset = Address - CandidateSection->Address;
+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool RuntimeDyldMachO::
 loadSegment32(const MachOObject *Obj,
               const MachOObject::LoadCommandInfo *SegmentLCI,
@@ -210,6 +290,7 @@
 
   // Process the relocations for each section we're loading.
   Relocations.grow(Relocations.size() + SegmentLC->NumSections);
+  RelocationSources.grow(RelocationSources.size() + SegmentLC->NumSections);
   for (unsigned SectNum = 0; SectNum != SegmentLC->NumSections; ++SectNum) {
     InMemoryStruct<macho::Section> Sect;
     Obj->ReadSection(*SegmentLCI, SectNum, Sect);
@@ -218,51 +299,135 @@
     for (unsigned j = 0; j != Sect->NumRelocationTableEntries; ++j) {
       InMemoryStruct<macho::RelocationEntry> RE;
       Obj->ReadRelocationEntry(Sect->RelocationTableOffset, j, RE);
-      if (RE->Word0 & macho::RF_Scattered)
-        return Error("NOT YET IMPLEMENTED: scattered relocations.");
-      // Word0 of the relocation is the offset into the section where the
-      // relocation should be applied. We need to translate that into an
-      // offset into a function since that's our atom.
-      uint32_t Offset = RE->Word0;
-      bool isExtern = (RE->Word1 >> 27) & 1;
-
-      // FIXME: Get the relocation addend from the target address.
-      // FIXME: VERY imporant for internal relocations.
-
-      // Figure out the source symbol of the relocation. If isExtern is true,
-      // this relocation references the symbol table, otherwise it references
-      // a section in the same object, numbered from 1 through NumSections
-      // (SectionBases is [0, NumSections-1]).
-      uint32_t SourceNum = RE->Word1 & 0xffffff; // 24-bit value
-      if (!isExtern) {
-        assert(SourceNum > 0 && "Invalid relocation section number!");
-        unsigned SectionID = SectionMap[SourceNum - 1];
+      if (RE->Word0 & macho::RF_Scattered) {
+        // The lower 24 bits of Word0 of the scattered relocation is the offset
+        // into the section where the relocation should be applied, i.e., the
+        // current section.
+        uint32_t OffsetInTarget = RE->Word0 & 0x00ffffff;
         unsigned TargetID = SectionMap[SectNum];
-        DEBUG(dbgs() << "Internal relocation at Section #"
-                     << TargetID << " + " << Offset
-                     << " from Section #"
-                     << SectionID << " (Word1: "
-                     << format("0x%x", RE->Word1) << ")\n");
-
-        // Store the relocation information. It will get resolved when
-        // the section addresses are assigned.
-        Relocations[SectionID].push_back(RelocationEntry(TargetID,
-                                                         Offset,
-                                                         RE->Word1,
-                                                         0 /*Addend*/));
+        // Word1 of the scattered relocation is a file offset which needs to
+        // be resolved into Section+Offset form.  This gives the address of the
+        // source.
+        unsigned Source1ID;
+        uint64_t Source1Offset;
+        if (!ResolveSectionAndOffset(Obj,
+                                     SectionMap,
+                                     SegmentLCI,
+                                     SegmentLC,
+                                     RE->Word1,
+                                     Source1ID,
+                                     Source1Offset))
+          return Error("couldn't find scattered relocation value in sections");
+        // This relocation may have a paired relocation entry. If it does, set
+        // the source/offset information for it correctly.
+        unsigned Source2ID = SectionOffset::NoSectionID;
+        uint64_t Source2Offset = 0;
+        if (j + 1 < Sect->NumRelocationTableEntries) {
+          InMemoryStruct<macho::RelocationEntry> PairRE;
+          Obj->ReadRelocationEntry(Sect->RelocationTableOffset, j+1, PairRE);
+          if ((PairRE->Word0 & macho::RF_Scattered) &&
+              ((PairRE->Word0 & 0x0f000000) >> 24) == macho::RIT_Pair) {
+            if (!ResolveSectionAndOffset(Obj,
+                                         SectionMap,
+                                         SegmentLCI,
+                                         SegmentLC,
+                                         PairRE->Word1,
+                                         Source2ID,
+                                         Source2Offset))
+              return Error("couldn't find scattered relocation value in sections");
+            ++j;
+          }
+        }
+        if (Source2ID == SectionOffset::NoSectionID)
+          DEBUG(dbgs() << "Scattered relocation at Section #"
+                       << TargetID << " + " << OffsetInTarget
+                       << " from Section #" << Source1ID
+                       << "+" << Source1Offset
+                       << " (Word0: "
+                       << format("0x%x", RE->Word0) << ")\n");
+        else
+          DEBUG(dbgs() << "Scattered relocation at Section #"
+                       << TargetID << " + " << OffsetInTarget
+                       << " from Section #" << Source1ID
+                       << "+" << Source1Offset
+                       << " and Section #" << Source2ID
+                       << "+" << Source2Offset
+                       << " (Word0: "
+                       << format("0x%x", RE->Word0) << ")\n");
+        uint32_t RelocationIndex = Relocations[TargetID].size();
+        // FIXME: Get the relocation addend from the target address.
+        // FIXME: VERY imporant for internal relocations.
+        RelocationEntry TranslatedRE(OffsetInTarget,
+                                     Source1ID,
+                                     Source1Offset,
+                                     Source2ID,
+                                     Source2Offset,
+                                     RE->Word1,
+                                     0 /*Addend*/);
+        Relocations[TargetID].push_back(TranslatedRE);
+        RelocationSources[Source1ID].push_back(RelocationSource(TargetID,
+                                                                RelocationIndex,
+                                                                0));
+        if (Source2ID != SectionOffset::NoSectionID)
+          RelocationSources[Source2ID].push_back(RelocationSource(TargetID,
+                                                                  RelocationIndex,
+                                                                  1));
       } else {
-        StringRef SourceName = SymbolNames[SourceNum];
-
-        // Now store the relocation information. Associate it with the source
-        // symbol. Just add it to the unresolved list and let the general
-        // path post-load resolve it if we know where the symbol is.
-        UnresolvedRelocations[SourceName].push_back(RelocationEntry(SectNum,
-                                                                    Offset,
-                                                                    RE->Word1,
-                                                                 0 /*Addend*/));
-        DEBUG(dbgs() << "Relocation at Section #" << SectNum << " + " << Offset
-              << " from '" << SourceName << "(Word1: "
-              << format("0x%x", RE->Word1) << ")\n");
+        // Word0 of the relocation is the offset into the section where the
+        // relocation should be applied, i.e., the current section. We need
+        // to translate that into an offset into a function since that's our atom.
+        uint32_t OffsetInTarget = RE->Word0;
+        bool isExtern = (RE->Word1 >> 27) & 1;
+  
+        // FIXME: Get the relocation addend from the target address.
+        // FIXME: VERY imporant for internal relocations.
+  
+        // Figure out the source symbol of the relocation. If isExtern is true,
+        // this relocation references the symbol table, otherwise it references
+        // a section in the same object, numbered from 1 through NumSections
+        // (SectionBases is [0, NumSections-1]).
+        uint32_t SourceNum_OneBased = RE->Word1 & 0xffffff; // 24-bit value
+        if (!isExtern) {
+          assert(SourceNum_OneBased > 0 && "Invalid relocation section number!");
+          unsigned SourceID = SectionMap[SourceNum_OneBased - 1];
+          unsigned TargetID = SectionMap[SectNum];
+          DEBUG(dbgs() << "Internal relocation at Section #"
+                       << TargetID << " + " << OffsetInTarget
+                       << " from Section #"
+                       << SourceID << " (Word1: "
+                       << format("0x%x", RE->Word1) << ")\n");
+  
+          // Store the relocation information. It will get resolved when
+          // the section addresses are assigned.
+          uint32_t RelocationIndex = Relocations[TargetID].size();
+          Relocations[TargetID].push_back(RelocationEntry(OffsetInTarget,
+                                                          SourceID,
+                                                          SectionOffset::NoSectionID,
+                                                          RE->Word1,
+                                                          0 /*Addend*/));
+          RelocationSources[SourceID].push_back(RelocationSource(TargetID,
+                                                                 RelocationIndex,
+                                                                 0));
+        } else {
+          StringRef SourceName = SymbolNames[SourceNum_OneBased];
+  
+          // Now store the relocation information. Associate it with the source
+          // symbol. Just add it to the unresolved list and let the general
+          // path post-load resolve it if we know where the symbol is.
+          unsigned TargetID = SectionMap[SectNum];
+          uint32_t RelocationIndex = Relocations[TargetID].size();
+          Relocations[TargetID].push_back(RelocationEntry(OffsetInTarget,
+                                                          SectionOffset::UnresolvedSourceID,
+                                                          SectionOffset::NoSectionID,
+                                                          RE->Word1,
+                                                          0 /*Addend*/));
+          UnresolvedRelocations[SourceName].push_back(RelocationSource(TargetID,
+                                                                       RelocationIndex,
+                                                                       0));
+          DEBUG(dbgs() << "Relocation at Section #" << SectNum << " + " << OffsetInTarget
+                << " from '" << SourceName << "' (Word1: "
+                << format("0x%x", RE->Word1) << ")\n");
+        }
       }
     }
   }
@@ -332,6 +497,7 @@
 
   // Process the relocations for each section we're loading.
   Relocations.grow(Relocations.size() + Segment64LC->NumSections);
+  RelocationSources.grow(RelocationSources.size() + Segment64LC->NumSections);
   for (unsigned SectNum = 0; SectNum != Segment64LC->NumSections; ++SectNum) {
     InMemoryStruct<macho::Section64> Sect;
     Obj->ReadSection64(*SegmentLCI, SectNum, Sect);
@@ -341,11 +507,11 @@
       InMemoryStruct<macho::RelocationEntry> RE;
       Obj->ReadRelocationEntry(Sect->RelocationTableOffset, j, RE);
       if (RE->Word0 & macho::RF_Scattered)
-        return Error("NOT YET IMPLEMENTED: scattered relocations.");
+        return Error("scattered relocations don't exist on 64-bit platforms");
       // Word0 of the relocation is the offset into the section where the
       // relocation should be applied. We need to translate that into an
       // offset into a function since that's our atom.
-      uint32_t Offset = RE->Word0;
+      uint32_t OffsetInTarget = RE->Word0;
       bool isExtern = (RE->Word1 >> 27) & 1;
 
       // FIXME: Get the relocation addend from the target address.
@@ -355,34 +521,45 @@
       // this relocation references the symbol table, otherwise it references
       // a section in the same object, numbered from 1 through NumSections
       // (SectionBases is [0, NumSections-1]).
-      uint32_t SourceNum = RE->Word1 & 0xffffff; // 24-bit value
+      uint32_t SourceNum_OneBased = RE->Word1 & 0xffffff; // 24-bit value
       if (!isExtern) {
-        assert(SourceNum > 0 && "Invalid relocation section number!");
-        unsigned SectionID = SectionMap[SourceNum - 1];
+        assert(SourceNum_OneBased > 0 && "Invalid relocation section number!");
+        unsigned SourceID = SectionMap[SourceNum_OneBased - 1];
         unsigned TargetID = SectionMap[SectNum];
         DEBUG(dbgs() << "Internal relocation at Section #"
-                     << TargetID << " + " << Offset
+                     << TargetID << " + " << OffsetInTarget
                      << " from Section #"
-                     << SectionID << " (Word1: "
+                     << SourceID << " (Word1: "
                      << format("0x%x", RE->Word1) << ")\n");
 
         // Store the relocation information. It will get resolved when
         // the section addresses are assigned.
-        Relocations[SectionID].push_back(RelocationEntry(TargetID,
-                                                         Offset,
-                                                         RE->Word1,
-                                                         0 /*Addend*/));
+        uint32_t RelocationIndex = Relocations[TargetID].size();
+        Relocations[TargetID].push_back(RelocationEntry(OffsetInTarget,
+                                                        SourceID,
+                                                        SectionOffset::NoSectionID,
+                                                        RE->Word1,
+                                                        0 /*Addend*/));
+        RelocationSources[SourceID].push_back(RelocationSource(TargetID,
+                                                               RelocationIndex,
+                                                               0));
       } else {
-        StringRef SourceName = SymbolNames[SourceNum];
+        StringRef SourceName = SymbolNames[SourceNum_OneBased];
 
         // Now store the relocation information. Associate it with the source
         // symbol. Just add it to the unresolved list and let the general
         // path post-load resolve it if we know where the symbol is.
-        UnresolvedRelocations[SourceName].push_back(RelocationEntry(SectNum,
-                                                                    Offset,
-                                                                    RE->Word1,
-                                                                 0 /*Addend*/));
-        DEBUG(dbgs() << "Relocation at Section #" << SectNum << " + " << Offset
+        unsigned TargetID = SectionMap[SectNum];
+        uint32_t RelocationIndex = Relocations[TargetID].size();
+        Relocations[TargetID].push_back(RelocationEntry(OffsetInTarget,
+                                                        SectionOffset::UnresolvedSourceID,
+                                                        SectionOffset::NoSectionID,
+                                                        RE->Word1,
+                                                        0 /*Addend*/));
+        UnresolvedRelocations[SourceName].push_back(RelocationSource(TargetID,
+                                                                     RelocationIndex,
+                                                                     0));
+        DEBUG(dbgs() << "Relocation at Section #" << SectNum << " + " << OffsetInTarget
               << " from '" << SourceName << "(Word1: "
               << format("0x%x", RE->Word1) << ")\n");
       }
@@ -468,18 +645,22 @@
   if (Loc == SymbolTable.end())
     return;
 
-  RelocationList &Relocs = UnresolvedRelocations[Name];
+  RelocationSourceList &SourcesForSymbol = UnresolvedRelocations[Name];
   DEBUG(dbgs() << "Resolving symbol '" << Name << "'\n");
-  for (int i = 0, e = Relocs.size(); i != e; ++i) {
-    // Change the relocation to be section relative rather than symbol
-    // relative and move it to the resolved relocation list.
-    RelocationEntry Entry = Relocs[i];
-    Entry.Addend += Loc->second.second;
-    Relocations[Loc->second.first].push_back(Entry);
+  for (int i = 0, e = SourcesForSymbol.size(); i != e; ++i) {
+    // Find the relocation entry corresponding to this source and fill
+    // in its source information with the resolved information from this
+    // symbol.
+    RelocationSource &Source = SourcesForSymbol[i];
+    RelocationEntry &Entry = Relocations[Source.SectionID][Source.Index];
+    Entry.Sources[Source.SourceIdx].Offset = Loc->second.second;
+    Entry.Sources[Source.SourceIdx].ID = Loc->second.first;
+    // Now create a relocation source in the pointed-to section.
+    RelocationSources[Loc->second.first].push_back(Source);
   }
   // FIXME: Keep a worklist of the relocations we've added so that we can
   // resolve more selectively later.
-  Relocs.clear();
+  SourcesForSymbol.clear();
 }
 
 bool RuntimeDyldMachO::loadObject(MemoryBuffer *InputBuffer) {
@@ -575,6 +756,56 @@
   return false;
 }
 
+bool RuntimeDyldMachO::resolveRelocationEntry(unsigned SectionID,
+                                              RelocationEntry &RE)
+{
+  uint8_t *Target = (uint8_t*)Sections[SectionID].base() + RE.Offset;
+  uint64_t FinalTarget = SectionLoadAddress[SectionID] + RE.Offset;
+
+  uint64_t FinalSource1 = 0;
+  uint64_t FinalSource2 = 0;
+
+  if (RE.Sources[0].ID == SectionOffset::UnresolvedSourceID ||
+      RE.Sources[1].ID == SectionOffset::UnresolvedSourceID)
+    return false;
+
+  FinalSource1 = SectionLoadAddress[RE.Sources[0].ID] + RE.Sources[0].Offset;
+  if (RE.Sources[1].ID != SectionOffset::NoSectionID)
+    FinalSource2 = SectionLoadAddress[RE.Sources[1].ID] + RE.Sources[1].Offset;
+
+  bool isPCRel = RE.isPCRel();
+  unsigned Type = RE.type();
+  unsigned Size = RE.length();
+
+  if (RE.Sources[1].ID == SectionOffset::NoSectionID)
+    DEBUG(dbgs() << "Resolving relocation at Section #" << SectionID
+          << " + " << RE.Offset << " (" << format("%p", Target) << ")"
+          << " from Section #" << RE.Sources[0].ID << "+" << RE.Sources[0].Offset
+          << " (" << format("0x%llx", FinalSource1) << ")"
+          << " (" << (isPCRel ? "pcrel" : "absolute")
+          << ", type: " << Type << ", Size: " << Size << ", Addend: "
+          << RE.Addend << ").\n");
+  else
+    DEBUG(dbgs() << "Resolving relocation at Section #" << SectionID
+          << " + " << RE.Offset << " (" << format("%p", Target) << ")"
+          << " from Section #" << RE.Sources[0].ID << "+" << RE.Sources[0].Offset
+          << " (" << format("0x%llx", FinalSource1) << ")"
+          << " and Section #" << RE.Sources[1].ID << "+" << RE.Sources[1].Offset
+          << " (" << format("0x%llx", FinalSource2) << ")"
+          << " (" << (isPCRel ? "pcrel" : "absolute")
+          << ", type: " << Type << ", Size: " << Size << ", Addend: "
+          << RE.Addend << ").\n");
+
+  return resolveRelocation(Target,
+                           FinalTarget,
+                           FinalSource1,
+                           FinalSource2,
+                           isPCRel,
+                           Type,
+                           Size,
+                           RE.Addend);
+}
+
 // Assign an address to a symbol name and resolve all the relocations
 // associated with it.
 void RuntimeDyldMachO::reassignSectionAddress(unsigned SectionID,
@@ -590,30 +821,17 @@
 
   SectionLoadAddress[SectionID] = Addr;
 
-  RelocationList &Relocs = Relocations[SectionID];
-  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
-    RelocationEntry &RE = Relocs[i];
-    uint8_t *Target = (uint8_t*)Sections[RE.SectionID].base() + RE.Offset;
-    uint64_t FinalTarget = (uint64_t)SectionLoadAddress[RE.SectionID] + RE.Offset;
-    bool isPCRel = (RE.Data >> 24) & 1;
-    unsigned Type = (RE.Data >> 28) & 0xf;
-    unsigned Size = 1 << ((RE.Data >> 25) & 3);
-
-    DEBUG(dbgs() << "Resolving relocation at Section #" << RE.SectionID
-          << " + " << RE.Offset << " (" << format("%p", Target) << ")"
-          << " from Section #" << SectionID << " (" << format("%p", Addr) << ")"
-          << "(" << (isPCRel ? "pcrel" : "absolute")
-          << ", type: " << Type << ", Size: " << Size << ", Addend: "
-          << RE.Addend << ").\n");
-
-    resolveRelocation(Target,
-                      FinalTarget,
-                      Addr,
-                      isPCRel,
-                      Type,
-                      Size,
-                      RE.Addend);
+  RelocationList &RelocsForSection = Relocations[SectionID];
+  for (unsigned i = 0, e = RelocsForSection.size(); i != e; ++i) {
+    RelocationEntry &RE = RelocsForSection[i];
+    resolveRelocationEntry(SectionID, RE);
   }
+  RelocationSourceList &SourcesForSection = RelocationSources[SectionID];
+  for (unsigned i = 0, e = SourcesForSection.size(); i != e; ++i) {
+    RelocationSource &R = SourcesForSection[i];
+    RelocationEntry &RE = Relocations[R.SectionID][R.Index];
+    resolveRelocationEntry(R.SectionID, RE);
+  }
 }
 
 bool RuntimeDyldMachO::isKnownFormat(const MemoryBuffer *InputBuffer) {
Index: lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
===================================================================
--- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h	(revision 152265)
+++ lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h	(working copy)
@@ -26,48 +26,183 @@
 namespace llvm {
 class RuntimeDyldMachO : public RuntimeDyldImpl {
 
-  // For each symbol, keep a list of relocations based on it. Anytime
-  // its address is reassigned (the JIT re-compiled the function, e.g.),
-  // the relocations get re-resolved.
-  // The symbol (or section) the relocation is sourced from is the Key
-  // in the relocation list where it's stored.
+  // For each section, keep a list of relocatable pieces of data that
+  // reside in it.  If the section moves, or the sections whose
+  // locations the data depends on move, re-resolve the relocations
+  // based on that movement.
+  //
+  // RelocationEntry structures correspond to one or two Mach-O
+  // relocation_info or scattered_relocation_info structures --
+  // usually one, but two iff the original has a paired structure
+  // following it.
+  //
+  // To facilitate updating a relocation when its sources move, we
+  // also keep RelocationSource structures associated with the sections
+  // whose location the data depends on.
+
+  // FIXME: Use SymbolLoc for this instead.  Where should the enum live?
+  struct SectionOffset {
+    uint64_t    Offset;     // Offset of the location into its section.
+    unsigned    ID;         // The section the location is contained in.
+
+    enum {
+      NoSectionID        = 0xffff0000,
+      UnresolvedSourceID = 0xffffffff
+    };
+  };
+
   struct RelocationEntry {
-    unsigned    SectionID;  // Section the relocation is contained in.
-    uint64_t    Offset;     // Offset into the section for the relocation.
-    uint32_t    Data;       // Second word of the raw macho relocation entry.
-    int64_t     Addend;     // Addend encoded in the instruction itself, if any,
-                            // plus the offset into the source section for
-                            // the symbol once the relocation is resolvable.
+    SectionOffset Sources[2]; // The section/offset pairs this relocation
+                              // refers to.
+                              // If the original Mach-O relocation entries used
+                              // relocation_info, this data is computed from
+                              // r_symbolnum and the offsets are locked to 0.
+                              // (The only offset is determined by the addend.)
+                              // If the original Mach-O relocation entries used
+                              // scattered_relocation_info, this data, including
+                              // offsets, is computed by looking r_value up in
+                              // the section table.
 
-    RelocationEntry(unsigned id, uint64_t offset, uint32_t data, int64_t addend)
-      : SectionID(id), Offset(offset), Data(data), Addend(addend) {}
+    uint64_t      Offset;     // The offset of the data to be relocated.
+                              // We don't use a SectionOffset because this
+                              // RelocationEntry is already associated with the
+                              // proper Section.
+
+    int64_t       Addend;     // Addend encoded in the instruction itself, if any,
+                              // plus the offset into the source section for
+                              // the symbol once the relocation is resolvable.
+
+    uint32_t      Data;       // If the original Mach-O relocation entry was a
+                              // relocation_info, the bitfield { r_symbolnum,
+                              // r_pcrel, r_length, r_extern, r_type }.
+                              // If the original Mach-O relocation entry was a
+                              // scattered_relocation_info, the bitfield
+                              // { r_address, r_type, r_length, r_pcrel,
+                              // r_scattered }.
+
+    bool          Scattered;  // True iff this relocation is scattered.
+
+    bool isPCRel()
+    {
+      if (Scattered)
+        return (Data & 0x40000000) >> 30;
+      else
+        return (Data & 0x01000000) >> 24;
+    }
+
+    uint8_t type()
+    {
+      if (Scattered)
+        return (Data & 0x0f000000) >> 24;
+      else
+        return (Data & 0xf0000000) >> 28;
+    }
+
+    // Returns the decoded version of the length field
+    uint8_t length()
+    {
+      if (Scattered)
+        return 1 << ((Data & 0x30000000) >> 28);
+      else
+        return 1 << ((Data & 0x0e000000) >> 25);
+    }
+
+    // Used with an ordinary relocation entry, where the source_offsets are not
+    // known yet.
+    RelocationEntry(uint64_t offset,      // See the Offset field.
+                    unsigned source_id0,  // The section ID for the first source.
+                    unsigned source_id1,  // The section ID for the second source.
+                    uint32_t data,        // See the Data field.
+                    int64_t addend)       // See the Addend field.
+      : Offset(offset),
+        Addend(addend),
+        Data(data),
+        Scattered(false) {
+      Sources[0].ID = source_id0;
+      Sources[0].Offset = 0;
+      Sources[1].ID = source_id1;
+      Sources[1].Offset = 0;
+    }
+  
+    // Used with a scattered relocation entry, where the source_offsets can be
+    // derived from the value.
+    RelocationEntry(uint64_t offset,      // See the Offset field.
+                    unsigned source_id0,  // The section ID for the first source.
+                    uint64_t source_off0, // The offset for the first source.
+                    unsigned source_id1,  // The section ID for the second source.
+                    uint64_t source_off1, // The offset for the second source.
+                    uint32_t data,        // See the Data field.
+                    int64_t addend)       // See the Addend field.
+      : Offset(offset),
+        Addend(addend),
+        Data(data), 
+        Scattered(true) {
+      Sources[0].ID = source_id0;
+      Sources[0].Offset = source_off0;
+      Sources[1].ID = source_id1;
+      Sources[1].Offset = source_off1;
+    }
   };
   typedef SmallVector<RelocationEntry, 4> RelocationList;
-  // Relocations to sections already loaded. Indexed by SectionID which is the
-  // source of the address. The target where the address will be writen is
-  // SectionID/Offset in the relocation itself.
+
+  // For each section, keep a list of sources that are used by relocations in
+  // other sections.  Whenever a relocation gets created, create one or two
+  // corresponding relocation sources.  Whenever relocations are re-resolved
+  // for a section, also re-resolve the relocations corresponding to that
+  // section's relocation targets.
+  struct RelocationSource {
+    unsigned    SectionID;      // Section whose RelocationList contains the relocation.
+    uint32_t    Index : 24;     // Index of the RelocatonEntry in that RelocationList.
+    uint8_t     SourceIdx : 1;  // Index of this source in the RelocationEntry's Sources.
+
+    RelocationSource(unsigned id,
+                     uint32_t index,
+                     uint8_t source_idx)
+      : SectionID(id),
+        Index(index),
+        SourceIdx(source_idx) {}
+  };
+  typedef SmallVector<RelocationSource, 4> RelocationSourceList;
+
+  // Relocations which refer to already-loaded section. Indexed by SectionID
+  // which is the section containing the relocatable data.
   IndexedMap<RelocationList> Relocations;
+  // Targets corresponding to Relocations.
+  IndexedMap<RelocationSourceList> RelocationSources;
   // Relocations to symbols that are not yet resolved. Must be external
   // relocations by definition. Indexed by symbol name.
-  StringMap<RelocationList> UnresolvedRelocations;
+  StringMap<RelocationSourceList> UnresolvedRelocations;
 
+  bool resolveRelocationEntry(unsigned SectionID,
+                              RelocationEntry &RE);
   bool resolveRelocation(uint8_t *LocalAddress,
                          uint64_t FinalAddress,
-                         uint64_t Value,
+                         uint64_t FinalSource1,
+                         uint64_t FinalSource2,
                          bool isPCRel,
                          unsigned Type,
                          unsigned Size,
                          int64_t Addend);
+  bool resolveI386Relocation(uint8_t *LocalAddress,
+                             uint64_t FinalAddress,
+                             uint64_t FinalSource1,
+                             uint64_t FinalSource2,
+                             bool isPCRel,
+                             unsigned Type,
+                             unsigned Size,
+                             int64_t Addend);
   bool resolveX86_64Relocation(uint8_t *LocalAddress,
                                uint64_t FinalAddress,
-                               uint64_t Value,
+                               uint64_t FinalSource1,
+                               uint64_t FinalSource2,
                                bool isPCRel,
                                unsigned Type,
                                unsigned Size,
                                int64_t Addend);
   bool resolveARMRelocation(uint8_t *LocalAddress,
                             uint64_t FinalAddress,
-                            uint64_t Value,
+                            uint64_t FinalSource1,
+                            uint64_t FinalSource2,
                             bool isPCRel,
                             unsigned Type,
                             unsigned Size,