CLRX  1
An unofficial OpenCL extensions designed for Radeon GPUs
Disassembler.h
Go to the documentation of this file.
1 /*
2  * CLRadeonExtender - Unofficial OpenCL Radeon Extensions Library
3  * Copyright (C) 2014-2018 Mateusz Szpakowski
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
23 #ifndef __CLRX_DISASSEMBLER_H__
24 #define __CLRX_DISASSEMBLER_H__
25 
26 #include <CLRX/Config.h>
27 #include <string>
28 #include <istream>
29 #include <ostream>
30 #include <vector>
31 #include <utility>
32 #include <memory>
37 #include <CLRX/amdbin/AmdBinGen.h>
38 #include <CLRX/amdasm/Commons.h>
39 #include <CLRX/utils/Utilities.h>
40 #include <CLRX/utils/InputOutput.h>
41 
43 namespace CLRX
44 {
45 
48 {
49 public:
51  DisasmException() = default;
53  explicit DisasmException(const std::string& message);
55  virtual ~DisasmException() noexcept = default;
56 };
57 
58 class Disassembler;
59 
60 enum: Flags
61 {
68  DISASM_SETUP = 64,
69  DISASM_CONFIG = 128,
70  DISASM_BUGGYFPLIT = 0x100,
71  DISASM_CODEPOS = 0x200,
72  DISASM_HSACONFIG = 0x400,
73  DISASM_HSALAYOUT = 0x800,
74  DISASM_WAVE32 = 0x1000,
75 
77  DISASM_ALL = FLAGS_ALL&(~(DISASM_CONFIG|DISASM_BUGGYFPLIT|DISASM_WAVE32|
79 };
80 
81 struct GCNDisasmUtils;
82 
85 {
86 private:
87  friend struct GCNDisasmUtils; // INTERNAL LOGIC
88 public:
89  typedef std::vector<size_t>::const_iterator LabelIter;
90 
92  typedef std::vector<std::pair<size_t, CString> >::const_iterator NamedLabelIter;
93 protected:
95  struct Relocation
96  {
97  size_t symbol;
99  int64_t addend;
100  };
101 
103  typedef std::vector<std::pair<size_t, Relocation> >::const_iterator RelocIter;
104 
106  size_t startOffset;
107  size_t labelStartOffset;
108  size_t inputSize;
109  const cxbyte* input;
110  bool dontPrintLabelsAfterCode;
111  std::vector<size_t> labels;
112  std::vector<std::pair<size_t, CString> > namedLabels;
113  std::vector<CString> relSymbols;
114  std::vector<std::pair<size_t, Relocation> > relocations;
116 
118  explicit ISADisassembler(Disassembler& disassembler, cxuint outBufSize = 600);
119 
121  void writeLocation(size_t pos);
123  bool writeRelocation(size_t pos, RelocIter& relocIter);
124 
125 public:
126  virtual ~ISADisassembler();
127 
129  void writeLabelsToPosition(size_t pos, LabelIter& labelIter,
130  NamedLabelIter& namedLabelIter);
132  void writeLabelsToEnd(size_t start, LabelIter labelIter, NamedLabelIter namedLabelIter);
133 
135  void setInput(size_t inputSize, const cxbyte* input, size_t startOffset = 0,
136  size_t labelStartOffset = 0)
137  {
138  this->inputSize = inputSize;
139  this->input = input;
140  this->startOffset = startOffset;
141  this->labelStartOffset = labelStartOffset;
142  }
143 
144  void setDontPrintLabels(bool after)
145  { dontPrintLabelsAfterCode = after; }
146 
148  virtual void analyzeBeforeDisassemble() = 0;
149 
151  void clearNumberedLabels();
153  void prepareLabelsAndRelocations();
155  void beforeDisassemble();
157  virtual void disassemble() = 0;
158 
160  void addNamedLabel(size_t pos, const CString& name)
161  { namedLabels.push_back(std::make_pair(pos, name)); }
163  void addNamedLabel(size_t pos, CString&& name)
164  { namedLabels.push_back(std::make_pair(pos, name)); }
165 
167  size_t addRelSymbol(const CString& symName)
168  {
169  size_t index = relSymbols.size();
170  relSymbols.push_back(symName);
171  return index;
172  }
174  void addRelocation(size_t offset, RelocType type, size_t symIndex, int64_t addend)
175  { relocations.push_back(std::make_pair(offset, Relocation{symIndex, type, addend})); }
178  {
179  relSymbols.clear();
180  relocations.clear();
181  }
183  const std::vector<size_t>& getLabels() const
184  { return labels; }
186  const std::vector<std::pair<size_t, CString> >& getNamedLabels() const
187  { return namedLabels; }
189  void flushOutput()
190  { return output.flush(); }
191 
193  Flags getFlags() const;
195  void setFlags(Flags flags);
196 };
197 
200 {
201 private:
202  bool instrOutOfCode;
203 
204  friend struct GCNDisasmUtils; // INTERNAL LOGIC
205 public:
207  GCNDisassembler(Disassembler& disassembler);
209  ~GCNDisassembler();
210 
212  void analyzeBeforeDisassemble();
214  void disassemble();
215 };
216 
218 
221 {
223  size_t metadataSize;
224  const char* metadata;
225  size_t headerSize;
226  const cxbyte* header;
227  std::vector<CALNoteInput> calNotes;
228  size_t dataSize;
229  const cxbyte* data;
230  size_t codeSize;
231  const cxbyte* code;
232 };
233 
235 
238 {
240  bool is64BitMode;
243  size_t globalDataSize;
245  std::vector<AmdDisasmKernelInput> kernels;
246 };
247 
250 {
251  size_t offset;
254  int64_t addend;
255 };
256 
258 
261 {
263  size_t metadataSize;
264  const cxbyte* metadata;
267  size_t setupSize;
268  const cxbyte* setup;
269  size_t stubSize;
270  const cxbyte* stub;
271  std::vector<AmdCL2RelaEntry> textRelocs;
272  size_t codeSize;
273  const cxbyte* code;
274 };
275 
277 
280 {
282  uint32_t archMinor;
283  uint32_t archStepping;
284  bool is64BitMode;
288  size_t globalDataSize;
290  size_t rwDataSize;
291  const cxbyte* rwData;
292  size_t bssAlignment;
293  size_t bssSize;
296  size_t codeSize;
297  const cxbyte* code;
298  std::vector<AmdCL2RelaEntry> textRelocs;
299 
301  std::vector<std::pair<size_t, size_t> > samplerRelocs;
302  std::vector<AmdCL2DisasmKernelInput> kernels;
303 };
304 
307 {
309  size_t size;
310  size_t offset;
312 };
313 
315 {
316  size_t sectionOffset;
317  const ROCmKernelDescriptor* desc;
318 };
319 
322 {
324  uint32_t archMinor;
325  uint32_t archStepping;
326  uint32_t eflags;
329  bool metadataV3;
330  std::vector<ROCmDisasmRegionInput> regions;
331  size_t codeSize;
332  const cxbyte* code;
333  size_t globalDataSize;
336  size_t metadataSize;
337  const char* metadata;
339  std::vector<ROCmDisasmKernelDescInfo> kernelDescs;
340 };
341 
344 {
346  GalliumProgInfoEntry progInfo[5];
347  uint32_t offset;
348  std::vector<GalliumArgInfo> argInfos;
349 };
350 
353 {
355  bool is64BitMode;
356  bool isLLVM390;
357  bool isMesa170;
358  bool isAMDHSA;
359  size_t globalDataSize;
361  std::vector<GalliumDisasmKernelInput> kernels;
362  size_t codeSize;
363  const cxbyte* code;
364  std::vector<GalliumScratchReloc> scratchRelocs;
365 };
366 
369 {
371  size_t codeSize;
372  const cxbyte* code;
373 };
374 
377 {
378 private:
379  friend class ISADisassembler;
380  std::unique_ptr<ISADisassembler> isaDisassembler;
381  bool fromBinary;
382  BinaryFormat binaryFormat;
383  union {
384  const AmdDisasmInput* amdInput;
385  const AmdCL2DisasmInput* amdCL2Input;
386  const GalliumDisasmInput* galliumInput;
387  const ROCmDisasmInput* rocmInput;
388  const RawCodeInput* rawInput;
389  };
390  std::ostream& output;
391  Flags flags;
392  size_t sectionCount;
393 public:
395 
400  Disassembler(const AmdMainGPUBinary32& binary, std::ostream& output,
401  Flags flags = 0);
403 
408  Disassembler(const AmdMainGPUBinary64& binary, std::ostream& output,
409  Flags flags = 0);
411 
417  Disassembler(const AmdCL2MainGPUBinary32& binary, std::ostream& output,
418  Flags flags = 0, cxuint driverVersion = 0);
420 
426  Disassembler(const AmdCL2MainGPUBinary64& binary, std::ostream& output,
427  Flags flags = 0, cxuint driverVersion = 0);
429 
434  Disassembler(const ROCmBinary& binary, std::ostream& output, Flags flags = 0);
436 
441  Disassembler(const AmdDisasmInput* disasmInput, std::ostream& output,
442  Flags flags = 0);
444 
449  Disassembler(const AmdCL2DisasmInput* disasmInput, std::ostream& output,
450  Flags flags = 0);
452 
457  Disassembler(const ROCmDisasmInput* disasmInput, std::ostream& output,
458  Flags flags = 0);
459 
461 
468  Disassembler(GPUDeviceType deviceType, const GalliumBinary& binary,
469  std::ostream& output, Flags flags = 0, cxuint llvmVersion = 0);
470 
472 
477  Disassembler(const GalliumDisasmInput* disasmInput, std::ostream& output,
478  Flags flags = 0);
479 
481  Disassembler(GPUDeviceType deviceType, size_t rawCodeSize, const cxbyte* rawCode,
482  std::ostream& output, Flags flags = 0);
483 
484  ~Disassembler();
485 
487  void disassemble();
488 
490  Flags getFlags() const
491  { return flags; }
493  void setFlags(Flags flags)
494  { this->flags = flags; }
495 
497  GPUDeviceType getDeviceType() const;
498 
501  { return amdInput; }
502 
505  { return amdCL2Input; }
506 
509  { return galliumInput; }
510 
512  const std::ostream& getOutput() const
513  { return output; }
515  std::ostream& getOutput()
516  { return output; }
517 };
518 
521 { return disassembler.getFlags(); }
524 { disassembler.setFlags(flags); }
525 
526 // routines to get binary config inputs
527 
530  const AmdMainGPUBinary32& binary, Flags flags);
533  const AmdMainGPUBinary64& binary, Flags flags);
536  const AmdCL2MainGPUBinary32& binary, cxuint driverVersion,
537  bool hsaLayout = false);
540  const AmdCL2MainGPUBinary64& binary, cxuint driverVersion,
541  bool hsaLayout = false);
544  const ROCmBinary& binary);
547  GPUDeviceType deviceType, const GalliumBinary& binary, cxuint llvmVersion);
548 
549 };
550 
551 #endif
CString target
LLVM target triple.
Definition: Disassembler.h:335
common definitions for assembler and disassembler
const cxbyte * globalData
global data
Definition: Disassembler.h:334
dump code
Definition: Disassembler.h:62
size_t metadataSize
metadata size
Definition: Disassembler.h:263
GalliumDisasmInput * getGalliumDisasmInputFromBinary(GPUDeviceType deviceType, const GalliumBinary &binary, cxuint llvmVersion)
prepare Gallium input from Gallium binary
const cxbyte * code
code
Definition: Disassembler.h:363
non copyable and non movable base structure (class)
Definition: Utilities.h:46
const cxbyte * header
kernel header size
Definition: Disassembler.h:226
size_t rwDataSize
global rw data size
Definition: Disassembler.h:290
bool is64BitMode
true if 64-bit mode of addressing
Definition: Disassembler.h:284
uint32_t archMinor
GPU arch minor.
Definition: Disassembler.h:324
int64_t addend
relocation addend
Definition: Disassembler.h:99
disasm kernel info structure (Gallium binaries)
Definition: Disassembler.h:343
AmdDisasmInput * getAmdDisasmInputFromBinary32(const AmdMainGPUBinary32 &binary, Flags flags)
prepare AMD OpenCL input from AMD 32-bit binary
main class for
Definition: Disassembler.h:84
uint32_t Flags
type for declaring various flags
Definition: Utilities.h:100
CString kernelName
kernel&#39;s name
Definition: Disassembler.h:345
internal relocation structure
Definition: Disassembler.h:95
void setInput(size_t inputSize, const cxbyte *input, size_t startOffset=0, size_t labelStartOffset=0)
set input code
Definition: Disassembler.h:135
uint32_t archStepping
GPU arch stepping.
Definition: Disassembler.h:283
size_t isaMetadataSize
metadata size
Definition: Disassembler.h:265
size_t dataSize
data (from inner binary) size
Definition: Disassembler.h:228
fast and direct output buffer
Definition: InputOutput.h:350
AMD OpenCL 2.0 main binary for GPU for 32-bit mode.
Definition: AmdCL2Binaries.h:493
size_t offset
offset
Definition: Disassembler.h:251
BinaryFormat
binary format for Assembler/Disassembler
Definition: Commons.h:38
bool metadataV3
new metadata v3 format
Definition: Disassembler.h:329
FastOutputBuffer output
output buffer
Definition: Disassembler.h:115
const cxbyte * code
code
Definition: Disassembler.h:372
size_t setupSize
data (from inner binary) size
Definition: Disassembler.h:267
size_t codeSize
code size
Definition: Disassembler.h:296
AMD OpenCL 2.0 binaries handling.
size_t codeSize
code size
Definition: Disassembler.h:362
CString driverInfo
driver info (for AMD Catalyst drivers)
Definition: Disassembler.h:241
size_t globalDataSize
global (constants for kernels) data size
Definition: Disassembler.h:243
CString aclVersionString
acl version string
Definition: Disassembler.h:287
const cxbyte * data
data from inner binary
Definition: Disassembler.h:229
void clearRelocations()
clear all relocations
Definition: Disassembler.h:177
void addNamedLabel(size_t pos, CString &&name)
add named label to list (must be called before disassembly)
Definition: Disassembler.h:163
void setFlags(Flags flags)
set disassemblers flags
Definition: Disassembler.h:493
disasm ROCm region
Definition: Disassembler.h:306
dump datas
Definition: Disassembler.h:64
std::vector< CString > relSymbols
symbols used by relocations
Definition: Disassembler.h:113
RelocType type
relocation type
Definition: Disassembler.h:98
const AmdCL2DisasmInput * getAmdCL2Input() const
get disassembler input
Definition: Disassembler.h:504
void addNamedLabel(size_t pos, const CString &name)
add named label to list (must be called before disassembly)
Definition: Disassembler.h:160
GPUDeviceType deviceType
GPU device type.
Definition: Disassembler.h:323
const char * metadata
kernel&#39;s metadata
Definition: Disassembler.h:224
GCN architectur dissassembler.
Definition: Disassembler.h:199
const cxbyte * globalData
global (constants for kernels) data
Definition: Disassembler.h:289
size_t bssSize
size of global bss section
Definition: Disassembler.h:293
std::vector< GalliumDisasmKernelInput > kernels
list of input kernels
Definition: Disassembler.h:361
std::vector< size_t >::const_iterator LabelIter
label iterator
Definition: Disassembler.h:89
std::vector< std::pair< size_t, size_t > > samplerRelocs
sampler relocations
Definition: Disassembler.h:301
ROCm binaries handling.
Array< std::pair< CString, size_t > > gotSymbols
GOT symbols names.
Definition: Disassembler.h:338
GPUDeviceType deviceType
GPU device type.
Definition: Disassembler.h:370
use WAVESIZE32
Definition: Disassembler.h:74
bool isAMDHSA
if AMDHSA (LLVM 4.0)
Definition: Disassembler.h:358
AmdCL2DisasmInput * getAmdCL2DisasmInputFromBinary64(const AmdCL2MainGPUBinary64 &binary, cxuint driverVersion, bool hsaLayout=false)
prepare AMD OpenCL 2.0 input from AMD 64-bit binary
std::vector< ROCmDisasmKernelDescInfo > kernelDescs
kernel descriptors
Definition: Disassembler.h:339
whole disassembler input (for Gallium driver GPU binaries)
Definition: Disassembler.h:352
whole disassembler input (for AMD Catalyst driver GPU binaries)
Definition: Disassembler.h:237
Definition: GalliumBinaries.h:294
std::vector< size_t > labels
list of local labels
Definition: Disassembler.h:111
an array class
Definition: Containers.h:41
CString kernelName
kernel name
Definition: Disassembler.h:262
std::vector< std::pair< size_t, Relocation > > relocations
relocations
Definition: Disassembler.h:114
Configuration header.
ROCmDisasmInput * getROCmDisasmInputFromBinary(const ROCmBinary &binary)
prepare ROCM input from ROCM binary
print kernel configuration instead raw data
Definition: Disassembler.h:69
size_t codeSize
code size
Definition: Disassembler.h:331
cxuint RelocType
relocation type
Definition: Commons.h:33
const cxbyte * rwData
global rw data data
Definition: Disassembler.h:291
const cxbyte * metadata
kernel&#39;s metadata
Definition: Disassembler.h:264
std::vector< CALNoteInput > calNotes
ATI CAL notes.
Definition: Disassembler.h:227
std::vector< AmdCL2RelaEntry > textRelocs
text relocations
Definition: Disassembler.h:298
size_t inputSize
< start offset of labels
Definition: Disassembler.h:108
const cxbyte * stub
data from inner binary
Definition: Disassembler.h:270
const cxbyte * globalData
global (constants for kernels) data
Definition: Disassembler.h:244
AmdDisasmInput * getAmdDisasmInputFromBinary64(const AmdMainGPUBinary64 &binary, Flags flags)
prepare AMD OpenCL input from AMD 64-bit binary
const cxbyte * isaMetadata
kernel&#39;s metadata
Definition: Disassembler.h:266
ROCm main binary for GPU for 64-bit mode.
Definition: ROCmBinaries.h:234
bool is64BitMode
true if 64-bit mode of addressing
Definition: Disassembler.h:240
CString compileOptions
compile options which used by in clBuildProgram
Definition: Disassembler.h:286
const char * metadata
metadata
Definition: Disassembler.h:337
bool isMesa170
if >=Mesa3D 17.0
Definition: Disassembler.h:357
GPUDeviceType deviceType
GPU device type.
Definition: Disassembler.h:281
void flushOutput()
flush output
Definition: Disassembler.h:189
size_t metadataSize
metadata size
Definition: Disassembler.h:223
GalliumCompute binaries handling (only with LLVM 3.6)
const cxbyte * code
code
Definition: Disassembler.h:297
print in comments float literals
Definition: Disassembler.h:66
input output utilities
const AmdDisasmInput * getAmdInput() const
get disassembler input
Definition: Disassembler.h:500
GPUDeviceType deviceType
GPU device type.
Definition: Disassembler.h:354
Definition: Disassembler.h:314
AMD binaries handling.
unsigned char cxbyte
unsigned byte
Definition: Config.h:229
size_t size
region size
Definition: Disassembler.h:309
const cxbyte * globalData
global (constants for kernels) data
Definition: Disassembler.h:360
cxuint driverVersion
driver version
Definition: Disassembler.h:285
kernel program info entry for Gallium binaries
Definition: GalliumBinaries.h:86
main namespace
Definition: AsmDefs.h:38
ROCmRegionType
ROCm region/symbol type.
Definition: ROCmBinaries.h:53
disasm ROCm input
Definition: Disassembler.h:321
AMD main binary for GPU for 64-bit mode.
Definition: AmdBinaries.h:612
std::ostream & getOutput()
get output stream
Definition: Disassembler.h:515
Disassembler & disassembler
disassembler instance
Definition: Disassembler.h:105
const cxbyte * code
code of kernel
Definition: Disassembler.h:231
const std::ostream & getOutput() const
get output stream
Definition: Disassembler.h:512
unsigned int cxuint
unsigned int
Definition: Config.h:237
std::vector< AmdDisasmKernelInput > kernels
kernel inputs
Definition: Disassembler.h:245
const cxbyte * code
code of kernel
Definition: Disassembler.h:273
print on left side hexadecimal code
Definition: Disassembler.h:67
AmdCL2DisasmInput * getAmdCL2DisasmInputFromBinary32(const AmdCL2MainGPUBinary32 &binary, cxuint driverVersion, bool hsaLayout=false)
prepare AMD OpenCL 2.0 input from AMD 32-bit binary
void addRelocation(size_t offset, RelocType type, size_t symIndex, int64_t addend)
add relocation
Definition: Disassembler.h:174
size_t codeSize
size of code of kernel
Definition: Disassembler.h:230
size_t offset
region offset in code
Definition: Disassembler.h:310
int64_t addend
addend
Definition: Disassembler.h:254
dump ATI CAL notes
Definition: Disassembler.h:65
CString regionName
region name
Definition: Disassembler.h:308
const cxbyte * input
input code
Definition: Disassembler.h:109
const std::vector< size_t > & getLabels() const
get numbered labels
Definition: Disassembler.h:183
bool llvm10BinFormat
new LLVM10 binary format
Definition: Disassembler.h:328
std::vector< std::pair< size_t, CString > > namedLabels
named labels
Definition: Disassembler.h:112
std::vector< std::pair< size_t, CString > >::const_iterator NamedLabelIter
named label iterator
Definition: Disassembler.h:92
size_t startOffset
start offset
Definition: Disassembler.h:106
print code position
Definition: Disassembler.h:71
bool isLLVM390
if >=LLVM3.9
Definition: Disassembler.h:356
GPUDeviceType
type of GPU device
Definition: GPUId.h:51
Flags getFlags() const
get disassemblers flags
Definition: Disassembler.h:520
virtual ~DisasmException() noexcept=default
destructor
const GalliumDisasmInput * getGalliumInput() const
get disassembler input
Definition: Disassembler.h:508
cxuint symbol
symbol
Definition: Disassembler.h:253
size_t bssAlignment
alignment of global bss section
Definition: Disassembler.h:292
bool is64BitMode
true if 64-bit mode of addressing
Definition: Disassembler.h:355
size_t headerSize
kernel header size
Definition: Disassembler.h:225
utilities for other libraries and programs
std::string message
message
Definition: Utilities.h:64
print HSA configuration
Definition: Disassembler.h:72
AMD main binary for GPU for 32-bit mode.
Definition: AmdBinaries.h:568
CString kernelName
kernel name
Definition: Disassembler.h:222
exception class
Definition: Utilities.h:61
const std::vector< std::pair< size_t, CString > > & getNamedLabels() const
get named labels
Definition: Disassembler.h:186
AMD binaries generator.
size_t globalDataSize
global data size
Definition: Disassembler.h:333
print in HSA layout (like Gallium or ROCm)
Definition: Disassembler.h:73
RelocType type
relocation type
Definition: Disassembler.h:252
whole disassembler input (for AMD Catalyst driver GPU binaries)
Definition: Disassembler.h:279
size_t stubSize
data (from inner binary) size
Definition: Disassembler.h:269
ROCmRegionType type
type
Definition: Disassembler.h:311
single kernel input for disassembler
Definition: Disassembler.h:260
size_t samplerInitSize
sampler init data size
Definition: Disassembler.h:294
void setFlags(Flags flags)
set disassemblers flags
Definition: Disassembler.h:523
bool newBinFormat
new binary format
Definition: Disassembler.h:327
GPUDeviceType deviceType
GPU device type.
Definition: Disassembler.h:239
std::vector< ROCmDisasmRegionInput > regions
regions
Definition: Disassembler.h:330
size_t globalDataSize
global (constants for kernels) data size
Definition: Disassembler.h:288
const cxbyte * setup
data from inner binary
Definition: Disassembler.h:268
std::vector< AmdCL2RelaEntry > textRelocs
text relocations
Definition: Disassembler.h:271
disassembler input for raw code
Definition: Disassembler.h:368
const cxbyte * samplerInit
sampler init data
Definition: Disassembler.h:295
size_t globalDataSize
global (constants for kernels) data size
Definition: Disassembler.h:359
size_t codeSize
code size
Definition: Disassembler.h:371
std::vector< GalliumArgInfo > argInfos
arguments
Definition: Disassembler.h:348
CString compileOptions
compile options which used by in clBuildProgram
Definition: Disassembler.h:242
single kernel input for disassembler
Definition: Disassembler.h:220
uint32_t archStepping
GPU arch stepping.
Definition: Disassembler.h:325
size_t symbol
symbol index
Definition: Disassembler.h:97
Flags getFlags() const
get disassemblers flags
Definition: Disassembler.h:490
void flush()
write output buffer
Definition: InputOutput.h:379
dump metadatas
Definition: Disassembler.h:63
DisasmException()=default
empty constructor
uint32_t archMinor
GPU arch minor.
Definition: Disassembler.h:282
std::vector< std::pair< size_t, Relocation > >::const_iterator RelocIter
relocation iterator
Definition: Disassembler.h:103
Definition: ROCmBinaries.h:204
const cxbyte * code
code
Definition: Disassembler.h:332
AMD OpenCL 2.0 main binary for GPU for 64-bit mode.
Definition: AmdCL2Binaries.h:529
size_t addRelSymbol(const CString &symName)
add symbol to relocations
Definition: Disassembler.h:167
disassembler class
Definition: Disassembler.h:376
size_t codeSize
size of code of kernel
Definition: Disassembler.h:272
relocation with addend
Definition: Disassembler.h:249
std::vector< AmdCL2DisasmKernelInput > kernels
kernel inputs
Definition: Disassembler.h:302
Disassembler exception class.
Definition: Disassembler.h:47
uint32_t eflags
ELF header e_flags field.
Definition: Disassembler.h:326
size_t metadataSize
metadata size
Definition: Disassembler.h:336
simple C-string container
Definition: CString.h:38
std::vector< GalliumScratchReloc > scratchRelocs
scratch buffer text relocations
Definition: Disassembler.h:364
uint32_t offset
offset of kernel code
Definition: Disassembler.h:347