1 //===-- llvm/BinaryFormat/XCOFF.h - The XCOFF file format -------*- 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 defines manifest constants for the XCOFF object file format. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_BINARYFORMAT_XCOFF_H 14 #define LLVM_BINARYFORMAT_XCOFF_H 15 16 #include "llvm/Support/Compiler.h" 17 #include <stddef.h> 18 #include <stdint.h> 19 20 namespace llvm { 21 class StringRef; 22 template <unsigned> class SmallString; 23 template <typename T> class Expected; 24 25 namespace XCOFF { 26 27 // Constants used in the XCOFF definition. 28 29 constexpr size_t FileNamePadSize = 6; 30 constexpr size_t NameSize = 8; 31 constexpr size_t AuxFileEntNameSize = 14; 32 constexpr size_t FileHeaderSize32 = 20; 33 constexpr size_t FileHeaderSize64 = 24; 34 constexpr size_t AuxFileHeaderSize32 = 72; 35 constexpr size_t AuxFileHeaderSize64 = 110; 36 constexpr size_t AuxFileHeaderSizeShort = 28; 37 constexpr size_t SectionHeaderSize32 = 40; 38 constexpr size_t SectionHeaderSize64 = 72; 39 constexpr size_t SymbolTableEntrySize = 18; 40 constexpr size_t RelocationSerializationSize32 = 10; 41 constexpr size_t RelocationSerializationSize64 = 14; 42 constexpr size_t ExceptionSectionEntrySize32 = 6; 43 constexpr size_t ExceptionSectionEntrySize64 = 10; 44 constexpr uint16_t RelocOverflow = 65535; 45 constexpr uint8_t AllocRegNo = 31; 46 47 enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 }; 48 49 enum MagicNumber : uint16_t { XCOFF32 = 0x01DF, XCOFF64 = 0x01F7 }; 50 51 // Masks for packing/unpacking the r_rsize field of relocations. 52 53 // The msb is used to indicate if the bits being relocated are signed or 54 // unsigned. 55 static constexpr uint8_t XR_SIGN_INDICATOR_MASK = 0x80; 56 // The 2nd msb is used to indicate that the binder has replaced/modified the 57 // original instruction. 58 static constexpr uint8_t XR_FIXUP_INDICATOR_MASK = 0x40; 59 // The remaining bits specify the bit length of the relocatable reference 60 // minus one. 61 static constexpr uint8_t XR_BIASED_LENGTH_MASK = 0x3f; 62 63 // This field only exists in the XCOFF64 definition. 64 enum AuxHeaderFlags64 : uint16_t { 65 SHR_SYMTAB = 0x8000, ///< At exec time, create shared symbol table for program 66 ///< (main program only). 67 FORK_POLICY = 0x4000, ///< Forktree policy specified (main program only). 68 FORK_COR = 0x2000 ///< If _AOUT_FORK_POLICY is set, specify copy-on-reference 69 ///< if this bit is set. Specify copy-on- write otherwise. 70 ///< If _AOUT_FORK_POLICY is 0, this bit is reserved for 71 ///< future use and should be set to 0. 72 }; 73 74 enum XCOFFInterpret : uint16_t { 75 OLD_XCOFF_INTERPRET = 1, 76 NEW_XCOFF_INTERPRET = 2 77 }; 78 79 enum FileFlag : uint16_t { 80 F_RELFLG = 0x0001, ///< relocation info stripped from file 81 F_EXEC = 0x0002, ///< file is executable (i.e., it 82 ///< has a loader section) 83 F_LNNO = 0x0004, ///< line numbers stripped from file 84 F_LSYMS = 0x0008, ///< local symbols stripped from file 85 F_FDPR_PROF = 0x0010, ///< file was profiled with FDPR 86 F_FDPR_OPTI = 0x0020, ///< file was reordered with FDPR 87 F_DSA = 0x0040, ///< file uses Dynamic Segment Allocation (32-bit 88 ///< only) 89 F_DEP_1 = 0x0080, ///< Data Execution Protection bit 1 90 F_VARPG = 0x0100, ///< executable requests using variable size pages 91 F_LPTEXT = 0x0400, ///< executable requires large pages for text 92 F_LPDATA = 0x0800, ///< executable requires large pages for data 93 F_DYNLOAD = 0x1000, ///< file is dynamically loadable and 94 ///< executable (equivalent to F_EXEC on AIX) 95 F_SHROBJ = 0x2000, ///< file is a shared object 96 F_LOADONLY = 97 0x4000, ///< file can be loaded by the system loader, but it is 98 ///< ignored by the linker if it is a member of an archive. 99 F_DEP_2 = 0x8000 ///< Data Execution Protection bit 2 100 }; 101 102 // x_smclas field of x_csect from system header: /usr/include/syms.h 103 /// Storage Mapping Class definitions. 104 enum StorageMappingClass : uint8_t { 105 // READ ONLY CLASSES 106 XMC_PR = 0, ///< Program Code 107 XMC_RO = 1, ///< Read Only Constant 108 XMC_DB = 2, ///< Debug Dictionary Table 109 XMC_GL = 6, ///< Global Linkage (Interfile Interface Code) 110 XMC_XO = 7, ///< Extended Operation (Pseudo Machine Instruction) 111 XMC_SV = 8, ///< Supervisor Call (32-bit process only) 112 XMC_SV64 = 17, ///< Supervisor Call for 64-bit process 113 XMC_SV3264 = 18, ///< Supervisor Call for both 32- and 64-bit processes 114 XMC_TI = 12, ///< Traceback Index csect 115 XMC_TB = 13, ///< Traceback Table csect 116 117 // READ WRITE CLASSES 118 XMC_RW = 5, ///< Read Write Data 119 XMC_TC0 = 15, ///< TOC Anchor for TOC Addressability 120 XMC_TC = 3, ///< General TOC item 121 XMC_TD = 16, ///< Scalar data item in the TOC 122 XMC_DS = 10, ///< Descriptor csect 123 XMC_UA = 4, ///< Unclassified - Treated as Read Write 124 XMC_BS = 9, ///< BSS class (uninitialized static internal) 125 XMC_UC = 11, ///< Un-named Fortran Common 126 127 XMC_TL = 20, ///< Initialized thread-local variable 128 XMC_UL = 21, ///< Uninitialized thread-local variable 129 XMC_TE = 22 ///< Symbol mapped at the end of TOC 130 }; 131 132 // Flags for defining the section type. Masks for use with the (signed, 32-bit) 133 // s_flags field of the section header structure, selecting for values in the 134 // lower 16 bits. Defined in the system header `scnhdr.h`. 135 enum SectionTypeFlags : int32_t { 136 STYP_PAD = 0x0008, 137 STYP_DWARF = 0x0010, 138 STYP_TEXT = 0x0020, 139 STYP_DATA = 0x0040, 140 STYP_BSS = 0x0080, 141 STYP_EXCEPT = 0x0100, 142 STYP_INFO = 0x0200, 143 STYP_TDATA = 0x0400, 144 STYP_TBSS = 0x0800, 145 STYP_LOADER = 0x1000, 146 STYP_DEBUG = 0x2000, 147 STYP_TYPCHK = 0x4000, 148 STYP_OVRFLO = 0x8000 149 }; 150 151 /// Values for defining the section subtype of sections of type STYP_DWARF as 152 /// they would appear in the (signed, 32-bit) s_flags field of the section 153 /// header structure, contributing to the 16 most significant bits. Defined in 154 /// the system header `scnhdr.h`. 155 enum DwarfSectionSubtypeFlags : int32_t { 156 SSUBTYP_DWINFO = 0x1'0000, ///< DWARF info section 157 SSUBTYP_DWLINE = 0x2'0000, ///< DWARF line section 158 SSUBTYP_DWPBNMS = 0x3'0000, ///< DWARF pubnames section 159 SSUBTYP_DWPBTYP = 0x4'0000, ///< DWARF pubtypes section 160 SSUBTYP_DWARNGE = 0x5'0000, ///< DWARF aranges section 161 SSUBTYP_DWABREV = 0x6'0000, ///< DWARF abbrev section 162 SSUBTYP_DWSTR = 0x7'0000, ///< DWARF str section 163 SSUBTYP_DWRNGES = 0x8'0000, ///< DWARF ranges section 164 SSUBTYP_DWLOC = 0x9'0000, ///< DWARF loc section 165 SSUBTYP_DWFRAME = 0xA'0000, ///< DWARF frame section 166 SSUBTYP_DWMAC = 0xB'0000 ///< DWARF macinfo section 167 }; 168 169 // STORAGE CLASSES, n_sclass field of syment. 170 // The values come from `storclass.h` and `dbxstclass.h`. 171 enum StorageClass : uint8_t { 172 // Storage classes used for symbolic debugging symbols. 173 C_FILE = 103, // File name 174 C_BINCL = 108, // Beginning of include file 175 C_EINCL = 109, // Ending of include file 176 C_GSYM = 128, // Global variable 177 C_STSYM = 133, // Statically allocated symbol 178 C_BCOMM = 135, // Beginning of common block 179 C_ECOMM = 137, // End of common block 180 C_ENTRY = 141, // Alternate entry 181 C_BSTAT = 143, // Beginning of static block 182 C_ESTAT = 144, // End of static block 183 C_GTLS = 145, // Global thread-local variable 184 C_STTLS = 146, // Static thread-local variable 185 186 // Storage classes used for DWARF symbols. 187 C_DWARF = 112, // DWARF section symbol 188 189 // Storage classes used for absolute symbols. 190 C_LSYM = 129, // Automatic variable allocated on stack 191 C_PSYM = 130, // Argument to subroutine allocated on stack 192 C_RSYM = 131, // Register variable 193 C_RPSYM = 132, // Argument to function or procedure stored in register 194 C_ECOML = 136, // Local member of common block 195 C_FUN = 142, // Function or procedure 196 197 // Storage classes used for undefined external symbols or 198 // symbols of general sections. 199 C_EXT = 2, // External symbol 200 C_WEAKEXT = 111, // Weak external symbol 201 202 // Storage classes used for symbols of general sections. 203 C_NULL = 0, 204 C_STAT = 3, // Static 205 C_BLOCK = 100, // ".bb" or ".eb" 206 C_FCN = 101, // ".bf" or ".ef" 207 C_HIDEXT = 107, // Un-named external symbol 208 C_INFO = 110, // Comment string in .info section 209 C_DECL = 140, // Declaration of object (type) 210 211 // Storage classes - Obsolete/Undocumented. 212 C_AUTO = 1, // Automatic variable 213 C_REG = 4, // Register variable 214 C_EXTDEF = 5, // External definition 215 C_LABEL = 6, // Label 216 C_ULABEL = 7, // Undefined label 217 C_MOS = 8, // Member of structure 218 C_ARG = 9, // Function argument 219 C_STRTAG = 10, // Structure tag 220 C_MOU = 11, // Member of union 221 C_UNTAG = 12, // Union tag 222 C_TPDEF = 13, // Type definition 223 C_USTATIC = 14, // Undefined static 224 C_ENTAG = 15, // Enumeration tag 225 C_MOE = 16, // Member of enumeration 226 C_REGPARM = 17, // Register parameter 227 C_FIELD = 18, // Bit field 228 C_EOS = 102, // End of structure 229 C_LINE = 104, 230 C_ALIAS = 105, // Duplicate tag 231 C_HIDDEN = 106, // Special storage class for external 232 C_EFCN = 255, // Physical end of function 233 234 // Storage classes - reserved 235 C_TCSYM = 134 // Reserved 236 }; 237 238 // Flags for defining the symbol type. Values to be encoded into the lower 3 239 // bits of the (unsigned, 8-bit) x_smtyp field of csect auxiliary symbol table 240 // entries. Defined in the system header `syms.h`. 241 enum SymbolType : uint8_t { 242 XTY_ER = 0, ///< External reference. 243 XTY_SD = 1, ///< Csect definition for initialized storage. 244 XTY_LD = 2, ///< Label definition. 245 ///< Defines an entry point to an initialized csect. 246 XTY_CM = 3 ///< Common csect definition. For uninitialized storage. 247 }; 248 249 /// Values for visibility as they would appear when encoded in the high 4 bits 250 /// of the 16-bit unsigned n_type field of symbol table entries. Valid for 251 /// 32-bit XCOFF only when the vstamp in the auxiliary header is greater than 1. 252 enum VisibilityType : uint16_t { 253 SYM_V_UNSPECIFIED = 0x0000, 254 SYM_V_INTERNAL = 0x1000, 255 SYM_V_HIDDEN = 0x2000, 256 SYM_V_PROTECTED = 0x3000, 257 SYM_V_EXPORTED = 0x4000 258 }; 259 260 constexpr uint16_t VISIBILITY_MASK = 0x7000; 261 262 // Relocation types, defined in `/usr/include/reloc.h`. 263 enum RelocationType : uint8_t { 264 R_POS = 0x00, ///< Positive relocation. Provides the address of the referenced 265 ///< symbol. 266 R_RL = 0x0c, ///< Positive indirect load relocation. Modifiable instruction. 267 R_RLA = 0x0d, ///< Positive load address relocation. Modifiable instruction. 268 269 R_NEG = 0x01, ///< Negative relocation. Provides the negative of the address 270 ///< of the referenced symbol. 271 R_REL = 0x02, ///< Relative to self relocation. Provides a displacement value 272 ///< between the address of the referenced symbol and the 273 ///< address being relocated. 274 275 R_TOC = 0x03, ///< Relative to the TOC relocation. Provides a displacement 276 ///< that is the difference between the address of the 277 ///< referenced symbol and the TOC anchor csect. 278 R_TRL = 0x12, ///< TOC relative indirect load relocation. Similar to R_TOC, 279 ///< but not modifiable instruction. 280 281 R_TRLA = 282 0x13, ///< Relative to the TOC or to the thread-local storage base 283 ///< relocation. Compilers are not permitted to generate this 284 ///< relocation type. It is the result of a reversible 285 ///< transformation by the linker of an R_TOC relation that turned a 286 ///< load instruction into an add-immediate instruction. 287 288 R_GL = 0x05, ///< Global linkage-external TOC address relocation. Provides the 289 ///< address of the external TOC associated with a defined 290 ///< external symbol. 291 R_TCL = 0x06, ///< Local object TOC address relocation. Provides the address 292 ///< of the local TOC entry of a defined external symbol. 293 294 R_REF = 0x0f, ///< A non-relocating relocation. Used to prevent the binder 295 ///< from garbage collecting a csect (such as code used for 296 ///< dynamic initialization of non-local statics) for which 297 ///< another csect has an implicit dependency. 298 299 R_BA = 0x08, ///< Branch absolute relocation. Provides the address of the 300 ///< referenced symbol. References a non-modifiable instruction. 301 R_BR = 0x0a, ///< Branch relative to self relocation. Provides the 302 ///< displacement that is the difference between the address of 303 ///< the referenced symbol and the address of the referenced 304 ///< branch instruction. References a non-modifiable instruction. 305 R_RBA = 0x18, ///< Branch absolute relocation. Similar to R_BA but 306 ///< references a modifiable instruction. 307 R_RBR = 0x1a, ///< Branch relative to self relocation. Similar to the R_BR 308 ///< relocation type, but references a modifiable instruction. 309 310 R_TLS = 0x20, ///< General-dynamic reference to TLS symbol. 311 R_TLS_IE = 0x21, ///< Initial-exec reference to TLS symbol. 312 R_TLS_LD = 0x22, ///< Local-dynamic reference to TLS symbol. 313 R_TLS_LE = 0x23, ///< Local-exec reference to TLS symbol. 314 R_TLSM = 0x24, ///< Module reference to TLS. Provides a handle for the module 315 ///< containing the referenced symbol. 316 R_TLSML = 0x25, ///< Module reference to the local TLS storage. 317 318 R_TOCU = 0x30, ///< Relative to TOC upper. Specifies the high-order 16 bits of 319 ///< a large code model TOC-relative relocation. 320 R_TOCL = 0x31 ///< Relative to TOC lower. Specifies the low-order 16 bits of a 321 ///< large code model TOC-relative relocation. 322 }; 323 324 enum CFileStringType : uint8_t { 325 XFT_FN = 0, ///< Specifies the source-file name. 326 XFT_CT = 1, ///< Specifies the compiler time stamp. 327 XFT_CV = 2, ///< Specifies the compiler version number. 328 XFT_CD = 128 ///< Specifies compiler-defined information. 329 }; 330 331 enum CFileLangId : uint8_t { 332 TB_C = 0, ///< C language. 333 TB_Fortran = 1, ///< Fortran language. 334 TB_CPLUSPLUS = 9 ///< C++ language. 335 }; 336 337 // XCOFF specific CPU IDs, defined in AIX OS header: `/usr/include/aouthdr.h`. 338 enum CFileCpuId : uint8_t { 339 TCPU_INVALID = 0, ///< Invalid id - assumes POWER for old objects. 340 TCPU_PPC = 1, ///< PowerPC common architecture 32 bit mode. 341 TCPU_PPC64 = 2, ///< PowerPC common architecture 64-bit mode. 342 TCPU_COM = 3, ///< POWER and PowerPC architecture common. 343 TCPU_PWR = 4, ///< POWER common architecture objects. 344 TCPU_ANY = 5, ///< Mixture of any incompatable POWER 345 ///< and PowerPC architecture implementations. 346 TCPU_601 = 6, ///< 601 implementation of PowerPC architecture. 347 TCPU_603 = 7, ///< 603 implementation of PowerPC architecture. 348 TCPU_604 = 8, ///< 604 implementation of PowerPC architecture. 349 350 // The following are PowerPC 64-bit architectures. 351 TCPU_620 = 16, 352 TCPU_A35 = 17, 353 TCPU_PWR5 = 18, 354 TCPU_970 = 19, 355 TCPU_PWR6 = 20, 356 TCPU_PWR5X = 22, 357 TCPU_PWR6E = 23, 358 TCPU_PWR7 = 24, 359 TCPU_PWR8 = 25, 360 TCPU_PWR9 = 26, 361 TCPU_PWR10 = 27, 362 363 TCPU_PWRX = 224 ///< RS2 implementation of POWER architecture. 364 }; 365 366 enum SymbolAuxType : uint8_t { 367 AUX_EXCEPT = 255, ///< Identifies an exception auxiliary entry. 368 AUX_FCN = 254, ///< Identifies a function auxiliary entry. 369 AUX_SYM = 253, ///< Identifies a symbol auxiliary entry. 370 AUX_FILE = 252, ///< Identifies a file auxiliary entry. 371 AUX_CSECT = 251, ///< Identifies a csect auxiliary entry. 372 AUX_SECT = 250 ///< Identifies a SECT auxiliary entry. 373 }; // 64-bit XCOFF file only. 374 375 LLVM_ABI StringRef getMappingClassString(XCOFF::StorageMappingClass SMC); 376 LLVM_ABI StringRef getRelocationTypeString(XCOFF::RelocationType Type); 377 LLVM_ABI StringRef getTCPUString(XCOFF::CFileCpuId TCPU); 378 LLVM_ABI Expected<SmallString<32>> parseParmsType(uint32_t Value, 379 unsigned FixedParmsNum, 380 unsigned FloatingParmsNum); 381 LLVM_ABI Expected<SmallString<32>> 382 parseParmsTypeWithVecInfo(uint32_t Value, unsigned FixedParmsNum, 383 unsigned FloatingParmsNum, unsigned VectorParmsNum); 384 LLVM_ABI Expected<SmallString<32>> parseVectorParmsType(uint32_t Value, 385 unsigned ParmsNum); 386 387 struct TracebackTable { 388 enum LanguageID : uint8_t { 389 C, 390 Fortran, 391 Pascal, 392 Ada, 393 PL1, 394 Basic, 395 Lisp, 396 Cobol, 397 Modula2, 398 CPlusPlus, 399 Rpg, 400 PL8, 401 PLIX = PL8, 402 Assembly, 403 Java, 404 ObjectiveC 405 }; 406 // Byte 1 407 static constexpr uint32_t VersionMask = 0xFF00'0000; 408 static constexpr uint8_t VersionShift = 24; 409 410 // Byte 2 411 static constexpr uint32_t LanguageIdMask = 0x00FF'0000; 412 static constexpr uint8_t LanguageIdShift = 16; 413 414 // Byte 3 415 static constexpr uint32_t IsGlobaLinkageMask = 0x0000'8000; 416 static constexpr uint32_t IsOutOfLineEpilogOrPrologueMask = 0x0000'4000; 417 static constexpr uint32_t HasTraceBackTableOffsetMask = 0x0000'2000; 418 static constexpr uint32_t IsInternalProcedureMask = 0x0000'1000; 419 static constexpr uint32_t HasControlledStorageMask = 0x0000'0800; 420 static constexpr uint32_t IsTOClessMask = 0x0000'0400; 421 static constexpr uint32_t IsFloatingPointPresentMask = 0x0000'0200; 422 static constexpr uint32_t IsFloatingPointOperationLogOrAbortEnabledMask = 423 0x0000'0100; 424 425 // Byte 4 426 static constexpr uint32_t IsInterruptHandlerMask = 0x0000'0080; 427 static constexpr uint32_t IsFunctionNamePresentMask = 0x0000'0040; 428 static constexpr uint32_t IsAllocaUsedMask = 0x0000'0020; 429 static constexpr uint32_t OnConditionDirectiveMask = 0x0000'001C; 430 static constexpr uint32_t IsCRSavedMask = 0x0000'0002; 431 static constexpr uint32_t IsLRSavedMask = 0x0000'0001; 432 static constexpr uint8_t OnConditionDirectiveShift = 2; 433 434 // Byte 5 435 static constexpr uint32_t IsBackChainStoredMask = 0x8000'0000; 436 static constexpr uint32_t IsFixupMask = 0x4000'0000; 437 static constexpr uint32_t FPRSavedMask = 0x3F00'0000; 438 static constexpr uint32_t FPRSavedShift = 24; 439 440 // Byte 6 441 static constexpr uint32_t HasExtensionTableMask = 0x0080'0000; 442 static constexpr uint32_t HasVectorInfoMask = 0x0040'0000; 443 static constexpr uint32_t GPRSavedMask = 0x003F'0000; 444 static constexpr uint32_t GPRSavedShift = 16; 445 446 // Byte 7 447 static constexpr uint32_t NumberOfFixedParmsMask = 0x0000'FF00; 448 static constexpr uint8_t NumberOfFixedParmsShift = 8; 449 450 // Byte 8 451 static constexpr uint32_t NumberOfFloatingPointParmsMask = 0x0000'00FE; 452 static constexpr uint32_t HasParmsOnStackMask = 0x0000'0001; 453 static constexpr uint8_t NumberOfFloatingPointParmsShift = 1; 454 455 // Masks to select leftmost bits for decoding parameter type information. 456 // Bit to use when vector info is not presented. 457 static constexpr uint32_t ParmTypeIsFloatingBit = 0x8000'0000; 458 static constexpr uint32_t ParmTypeFloatingIsDoubleBit = 0x4000'0000; 459 // Bits to use when vector info is presented. 460 static constexpr uint32_t ParmTypeIsFixedBits = 0x0000'0000; 461 static constexpr uint32_t ParmTypeIsVectorBits = 0x4000'0000; 462 static constexpr uint32_t ParmTypeIsFloatingBits = 0x8000'0000; 463 static constexpr uint32_t ParmTypeIsDoubleBits = 0xC000'0000; 464 static constexpr uint32_t ParmTypeMask = 0xC000'0000; 465 466 // Vector extension 467 static constexpr uint16_t NumberOfVRSavedMask = 0xFC00; 468 static constexpr uint16_t IsVRSavedOnStackMask = 0x0200; 469 static constexpr uint16_t HasVarArgsMask = 0x0100; 470 static constexpr uint8_t NumberOfVRSavedShift = 10; 471 472 static constexpr uint16_t NumberOfVectorParmsMask = 0x00FE; 473 static constexpr uint16_t HasVMXInstructionMask = 0x0001; 474 static constexpr uint8_t NumberOfVectorParmsShift = 1; 475 476 static constexpr uint32_t ParmTypeIsVectorCharBit = 0x0000'0000; 477 static constexpr uint32_t ParmTypeIsVectorShortBit = 0x4000'0000; 478 static constexpr uint32_t ParmTypeIsVectorIntBit = 0x8000'0000; 479 static constexpr uint32_t ParmTypeIsVectorFloatBit = 0xC000'0000; 480 481 static constexpr uint8_t WidthOfParamType = 2; 482 }; 483 484 // Extended Traceback table flags. 485 enum ExtendedTBTableFlag : uint8_t { 486 TB_OS1 = 0x80, ///< Reserved for OS use. 487 TB_RESERVED = 0x40, ///< Reserved for compiler. 488 TB_SSP_CANARY = 0x20, ///< stack smasher canary present on stack. 489 TB_OS2 = 0x10, ///< Reserved for OS use. 490 TB_EH_INFO = 0x08, ///< Exception handling info present. 491 TB_LONGTBTABLE2 = 0x01 ///< Additional tbtable extension exists. 492 }; 493 494 LLVM_ABI StringRef 495 getNameForTracebackTableLanguageId(TracebackTable::LanguageID LangId); 496 LLVM_ABI SmallString<32> getExtendedTBTableFlagString(uint8_t Flag); 497 LLVM_ABI XCOFF::CFileCpuId getCpuID(StringRef CPU); 498 499 struct CsectProperties { CsectPropertiesCsectProperties500 CsectProperties(StorageMappingClass SMC, SymbolType ST) 501 : MappingClass(SMC), Type(ST) {} 502 StorageMappingClass MappingClass; 503 SymbolType Type; 504 }; 505 506 } // end namespace XCOFF 507 } // end namespace llvm 508 509 #endif 510