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