Subversion Repositories Kolibri OS

 

 

 

 

struct SOpcodeDef {

   const char * Name;                  // opcode name

   uint32 InstructionSet;              // mmx, sse, 3dnow, x64, etc.

   uint32 AllowedPrefixes;             // prefixes allowed for this opcode

   uint16 InstructionFormat;           // opcode type, number of operands

   uint16 Destination;                 // type and size of destination operand

   uint16 Source1;                     // type and size of 1. source operand

   uint16 Source2;                     // type and size of 2. source operand

   uint16 Source3;                     // type and size of 3. source operand

   uint16 EVEX;                        // options for interpreting EVEX prefix, may be used for 4. source operand otherwise (unused)

   uint16 MVEX;                        // options for interpreting MVEX prefix: swizzle, convert, mask options

   uint16 TableLink;                   // this entry is a link to another map

   uint16 Options;                     // miscellaneous options

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

struct SwizSpec {

    uint32 memop;       // memory operand type

    uint32 memopsize;   // memory operand size = byte offset multiplier = required alignment

    uint32 elementsize; // memory operand size for broadcast, gather and scatter instructions

    const char * name;  // name of permutation, conversion or rounding

 

 

 

struct SOpcodeProp {

   SOpcodeDef const * OpcodeDef;                 // Points to entry in opcode map

   uint8  Prefixes[8];                           // Stores the last prefix encountered in each category

   uint8  Conflicts[8];                          // Counts prefix conflicts as different prefixes in the same category

   uint32 Warnings1;                             // Warnings about conditions that could be intentional and suboptimal code

   uint32 Warnings2;                             // Warnings about possible misinterpretation

   uint32 Errors;                                // Errors that will prevent execution or are unlikely to be intentional

   uint32 AddressSize;                           // Address size: 16, 32 or 64

   uint32 OperandSize;                           // Operand size: 16, 32 or 64

   uint32 MaxNumOperands;                        // Number of opcode table operands to check

   uint32 Mod;                                   // mod bits of mod/reg/rm byte

   uint32 Reg;                                   // reg bits of mod/reg/rm byte

   uint32 RM;                                    // r/m bits of mod/reg/rm byte

   uint32 MFlags;                                // Memory operand type: 1=has memory operand, 2=has mod/reg/rm byte, 4=has SIB byte, 8=has VEX or DREX byte, 0x100=is rip-relative

   uint32 BaseReg;                               // Base  register + 1. (0 if none)

   uint32 IndexReg;                              // Index register + 1. (0 if none)

   uint32 Scale;                                 // Scale factor = 2^Scale

   uint32 Vreg;                                  // ~VEX.vvvv or AMD DREX byte

   uint32 Kreg;                                  // EVEX.aaa = MVEX.kkk mask register

   uint32 Esss;                                  // EVEX.zLLb = MVEX.Esss option bits

   SwizSpec const * SwizRecord;                  // Selected entry in MVEX table for MVEX code

   uint32 OffsetMultiplier;                      // Multiplier for 1-byte offset calculated from EVEX or obtained from MVEX.sss and table lookup

   uint32 Operands[5];                           // Operand types for destination, source, immediate

   uint32 OpcodeStart1;                          // Index to first opcode byte, after prefixes

   uint32 OpcodeStart2;                          // Index to last opcode byte, after 0F, 0F 38, etc., before mod/reg/rm byte and operands

   uint32 AddressField;                          // Beginning of address/displacement field

   uint32 AddressFieldSize;                      // Size of address/displacement field

   uint32 AddressRelocation;                     // Relocation pointing to address field

   uint32 ImmediateField;                        // Beginning of immediate operand or jump address field

   uint32 ImmediateFieldSize;                    // Size of immediate operand or jump address field

   uint32 ImmediateRelocation;                   // Relocation pointing to immediate operand or jump address field

   const char * OpComment;                       // Additional comment for opcode

   void   Reset() {                              // Set everything to zero

      memset(this, 0, sizeof(*this));}

 

 

struct SATracer {

   uint8  Regist[16];                            // Defines the type of information contained in each g.p. register

