lib/Target/MSIL/MSILWriter.h

   1 //===-- MSILWriter.h - TargetMachine for the MSIL ---------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares the MSILWriter that is used by the MSIL.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #ifndef MSILWRITER_H
  14 #define MSILWRITER_H
  15
  16 #include "llvm/CallingConv.h"
  17 #include "llvm/Constants.h"
  18 #include "llvm/Module.h"
  19 #include "llvm/Instructions.h"
  20 #include "llvm/IntrinsicInst.h"
  21 #include "llvm/Pass.h"
  22 #include "llvm/PassManager.h"
  23 #include "llvm/ADT/StringRef.h"
  24 #include "llvm/Analysis/FindUsedTypes.h"
  25 #include "llvm/Analysis/LoopInfo.h"
  26 #include "llvm/Support/FormattedStream.h"
  27 #include "llvm/Support/GetElementPtrTypeIterator.h"
  28 #include "llvm/Target/TargetData.h"
  29 #include "llvm/Target/TargetMachine.h"
  30 #include "llvm/Support/Mangler.h"
  31
  32 namespace llvm {
  33   extern Target TheMSILTarget;
  34
  35   class MSILModule : public ModulePass {
  36     Module *ModulePtr;
  37     const std::set<const Type *>*& UsedTypes;
  38     const TargetData*& TD;
  39
  40   public:
  41     static char ID;
  42     MSILModule(const std::set<const Type *>*& _UsedTypes,
  43                const TargetData*& _TD)
  44       : ModulePass(&ID), UsedTypes(_UsedTypes), TD(_TD) {}
  45
  46     void getAnalysisUsage(AnalysisUsage &AU) const {
  47       AU.addRequired<FindUsedTypes>();
  48       AU.addRequired<TargetData>();
  49     }
  50
  51     virtual const char *getPassName() const {
  52       return "MSIL backend definitions";
  53     }
  54
  55     virtual bool runOnModule(Module &M);
  56
  57   };
  58
  59   class MSILWriter : public FunctionPass {
  60     struct StaticInitializer {
  61       const Constant* constant;
  62       uint64_t offset;
  63
  64       StaticInitializer()
  65         : constant(0), offset(0) {}
  66
  67       StaticInitializer(const Constant* _constant, uint64_t _offset)
  68         : constant(_constant), offset(_offset) {}
  69     };
  70
  71     uint64_t UniqID;
  72
  73     uint64_t getUniqID() {
  74       return ++UniqID;
  75     }
  76
  77   public:
  78     formatted_raw_ostream &Out;
  79     Module* ModulePtr;
  80     const TargetData* TD;
  81     Mangler* Mang;
  82     LoopInfo *LInfo;
  83     std::vector<StaticInitializer>* InitListPtr;
  84     std::map<const GlobalVariable*,std::vector<StaticInitializer> >
  85       StaticInitList;
  86     const std::set<const Type *>* UsedTypes;
  87     static char ID;
  88     DenseMap<const Value*, unsigned> AnonValueNumbers;
  89     unsigned NextAnonValueNumber;
  90
  91     MSILWriter(formatted_raw_ostream &o) : FunctionPass(&ID), Out(o),
  92          NextAnonValueNumber(0) {
  93       UniqID = 0;
  94     }
  95
  96     enum ValueType {
  97       UndefVT,
  98       GlobalVT,
  99       InternalVT,
 100       ArgumentVT,
 101       LocalVT,
 102       ConstVT,
 103       ConstExprVT
 104     };
 105
 106     bool isVariable(ValueType V) {
 107       return V==GlobalVT || V==InternalVT || V==ArgumentVT || V==LocalVT;
 108     }
 109
 110     bool isConstValue(ValueType V) {
 111       return V==ConstVT || V==ConstExprVT;
 112     }
 113
 114     virtual const char *getPassName() const { return "MSIL backend"; }
 115
 116     void getAnalysisUsage(AnalysisUsage &AU) const {
 117       AU.addRequired<LoopInfo>();
 118       AU.setPreservesAll();
 119     }
 120
 121     bool runOnFunction(Function &F);
 122
 123     virtual bool doInitialization(Module &M);
 124
 125     virtual bool doFinalization(Module &M);
 126
 127     void printModuleStartup();
 128
 129     bool isZeroValue(const Value* V);
 130
 131     std::string getValueName(const Value* V);
 132
 133     std::string getLabelName(const Value* V);
 134
 135     std::string getLabelName(const std::string& Name);
 136
 137     std::string getConvModopt(CallingConv::ID CallingConvID);
 138
 139     std::string getArrayTypeName(Type::TypeID TyID, const Type* Ty);
 140
 141     std::string getPrimitiveTypeName(const Type* Ty, bool isSigned);
 142
 143     std::string getFunctionTypeName(const Type* Ty);
 144
 145     std::string getPointerTypeName(const Type* Ty);
 146
 147     std::string getTypeName(const Type* Ty, bool isSigned = false,
 148                             bool isNested = false);
 149
 150     ValueType getValueLocation(const Value* V);
 151
 152     std::string getTypePostfix(const Type* Ty, bool Expand,
 153                                bool isSigned = false);
 154
 155     void printConvToPtr();
 156
 157     void printPtrLoad(uint64_t N);
 158
 159     void printValuePtrLoad(const Value* V);
 160
 161     void printConstLoad(const Constant* C);
 162
 163     void printValueLoad(const Value* V);
 164
 165     void printValueSave(const Value* V);
 166
 167     void printBinaryInstruction(const char* Name, const Value* Left,
 168                                 const Value* Right);
 169
 170     void printSimpleInstruction(const char* Inst, const char* Operand = NULL);
 171
 172     void printPHICopy(const BasicBlock* Src, const BasicBlock* Dst);
 173
 174     void printBranchToBlock(const BasicBlock* CurrBB,
 175                             const BasicBlock* TrueBB,
 176                             const BasicBlock* FalseBB);
 177
 178     void printBranchInstruction(const BranchInst* Inst);
 179
 180     void printSelectInstruction(const Value* Cond, const Value* VTrue,
 181                                 const Value* VFalse);
 182
 183     void printIndirectLoad(const Value* V);
 184
 185     void printIndirectSave(const Value* Ptr, const Value* Val);
 186
 187     void printIndirectSave(const Type* Ty);
 188
 189     void printCastInstruction(unsigned int Op, const Value* V,
 190                               const Type* Ty, const Type* SrcTy=0);
 191
 192     void printGepInstruction(const Value* V, gep_type_iterator I,
 193                              gep_type_iterator E);
 194
 195     std::string getCallSignature(const FunctionType* Ty,
 196                                  const Instruction* Inst,
 197                                  std::string Name);
 198
 199     void printFunctionCall(const Value* FnVal, const Instruction* Inst);
 200
 201     void printIntrinsicCall(const IntrinsicInst* Inst);
 202
 203     void printCallInstruction(const Instruction* Inst);
 204
 205     void printICmpInstruction(unsigned Predicate, const Value* Left,
 206                               const Value* Right);
 207
 208     void printFCmpInstruction(unsigned Predicate, const Value* Left,
 209                               const Value* Right);
 210
 211     void printInvokeInstruction(const InvokeInst* Inst);
 212
 213     void printSwitchInstruction(const SwitchInst* Inst);
 214
 215     void printVAArgInstruction(const VAArgInst* Inst);
 216
 217     void printAllocaInstruction(const AllocaInst* Inst);
 218
 219     void printInstruction(const Instruction* Inst);
 220
 221     void printLoop(const Loop* L);
 222
 223     void printBasicBlock(const BasicBlock* BB);
 224
 225     void printLocalVariables(const Function& F);
 226
 227     void printFunctionBody(const Function& F);
 228
 229     void printConstantExpr(const ConstantExpr* CE);
 230
 231     void printStaticInitializerList();
 232
 233     void printFunction(const Function& F);
 234
 235     void printDeclarations(const TypeSymbolTable& ST);
 236
 237     unsigned int getBitWidth(const Type* Ty);
 238
 239     void printStaticConstant(const Constant* C, uint64_t& Offset);
 240
 241     void printStaticInitializer(const Constant* C, const std::string& Name);
 242
 243     void printVariableDefinition(const GlobalVariable* G);
 244
 245     void printGlobalVariables();
 246
 247     const char* getLibraryName(const Function* F);
 248
 249     const char* getLibraryName(const GlobalVariable* GV);
 250
 251     const char* getLibraryForSymbol(const StringRef &Name, bool isFunction,
 252                                     CallingConv::ID CallingConv);
 253
 254     void printExternals();
 255   };
 256
 257 }
 258
 259 #endif
 260