1 //===- InputChunks.cpp ----------------------------------------------------===//
2 //
3 //                             The LLVM Linker
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "InputChunks.h"
11 #include "Config.h"
12 #include "OutputSegment.h"
13 #include "lld/Common/ErrorHandler.h"
14 #include "lld/Common/LLVM.h"
15 #include "llvm/Support/LEB128.h"
16 
17 #define DEBUG_TYPE "lld"
18 
19 using namespace llvm;
20 using namespace llvm::wasm;
21 using namespace lld;
22 using namespace lld::wasm;
23 
24 uint32_t InputSegment::translateVA(uint32_t Address) const {
25   assert(Address >= startVA() && Address < endVA());
26   int32_t Delta = OutputSeg->StartVA + OutputSegmentOffset - startVA();
27   DEBUG(dbgs() << "translateVA: " << getName() << " Delta=" << Delta
28                << " Address=" << Address << "\n");
29   return Address + Delta;
30 }
31 
32 void InputChunk::copyRelocations(const WasmSection &Section) {
33   if (Section.Relocations.empty())
34     return;
35   size_t Start = getInputSectionOffset();
36   size_t Size = getSize();
37   for (const WasmRelocation &R : Section.Relocations)
38     if (R.Offset >= Start && R.Offset < Start + Size)
39       Relocations.push_back(R);
40 }
41 
42 static void applyRelocation(uint8_t *Buf, const OutputRelocation &Reloc) {
43   DEBUG(dbgs() << "write reloc: type=" << Reloc.Reloc.Type
44                << " index=" << Reloc.Reloc.Index << " value=" << Reloc.Value
45                << " offset=" << Reloc.Reloc.Offset << "\n");
46   Buf += Reloc.Reloc.Offset;
47   int64_t ExistingValue;
48   switch (Reloc.Reloc.Type) {
49   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
50   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
51   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
52     ExistingValue = decodeULEB128(Buf);
53     // Additional check to verify that the existing value that the location
54     // matches our expectations.
55     if (ExistingValue != Reloc.Reloc.Index) {
56       DEBUG(dbgs() << "existing value: " << decodeULEB128(Buf) << "\n");
57       assert(decodeULEB128(Buf) == Reloc.Reloc.Index);
58     }
59     LLVM_FALLTHROUGH;
60   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
61     encodeULEB128(Reloc.Value, Buf, 5);
62     break;
63   case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
64   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
65     encodeSLEB128(static_cast<int32_t>(Reloc.Value), Buf, 5);
66     break;
67   case R_WEBASSEMBLY_TABLE_INDEX_I32:
68   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
69     support::endian::write32<support::little>(Buf, Reloc.Value);
70     break;
71   default:
72     llvm_unreachable("unknown relocation type");
73   }
74 }
75 
76 static void applyRelocations(uint8_t *Buf, ArrayRef<OutputRelocation> Relocs) {
77   if (!Relocs.size())
78     return;
79   DEBUG(dbgs() << "applyRelocations: count=" << Relocs.size() << "\n");
80   for (const OutputRelocation &Reloc : Relocs)
81     applyRelocation(Buf, Reloc);
82 }
83 
84 void InputChunk::writeTo(uint8_t *SectionStart) const {
85   memcpy(SectionStart + getOutputOffset(), data().data(), data().size());
86   applyRelocations(SectionStart, OutRelocations);
87 }
88 
89 // Populate OutRelocations based on the input relocations and offset within the
90 // output section.  Calculates the updated index and offset for each relocation
91 // as well as the value to write out in the final binary.
92 void InputChunk::calcRelocations() {
93   if (Relocations.empty())
94     return;
95   int32_t Off = getOutputOffset() - getInputSectionOffset();
96   DEBUG(dbgs() << "calcRelocations: " << File->getName()
97                << " offset=" << Twine(Off) << "\n");
98   for (const WasmRelocation &Reloc : Relocations) {
99     OutputRelocation NewReloc;
100     NewReloc.Reloc = Reloc;
101     assert(Reloc.Offset + Off > 0);
102     NewReloc.Reloc.Offset += Off;
103     DEBUG(dbgs() << "reloc: type=" << Reloc.Type << " index=" << Reloc.Index
104                  << " offset=" << Reloc.Offset
105                  << " newOffset=" << NewReloc.Reloc.Offset << "\n");
106 
107     if (Config->Relocatable)
108       NewReloc.NewIndex = File->calcNewIndex(Reloc);
109 
110     NewReloc.Value = File->calcNewValue(Reloc);
111     OutRelocations.emplace_back(NewReloc);
112   }
113 }
114 
115 void InputFunction::setOutputIndex(uint32_t Index) {
116   DEBUG(dbgs() << "InputFunction::setOutputIndex: " << getName() << " -> " << Index << "\n");
117   assert(!hasOutputIndex());
118   OutputIndex = Index;
119 }
120 
121 void InputFunction::setTableIndex(uint32_t Index) {
122   DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> " << Index << "\n");
123   assert(!hasTableIndex());
124   TableIndex = Index;
125 }
126