   uint32 Value[16];                             // Meaning depends on the value of Regist[i]

   void Reset() {                                // Set to zero

      *(uint64*)Regist = 0; *(uint64*)(Regist+8) = 0;

   }

 

struct SASection {

   uint8 * Start;                                // Point to start of binary data

   uint32  SectionAddress;                       // Address of section (image relative)

   uint32  InitSize;                             // Size of initialized data in section

   uint32  TotalSize;                            // Size of initialized and uninitialized data in section

   uint32  Type;                                 // 0 = unknown, 1 = code,

                                                 // 2 = data, 3 = uninitialized data only, 4 = constant data,

                                                 // 0x10 = debug info, 0x11 = exception info.

                                                 // 0x800 = segment group

                                                 // 0x1000 = communal section

   uint32  Align;                                // Alignment = 1 << Align

   uint32  WordSize;                             // Word size, 16, 32, 64

   uint32  Name;                                 // Name, as index into CDisassembler::NameBuffer

   int32   Group;                                // Group that the segment is member of. 0 = none, -2 = flat, > 0 = defined group

 

struct SARelocation {

   int32   Section;                              // Section of relocation source

   uint32  Offset;                               // Offset of relocation source into section

   uint32  Type;                                 // Relocation types:

   // 0 = unknown, 1 = direct, 2 = self-relative, 4 = image-relative,

   // 8 = segment relative, 0x10 = relative to arbitrary ref. point,

   // 0x21 = direct, has already been relocated to image base (executable files only)

   // 0x41 = direct, make entry in procedure linkage table. Ignore addend (executable files only)

   // 0x81 = direct to Gnu indirect function PLT entry

   // 0x100 = segment address/descriptor, 0x200 = segment of symbol,

   // 0x400 = segment:offset far

   // 0x1001 = reference to GOT entry relative to GOT. 0x1002 = self-relative reference to GOT or GOT-entry

   // 0x2002 = self-relative to PLT

   uint32  Size;                                 // 1 = byte, 2 = word, 4 = dword, 6 = fword, 8 = qword

   int32   Addend;                               // Addend to add to target address,

                                                 // including distance from source to instruction pointer in self-relative addresses,

                                                 // not including inline addend.

   uint32  TargetOldIndex;                       // Old symbol table index of target

   uint32  RefOldIndex;                          // Old symbol table index of reference point if Type = 8, 0x10, 0x200

   int operator < (const SARelocation & y) const{// Operator for sorting relocation table by source address

      return Section < y.Section || (Section == y.Section && Offset < y.Offset);}

 

struct SFunctionRecord {

   int32  Section;                               // Section containing function

   uint32 Start;                                 // Offset of function start

   uint32 End;                                   // Offset of function end

   uint32 Scope;                                 // Scope of function. 0 = inaccessible, 1 = function local, 2 = file local, 4 = public, 8 = weak public, 0x10 = communal, 0x20 = external

                                                 // 0x10000 means End not known, extend it when you pass End

   uint32 OldSymbolIndex;                        // Old symbol table index

   int operator < (const SFunctionRecord & y) const{// Operator for sorting function table by source address

      return Section < y.Section || (Section == y.Section && Start < y.Start);}

 

struct SASymbol {

   int32   Section;                              // Section number. 0 = external, -1 = absolute symbol, -16 = section to be found from image-relative offset

   uint32  Offset;                               // Offset into section. (Value for absolute symbol)

   uint32  Size;                                 // Number of bytes used by symbol or function. 0 = unknown

   uint32  Type;                                 // Use values listed above for SOpcodeDef operands. 0 = unknown type

   uint32  Name;                                 // Name, as index into CDisassembler::SymbolNameBuffer. 0 = no name yet

   uint32  DLLName;                              // Name of DLL if symbol imported by dynamic linking

   uint32  Scope;                                // 0 = inaccessible, 1 = function local, 2 = file local, 4 = public, 8 = weak public, 0x10 = communal, 0x20 = external, 0x100 = has been written

   uint32  OldIndex;                             // Index in original symbol table. Used for tracking relocation entries

