17 files changed, 382 insertions, 613 deletions

diff --git a/include/llvm/CodeGen/AsmPrinter.h b/include/llvm/CodeGen/AsmPrinter.h
index 686a075519..042e1d3f02 100644
--- a/include/llvm/CodeGen/AsmPrinter.h
+++ b/include/llvm/CodeGen/AsmPrinter.h
@@ -7,9 +7,9 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This class is intended to be used as a base class for target-specific
-// asmwriters.  This class primarily takes care of printing global constants,
-// which are printed in a very similar way across all targets.
+// This file contains a class to be used as the base class for target specific
+// asm writers.  This class primarily handles common functionality used by
+// all asm writers.
 //
 //===----------------------------------------------------------------------===//
 
@@ -22,10 +22,14 @@
 namespace llvm {
   class Constant;
   class ConstantArray;
-  class Mangler;
   class GlobalVariable;
   class MachineConstantPoolEntry;
+  class Mangler;
+  class TargetAsmInfo;
+  
 
+  /// AsmPrinter - This class is intended to be used as a driving class for all
+  /// asm writers.
   class AsmPrinter : public MachineFunctionPass {
     /// FunctionNumber - This provides a unique ID for each function emitted in
     /// this translation unit.  It is autoincremented by SetupMachineFunction,
@@ -42,6 +46,10 @@ namespace llvm {
     /// Target machine description.
     ///
     TargetMachine &TM;
+    
+    /// Target Asm Printer information.
+    ///
+    TargetAsmInfo *TAI;
 
     /// Name-mangler for global names.
     ///
@@ -51,163 +59,13 @@ namespace llvm {
     /// beginning of each call to runOnMachineFunction().
     ///
     std::string CurrentFnName;
-
-    //===------------------------------------------------------------------===//
-    // Properties to be set by the derived class ctor, used to configure the
-    // asmwriter.
-
-    /// CommentString - This indicates the comment character used by the
-    /// assembler.
-    const char *CommentString;     // Defaults to "#"
-
-    /// GlobalPrefix - If this is set to a non-empty string, it is prepended
-    /// onto all global symbols.  This is often used for "_" or ".".
-    const char *GlobalPrefix;    // Defaults to ""
-
-    /// PrivateGlobalPrefix - This prefix is used for globals like constant
-    /// pool entries that are completely private to the .o file and should not
-    /// have names in the .o file.  This is often "." or "L".
-    const char *PrivateGlobalPrefix;   // Defaults to "."
-    
-    /// GlobalVarAddrPrefix/Suffix - If these are nonempty, these strings
-    /// will enclose any GlobalVariable (that isn't a function)
-    ///
-    const char *GlobalVarAddrPrefix;       // Defaults to ""
-    const char *GlobalVarAddrSuffix;       // Defaults to ""
-
-    /// FunctionAddrPrefix/Suffix - If these are nonempty, these strings
-    /// will enclose any GlobalVariable that points to a function.
-    /// For example, this is used by the IA64 backend to materialize
-    /// function descriptors, by decorating the ".data8" object with the
-    /// \literal @fptr( ) \endliteral
-    /// link-relocation operator.
-    ///
-    const char *FunctionAddrPrefix;       // Defaults to ""
-    const char *FunctionAddrSuffix;       // Defaults to ""
-
-    /// InlineAsmStart/End - If these are nonempty, they contain a directive to
-    /// emit before and after an inline assmebly statement.
-    const char *InlineAsmStart;           // Defaults to "#APP\n"
-    const char *InlineAsmEnd;             // Defaults to "#NO_APP\n"
-    
-    //===--- Data Emission Directives -------------------------------------===//
-
-    /// ZeroDirective - this should be set to the directive used to get some
-    /// number of zero bytes emitted to the current section.  Common cases are
-    /// "\t.zero\t" and "\t.space\t".  If this is set to null, the
-    /// Data*bitsDirective's will be used to emit zero bytes.
-    const char *ZeroDirective;   // Defaults to "\t.zero\t"
-    const char *ZeroDirectiveSuffix;  // Defaults to ""
-
-    /// AsciiDirective - This directive allows emission of an ascii string with
-    /// the standard C escape characters embedded into it.
-    const char *AsciiDirective;  // Defaults to "\t.ascii\t"
-    
-    /// AscizDirective - If not null, this allows for special handling of
-    /// zero terminated strings on this target.  This is commonly supported as
-    /// ".asciz".  If a target doesn't support this, it can be set to null.
-    const char *AscizDirective;  // Defaults to "\t.asciz\t"
-
-    /// DataDirectives - These directives are used to output some unit of
-    /// integer data to the current section.  If a data directive is set to
-    /// null, smaller data directives will be used to emit the large sizes.
-    const char *Data8bitsDirective;   // Defaults to "\t.byte\t"
-    const char *Data16bitsDirective;  // Defaults to "\t.short\t"
-    const char *Data32bitsDirective;  // Defaults to "\t.long\t"
-    const char *Data64bitsDirective;  // Defaults to "\t.quad\t"
-
-    //===--- Alignment Information ----------------------------------------===//
-
-    /// AlignDirective - The directive used to emit round up to an alignment
-    /// boundary.
-    ///
-    const char *AlignDirective;       // Defaults to "\t.align\t"
-
-    /// AlignmentIsInBytes - If this is true (the default) then the asmprinter
-    /// emits ".align N" directives, where N is the number of bytes to align to.
-    /// Otherwise, it emits ".align log2(N)", e.g. 3 to align to an 8 byte
-    /// boundary.
-    bool AlignmentIsInBytes;          // Defaults to true
-    
-    //===--- Section Switching Directives ---------------------------------===//
     
     /// CurrentSection - The current section we are emitting to.  This is
     /// controlled and used by the SwitchSection method.
     std::string CurrentSection;
-    
-    /// SwitchToSectionDirective - This is the directive used when we want to
-    /// emit a global to an arbitrary section.  The section name is emited after
-    /// this.
-    const char *SwitchToSectionDirective;  // Defaults to "\t.section\t"
-    
-    /// TextSectionStartSuffix - This is printed after each start of section
-    /// directive for text sections.
-    const char *TextSectionStartSuffix;        // Defaults to "".
-
-    /// DataSectionStartSuffix - This is printed after each start of section
-    /// directive for data sections.
-    const char *DataSectionStartSuffix;        // Defaults to "".
-    
-    /// SectionEndDirectiveSuffix - If non-null, the asm printer will close each
-    /// section with the section name and this suffix printed.
-    const char *SectionEndDirectiveSuffix; // Defaults to null.
-    
-    /// ConstantPoolSection - This is the section that we SwitchToSection right
-    /// before emitting the constant pool for a function.
-    const char *ConstantPoolSection;     // Defaults to "\t.section .rodata\n"
-
-    /// JumpTableDataSection - This is the section that we SwitchToSection right
-    /// before emitting the jump tables for a function when the relocation model
-    /// is not PIC.
-    const char *JumpTableDataSection;     // Defaults to "\t.section .rodata\n"
-    
-    /// JumpTableTextSection - This is the section that we SwitchToSection right
-    /// before emitting the jump tables for a function when the relocation model
-    /// is PIC.
-    const char *JumpTableTextSection;     // Defaults to "\t.text\n"
-    
-    /// StaticCtorsSection - This is the directive that is emitted to switch to
-    /// a section to emit the static constructor list.
-    /// Defaults to "\t.section .ctors,\"aw\",@progbits".
-    const char *StaticCtorsSection;
-
-    /// StaticDtorsSection - This is the directive that is emitted to switch to
-    /// a section to emit the static destructor list.
-    /// Defaults to "\t.section .dtors,\"aw\",@progbits".
-    const char *StaticDtorsSection;
-
-    /// FourByteConstantSection, EightByteConstantSection,
-    /// SixteenByteConstantSection - These are special sections where we place
-    /// 4-, 8-, and 16- byte constant literals.
-    const char *FourByteConstantSection;
-    const char *EightByteConstantSection;
-    const char *SixteenByteConstantSection;
-    
-    //===--- Global Variable Emission Directives --------------------------===//
-    
-    /// SetDirective - This is the name of a directive that can be used to tell
-    /// the assembler to set the value of a variable to some expression.
-    const char *SetDirective;            // Defaults to null.
-    
-    /// LCOMMDirective - This is the name of a directive (if supported) that can
-    /// be used to efficiently declare a local (internal) block of zero
-    /// initialized data in the .bss/.data section.  The syntax expected is:
-    /// \literal <LCOMMDirective> SYMBOLNAME LENGTHINBYTES, ALIGNMENT
-    /// \endliteral
-    const char *LCOMMDirective;          // Defaults to null.
-    
-    const char *COMMDirective;           // Defaults to "\t.comm\t".
-
-    /// COMMDirectiveTakesAlignment - True if COMMDirective take a third
-    /// argument that specifies the alignment of the declaration.
-    bool COMMDirectiveTakesAlignment;    // Defaults to true.
-    
-    /// HasDotTypeDotSizeDirective - True if the target has .type and .size
-    /// directives, this is true for most ELF targets.
-    bool HasDotTypeDotSizeDirective;     // Defaults to true.
   
   protected:
-    AsmPrinter(std::ostream &o, TargetMachine &TM);
+    AsmPrinter(std::ostream &o, TargetMachine &TM, TargetAsmInfo *T);
     
   public:
     /// SwitchToTextSection - Switch to the specified section of the executable
diff --git a/include/llvm/CodeGen/DwarfWriter.h b/include/llvm/CodeGen/DwarfWriter.h
index d501d50191..1b5cd8f6c4 100644
--- a/include/llvm/CodeGen/DwarfWriter.h
+++ b/include/llvm/CodeGen/DwarfWriter.h
@@ -48,6 +48,7 @@ class Module;
 class MRegisterInfo;
 class SubprogramDesc;
 class SourceLineInfo;
+class TargetAsmInfo;
 class TargetData;
 class Type;
 class TypeDesc;
@@ -70,7 +71,8 @@ public:
 // DwarfWriter - Emits Dwarf debug and exception handling directives.
 //
 class DwarfWriter {
-protected:
+
+private:
 
   //===--------------------------------------------------------------------===//
   // Core attributes used by the Dwarf  writer.
@@ -85,6 +87,9 @@ protected:
   ///
   AsmPrinter *Asm;
   
+  /// TAI - Target Asm Printer.
+  TargetAsmInfo *TAI;
+  
   /// TD - Target data.
   const TargetData *TD;
   
@@ -147,93 +152,14 @@ protected:
   /// SectionSourceLines - Tracks line numbers per text section.
   ///
   std::vector<std::vector<SourceLineInfo *> > SectionSourceLines;
-  
-  //===--------------------------------------------------------------------===//
-  // Properties to be set by the derived class ctor, used to configure the
-  // Dwarf writer.
-  //
-  
-  /// AddressSize - Size of addresses used in file.
-  ///
-  unsigned AddressSize;
 
-  /// hasLEB128 - True if target asm supports leb128 directives.
-  ///
-  bool hasLEB128; /// Defaults to false.
-  
-  /// hasDotLoc - True if target asm supports .loc directives.
-  ///
-  bool hasDotLoc; /// Defaults to false.
-  
-  /// hasDotFile - True if target asm supports .file directives.
-  ///
-  bool hasDotFile; /// Defaults to false.
-  
-  /// needsSet - True if target asm can't compute addresses on data
-  /// directives.
-  bool needsSet; /// Defaults to false.
-  
-  /// DwarfAbbrevSection - Section directive for Dwarf abbrev.
-  ///
-  const char *DwarfAbbrevSection; /// Defaults to ".debug_abbrev".
-
-  /// DwarfInfoSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfInfoSection; /// Defaults to ".debug_info".
 
-  /// DwarfLineSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfLineSection; /// Defaults to ".debug_line".
-  
-  /// DwarfFrameSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfFrameSection; /// Defaults to ".debug_frame".
-  
-  /// DwarfPubNamesSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfPubNamesSection; /// Defaults to ".debug_pubnames".
-  
-  /// DwarfPubTypesSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfPubTypesSection; /// Defaults to ".debug_pubtypes".
-  
-  /// DwarfStrSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfStrSection; /// Defaults to ".debug_str".
-
-  /// DwarfLocSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfLocSection; /// Defaults to ".debug_loc".
-
-  /// DwarfARangesSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfARangesSection; /// Defaults to ".debug_aranges".
-
-  /// DwarfRangesSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfRangesSection; /// Defaults to ".debug_ranges".
-
-  /// DwarfMacInfoSection - Section directive for Dwarf info.
-  ///
-  const char *DwarfMacInfoSection; /// Defaults to ".debug_macinfo".
-
-  /// TextSection - Section directive for standard text.
-  ///
-  const char *TextSection; /// Defaults to ".text".
-  
-  /// DataSection - Section directive for standard data.
-  ///
-  const char *DataSection; /// Defaults to ".data".
+public:
 
   //===--------------------------------------------------------------------===//
   // Emission and print routines
   //
 
-public:
-  /// getAddressSize - Return the size of a target address in bytes.
-  ///
-  unsigned getAddressSize() const { return AddressSize; }
-
   /// PrintHex - Print a value as a hexidecimal value.
   ///
   void PrintHex(int Value) const;
@@ -461,9 +387,13 @@ private:
 
 public:
   
-  DwarfWriter(std::ostream &OS, AsmPrinter *A);
+  DwarfWriter(std::ostream &OS, AsmPrinter *A, TargetAsmInfo *T);
   virtual ~DwarfWriter();
   
+  // Accessors.
+  //
+  TargetAsmInfo *getTargetAsmInfo() const { return TAI; }
+  
   /// SetDebugInfo - Set DebugInfo when it's known that pass manager has
   /// created it.  Set by the target AsmPrinter.
   void SetDebugInfo(MachineDebugInfo *DI);
diff --git a/lib/CodeGen/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter.cpp
index 9414e69b4c..91b2bb8f28 100644
--- a/lib/CodeGen/AsmPrinter.cpp
+++ b/lib/CodeGen/AsmPrinter.cpp
@@ -20,51 +20,16 @@
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
 #include "llvm/Support/Mangler.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Target/TargetAsmInfo.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Target/TargetMachine.h"
 #include <iostream>
 #include <cerrno>
 using namespace llvm;
 
-AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm)
-: FunctionNumber(0), O(o), TM(tm),
-  CommentString("#"),
-  GlobalPrefix(""),
-  PrivateGlobalPrefix("."),
-  GlobalVarAddrPrefix(""),
-  GlobalVarAddrSuffix(""),
-  FunctionAddrPrefix(""),
-  FunctionAddrSuffix(""),
-  InlineAsmStart("#APP"),
-  InlineAsmEnd("#NO_APP"),
-  ZeroDirective("\t.zero\t"),
-  ZeroDirectiveSuffix(0),
-  AsciiDirective("\t.ascii\t"),
-  AscizDirective("\t.asciz\t"),
-  Data8bitsDirective("\t.byte\t"),
-  Data16bitsDirective("\t.short\t"),
-  Data32bitsDirective("\t.long\t"),
-  Data64bitsDirective("\t.quad\t"),
-  AlignDirective("\t.align\t"),
-  AlignmentIsInBytes(true),
-  SwitchToSectionDirective("\t.section\t"),
-  TextSectionStartSuffix(""),
-  DataSectionStartSuffix(""),
-  SectionEndDirectiveSuffix(0),
-  ConstantPoolSection("\t.section .rodata\n"),
-  JumpTableDataSection("\t.section .rodata\n"),
-  JumpTableTextSection("\t.text\n"),
-  StaticCtorsSection("\t.section .ctors,\"aw\",@progbits"),
-  StaticDtorsSection("\t.section .dtors,\"aw\",@progbits"),
-  FourByteConstantSection(0),
-  EightByteConstantSection(0),
-  SixteenByteConstantSection(0),
-  SetDirective(0),
-  LCOMMDirective(0),
-  COMMDirective("\t.comm\t"),
-  COMMDirectiveTakesAlignment(true),
-  HasDotTypeDotSizeDirective(true) {
-}
+AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm, TargetAsmInfo *T)
+: FunctionNumber(0), O(o), TM(tm), TAI(T)
+{}
 
 
 /// SwitchToTextSection - Switch to the specified text section of the executable
@@ -74,7 +39,7 @@ void AsmPrinter::SwitchToTextSection(const char *NewSection,
                                      const GlobalValue *GV) {
   std::string NS;
   if (GV && GV->hasSection())
-    NS = SwitchToSectionDirective + GV->getSection();
+    NS = TAI->getSwitchToSectionDirective() + GV->getSection();
   else
     NS = NewSection;
   
@@ -82,13 +47,13 @@ void AsmPrinter::SwitchToTextSection(const char *NewSection,
   if (CurrentSection == NS) return;
 
   // Close the current section, if applicable.
-  if (SectionEndDirectiveSuffix && !CurrentSection.empty())
-    O << CurrentSection << SectionEndDirectiveSuffix << "\n";
+  if (TAI->getSectionEndDirectiveSuffix() && !CurrentSection.empty())
+    O << CurrentSection << TAI->getSectionEndDirectiveSuffix() << "\n";
 
   CurrentSection = NS;
 
   if (!CurrentSection.empty())
-    O << CurrentSection << TextSectionStartSuffix << '\n';
+    O << CurrentSection << TAI->getTextSectionStartSuffix() << '\n';
 }
 
 /// SwitchToDataSection - Switch to the specified data section of the executable
@@ -98,7 +63,7 @@ void AsmPrinter::SwitchToDataSection(const char *NewSection,
                                      const GlobalValue *GV) {
   std::string NS;
   if (GV && GV->hasSection())
-    NS = SwitchToSectionDirective + GV->getSection();
+    NS = TAI->getSwitchToSectionDirective() + GV->getSection();
   else
     NS = NewSection;
   
@@ -106,23 +71,24 @@ void AsmPrinter::SwitchToDataSection(const char *NewSection,
   if (CurrentSection == NS) return;
 
   // Close the current section, if applicable.
-  if (SectionEndDirectiveSuffix && !CurrentSection.empty())
-    O << CurrentSection << SectionEndDirectiveSuffix << "\n";
+  if (TAI->getSectionEndDirectiveSuffix() && !CurrentSection.empty())
+    O << CurrentSection << TAI->getSectionEndDirectiveSuffix() << "\n";
 
   CurrentSection = NS;
   
   if (!CurrentSection.empty())
-    O << CurrentSection << DataSectionStartSuffix << '\n';
+    O << CurrentSection << TAI->getDataSectionStartSuffix() << '\n';
 }
 
 
 bool AsmPrinter::doInitialization(Module &M) {
-  Mang = new Mangler(M, GlobalPrefix);
+  Mang = new Mangler(M, TAI->getGlobalPrefix());
   
   if (!M.getModuleInlineAsm().empty())
-    O << CommentString << " Start of file scope inline assembly\n"
+    O << TAI->getCommentString() << " Start of file scope inline assembly\n"
       << M.getModuleInlineAsm()
-      << "\n" << CommentString << " End of file scope inline assembly\n";
+      << "\n" << TAI->getCommentString()
+      << " End of file scope inline assembly\n";
 
   SwitchToDataSection("", 0);   // Reset back to no section.
   
@@ -163,13 +129,13 @@ void AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) {
     MachineConstantPoolEntry CPE = CP[i];
     const Constant *CV = CPE.Val;
     const Type *Ty = CV->getType();
-    if (FourByteConstantSection &&
+    if (TAI->getFourByteConstantSection() &&
         TM.getTargetData()->getTypeSize(Ty) == 4)
       FourByteCPs.push_back(std::make_pair(CPE, i));
-    else if (EightByteConstantSection &&
+    else if (TAI->getSectionEndDirectiveSuffix() &&
              TM.getTargetData()->getTypeSize(Ty) == 8)
       EightByteCPs.push_back(std::make_pair(CPE, i));
-    else if (SixteenByteConstantSection &&
+    else if (TAI->getSectionEndDirectiveSuffix() &&
              TM.getTargetData()->getTypeSize(Ty) == 16)
       SixteenByteCPs.push_back(std::make_pair(CPE, i));
     else
@@ -177,10 +143,11 @@ void AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) {
   }
 
   unsigned Alignment = MCP->getConstantPoolAlignment();
-  EmitConstantPool(Alignment, FourByteConstantSection,    FourByteCPs);
-  EmitConstantPool(Alignment, EightByteConstantSection,   EightByteCPs);
-  EmitConstantPool(Alignment, SixteenByteConstantSection, SixteenByteCPs);
-  EmitConstantPool(Alignment, ConstantPoolSection,        OtherCPs);
+  EmitConstantPool(Alignment, TAI->getFourByteConstantSection(), FourByteCPs);
+  EmitConstantPool(Alignment, TAI->getEightByteConstantSection(), EightByteCPs);
+  EmitConstantPool(Alignment, TAI->getSixteenByteConstantSection(),
+                   SixteenByteCPs);
+  EmitConstantPool(Alignment, TAI->getConstantPoolSection(), OtherCPs);
 }
 
 void AsmPrinter::EmitConstantPool(unsigned Alignment, const char *Section,
@@ -190,8 +157,8 @@ void AsmPrinter::EmitConstantPool(unsigned Alignment, const char *Section,
   SwitchToDataSection(Section, 0);
   EmitAlignment(Alignment);
   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
-    O << PrivateGlobalPrefix << "CPI" << getFunctionNumber() << '_'
-      << CP[i].second << ":\t\t\t\t\t" << CommentString << " ";
+    O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
+      << CP[i].second << ":\t\t\t\t\t" << TAI->getCommentString() << " ";
     WriteTypeSymbolic(O, CP[i].first.Val->getType(), 0) << '\n';
     EmitGlobalConstant(CP[i].first.Val);
     if (i != e-1) {
@@ -215,16 +182,16 @@ void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI) {
   // JTEntryDirective is a string to print sizeof(ptr) for non-PIC jump tables,
   // and 32 bits for PIC since PIC jump table entries are differences, not
   // pointers to blocks.
-  const char *JTEntryDirective = Data32bitsDirective;
+  const char *JTEntryDirective = TAI->getData32bitsDirective();
   
   // Pick the directive to use to print the jump table entries, and switch to 
   // the appropriate section.
   if (TM.getRelocationModel() == Reloc::PIC_) {
-    SwitchToTextSection(JumpTableTextSection, 0);
+    SwitchToTextSection(TAI->getJumpTableTextSection(), 0);
   } else {
-    SwitchToDataSection(JumpTableDataSection, 0);
+    SwitchToDataSection(TAI->getJumpTableDataSection(), 0);
     if (TD->getPointerSize() == 8)
-      JTEntryDirective = Data64bitsDirective;
+      JTEntryDirective = TAI->getData64bitsDirective();
   }
   EmitAlignment(Log2_32(TD->getPointerAlignment()));
   
@@ -235,13 +202,13 @@ void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI) {
     // the number of relocations the assembler will generate for the jump table.
     // Set directives are all printed before the jump table itself.
     std::set<MachineBasicBlock*> EmittedSets;
-    if (SetDirective && TM.getRelocationModel() == Reloc::PIC_)
+    if (TAI->getSetDirective() && TM.getRelocationModel() == Reloc::PIC_)
       for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii)
         if (EmittedSets.insert(JTBBs[ii]).second)
           printSetLabel(i, JTBBs[ii]);
     
-    O << PrivateGlobalPrefix << "JTI" << getFunctionNumber() << '_' << i 
-      << ":\n";
+    O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() 
+      << '_' << i << ":\n";
     
     for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) {
       O << JTEntryDirective << ' ';
@@ -251,12 +218,12 @@ void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI) {
       // If we're emitting non-PIC code, then emit the entries as direct
       // references to the target basic blocks.
       if (!EmittedSets.empty()) {
-        O << PrivateGlobalPrefix << getFunctionNumber() << '_' << i << "_set_"
-          << JTBBs[ii]->getNumber();
+        O << TAI->getPrivateGlobalPrefix() << getFunctionNumber()
+          << '_' << i << "_set_" << JTBBs[ii]->getNumber();
       } else if (TM.getRelocationModel() == Reloc::PIC_) {
         printBasicBlockLabel(JTBBs[ii], false, false);
-        O << '-' << PrivateGlobalPrefix << "JTI" << getFunctionNumber() 
-          << '_' << i;
+        O << '-' << TAI->getPrivateGlobalPrefix() << "JTI"
+          << getFunctionNumber() << '_' << i;
       } else {
         printBasicBlockLabel(JTBBs[ii], false, false);
       }
@@ -280,14 +247,14 @@ bool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) {
     return true;  // No need to emit this at all.
 
   if (GV->getName() == "llvm.global_ctors" && GV->use_empty()) {
-    SwitchToDataSection(StaticCtorsSection, 0);
+    SwitchToDataSection(TAI->getStaticCtorsSection(), 0);
     EmitAlignment(2, 0);
     EmitXXStructorList(GV->getInitializer());
     return true;
   } 
   
   if (GV->getName() == "llvm.global_dtors" && GV->use_empty()) {
-    SwitchToDataSection(StaticDtorsSection, 0);
+    SwitchToDataSection(TAI->getStaticDtorsSection(), 0);
     EmitAlignment(2, 0);
     EmitXXStructorList(GV->getInitializer());
     return true;
@@ -342,22 +309,22 @@ void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV) const {
   if (GV && GV->getAlignment())
     NumBits = Log2_32(GV->getAlignment());
   if (NumBits == 0) return;   // No need to emit alignment.
-  if (AlignmentIsInBytes) NumBits = 1 << NumBits;
-  O << AlignDirective << NumBits << "\n";
+  if (TAI->getAlignmentIsInBytes()) NumBits = 1 << NumBits;
+  O << TAI->getAlignDirective() << NumBits << "\n";
 }
 
 /// EmitZeros - Emit a block of zeros.
 ///
 void AsmPrinter::EmitZeros(uint64_t NumZeros) const {
   if (NumZeros) {
-    if (ZeroDirective) {
-      O << ZeroDirective << NumZeros;
-      if (ZeroDirectiveSuffix)
-        O << ZeroDirectiveSuffix;
+    if (TAI->getZeroDirective()) {
+      O << TAI->getZeroDirective() << NumZeros;
+      if (TAI->getZeroDirectiveSuffix())
+        O << TAI->getZeroDirectiveSuffix();
       O << "\n";
     } else {
       for (; NumZeros; --NumZeros)
-        O << Data8bitsDirective << "0\n";
+        O << TAI->getData8bitsDirective() << "0\n";
     }
   }
 }
@@ -382,10 +349,15 @@ void AsmPrinter::EmitConstantValueOnly(const Constant *CV) {
     // name of the variable or function as the address value, possibly
     // decorating it with GlobalVarAddrPrefix/Suffix or
     // FunctionAddrPrefix/Suffix (these all default to "" )
-    if (isa<Function>(GV))
-      O << FunctionAddrPrefix << Mang->getValueName(GV) << FunctionAddrSuffix;
-    else
-      O << GlobalVarAddrPrefix << Mang->getValueName(GV) << GlobalVarAddrSuffix;
+    if (isa<Function>(GV)) {
+      O << TAI->getFunctionAddrPrefix()
+        << Mang->getValueName(GV)
+        << TAI->getFunctionAddrSuffix();
+    } else {
+      O << TAI->getGlobalVarAddrPrefix()
+        << Mang->getValueName(GV)
+        << TAI->getGlobalVarAddrSuffix();
+    }
   } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
     const TargetData *TD = TM.getTargetData();
     switch(CE->getOpcode()) {
@@ -495,12 +467,12 @@ static void printAsCString(std::ostream &O, const ConstantArray *CVA,
 ///
 void AsmPrinter::EmitString(const ConstantArray *CVA) const {
   unsigned NumElts = CVA->getNumOperands();
-  if (AscizDirective && NumElts && 
+  if (TAI->getAscizDirective() && NumElts && 
       cast<ConstantInt>(CVA->getOperand(NumElts-1))->getRawValue() == 0) {
-    O << AscizDirective;
+    O << TAI->getAscizDirective();
     printAsCString(O, CVA, NumElts-1);
   } else {
-    O << AsciiDirective;
+    O << TAI->getAsciiDirective();
     printAsCString(O, CVA, NumElts);
   }
   O << "\n";
@@ -550,50 +522,50 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
     // precision...
     double Val = CFP->getValue();
     if (CFP->getType() == Type::DoubleTy) {
-      if (Data64bitsDirective)
-        O << Data64bitsDirective << DoubleToBits(Val) << "\t" << CommentString
-          << " double value: " << Val << "\n";
+      if (TAI->getData64bitsDirective())
+        O << TAI->getData64bitsDirective() << DoubleToBits(Val) << "\t"
+          << TAI->getCommentString() << " double value: " << Val << "\n";
       else if (TD->isBigEndian()) {
-        O << Data32bitsDirective << unsigned(DoubleToBits(Val) >> 32)
-          << "\t" << CommentString << " double most significant word "
-          << Val << "\n";
-        O << Data32bitsDirective << unsigned(DoubleToBits(Val))
-          << "\t" << CommentString << " double least significant word "
-          << Val << "\n";
+        O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val) >> 32)
+          << "\t" << TAI->getCommentString()
+          << " double most significant word " << Val << "\n";
+        O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val))
+          << "\t" << TAI->getCommentString()
+          << " double least significant word " << Val << "\n";
       } else {
-        O << Data32bitsDirective << unsigned(DoubleToBits(Val))
-          << "\t" << CommentString << " double least significant word " << Val
-          << "\n";
-        O << Data32bitsDirective << unsigned(DoubleToBits(Val) >> 32)
-          << "\t" << CommentString << " double most significant word " << Val
-          << "\n";
+        O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val))
+          << "\t" << TAI->getCommentString()
+          << " double least significant word " << Val << "\n";
+        O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val) >> 32)
+          << "\t" << TAI->getCommentString()
+          << " double most significant word " << Val << "\n";
       }
       return;
     } else {
-      O << Data32bitsDirective << FloatToBits(Val) << "\t" << CommentString
-        << " float " << Val << "\n";
+      O << TAI->getData32bitsDirective() << FloatToBits(Val)
+        << "\t" << TAI->getCommentString() << " float " << Val << "\n";
       return;
     }
   } else if (CV->getType() == Type::ULongTy || CV->getType() == Type::LongTy) {
     if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
       uint64_t Val = CI->getRawValue();
 
-      if (Data64bitsDirective)
-        O << Data64bitsDirective << Val << "\n";
+      if (TAI->getData64bitsDirective())
+        O << TAI->getData64bitsDirective() << Val << "\n";
       else if (TD->isBigEndian()) {
-        O << Data32bitsDirective << unsigned(Val >> 32)
-          << "\t" << CommentString << " Double-word most significant word "
-          << Val << "\n";
-        O << Data32bitsDirective << unsigned(Val)
-          << "\t" << CommentString << " Double-word least significant word "
-          << Val << "\n";
+        O << TAI->getData32bitsDirective() << unsigned(Val >> 32)
+          << "\t" << TAI->getCommentString()
+          << " Double-word most significant word " << Val << "\n";
+        O << TAI->getData32bitsDirective() << unsigned(Val)
+          << "\t" << TAI->getCommentString()
+          << " Double-word least significant word " << Val << "\n";
       } else {
-        O << Data32bitsDirective << unsigned(Val)
-          << "\t" << CommentString << " Double-word least significant word "
-          << Val << "\n";
-        O << Data32bitsDirective << unsigned(Val >> 32)
-          << "\t" << CommentString << " Double-word most significant word "
-          << Val << "\n";
+        O << TAI->getData32bitsDirective() << unsigned(Val)
+          << "\t" << TAI->getCommentString()
+          << " Double-word least significant word " << Val << "\n";
+        O << TAI->getData32bitsDirective() << unsigned(Val >> 32)
+          << "\t" << TAI->getCommentString()
+          << " Double-word most significant word " << Val << "\n";
       }
       return;
     }
@@ -610,25 +582,26 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
   switch (type->getTypeID()) {
   case Type::BoolTyID:
   case Type::UByteTyID: case Type::SByteTyID:
-    O << Data8bitsDirective;
+    O << TAI->getData8bitsDirective();
     break;
   case Type::UShortTyID: case Type::ShortTyID:
-    O << Data16bitsDirective;
+    O << TAI->getData16bitsDirective();
     break;
   case Type::PointerTyID:
     if (TD->getPointerSize() == 8) {
-      assert(Data64bitsDirective &&
+      assert(TAI->getData64bitsDirective() &&
              "Target cannot handle 64-bit pointer exprs!");
-      O << Data64bitsDirective;
+      O << TAI->getData64bitsDirective();
       break;
     }
     //Fall through for pointer size == int size
   case Type::UIntTyID: case Type::IntTyID:
-    O << Data32bitsDirective;
+    O << TAI->getData32bitsDirective();
     break;
   case Type::ULongTyID: case Type::LongTyID:
-    assert(Data64bitsDirective &&"Target cannot handle 64-bit constant exprs!");
-    O << Data64bitsDirective;
+    assert(TAI->getData64bitsDirective() &&
+           "Target cannot handle 64-bit constant exprs!");
+    O << TAI->