Implement LLVM JIT side of GDB JIT debugging interface

lib/CodeGen/ELFWriter.h

 //===-- ELFWriter.h - Target-independent ELF writer support -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the ELFWriter class.
@@ skipping 15 matching lines @@
   class ELFCodeEmitter;
   class ELFRelocation;
   class ELFSection;
   struct ELFSym;
   class GlobalVariable;
   class JITDebugRegisterer;
   class Mangler;
   class MachineCodeEmitter;
   class MachineConstantPoolEntry;
   class ObjectCodeEmitter;
-  class TargetAsmInfo;
+  class MCAsmInfo;
   class TargetELFWriterInfo;
   class TargetLoweringObjectFile;
   class raw_ostream;
   class SectionKind;
   class MCContext;
 
   typedef std::vector<ELFSym*>::iterator ELFSymIter;
   typedef std::vector<ELFSection*>::iterator ELFSectionIter;
   typedef SetVector<const GlobalValue*>::const_iterator PendingGblsIter;
   typedef SetVector<const char *>::const_iterator PendingExtsIter;
@@ skipping 34 matching lines @@
     Mangler *Mang;
 
     /// MCE - The MachineCodeEmitter object that we are exposing to emit machine
     /// code for functions to the .o file.
     ELFCodeEmitter *ElfCE;
 
     /// TLOF - Target Lowering Object File, provide section names for globals 
     /// and other object file specific stuff
     const TargetLoweringObjectFile &TLOF;
 
-    /// TAI - Target Asm Info, provide information about section names for
+    /// MAI - Target Asm Info, provide information about section names for
     /// globals and other target specific stuff.
-    const TargetAsmInfo *TAI;
+    const MCAsmInfo *MAI;
 
     //===------------------------------------------------------------------===//
     // Properties inferred automatically from the target machine.
     //===------------------------------------------------------------------===//
 
     /// is64Bit/isLittleEndian - This information is inferred from the target
     /// machine directly, indicating whether to emit a 32- or 64-bit ELF file.
     bool is64Bit, isLittleEndian;
 
     /// doInitialization - Emit the file header and all of the global variables
     /// for the module to the ELF file.
     bool doInitialization(Module &M);
     bool runOnMachineFunction(MachineFunction &MF);
 
     /// doFinalization - Now that the module has been completely processed, emit
     /// the ELF file to 'O'.
     bool doFinalization(Module &M);
 
   private:
     /// Blob containing the Elf header
     BinaryObject ElfHdr;
 
     /// SectionList - This is the list of sections that we have emitted to the
     /// file. Once the file has been completely built, the section header table
     /// is constructed from this info.
     std::vector<ELFSection*> SectionList;
     unsigned NumSections;   // Always = SectionList.size()
 
     /// SectionLookup - This is a mapping from section name to section number in
-    /// the SectionList. Used to quickly gather the Section Index from TAI names
+    /// the SectionList. Used to quickly gather the Section Index from MAI names
     std::map<std::string, ELFSection*> SectionLookup;
 
     /// PendingGlobals - Globals not processed as symbols yet.
     SetVector<const GlobalValue*> PendingGlobals;
 
     /// GblSymLookup - This is a mapping from global value to a symbol index
     /// in the symbol table or private symbols list. This is useful since reloc
     /// symbol references must be quickly mapped to their indices on the lists.
     std::map<const GlobalValue*, uint32_t> GblSymLookup;
 
@@ skipping 107 matching lines @@
     void EmitStringTable(const std::string &ModuleName);
     void OutputSectionsAndSectionTable();
     void RelocateField(BinaryObject &BO, uint32_t Offset, int64_t Value,
                        unsigned Size);
     unsigned SortSymbols();
     CstExprResTy ResolveConstantExpr(const Constant *CV);
   };
 }
 
 #endif