   void    Reset() {                             // Set everything to zero

      memset(this, 0, sizeof(*this));}

   int operator < (const SASymbol & y) const {   // Operator for sorting symbol table

      return Section < y.Section || (Section == y.Section && Offset < y.Offset);}

 

class CSymbolTable {

   CSymbolTable();                               // Constructor

   uint32 AddSymbol(int32 Section, uint32 Offset,// Add a symbol from original file

      uint32 Size, uint32 Type, uint32 Scope,

      uint32 OldIndex, const char * Name, const char * DLLName = 0);

   uint32 NewSymbol(int32 Section, uint32 Offset, uint32 Scope); // Add symbol to list

   uint32 NewSymbol(SASymbol & sym);             // Add symbol to list

   void AssignNames();                           // Assign names to symbols that do not have a name

   uint32 FindByAddress(int32 Section, uint32 Offset, uint32 * Last, uint32 * NextAfter = 0); // Find symbols by address

   uint32 FindByAddress(int32 Section, uint32 Offset); // Find symbols by address

   uint32 Old2NewIndex(uint32 OldIndex);         // Translate old symbol index to new index

   SASymbol & operator [](uint32 NewIndex) {     // Access symbol by new index

      return List[NewIndex];}

   const char * HasName(uint32 symo);            // Ask if symbol has a name, input = old index, output = name or 0

   const char * GetName(uint32 symi);            // Get symbol name by new index. (Assign a name if none)

   const char * GetNameO(uint32 symo);           // Get symbol name by old index. (Assign a name if none)

   const char * GetDLLName(uint32 symi);         // Get import DLL name

   void   AssignName(uint32 symi, const char *name); // Give symbol a specific name

   uint32 GetLimit() {return OldNum;}            // Get highest old symbol number + 1

   uint32 GetNumEntries() {return List.GetNumEntries();}// Get highest new symbol number + 1

   CSList<SASymbol> List;                        // List of symbols, sorted by address

   CMemoryBuffer    SymbolNameBuffer;            // String buffer for names of symbols

   CSList<uint32>   TranslateOldIndex;           // Table to translate old symbol index to new symbol index

   void UpdateIndex();                           // Update TranslateOldIndex

   uint32 OldNum;                                // = 1 + max OldIndex

   uint32 NewNum;                                // Number of entries in List

   uint32 UnnamedNum;                            // Number of unnamed symbols

   const char * UnnamedSymbolsPrefix;            // Prefix for names of unnamed symbols

   const char * UnnamedSymFormat;                // Format string for giving names to unnamed symbols

   const char * ImportTablePrefix;               // Prefix for pointers in import table

 

 

 

 

class CDisassembler {

   CDisassembler();                              // Constructor. Initializes tables etc.

   void Go();                                    // Do the disassembly

   void Init(uint32 ExeType, int64 ImageBase);   // Define file type and imagebase if executable file

                                                 // ExeType: 0 = object, 1 = position independent shared object, 2 = executable file

                                                 // Set ExeType = 2 if addresses have been relocated to a nonzero image base and there is no base relocation table.

   void AddSection(                              // Define section to be disassembled

      uint8 * Buffer,                            // Buffer containing raw data

      uint32  InitSize,                          // Size of initialized data in section

      uint32  TotalSize,                         // Size of initialized and uninitialized data in section

      uint32  SectionAddress,                    // Start address of section (image relative)

      uint32  Type,                              // 0 = unknown, 1 = code, 2 = data, 3 = uninitialized data, 4 = constant data

      uint32  Align,                             // Alignment = 1 << Align

      uint32  WordSize,                          // Segment word size: 16, 32 or 64

      const char * Name,                         // Name of section

      uint32  NameLength = 0);                   // Length of name if not zero terminated

