CLRX  1
An unofficial OpenCL extensions designed for Radeon GPUs
AsmFormats.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_ASMFORMATS_H__
24 #define __CLRX_ASMFORMATS_H__
25 
26 #include <CLRX/Config.h>
27 #include <cstdint>
28 #include <string>
29 #include <vector>
30 #include <utility>
31 #include <memory>
32 #include <unordered_set>
33 #include <unordered_map>
36 #include <CLRX/amdbin/AmdBinGen.h>
39 #include <CLRX/utils/Utilities.h>
40 #include <CLRX/utils/GPUId.h>
41 #include <CLRX/amdasm/Commons.h>
42 
43 namespace CLRX
44 {
45 
48 {
49  DATA = 0,
50  CODE,
51  CONFIG,
53 
54  AMD_HEADER = LAST_COMMON+1,
55  AMD_METADATA,
56  AMD_CALNOTE,
57 
58  AMDCL2_RWDATA = LAST_COMMON+1,
59  AMDCL2_BSS,
60  AMDCL2_SAMPLERINIT,
61  AMDCL2_SETUP,
62  AMDCL2_STUB,
63  AMDCL2_METADATA,
64  AMDCL2_ISAMETADATA,
65  AMDCL2_CONFIG_CTRL_DIRECTIVE,
66  AMDCL2_DUMMY,
67 
68  GALLIUM_COMMENT = LAST_COMMON+1,
69  GALLIUM_CONFIG_CTRL_DIRECTIVE,
71 
72  ROCM_COMMENT = LAST_COMMON+1,
73  ROCM_CONFIG_CTRL_DIRECTIVE,
74  ROCM_METADATA,
75  ROCM_GOT,
76 
77  EXTRA_FIRST = 0xfc,
78  EXTRA_PROGBITS = 0xfc,
79  EXTRA_NOBITS = 0xfd,
80  EXTRA_NOTE = 0xfe,
81  EXTRA_SECTION = 0xff
82 };
83 
84 enum: AsmSectionId
85 {
86  ASMSECT_ABS = UINT_MAX,
87  ASMSECT_NONE = UINT_MAX,
88 };
89 
90 enum: AsmKernelId
91 {
92  ASMKERN_GLOBAL = UINT_MAX,
93  ASMKERN_INNER = UINT_MAX-1
94 };
95 
96 enum: Flags
97 {
98  ASMSECT_WRITEABLE = 1,
99  ASMSECT_ADDRESSABLE = 2,
100  ASMSECT_ABS_ADDRESSABLE = 4,
102 
103  ASMELFSECT_ALLOCATABLE = 0x10,
104  ASMELFSECT_WRITEABLE = 0x20,
105  ASMELFSECT_EXECUTABLE = 0x40
106 };
107 
108 class Assembler;
109 class AsmExpression;
110 struct AsmRelocation;
111 struct AsmSymbol;
112 
115 {
116 public:
118  AsmFormatException() = default;
120  explicit AsmFormatException(const std::string& message);
122  virtual ~AsmFormatException() noexcept = default;
123 };
124 
127 {
128 public:
130  struct SectionInfo
131  {
132  const char* name;
136 
137  SectionInfo() : name(nullptr), type(AsmSectionType::DATA), flags(0),
138  relSpace(UINT_MAX)
139  { }
140  SectionInfo(const char* _name, AsmSectionType _type, Flags _flags = 0,
141  cxuint _relSpace = UINT_MAX) : name(_name), type(_type), flags(_flags),
142  relSpace(_relSpace)
143  { }
144  };
145 
146  struct KernelBase
147  {
148  cxuint allocRegs[MAX_REGTYPES_NUM];
149  Flags allocRegFlags;
150  Flags codeFlags;
151  };
152 protected:
154  bool sectionDiffsResolvable;
155 
157  explicit AsmFormatHandler(Assembler& assembler);
158 
159  // resolve LO32BIT/HI32BIT relocations (partially, helper)
160  bool resolveLoHiRelocExpression(const AsmExpression* expr, RelocType& relType,
161  AsmSectionId& relSectionId, uint64_t& relValue);
162 public:
163  virtual ~AsmFormatHandler();
164 
167  { return sectionDiffsResolvable; }
168 
170 
176  virtual AsmKernelId addKernel(const char* kernelName) = 0;
178 
185  virtual AsmSectionId addSection(const char* sectionName, AsmKernelId kernelId) = 0;
186 
188  virtual AsmSectionId getSectionId(const char* sectionName) const = 0;
189 
191  virtual void setCurrentKernel(AsmKernelId kernel) = 0;
193  virtual void setCurrentSection(AsmSectionId sectionId) = 0;
194 
196  virtual SectionInfo getSectionInfo(AsmSectionId sectionId) const = 0;
198  virtual bool parsePseudoOp(const CString& firstName,
199  const char* stmtPlace, const char* linePtr) = 0;
201  virtual void handleLabel(const CString& label);
203  virtual bool resolveSymbol(const AsmSymbol& symbol,
204  uint64_t& value, AsmSectionId& sectionId);
206  virtual bool resolveRelocation(const AsmExpression* expr,
207  uint64_t& value, AsmSectionId& sectionId);
209  virtual bool prepareBinary() = 0;
211  virtual void writeBinary(std::ostream& os) const = 0;
213  virtual void writeBinary(Array<cxbyte>& array) const = 0;
214 
216  virtual bool prepareSectionDiffsResolving();
217  virtual void setCodeFlags(Flags codeFlags);
218 };
219 
222 {
223 protected:
224  friend struct AsmKcodePseudoOps;
225  std::vector<AsmKernelId> kcodeSelection; // kcode
226  std::stack<std::vector<AsmKernelId> > kcodeSelStack;
227  AsmKernelId currentKcodeKernel;
228  AsmSectionId codeSection;
229 
230  explicit AsmKcodeHandler(Assembler& assembler);
231  ~AsmKcodeHandler() = default;
232 
233  void restoreKcodeCurrentAllocRegs();
234  void saveKcodeCurrentAllocRegs();
235  // prepare kcode state while preparing binary
236  void prepareKcodeState();
237 public:
238  void handleLabel(const CString& label);
239 
241  virtual bool isCodeSection() const = 0;
243  virtual KernelBase& getKernelBase(AsmKernelId index) = 0;
245  virtual const KernelBase& getKernelBase(AsmKernelId index) const = 0;
247  virtual size_t getKernelsNum() const = 0;
248 };
249 
252 {
253 public:
255  explicit AsmRawCodeHandler(Assembler& assembler);
257  ~AsmRawCodeHandler() = default;
258 
259  AsmKernelId addKernel(const char* kernelName);
260  AsmSectionId addSection(const char* sectionName, AsmKernelId kernelId);
261 
262  AsmSectionId getSectionId(const char* sectionName) const;
263 
264  void setCurrentKernel(AsmKernelId kernel);
265  void setCurrentSection(AsmSectionId sectionId);
266 
267  SectionInfo getSectionInfo(AsmSectionId sectionId) const;
268  bool parsePseudoOp(const CString& firstName,
269  const char* stmtPlace, const char* linePtr);
270 
271  bool prepareBinary();
272  void writeBinary(std::ostream& os) const;
273  void writeBinary(Array<cxbyte>& array) const;
274 };
275 
278 {
279 private:
280  typedef std::unordered_map<CString, AsmSectionId> SectionMap;
281  friend struct AsmAmdPseudoOps;
282  AmdInput output;
283  struct Section
284  {
285  AsmKernelId kernelId;
286  AsmSectionType type;
287  AsmSectionId elfBinSectId;
288  const char* name;
289  uint32_t extraId; // for example CALNote id
290  };
291  struct Kernel : KernelBase
292  {
293  AsmSectionId headerSection;
294  AsmSectionId metadataSection;
295  AsmSectionId configSection;
296  AsmSectionId codeSection;
297  AsmSectionId dataSection;
298  std::vector<AsmSectionId> calNoteSections;
299  SectionMap extraSectionMap;
300  AsmSectionId extraSectionCount;
301  AsmSectionId savedSection;
302  std::unordered_set<CString> argNamesSet;
303 
304  explicit Kernel(AsmSectionId _codeSection = ASMSECT_NONE) : KernelBase{},
305  headerSection(ASMSECT_NONE), metadataSection(ASMSECT_NONE),
306  configSection(ASMSECT_NONE), codeSection(_codeSection),
307  dataSection(ASMSECT_NONE), extraSectionCount(0),
308  savedSection(ASMSECT_NONE)
309  { }
310  };
311  std::vector<Section> sections;
312  // use pointer to prevents copying Kernel objects
313  std::vector<Kernel*> kernelStates;
314  SectionMap extraSectionMap;
315  AsmSectionId dataSection; // global
316  AsmSectionId savedSection;
317  AsmSectionId extraSectionCount;
318 
319  cxuint detectedDriverVersion;
320 
321  void saveCurrentSection();
322  void restoreCurrentAllocRegs();
323  void saveCurrentAllocRegs();
324 
325  cxuint determineDriverVersion() const;
326 public:
328  explicit AsmAmdHandler(Assembler& assembler);
330  ~AsmAmdHandler();
331 
332  AsmKernelId addKernel(const char* kernelName);
333  AsmSectionId addSection(const char* sectionName, AsmKernelId kernelId);
334 
335  AsmSectionId getSectionId(const char* sectionName) const;
336  void setCurrentKernel(AsmKernelId kernel);
337  void setCurrentSection(AsmSectionId sectionId);
338 
339  SectionInfo getSectionInfo(AsmSectionId sectionId) const;
340  bool parsePseudoOp(const CString& firstName,
341  const char* stmtPlace, const char* linePtr);
342 
343  bool prepareBinary();
344  void writeBinary(std::ostream& os) const;
345  void writeBinary(Array<cxbyte>& array) const;
347  const AmdInput* getOutput() const
348  { return &output; }
349 };
350 
353 {
358  bool ieeeMode;
362  bool tgSize;
363  bool debugMode;
365  bool dx10Clamp;
366  cxuint sharedVGPRsNum;
367  uint32_t pgmRsrc3;
368 
369  void initialize();
370 };
371 
374 {
375 private:
376  typedef std::unordered_map<CString, AsmSectionId> SectionMap;
377  friend struct AsmAmdCL2PseudoOps;
378  AmdCL2Input output;
379  struct Section
380  {
381  AsmKernelId kernelId;
382  AsmSectionType type;
383  AsmSectionId elfBinSectId;
384  const char* name;
385  uint32_t extraId;
386  };
387  struct Relocation
388  {
389  RelocType type;
390  cxuint symbol; // 0,1,2
391  size_t addend;
392  };
393  /* relocmap: key - symbol, value - relocation */
394  typedef std::unordered_map<CString, Relocation> RelocMap;
395  struct Kernel : KernelBase
396  {
397  AsmSectionId stubSection;
398  AsmSectionId setupSection;
399  AsmSectionId metadataSection;
400  AsmSectionId isaMetadataSection;
401  AsmSectionId configSection;
402  AsmSectionId ctrlDirSection;
403  AsmSectionId codeSection;
404  AsmSectionId savedSection;
405  bool useHsaConfig; //
406  std::unique_ptr<AsmAmdHsaKernelConfig> hsaConfig; // hsaConfig
407  std::unordered_set<CString> argNamesSet;
408 
409  explicit Kernel(AsmSectionId _codeSection = ASMSECT_NONE) : KernelBase{},
410  stubSection(ASMSECT_NONE), setupSection(ASMSECT_NONE),
411  metadataSection(ASMSECT_NONE), isaMetadataSection(ASMSECT_NONE),
412  configSection(ASMSECT_NONE), ctrlDirSection(ASMSECT_NONE),
413  codeSection(_codeSection), savedSection(ASMSECT_NONE),
414  useHsaConfig(false)
415  { }
416 
417  void initializeKernelConfig();
418  };
419  std::vector<Section> sections;
420  // use pointer to prevents copying Kernel objects
421  std::vector<Kernel*> kernelStates;
422  RelocMap relocsMap;
423  SectionMap extraSectionMap;
424  SectionMap innerExtraSectionMap;
425  AsmSectionId rodataSection; // global inner
426  AsmSectionId dataSection; // global inner
427  AsmSectionId bssSection; // global inner
428  AsmSectionId samplerInitSection;
429  AsmSectionId savedSection;
430  AsmSectionId innerSavedSection;
431  AsmSectionId extraSectionCount;
432  AsmSectionId innerExtraSectionCount;
433  bool hsaLayout;
434 
435  cxuint detectedDriverVersion;
436 
437  void saveCurrentSection();
438  void restoreCurrentAllocRegs();
439  void saveCurrentAllocRegs();
440  cxuint getDriverVersion() const;
441 public:
443  explicit AsmAmdCL2Handler(Assembler& assembler);
445  ~AsmAmdCL2Handler();
446 
447  AsmKernelId addKernel(const char* kernelName);
448  AsmSectionId addSection(const char* sectionName, AsmKernelId kernelId);
449 
450  AsmSectionId getSectionId(const char* sectionName) const;
451  void setCurrentKernel(AsmKernelId kernel);
452  void setCurrentSection(AsmSectionId sectionId);
453 
454  SectionInfo getSectionInfo(AsmSectionId sectionId) const;
455  bool parsePseudoOp(const CString& firstName,
456  const char* stmtPlace, const char* linePtr);
457 
458  bool resolveSymbol(const AsmSymbol& symbol, uint64_t& value, AsmSectionId& sectionId);
459  bool resolveRelocation(const AsmExpression* expr, uint64_t& value,
460  AsmSectionId& sectionId);
461  bool prepareBinary();
462  void writeBinary(std::ostream& os) const;
463  void writeBinary(Array<cxbyte>& array) const;
465  const AmdCL2Input* getOutput() const
466  { return &output; }
467 
468  // kcode support
469  bool isCodeSection() const;
470  KernelBase& getKernelBase(AsmKernelId index);
471  const KernelBase& getKernelBase(AsmKernelId index) const;
472  size_t getKernelsNum() const;
473  void handleLabel(const CString& label);
474 };
475 
478 {
479 private:
480  enum class Inside : cxbyte {
481  MAINLAYOUT, CONFIG, ARGS, PROGINFO
482  };
483 
484  typedef std::unordered_map<CString, AsmSectionId> SectionMap;
485  friend struct AsmGalliumPseudoOps;
486  GalliumInput output;
487  struct Section
488  {
489  AsmKernelId kernelId;
490  AsmSectionType type;
491  AsmSectionId elfBinSectId;
492  const char* name; // must be available by whole lifecycle
493  };
494  struct Kernel : KernelBase
495  {
496  AsmSectionId defaultSection;
497  std::unique_ptr<AsmAmdHsaKernelConfig> hsaConfig;
498  AsmSectionId ctrlDirSection;
499  bool hasProgInfo;
500  cxbyte progInfoEntries;
501 
502  explicit Kernel(AsmSectionId _defaultSection = ASMSECT_NONE) : KernelBase{},
503  defaultSection(_defaultSection), hsaConfig(nullptr),
504  ctrlDirSection(ASMSECT_NONE), hasProgInfo(false), progInfoEntries(0)
505  { }
506 
507  void initializeAmdHsaKernelConfig();
508  };
509  std::vector<Kernel*> kernelStates;
510  std::vector<Section> sections;
511  SectionMap extraSectionMap;
512  AsmSectionId dataSection;
513  AsmSectionId commentSection;
514  AsmSectionId scratchSection;
515  AsmSectionId savedSection;
516  Inside inside;
517  AsmSectionId extraSectionCount;
518 
519  cxuint detectedDriverVersion;
520  cxuint detectedLLVMVersion;
521 
522  uint32_t archMinor;
523  uint32_t archStepping;
524 
525  cxuint determineDriverVersion() const;
526  cxuint determineLLVMVersion() const;
527 public:
529  explicit AsmGalliumHandler(Assembler& assembler);
532 
533  AsmKernelId addKernel(const char* kernelName);
534  AsmSectionId addSection(const char* sectionName, AsmKernelId kernelId);
535 
536  AsmSectionId getSectionId(const char* sectionName) const;
537  void setCurrentKernel(AsmKernelId kernel);
538  void setCurrentSection(AsmSectionId sectionId);
539 
540  SectionInfo getSectionInfo(AsmSectionId sectionId) const;
541  bool parsePseudoOp(const CString& firstName,
542  const char* stmtPlace, const char* linePtr);
543 
544  bool resolveSymbol(const AsmSymbol& symbol, uint64_t& value, AsmSectionId& sectionId);
545  bool resolveRelocation(const AsmExpression* expr, uint64_t& value,
546  AsmSectionId& sectionId);
547  bool prepareBinary();
548  void writeBinary(std::ostream& os) const;
549  void writeBinary(Array<cxbyte>& array) const;
551  const GalliumInput* getOutput() const
552  { return &output; }
553 
554  // kcode support
555  bool isCodeSection() const;
556  KernelBase& getKernelBase(AsmKernelId index);
557  const KernelBase& getKernelBase(AsmKernelId index) const;
558  size_t getKernelsNum() const;
559 };
560 
562 
565 {
566 private:
567  typedef std::unordered_map<CString, AsmSectionId> SectionMap;
568  friend struct AsmROCmPseudoOps;
569  ROCmInput output;
570  std::unique_ptr<ROCmBinGenerator> binGen;
571  struct Section
572  {
573  AsmKernelId kernelId;
574  AsmSectionType type;
575  AsmSectionId elfBinSectId;
576  const char* name; // must be available by whole lifecycle
577  };
578  struct Kernel : KernelBase
579  {
580  AsmSectionId configSection;
581  std::unique_ptr<AsmROCmKernelConfig> config;
582  bool isFKernel;
583  AsmSectionId ctrlDirSection;
584  AsmSectionId savedSection;
585 
586  explicit Kernel(AsmSectionId _configSection = ASMSECT_NONE): KernelBase{},
587  configSection(_configSection), config(nullptr), isFKernel(false),
588  ctrlDirSection(ASMSECT_NONE), savedSection(ASMSECT_NONE)
589  { }
590 
591  void initializeKernelConfig();
592  };
593  std::vector<Kernel*> kernelStates;
594  std::vector<Section> sections;
595  std::vector<CString> gotSymbols;
596  SectionMap extraSectionMap;
597  AsmSectionId commentSection;
598  AsmSectionId metadataSection;
599  AsmSectionId dataSection;
600  AsmSectionId gotSection;
601  AsmSectionId savedSection;
602  AsmSectionId extraSectionCount;
603 
604  size_t prevSymbolsCount;
605 
606  bool unresolvedGlobals;
607  bool good;
608 
609  void addSymbols(bool sectionDiffsPrepared);
610 public:
612  explicit AsmROCmHandler(Assembler& assembler);
614  ~AsmROCmHandler();
615 
616  AsmKernelId addKernel(const char* kernelName);
617  AsmSectionId addSection(const char* sectionName, AsmKernelId kernelId);
618 
619  AsmSectionId getSectionId(const char* sectionName) const;
620  void setCurrentKernel(AsmKernelId kernel);
621  void setCurrentSection(AsmSectionId sectionId);
622 
623  SectionInfo getSectionInfo(AsmSectionId sectionId) const;
624  bool parsePseudoOp(const CString& firstName,
625  const char* stmtPlace, const char* linePtr);
626 
627  bool prepareBinary();
628  void writeBinary(std::ostream& os) const;
629  void writeBinary(Array<cxbyte>& array) const;
631  const ROCmInput* getOutput() const
632  { return &output; }
633 
634  bool prepareSectionDiffsResolving();
635 
636  // kcode support
637  bool isCodeSection() const;
638  KernelBase& getKernelBase(AsmKernelId index);
639  const KernelBase& getKernelBase(AsmKernelId index) const;
640  size_t getKernelsNum() const;
641  void setCodeFlags(Flags codeFlags);
642 };
643 
644 };
645 
646 #endif
code of program or kernel
common definitions for assembler and disassembler
main class of assembler
Definition: Assembler.h:529
Assembler & assembler
assembler reference
Definition: AsmFormats.h:153
non copyable and non movable base structure (class)
Definition: Utilities.h:46
assembler expression class
Definition: AsmDefs.h:286
uint32_t Flags
type for declaring various flags
Definition: Utilities.h:100
dummy (empty) section for kernel
ROCm binary input structure.
Definition: ROCmBinaries.h:423
cxbyte userDataNum
number of user data
Definition: AsmFormats.h:357
no kernel, inner global space
Definition: AsmFormats.h:93
Flags flags
section flags
Definition: AsmFormats.h:134
configuration (global or for kernel)
bool privilegedMode
prvileged mode
Definition: AsmFormats.h:364
AMD Catalyst kernel&#39;s metadata.
handles raw code format
Definition: AsmFormats.h:251
Gallium input.
Definition: GalliumBinaries.h:443
AsmSectionType type
section type
Definition: AsmFormats.h:133
bool debugMode
debug mode
Definition: AsmFormats.h:363
AMD HSA kernel configuration structure.
Definition: Commons.h:66
ROCm binaries handling.
const char * name
section name
Definition: AsmFormats.h:132
an array class
Definition: Containers.h:41
bool isSectionDiffsResolvable() const
return true if format handler can resolve differences between sections
Definition: AsmFormats.h:166
bool ieeeMode
IEEE mode.
Definition: AsmFormats.h:358
cxbyte floatMode
float mode
Definition: AsmFormats.h:359
Configuration header.
cxuint AsmSectionId
type for Asm section id (index)
Definition: Commons.h:35
Definition: AsmFormats.h:146
handles ROCM binary format
Definition: AsmFormats.h:564
cxuint RelocType
relocation type
Definition: Commons.h:33
bool tgSize
enable TG_SIZE_EN bit
Definition: AsmFormats.h:362
empty section for scratch symbol
GalliumCompute binaries handling (only with LLVM 3.6)
assembler relocation
Definition: AsmDefs.h:265
const AmdCL2Input * getOutput() const
get output structure pointer
Definition: AsmFormats.h:465
AsmSectionType
assembler section type
Definition: AsmFormats.h:47
AMD binaries handling.
assembler format handler
Definition: AsmFormats.h:126
unsigned char cxbyte
unsigned byte
Definition: Config.h:229
AMD OpenCL2 binaries generator.
main namespace
Definition: AsmDefs.h:38
format handler with Kcode (kernel-code) handling
Definition: AsmFormats.h:221
unsigned int cxuint
unsigned int
Definition: Config.h:237
const GalliumInput * getOutput() const
get output object (input for bingenerator)
Definition: AsmFormats.h:551
cxuint AsmKernelId
type for Asm kernel id (index)
Definition: Commons.h:33
section information
Definition: AsmFormats.h:130
AMD Catalyst kernel&#39;s header.
no kernel, global space
Definition: AsmFormats.h:92
utilities for other libraries and programs
exception class
Definition: Utilities.h:61
AMD binaries generator.
main Input for AmdCL2GPUBinGenerator
Definition: AmdCL2BinGen.h:119
cxuint usedVGPRsNum
number of used VGPRs
Definition: AsmFormats.h:355
cxbyte priority
priority
Definition: AsmFormats.h:360
cxuint relSpace
relative space
Definition: AsmFormats.h:135
GPU identification utilities.
const AmdInput * getOutput() const
get output structure pointer
Definition: AsmFormats.h:347
main Input for AmdGPUBinGenerator
Definition: AmdBinGen.h:154
bool dx10Clamp
DX10 CLAMP mode.
Definition: AsmFormats.h:365
section is unresolvable
Definition: AsmFormats.h:101
const ROCmInput * getOutput() const
get output object (input for bingenerator)
Definition: AsmFormats.h:631
none section id
Definition: AsmFormats.h:87
kernel or global data
cxuint dimMask
mask of dimension (bits: 0 - X, 1 - Y, 2 - Z)
Definition: AsmFormats.h:354
handles GalliumCompute format
Definition: AsmFormats.h:477
absolute section id
Definition: AsmFormats.h:86
cxuint usedSGPRsNum
number of used SGPRs
Definition: AsmFormats.h:356
assembler symbol structure
Definition: AsmDefs.h:143
cxbyte exceptions
enabled exceptions
Definition: AsmFormats.h:361
handles AMD Catalyst format
Definition: AsmFormats.h:277
handles AMD OpenCL 2.0 binary format
Definition: AsmFormats.h:373
assembler format exception
Definition: AsmFormats.h:114
Asm AMD HSA kernel configuration.
Definition: AsmFormats.h:352
simple C-string container
Definition: CString.h:38