#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/Support/DataTypes.h"
+#include <set>
namespace llvm {
class Constant;
class ConstantArray;
class GlobalVariable;
+ class GlobalAlias;
class MachineConstantPoolEntry;
class MachineConstantPoolValue;
class Mangler;
/// AsmPrinter - This class is intended to be used as a driving class for all
/// asm writers.
class AsmPrinter : public MachineFunctionPass {
+ static const char ID;
+
/// FunctionNumber - This provides a unique ID for each function emitted in
/// this translation unit. It is autoincremented by SetupMachineFunction,
/// and can be accessed with getFunctionNumber() and
///
unsigned FunctionNumber;
+ protected:
+ // Necessary for external weak linkage support
+ std::set<const GlobalValue*> ExtWeakSymbols;
+
public:
/// Output stream on which we're printing assembly code.
///
///
/// 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
/// is the same as the SwitchToTextSection method, but not all assemblers
/// are the same.
///
- void SwitchToDataSection(const char *NewSection, const GlobalValue *GV);
-
- /// getPreferredAlignmentLog - Return the preferred alignment of the
- /// specified global, returned in log form. This includes an explicitly
- /// requested alignment (if the global has one).
- unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const;
+ 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
/// 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;
/// 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,
/// 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.
projects / oota-llvm.git / blobdiff