   uint32 AddSymbol(                             // Define symbol for disassembler

      int32   Section,                           // Section number (1-based). 0 = external, -1 = absolute, -16 = Offset contains image-relative address

      uint32  Offset,                            // Offset into section. (Value for absolute symbol)

      uint32  Size,                              // Number of bytes used by symbol or function. 0 = unknown

      uint32  Type,                              // Symbol type. Use values listed above for SOpcodeDef operands. 0 = unknown type

      uint32  Scope,                             // 1 = function local, 2 = file local, 4 = public, 8 = weak public, 0x10 = communal, 0x20 = external

      uint32  OldIndex,                          // Unique identifier used in relocation entries. Value must be > 0 and limited because an array is created with this as index.

                                                 // A value will be assigned and returned if 0.

      const char * Name,                         // Name of symbol. Zero-terminated ASCII string. A name will be assigned if 0.

      const char * DLLName = 0);                 // Name of DLL if imported dynamically                    

   void AddRelocation(                           // Define relocation or cross-reference for disassembler

      int32   Section,                           // Section of relocation source:

                                                 // Sections (and groups) are numbered in the order they are defined, starting at 1

                                                 // 0 = none or external, -1 = absolute symbol

                                                 // -16 = Offset contains image-relative address

      uint32  Offset,                            // Offset of relocation source into section

      int32   Addend,                            // Addend to add to target address,

                                                 // including distance from source to instruction pointer in self-relative addresses,

                                                 // not including inline addend.

      uint32  Type,                              // see above at SARelocation for definition of relocation types

      uint32  Size,                              // 1 = byte, 2 = word, 4 = dword, 8 = qword

      uint32  TargetIndex,                       // Symbol index of target

      uint32  ReferenceIndex = 0);               // Symbol index of reference point if Type 0x10, Segment index if Type = 8 or 0x200

   int32 AddSectionGroup(                        // Define section group (from OMF file)

      const char * Name,                         // Name of group

      int32 MemberSegment);                      // Group member. Repeat for multiple members. 0 if none.

   static void CountInstructions();              // Count total number of instructions defined in opcodes.cpp

   const char * CommentSeparator;                // "; " or "# " Start of comment string

   const char * HereOperator;                    // "$" or "." indicating current position

   CTextFileBuffer   OutFile;                    // Output file

   CSymbolTable Symbols;                         // Table of symbols

   CSList<SASection> Sections;                   // List of sections. First is 0

   CSList<SARelocation> Relocations;             // List of cross references. First is 0

   CMemoryBuffer NameBuffer;                     // String buffer for names of sections. First is 0.

   CSList<SFunctionRecord> FunctionList;         // List of functions

   int64   ImageBase;                            // Image base for executable files

   uint32  ExeType;                              // File type: 0 = object, 1 = position independent shared object, 2 = executable

   uint32  RelocationsInSource;                  // Number of relocations in source file

 

   // Code parser: The following members are used for parsing

   // an opcode and identifying its components

   uint8 * Buffer;                               // Point to start of binary data

   SOpcodeProp s;                                // Properties of current opcode

   SATracer t;                                   // Trace of register contents

   uint32  Pass;                                 // 1 = pass 1, 2-3 = pass 1 repeated, 0x10 = pass 2, 0x100 = repetition requested

   uint32  SectionEnd;                           // End of current section

   uint32  WordSize;                             // Segment word size: 16, 32, 64

   uint32  Section;                              // Current section/segment

   uint32  SectionAddress;                       // Address of beginning of this section

   uint32  SectionType;                          // 0 = unknown, 1 = code, 2 = data, 3 = uninitialized data, 4 = constant data

   uint32  CodeMode;                             // 1 if current position contains code, 2 if dubiuos, 4 if data

   uint32  IFunction;                            // Index into FunctionList

   uint32  FunctionEnd;                          // End address of current function (pass 2)

   uint32  LabelBegin;                           // Address of nearest preceding label

   uint32  LabelEnd;                             // Address of next label

   uint32  LabelInaccessible;                    // Address of inaccessible code

   uint32  IBegin;                               // Begin of current instruction

   uint32  IEnd;                                 // End of current instruction

   uint32  DataType;                             // Type of current data

   uint32  DataSize;                             // Size of current data

   uint32  FlagPrevious;                         // 1: previous instruction was a NOP.

                                                 // 2: previous instruction was unconditional jump. 6: instruction was ud2

                                                 // 0x100: previous data aligned by 16

