1//=== i386.h - Generic JITLink i386 edge kinds, utilities -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Generic utilities for graphs representing i386 objects.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_EXECUTIONENGINE_JITLINK_I386_H
14#define LLVM_EXECUTIONENGINE_JITLINK_I386_H
15
16#include "llvm/ExecutionEngine/JITLink/JITLink.h"
17#include "llvm/ExecutionEngine/JITLink/TableManager.h"
18
19namespace llvm::jitlink::i386 {
20/// Represets i386 fixups
21enum EdgeKind_i386 : Edge::Kind {
22
23  /// None
24  None = Edge::FirstRelocation,
25
26  /// A plain 32-bit pointer value relocation.
27  ///
28  /// Fixup expression:
29  ///   Fixup <- Target + Addend : uint32
30  ///
31  /// Errors:
32  ///   - The target must reside in the low 32-bits of the address space,
33  ///     otherwise an out-of-range error will be returned.
34  ///
35  Pointer32,
36
37  /// A 32-bit PC-relative relocation.
38  ///
39  /// Represents a data/control flow instruction using PC-relative addressing
40  /// to a target.
41  ///
42  /// The fixup expression for this kind includes an implicit offset to account
43  /// for the PC (unlike the Delta edges) so that a PCRel32 with a target
44  /// T and addend zero is a call/branch to the start (offset zero) of T.
45  ///
46  /// Fixup expression:
47  ///   Fixup <- Target - (Fixup + 4) + Addend : int32
48  ///
49  /// Errors:
50  ///   - The result of the fixup expression must fit into an int32, otherwise
51  ///     an out-of-range error will be returned.
52  ///
53  PCRel32,
54
55  /// A plain 16-bit pointer value relocation.
56  ///
57  /// Fixup expression:
58  ///   Fixup <- Target + Addend : uint16
59  ///
60  /// Errors:
61  ///   - The target must reside in the low 16-bits of the address space,
62  ///     otherwise an out-of-range error will be returned.
63  ///
64  Pointer16,
65
66  /// A 16-bit PC-relative relocation.
67  ///
68  /// Represents a data/control flow instruction using PC-relative addressing
69  /// to a target.
70  ///
71  /// The fixup expression for this kind includes an implicit offset to account
72  /// for the PC (unlike the Delta edges) so that a PCRel16 with a target
73  /// T and addend zero is a call/branch to the start (offset zero) of T.
74  ///
75  /// Fixup expression:
76  ///   Fixup <- Target - (Fixup + 4) + Addend : int16
77  ///
78  /// Errors:
79  ///   - The result of the fixup expression must fit into an int16, otherwise
80  ///     an out-of-range error will be returned.
81  ///
82  PCRel16,
83
84  /// A 32-bit delta.
85  ///
86  /// Delta from the fixup to the target.
87  ///
88  /// Fixup expression:
89  ///   Fixup <- Target - Fixup + Addend : int64
90  ///
91  /// Errors:
92  ///   - The result of the fixup expression must fit into an int32, otherwise
93  ///     an out-of-range error will be returned.
94  Delta32,
95
96  /// A 32-bit GOT delta.
97  ///
98  /// Delta from the global offset table to the target.
99  ///
100  /// Fixup expression:
101  ///   Fixup <- Target - GOTSymbol + Addend : int32
102  ///
103  /// Errors:
104  ///   - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
105  ///     symbol was not been defined.
106  Delta32FromGOT,
107
108  /// A GOT entry offset within GOT getter/constructor, transformed to
109  /// Delta32FromGOT pointing at the GOT entry for the original target.
110  ///
111  /// Indicates that this edge should be transformed into a Delta32FromGOT
112  /// targeting the GOT entry for the edge's current target, maintaining the
113  /// same addend.
114  /// A GOT entry for the target should be created if one does not already
115  /// exist.
116  ///
117  /// Edges of this kind are usually handled by a GOT builder pass inserted by
118  /// default
119  ///
120  /// Fixup expression:
121  ///   NONE
122  ///
123  /// Errors:
124  ///   - *ASSERTION* Failure to handle edges of this kind prior to the fixup
125  ///     phase will result in an assert/unreachable during the fixup phase
126  RequestGOTAndTransformToDelta32FromGOT,
127};
128
129/// Returns a string name for the given i386 edge. For debugging purposes
130/// only
131const char *getEdgeKindName(Edge::Kind K);
132
133/// Returns true if the given uint32_t value is in range for a uint16_t.
134inline bool isInRangeForImmU16(uint32_t Value) {
135  return Value <= std::numeric_limits<uint16_t>::max();
136}
137
138/// Returns true if the given int32_t value is in range for an int16_t.
139inline bool isInRangeForImmS16(int32_t Value) {
140  return (Value >= std::numeric_limits<int16_t>::min() &&
141          Value <= std::numeric_limits<int16_t>::max());
142}
143
144/// Apply fixup expression for edge to block content.
145inline Error applyFixup(LinkGraph &G, Block &B, const Edge &E,
146                        const Symbol *GOTSymbol) {
147  using namespace i386;
148  using namespace llvm::support;
149
150  char *BlockWorkingMem = B.getAlreadyMutableContent().data();
151  char *FixupPtr = BlockWorkingMem + E.getOffset();
152  auto FixupAddress = B.getAddress() + E.getOffset();
153
154  switch (E.getKind()) {
155  case i386::None: {
156    break;
157  }
158
159  case i386::Pointer32: {
160    uint32_t Value = E.getTarget().getAddress().getValue() + E.getAddend();
161    *(ulittle32_t *)FixupPtr = Value;
162    break;
163  }
164
165  case i386::PCRel32: {
166    int32_t Value =
167        E.getTarget().getAddress() - (FixupAddress + 4) + E.getAddend();
168    *(little32_t *)FixupPtr = Value;
169    break;
170  }
171
172  case i386::Pointer16: {
173    uint32_t Value = E.getTarget().getAddress().getValue() + E.getAddend();
174    if (LLVM_LIKELY(isInRangeForImmU16(Value)))
175      *(ulittle16_t *)FixupPtr = Value;
176    else
177      return makeTargetOutOfRangeError(G, B, E);
178    break;
179  }
180
181  case i386::PCRel16: {
182    int32_t Value =
183        E.getTarget().getAddress() - (FixupAddress + 4) + E.getAddend();
184    if (LLVM_LIKELY(isInRangeForImmS16(Value)))
185      *(little16_t *)FixupPtr = Value;
186    else
187      return makeTargetOutOfRangeError(G, B, E);
188    break;
189  }
190
191  case i386::Delta32: {
192    int32_t Value = E.getTarget().getAddress() - FixupAddress + E.getAddend();
193    *(little32_t *)FixupPtr = Value;
194    break;
195  }
196
197  case i386::Delta32FromGOT: {
198    assert(GOTSymbol && "No GOT section symbol");
199    int32_t Value =
200        E.getTarget().getAddress() - GOTSymbol->getAddress() + E.getAddend();
201    *(little32_t *)FixupPtr = Value;
202    break;
203  }
204
205  default:
206    return make_error<JITLinkError>(
207        "In graph " + G.getName() + ", section " + B.getSection().getName() +
208        "unsupported edge kind" + getEdgeKindName(E.getKind()));
209  }
210
211  return Error::success();
212}
213
214/// i386 pointer size.
215constexpr uint32_t PointerSize = 4;
216
217/// i386 null pointer content.
218extern const char NullPointerContent[PointerSize];
219
220/// Creates a new pointer block in the given section and returns an anonymous
221/// symbol pointing to it.
222///
223/// If InitialTarget is given then an Pointer32 relocation will be added to the
224/// block pointing at InitialTarget.
225///
226/// The pointer block will have the following default values:
227///   alignment: 32-bit
228///   alignment-offset: 0
229///   address: highest allowable (~7U)
230inline Symbol &createAnonymousPointer(LinkGraph &G, Section &PointerSection,
231                                      Symbol *InitialTarget = nullptr,
232                                      uint64_t InitialAddend = 0) {
233  auto &B = G.createContentBlock(PointerSection, NullPointerContent,
234                                 orc::ExecutorAddr(), 8, 0);
235  if (InitialTarget)
236    B.addEdge(Pointer32, 0, *InitialTarget, InitialAddend);
237  return G.addAnonymousSymbol(B, 0, PointerSize, false, false);
238}
239
240/// Global Offset Table Builder.
241class GOTTableManager : public TableManager<GOTTableManager> {
242public:
243  static StringRef getSectionName() { return "$__GOT"; }
244
245  bool visitEdge(LinkGraph &G, Block *B, Edge &E) {
246    Edge::Kind KindToSet = Edge::Invalid;
247    switch (E.getKind()) {
248    case i386::Delta32FromGOT: {
249      // we need to make sure that the GOT section exists, but don't otherwise
250      // need to fix up this edge
251      getGOTSection(G);
252      return false;
253    }
254    case i386::RequestGOTAndTransformToDelta32FromGOT:
255      KindToSet = i386::Delta32FromGOT;
256      break;
257    default:
258      return false;
259    }
260    assert(KindToSet != Edge::Invalid &&
261           "Fell through switch, but no new kind to set");
262    DEBUG_WITH_TYPE("jitlink", {
263      dbgs() << "  Fixing " << G.getEdgeKindName(E.getKind()) << " edge at "
264             << B->getFixupAddress(E) << " (" << B->getAddress() << " + "
265             << formatv("{0:x}", E.getOffset()) << ")\n";
266    });
267    E.setKind(KindToSet);
268    E.setTarget(getEntryForTarget(G, E.getTarget()));
269    return true;
270  }
271
272  Symbol &createEntry(LinkGraph &G, Symbol &Target) {
273    return createAnonymousPointer(G, getGOTSection(G), &Target);
274  }
275
276private:
277  Section &getGOTSection(LinkGraph &G) {
278    if (!GOTSection)
279      GOTSection = &G.createSection(getSectionName(), orc::MemProt::Read);
280    return *GOTSection;
281  }
282
283  Section *GOTSection = nullptr;
284};
285
286} // namespace llvm::jitlink::i386
287
288#endif // LLVM_EXECUTIONENGINE_JITLINK_I386_H
289