Implement "general dynamic", "initial exec" and "local exec" TLS models for

[oota-llvm.git] / include / llvm / CodeGen / AsmPrinter.h

diff --git a/include/llvm/CodeGen/AsmPrinter.h b/include/llvm/CodeGen/AsmPrinter.h
index 223841e1d20858051128b749af259ebad4ecb6b6..e3ca8aa663e845d9af8f491adfc8b2cbe3c0ace1 100644 (file)
--- a/include/llvm/CodeGen/AsmPrinter.h
+++ b/include/llvm/CodeGen/AsmPrinter.h
@@ -18,6 +18,7 @@
 
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/Support/DataTypes.h"
+#include <set>
 
 namespace llvm {
   class Constant;
@@ -39,6 +40,10 @@ namespace llvm {
     ///
     unsigned FunctionNumber;
 
+  protected:
+    // Necessary for external weak linkage support
+    std::set<const GlobalValue*> ExtWeakSymbols;
+
   public:
     /// Output stream on which we're printing assembly code.
     ///
@@ -79,7 +84,7 @@ namespace llvm {
     ///
     /// This method is used when about to emit executable code.
     ///
-    void SwitchToTextSection(const char *NewSection, const GlobalValue *GV);
+    void SwitchToTextSection(const char *NewSection, const GlobalValue *GV = NULL);
 
     /// SwitchToDataSection - Switch to the specified section of the executable
     /// if we are not already in it!  If GV is non-null and if the global has an
@@ -93,13 +98,17 @@ namespace llvm {
     /// is the same as the SwitchToTextSection method, but not all assemblers
     /// are the same.
     ///
-    void SwitchToDataSection(const char *NewSection, const GlobalValue *GV);
+    void SwitchToDataSection(const char *NewSection, const GlobalValue *GV = NULL);
     
     /// getGlobalLinkName - Returns the asm/link name of of the specified
     /// global variable.  Should be overridden by each target asm printer to
     /// generate the appropriate value.
     virtual const std::string getGlobalLinkName(const GlobalVariable *GV) const;
 
+    /// EmitExternalGlobal - Emit the external reference to a global variable.
+    /// Should be overridden if an indirect reference should be used.
+    virtual void EmitExternalGlobal(const GlobalVariable *GV);
+
   protected:
     /// doInitialization - Set up the AsmPrinter when we are working on a new
     /// module.  If your pass overrides this, it must make sure to explicitly
@@ -169,12 +178,77 @@ namespace llvm {
     /// do nothing and return false.
     bool EmitSpecialLLVMGlobal(const GlobalVariable *GV);
     
+  public:
+    //===------------------------------------------------------------------===//
+    /// LEB 128 number encoding.
+
+    /// PrintULEB128 - Print a series of hexidecimal values(separated by commas)
+    /// representing an unsigned leb128 value.
+    void PrintULEB128(unsigned Value) const;
+
+    /// SizeULEB128 - Compute the number of bytes required for an unsigned
+    /// leb128 value.
+    static unsigned SizeULEB128(unsigned Value);
+
+    /// PrintSLEB128 - Print a series of hexidecimal values(separated by commas)
+    /// representing a signed leb128 value.
+    void PrintSLEB128(int Value) const;
+
+    /// SizeSLEB128 - Compute the number of bytes required for a signed leb128
+    /// value.
+    static unsigned SizeSLEB128(int Value);
+    
+    //===------------------------------------------------------------------===//
+    // Emission and print routines
+    //
+
+    /// PrintHex - Print a value as a hexidecimal value.
+    ///
+    void PrintHex(int Value) const;
+
+    /// EOL - Print a newline character to asm stream.  If a comment is present
+    /// then it will be printed first.  Comments should not contain '\n'.
+    void EOL() const;
+    void EOL(const std::string &Comment) const;
+    
+    /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
+    /// unsigned leb128 value.
+    void EmitULEB128Bytes(unsigned Value) const;
+    
+    /// EmitSLEB128Bytes - print an assembler byte data directive to compose a
+    /// signed leb128 value.
+    void EmitSLEB128Bytes(int Value) const;
+    
+    /// EmitInt8 - Emit a byte directive and value.
+    ///
+    void EmitInt8(int Value) const;
+
+    /// EmitInt16 - Emit a short directive and value.
+    ///
+    void EmitInt16(int Value) const;
+
+    /// EmitInt32 - Emit a long directive and value.
+    ///
+    void EmitInt32(int Value) const;
+
+    /// EmitInt64 - Emit a long long directive and value.
+    ///
+    void EmitInt64(uint64_t Value) const;
+
+    /// EmitString - Emit a string with quotes and a null terminator.
+    /// Special characters are emitted properly.
+    /// \literal (Eg. '\t') \endliteral
+    void EmitString(const std::string &String) const;
+    
+    //===------------------------------------------------------------------===//
+
     /// EmitAlignment - Emit an alignment directive to the specified power of
     /// two boundary.  For example, if you pass in 3 here, you will get an 8
     /// byte alignment.  If a global value is specified, and if that global has
     /// an explicit alignment requested, it will override the alignment request.
     void EmitAlignment(unsigned NumBits, const GlobalValue *GV = 0) const;
 
+  protected:
     /// EmitZeros - Emit a block of zeros.
     ///
     void EmitZeros(uint64_t NumZeros) const;
@@ -197,6 +271,10 @@ namespace llvm {
     /// instruction that is an inline asm.
     void printInlineAsm(const MachineInstr *MI) const;
     
+    /// printLabel - This method prints a local label used by debug and
+    /// exception handling tables.
+    void printLabel(const MachineInstr *MI) const;
+
     /// printBasicBlockLabel - This method prints the label for the specified
     /// MachineBasicBlock
     virtual void printBasicBlockLabel(const MachineBasicBlock *MBB,
@@ -206,6 +284,8 @@ namespace llvm {
     /// printSetLabel - This method prints a set label for the specified
     /// MachineBasicBlock
     void printSetLabel(unsigned uid, const MachineBasicBlock *MBB) const;
+    void printSetLabel(unsigned uid, unsigned uid2,
+                       const MachineBasicBlock *MBB) const;
 
     /// printDataDirective - This method prints the asm directive for the
     /// specified type.