                                                 // 0x200: previous data aligned by 32

   uint8   InstructionSetMax;                    // Highest instruction set encountered

   uint8   InstructionSetAMDMAX;                 // Highest AMD-specific instruction set encountered

   uint16  InstructionSetOR;                     // Bitwise OR of all instruction sets encountered

   uint16  Opcodei;                              // Map number and index in opcodes.cpp

   uint16  OpcodeOptions;                        // Option flags for opcode

   uint16  PreviousOpcodei;                      // Opcode for previous instruction

   uint16  PreviousOpcodeOptions;                // Option flags for previous instruction

   uint32  CountErrors;                          // Number of errors since last label

   uint32  Syntax;                               // Assembly syntax dialect: 1: MASM/TASM, 2: NASM/YASM, 4: GAS

   uint32  MasmOptions;                          // Options needed for MASM: 1: dotname, 2: fs used, 4: gs used

                                                 // 0x100: 16 bit segments, 0x200: 32 bit segments, 0x400: 64 bit segments

   uint32  NamesChanged;                         // Symbol names containing invalid characters changed

   int32   Assumes[6];                           // Assumed value of segment register es, cs, ss, ds, fs, gs. See CDisassembler::WriteSectionName for values

   void    Pass1();                              // Pass 1: Find symbols types and unnamed symbols

   void    Pass2();                              // Pass 2: Write output file

   int     NextFunction2();                      // Loop through function blocks in pass 2. Return 0 if finished

   int     NextLabel();                          // Loop through labels. (Pass 2)

   int     NextInstruction1();                   // Go to next instruction. Return 0 if none. (Pass 1)

   int     NextInstruction2();                   // Go to next instruction. Return 0 if none. (Pass 2)

   void    ParseInstruction();                   // Parse one opcode

   void    ScanPrefixes();                       // Scan prefixes

   void    StorePrefix(uint32 Category, uint8 Byte);// Store prefix according to category

   void    FindMapEntry();                       // Find entry in opcode maps

   void    FindOperands();                       // Interpret mod/reg/rm and SIB bytes and find operand fields

   void    FindOperandTypes();                   // Determine the types of each operand

   void    FindBroadcast();                      // Find broadcast and offset multiplier for EVEX code

   void    SwizTableLookup();                    // Find swizzle table entry for MVEX code

   void    FindLabels();                         // Find any labels at current position and next

   void    CheckForMisplacedLabel();             // Remove any label placed inside function

   void    FindRelocations();                    // Find any relocation sources in this instruction

   void    FindWarnings();                       // Find any reasons for warnings in code

   void    FindErrors();                         // Find any errors in code

   void    FindInstructionSet();                 // Update instruction set

   void    CheckForNops();                       // Check if warnings are caused by multi-byte NOP

   void    UpdateSymbols();                      // Find unnamed symbols, determine symbol types, update symbol list, call CheckJumpTarget if jump/call

   void    UpdateTracer();                       // Trace register values

   void    MarkCodeAsDubious();                  // Remember that this may be data in a code segment

   void    CheckRelocationTarget(uint32 IRel, uint32 TargetType, uint32 TargetSize);// Update relocation record and its target

   void    CheckJumpTarget(uint32 symi);         // Extend range of current function to jump target, if needed

   void    FollowJumpTable(uint32 symi, uint32 RelType);// Check jump/call table and its targets

   uint32  MakeMissingRelocation(int32 Section, uint32 Offset, uint32 RelType, uint32 TargetType, uint32 TargetScope, uint32 SourceSize = 0, uint32 RefPoint = 0); // Make a relocation and its target symbol from inline address

   void    CheckImportSymbol(uint32 symi);       // Check for indirect jump to import table entry

   void    CheckForFunctionBegin();              // Check if function begins at current position

   void    CheckForFunctionEnd();                // Check if function ends at current position

   void    CheckLabel();                         // Check if a label is needed before instruction

   void    InitialErrorCheck();                  // Check for illegal relocations table entries

   void    FinalErrorCheck();                    // Check for illegal entries in symbol table and relocations table

