LLVM 18.0.0git
GOFF.h
Go to the documentation of this file.
1//===- GOFF.h - GOFF object file implementation -----------------*- 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// This file declares the GOFFObjectFile class.
10// Record classes and derivatives are also declared and implemented.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_OBJECT_GOFF_H
15#define LLVM_OBJECT_GOFF_H
16
20#include "llvm/Support/Debug.h"
21#include "llvm/Support/Endian.h"
23
24namespace llvm {
25namespace object {
26
27/// \brief Represents a GOFF physical record.
28///
29/// Specifies protected member functions to manipulate the record. These should
30/// be called from deriving classes to change values as that record specifies.
31class Record {
32public:
33 static Error getContinuousData(const uint8_t *Record, uint16_t DataLength,
34 int DataIndex, SmallString<256> &CompleteData);
35
36 static bool isContinued(const uint8_t *Record) {
37 uint8_t IsContinued;
38 getBits(Record, 1, 7, 1, IsContinued);
39 return IsContinued;
40 }
41
42 static bool isContinuation(const uint8_t *Record) {
43 uint8_t IsContinuation;
44 getBits(Record, 1, 6, 1, IsContinuation);
45 return IsContinuation;
46 }
47
48protected:
49 /// \brief Get bit field of specified byte.
50 ///
51 /// Used to pack bit fields into one byte. Fields are packed left to right.
52 /// Bit index zero is the most significant bit of the byte.
53 ///
54 /// \param ByteIndex index of byte the field is in.
55 /// \param BitIndex index of first bit of field.
56 /// \param Length length of bit field.
57 /// \param Value value of bit field.
58 static void getBits(const uint8_t *Bytes, uint8_t ByteIndex, uint8_t BitIndex,
59 uint8_t Length, uint8_t &Value) {
60 assert(ByteIndex < GOFF::RecordLength && "Byte index out of bounds!");
61 assert(BitIndex < 8 && "Bit index out of bounds!");
62 assert(Length + BitIndex <= 8 && "Bit length too long!");
63
64 get<uint8_t>(Bytes, ByteIndex, Value);
65 Value = (Value >> (8 - BitIndex - Length)) & ((1 << Length) - 1);
66 }
67
68 template <class T>
69 static void get(const uint8_t *Bytes, uint8_t ByteIndex, T &Value) {
70 assert(ByteIndex + sizeof(T) <= GOFF::RecordLength &&
71 "Byte index out of bounds!");
72 Value = support::endian::read<T, llvm::endianness::big>(&Bytes[ByteIndex]);
73 }
74};
75
76class HDRRecord : public Record {
77public:
78 static Error getData(const uint8_t *Record, SmallString<256> &CompleteData);
79
80 static uint16_t getPropertyModuleLength(const uint8_t *Record) {
82 get<uint16_t>(Record, 52, Length);
83 return Length;
84 }
85};
86
87class ESDRecord : public Record {
88public:
89 /// \brief Number of bytes for name; any more must go in continuation.
90 /// This is the number of bytes that can fit into the data field of an ESD
91 /// record.
92 static const uint8_t ESDMaxUncontinuedNameLength = 8;
93
94 /// \brief Maximum name length for ESD records and continuations.
95 /// This is the number of bytes that can fit into the data field of an ESD
96 /// record AND following continuations. This is limited fundamentally by the
97 /// 16 bit SIGNED length field.
98 static const uint16_t MaxNameLength = 32 * 1024;
99
100public:
101 static Error getData(const uint8_t *Record, SmallString<256> &CompleteData);
102
103 // ESD Get routines.
104 static void getSymbolType(const uint8_t *Record,
106 uint8_t Value;
107 get<uint8_t>(Record, 3, Value);
109 }
110
111 static void getEsdId(const uint8_t *Record, uint32_t &EsdId) {
112 get<uint32_t>(Record, 4, EsdId);
113 }
114
115 static void getParentEsdId(const uint8_t *Record, uint32_t &EsdId) {
116 get<uint32_t>(Record, 8, EsdId);
117 }
118
119 static void getOffset(const uint8_t *Record, uint32_t &Offset) {
120 get<uint32_t>(Record, 16, Offset);
121 }
122
123 static void getLength(const uint8_t *Record, uint32_t &Length) {
124 get<uint32_t>(Record, 24, Length);
125 }
126
127 static void getNameSpaceId(const uint8_t *Record, GOFF::ESDNameSpaceId &Id) {
128 uint8_t Value;
129 get<uint8_t>(Record, 40, Value);
131 }
132
133 static void getFillBytePresent(const uint8_t *Record, bool &Present) {
134 uint8_t Value;
135 getBits(Record, 41, 0, 1, Value);
136 Present = (bool)Value;
137 }
138
139 static void getNameMangled(const uint8_t *Record, bool &Mangled) {
140 uint8_t Value;
141 getBits(Record, 41, 1, 1, Value);
142 Mangled = (bool)Value;
143 }
144
145 static void getRenamable(const uint8_t *Record, bool &Renamable) {
146 uint8_t Value;
147 getBits(Record, 41, 2, 1, Value);
148 Renamable = (bool)Value;
149 }
150
151 static void getRemovable(const uint8_t *Record, bool &Removable) {
152 uint8_t Value;
153 getBits(Record, 41, 3, 1, Value);
154 Removable = (bool)Value;
155 }
156
157 static void getFillByteValue(const uint8_t *Record, uint8_t &Fill) {
158 get<uint8_t>(Record, 42, Fill);
159 }
160
161 static void getAdaEsdId(const uint8_t *Record, uint32_t &EsdId) {
162 get<uint32_t>(Record, 44, EsdId);
163 }
164
165 static void getSortPriority(const uint8_t *Record, uint32_t &Priority) {
166 get<uint32_t>(Record, 48, Priority);
167 }
168
169 static void getAmode(const uint8_t *Record, GOFF::ESDAmode &Amode) {
170 uint8_t Value;
171 get<uint8_t>(Record, 60, Value);
172 Amode = (GOFF::ESDAmode)Value;
173 }
174
175 static void getRmode(const uint8_t *Record, GOFF::ESDRmode &Rmode) {
176 uint8_t Value;
177 get<uint8_t>(Record, 61, Value);
178 Rmode = (GOFF::ESDRmode)Value;
179 }
180
181 static void getTextStyle(const uint8_t *Record, GOFF::ESDTextStyle &Style) {
182 uint8_t Value;
183 getBits(Record, 62, 0, 4, Value);
184 Style = (GOFF::ESDTextStyle)Value;
185 }
186
187 static void getBindingAlgorithm(const uint8_t *Record,
188 GOFF::ESDBindingAlgorithm &Algorithm) {
189 uint8_t Value;
190 getBits(Record, 62, 4, 4, Value);
191 Algorithm = (GOFF::ESDBindingAlgorithm)Value;
192 }
193
194 static void getTaskingBehavior(const uint8_t *Record,
195 GOFF::ESDTaskingBehavior &TaskingBehavior) {
196 uint8_t Value;
197 getBits(Record, 63, 0, 3, Value);
198 TaskingBehavior = (GOFF::ESDTaskingBehavior)Value;
199 }
200
201 static void getReadOnly(const uint8_t *Record, bool &ReadOnly) {
202 uint8_t Value;
203 getBits(Record, 63, 4, 1, Value);
204 ReadOnly = (bool)Value;
205 }
206
207 static void getExecutable(const uint8_t *Record,
208 GOFF::ESDExecutable &Executable) {
209 uint8_t Value;
210 getBits(Record, 63, 5, 3, Value);
211 Executable = (GOFF::ESDExecutable)Value;
212 }
213
214 static void getDuplicateSeverity(const uint8_t *Record,
216 uint8_t Value;
217 getBits(Record, 64, 2, 2, Value);
219 }
220
221 static void getBindingStrength(const uint8_t *Record,
222 GOFF::ESDBindingStrength &Strength) {
223 uint8_t Value;
224 getBits(Record, 64, 4, 4, Value);
226 }
227
228 static void getLoadingBehavior(const uint8_t *Record,
229 GOFF::ESDLoadingBehavior &Behavior) {
230 uint8_t Value;
231 getBits(Record, 65, 0, 2, Value);
233 }
234
235 static void getIndirectReference(const uint8_t *Record, bool &Indirect) {
236 uint8_t Value;
237 getBits(Record, 65, 3, 1, Value);
238 Indirect = (bool)Value;
239 }
240
241 static void getBindingScope(const uint8_t *Record,
242 GOFF::ESDBindingScope &Scope) {
243 uint8_t Value;
244 getBits(Record, 65, 4, 4, Value);
246 }
247
248 static void getLinkageType(const uint8_t *Record,
250 uint8_t Value;
251 getBits(Record, 66, 2, 1, Value);
253 }
254
255 static void getAlignment(const uint8_t *Record,
256 GOFF::ESDAlignment &Alignment) {
257 uint8_t Value;
258 getBits(Record, 66, 3, 5, Value);
259 Alignment = (GOFF::ESDAlignment)Value;
260 }
261
262 static uint16_t getNameLength(const uint8_t *Record) {
264 get<uint16_t>(Record, 70, Length);
265 return Length;
266 }
267};
268
269class ENDRecord : public Record {
270public:
271 static Error getData(const uint8_t *Record, SmallString<256> &CompleteData);
272
273 static uint16_t getNameLength(const uint8_t *Record) {
275 get<uint16_t>(Record, 24, Length);
276 return Length;
277 }
278};
279
280} // end namespace object
281} // end namespace llvm
282
283#endif
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
static Error getData(const uint8_t *Record, SmallString< 256 > &CompleteData)
static uint16_t getNameLength(const uint8_t *Record)
Definition: GOFF.h:273
static void getIndirectReference(const uint8_t *Record, bool &Indirect)
Definition: GOFF.h:235
static void getBindingStrength(const uint8_t *Record, GOFF::ESDBindingStrength &Strength)
Definition: GOFF.h:221
static void getOffset(const uint8_t *Record, uint32_t &Offset)
Definition: GOFF.h:119
static void getDuplicateSeverity(const uint8_t *Record, GOFF::ESDDuplicateSymbolSeverity &DSS)
Definition: GOFF.h:214
static void getEsdId(const uint8_t *Record, uint32_t &EsdId)
Definition: GOFF.h:111
static void getLoadingBehavior(const uint8_t *Record, GOFF::ESDLoadingBehavior &Behavior)
Definition: GOFF.h:228
static Error getData(const uint8_t *Record, SmallString< 256 > &CompleteData)
static void getNameMangled(const uint8_t *Record, bool &Mangled)
Definition: GOFF.h:139
static void getTaskingBehavior(const uint8_t *Record, GOFF::ESDTaskingBehavior &TaskingBehavior)
Definition: GOFF.h:194
static void getFillBytePresent(const uint8_t *Record, bool &Present)
Definition: GOFF.h:133
static void getLength(const uint8_t *Record, uint32_t &Length)
Definition: GOFF.h:123
static void getAdaEsdId(const uint8_t *Record, uint32_t &EsdId)
Definition: GOFF.h:161
static void getBindingAlgorithm(const uint8_t *Record, GOFF::ESDBindingAlgorithm &Algorithm)
Definition: GOFF.h:187
static void getAmode(const uint8_t *Record, GOFF::ESDAmode &Amode)
Definition: GOFF.h:169
static const uint16_t MaxNameLength
Maximum name length for ESD records and continuations.
Definition: GOFF.h:98
static void getReadOnly(const uint8_t *Record, bool &ReadOnly)
Definition: GOFF.h:201
static void getRmode(const uint8_t *Record, GOFF::ESDRmode &Rmode)
Definition: GOFF.h:175
static void getSortPriority(const uint8_t *Record, uint32_t &Priority)
Definition: GOFF.h:165
static void getParentEsdId(const uint8_t *Record, uint32_t &EsdId)
Definition: GOFF.h:115
static void getFillByteValue(const uint8_t *Record, uint8_t &Fill)
Definition: GOFF.h:157
static void getSymbolType(const uint8_t *Record, GOFF::ESDSymbolType &SymbolType)
Definition: GOFF.h:104
static void getTextStyle(const uint8_t *Record, GOFF::ESDTextStyle &Style)
Definition: GOFF.h:181
static void getAlignment(const uint8_t *Record, GOFF::ESDAlignment &Alignment)
Definition: GOFF.h:255
static void getLinkageType(const uint8_t *Record, GOFF::ESDLinkageType &Type)
Definition: GOFF.h:248
static const uint8_t ESDMaxUncontinuedNameLength
Number of bytes for name; any more must go in continuation.
Definition: GOFF.h:92
static uint16_t getNameLength(const uint8_t *Record)
Definition: GOFF.h:262
static void getExecutable(const uint8_t *Record, GOFF::ESDExecutable &Executable)
Definition: GOFF.h:207
static void getBindingScope(const uint8_t *Record, GOFF::ESDBindingScope &Scope)
Definition: GOFF.h:241
static void getNameSpaceId(const uint8_t *Record, GOFF::ESDNameSpaceId &Id)
Definition: GOFF.h:127
static void getRemovable(const uint8_t *Record, bool &Removable)
Definition: GOFF.h:151
static void getRenamable(const uint8_t *Record, bool &Renamable)
Definition: GOFF.h:145
static Error getData(const uint8_t *Record, SmallString< 256 > &CompleteData)
static uint16_t getPropertyModuleLength(const uint8_t *Record)
Definition: GOFF.h:80
Represents a GOFF physical record.
Definition: GOFF.h:31
static void getBits(const uint8_t *Bytes, uint8_t ByteIndex, uint8_t BitIndex, uint8_t Length, uint8_t &Value)
Get bit field of specified byte.
Definition: GOFF.h:58
static bool isContinued(const uint8_t *Record)
Definition: GOFF.h:36
static Error getContinuousData(const uint8_t *Record, uint16_t DataLength, int DataIndex, SmallString< 256 > &CompleteData)
static void get(const uint8_t *Bytes, uint8_t ByteIndex, T &Value)
Definition: GOFF.h:69
static bool isContinuation(const uint8_t *Record)
Definition: GOFF.h:42
ESDLoadingBehavior
Definition: GOFF.h:127
ESDBindingAlgorithm
Definition: GOFF.h:97
ESDDuplicateSymbolSeverity
Definition: GOFF.h:115
ESDTextStyle
Definition: GOFF.h:91
ESDExecutable
Definition: GOFF.h:109
ESDAlignment
Definition: GOFF.h:144
ESDAmode
Definition: GOFF.h:75
ESDBindingScope
Definition: GOFF.h:134
ESDLinkageType
Definition: GOFF.h:142
constexpr uint8_t RecordLength
Length of the parts of a physical GOFF record.
Definition: GOFF.h:28
ESDNameSpaceId
Definition: GOFF.h:61
ESDSymbolType
Definition: GOFF.h:53
ESDTaskingBehavior
Definition: GOFF.h:102
ESDBindingStrength
Definition: GOFF.h:122
ESDRmode
Definition: GOFF.h:84
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
@ Length
Definition: DWP.cpp:456