   void    CheckNamesValid();                    // Fix invalid characters in symbol and section names

   void    FixRelocationTargetAddresses();       // Find missing relocation target addresses

   int     TranslateAbsAddress(int64 Addr, int32 &Sect, uint32 &Offset); // Translate absolute virtual address to section and offset

   void    WriteFileBegin();                     // Write begin of file

   void    WriteFileBeginMASM();                 // Write MASM-specific file init

   void    WriteFileBeginYASM();                 // Write YASM-specific file init

   void    WriteFileBeginGASM();                 // Write  GAS-specific file init

   void    WriteFileEnd();                       // Write end of file

   void    WriteSegmentBegin();                  // Write begin of segment

   void    WriteSegmentBeginMASM();              // Write begin of segment, MASM syntax

   void    WriteSegmentBeginYASM();              // Write begin of segment, YASM syntax

   void    WriteSegmentBeginGASM();              // Write begin of segment, GAS  syntax

   void    WriteSegmentEnd();                    // Write end of segment

   void    WritePublicsAndExternalsMASM();       // Write public and external symbol definitions, MASM syntax

   void    WritePublicsAndExternalsYASMGASM();   // Write public and external symbol definitions, YASM and GAS syntax

   void    WriteFunctionBegin();                 // Write begin of function

   void    WriteFunctionBeginMASM(uint32 symi, uint32 scope);// Write begin of function, MASM syntax

   void    WriteFunctionBeginYASM(uint32 symi, uint32 scope);// Write begin of function, YASM syntax

   void    WriteFunctionBeginGASM(uint32 symi, uint32 scope);// Write begin of function, GAS  syntax

   void    WriteFunctionEnd();                   // Write end of function

   void    WriteFunctionEndMASM(uint32 symi);    // Write end of function, MASM syntax

   void    WriteFunctionEndYASM(uint32 symi);    // Write end of function, YASM syntax

   void    WriteFunctionEndGASM(uint32 symi);    // Write end of function, GAS  syntax

   void    WriteCodeLabel(uint32 symi);          // Write private or public code label

   void    WriteCodeLabelMASM(uint32 symi, uint32 scope);// Write private or public code label, MASM syntax

   void    WriteCodeLabelYASM(uint32 symi, uint32 scope);// Write private or public code label, MASM syntax

   void    WriteCodeLabelGASM(uint32 symi, uint32 scope);// Write private or public code label, MASM syntax

   int     WriteFillers();                       // Check if code is a series of NOPs or other fillers. If so then write it as such

   void    WriteAlign(uint32 a);                 // Write alignment directive

   void    WriteErrorsAndWarnings();             // Write errors and warnings, if any

   void    WriteAssume();                        // Write assume directive for segment register

   void    WriteInstruction();                   // Write instruction and operands

   void    WriteCodeComment();                   // Write hex listing of instruction as comment after instruction

   void    WriteStringInstruction();             // Write string instruction or xlat instruction

   void    WriteShortRegOperand(uint32 Type);    // Write register operand from lower 3 bits of opcode byte to OutFile

   void    WriteRegOperand(uint32 Type);         // Write register operand from reg bits to OutFile

   void    WriteRMOperand(uint32 Type);          // Write memory or register operand from mod/rm bits of mod/reg/rm byte and possibly SIB byte to OutFile

   void    WriteDREXOperand(uint32 Type);        // Write register operand from dest bits of DREX byte

   void    WriteVEXOperand(uint32 Type, int i);  // Write register operand from VEX.vvvv bits or immediate bits

   void    WriteOperandAttributeEVEX(int i, int isMem);// Write operand attributes and instruction attributes from EVEX z, LL, b and aaa bits

   void    WriteOperandAttributeMVEX(int i, int isMem);// Write operand attributes and instruction attributes from MVEX sss, e and kkk bits

   void    WriteImmediateOperand(uint32 Type);   // Write immediate operand or direct jump/call address

   void    WriteOtherOperand(uint32 Type);       // Write other type of operand

   void    WriteRegisterName(uint32 Value, uint32 Type); // Write name of register to OutFile

   void    WriteSectionName(int32 SegIndex);     // Write section name from section index

   void    WriteSymbolName(uint32 symi);         // Write symbol name

   void    WriteRelocationTarget(uint32 irel, uint32 Context, int64 Addend);// Write cross reference

   void    WriteOperandType(uint32 type);        // Write type override before operand, e.g. "dword ptr"

   void    WriteOperandTypeMASM(uint32 type);    // Write type override before operand, e.g. "dword ptr", MASM syntax

   void    WriteOperandTypeYASM(uint32 type);    // Write type override before operand, e.g. "dword", YASM syntax

   void    WriteOperandTypeGASM(uint32 type);    // Write type override before operand, e.g. "dword ptr", GAS syntax

   void    WriteDataItems();                     // Write data items

   void    WriteDataLabelMASM(const char * name, uint32 sym, int line); // Write label before data item, MASM syntax

   void    WriteDataLabelYASM(const char * name, uint32 sym, int line); // Write label before data item, YASM syntax

   void    WriteDataLabelGASM(const char * name, uint32 sym, int line); // Write label before data item, GAS  syntax

   void    WriteUninitDataItemsMASM(uint32 size, uint32 count);// Write uninitialized (BSS) data, MASM syntax

   void    WriteUninitDataItemsYASM(uint32 size, uint32 count);// Write uninitialized (BSS) data, YASM syntax

   void    WriteUninitDataItemsGASM(uint32 size, uint32 count);// Write uninitialized (BSS) data, GAS  syntax

   void    WriteDataDirectiveMASM(uint32 size);  // Write DB, etc., MASM syntax

   void    WriteDataDirectiveYASM(uint32 size);  // Write DB, etc., MASM syntax

   void    WriteDataDirectiveGASM(uint32 size);  // Write DB, etc., MASM syntax

   void    WriteDataComment(uint32 ElementSize, uint32 LinePos, uint32 Pos, uint32 irel);// Write comment after data item

   uint32  GetDataItemSize(uint32 Type);         // Get size of data item with specified type

   uint32  GetDataElementSize(uint32 Type);      // Get size of vector element in data item with specified type

   int32   GetSegmentRegisterFromPrefix();       // Translate segment prefix to segment register

 

   template <class TX> TX & Get(uint32 Offset) { // Get object of arbitrary type from buffer

      return *(TX*)(Buffer + Offset);}

 

 

extern SOpcodeDef OpcodeMap0[256];               // First opcode map

 

extern uint32 OpcodeStartPageVEX[];              // Entries to opcode maps, indexed by VEX.mmmm bits

extern SOpcodeDef const * OpcodeStartPageXOP[];  // Entries to opcode maps, indexed by XOP.mmmm bits

 

extern const uint32 NumOpcodeStartPageVEX;       // Number of entries in OpcodeStartPage

extern const uint32 NumOpcodeStartPageXOP;       // Number of entries in OpcodeStartPageXOP

 

extern const SOpcodeDef * const OpcodeTables[];  // Pointers to all opcode tables

 

extern const uint32 OpcodeTableLength[];         // Size of each table pointed to by OpcodeTables[]

 

extern const uint32 NumOpcodeTables1, NumOpcodeTables2;// Number of entries in OpcodeTables[] and OpcodeTableLength[]

 

extern const char * RegisterNames8[8];           // Names of 8 bit registers

extern const char * RegisterNames8x[16];         // Names of 8 bit registers with REX prefix

extern const char * RegisterNames16[16];         // Names of 16 bit registers

extern const char * RegisterNames32[16];         // Names of 32 bit registers

extern const char * RegisterNames64[16];         // Names of 64 bit registers

extern const char * RegisterNamesSeg[8];         // Names of segment registers

extern const char * RegisterNamesCR[16];         // Names of control registers

 

extern SwizSpec const * SwizTables[][2];         // Pointers to swizzle tables

extern SwizSpec const * SwizRoundTables[][2];    // Pointers to swizzle round tables

extern const char * EVEXRoundingNames[5];        // Tables of rounding mode names for EVEX

 

 

                                   // ..leave it to the disassembler to find which section contains this address.