blob: aa9e07540f9e340aa8a712bcc0720b49fd9a5754 [file] [log] [blame]
Anton Korobeynikov099883f2007-03-21 21:38:25 +00001//===-- MSILWriter.h - TargetMachine for the MSIL ---------------*- C++ -*-===//
2//
Anton Korobeynikovbed29462007-04-16 18:10:23 +00003// The LLVM Compiler Infrastructure
Anton Korobeynikov099883f2007-03-21 21:38:25 +00004//
Chris Lattner4ee451d2007-12-29 20:36:04 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Anton Korobeynikov099883f2007-03-21 21:38:25 +00007//
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/Constants.h"
17#include "llvm/Module.h"
18#include "llvm/Instructions.h"
Anton Korobeynikovf13090c2007-05-06 20:13:33 +000019#include "llvm/IntrinsicInst.h"
Anton Korobeynikov099883f2007-03-21 21:38:25 +000020#include "llvm/Pass.h"
21#include "llvm/PassManager.h"
Daniel Dunbar92645ac2009-07-21 08:58:44 +000022#include "llvm/ADT/StringRef.h"
Anton Korobeynikov099883f2007-03-21 21:38:25 +000023#include "llvm/Analysis/FindUsedTypes.h"
24#include "llvm/Analysis/LoopInfo.h"
David Greene71847812009-07-14 20:18:05 +000025#include "llvm/Support/FormattedStream.h"
Anton Korobeynikov099883f2007-03-21 21:38:25 +000026#include "llvm/Support/GetElementPtrTypeIterator.h"
27#include "llvm/Target/TargetData.h"
28#include "llvm/Target/TargetMachine.h"
Anton Korobeynikov099883f2007-03-21 21:38:25 +000029#include "llvm/Support/Mangler.h"
Anton Korobeynikov099883f2007-03-21 21:38:25 +000030
Daniel Dunbar4cb1e132009-07-18 23:03:22 +000031namespace llvm {
32 extern Target TheMSILTarget;
Anton Korobeynikov099883f2007-03-21 21:38:25 +000033
34 class MSILModule : public ModulePass {
35 Module *ModulePtr;
36 const std::set<const Type *>*& UsedTypes;
37 const TargetData*& TD;
38
39 public:
Devang Patel19974732007-05-03 01:11:54 +000040 static char ID;
Anton Korobeynikov099883f2007-03-21 21:38:25 +000041 MSILModule(const std::set<const Type *>*& _UsedTypes,
42 const TargetData*& _TD)
Dan Gohmanae73dc12008-09-04 17:05:41 +000043 : ModulePass(&ID), UsedTypes(_UsedTypes), TD(_TD) {}
Anton Korobeynikov099883f2007-03-21 21:38:25 +000044
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
Nick Lewycky92fbbc72009-07-26 08:16:51 +000058 class MSILWriter : public FunctionPass {
Anton Korobeynikov099883f2007-03-21 21:38:25 +000059 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
Anton Korobeynikovf13090c2007-05-06 20:13:33 +000070 uint64_t UniqID;
Anton Korobeynikov099883f2007-03-21 21:38:25 +000071
72 uint64_t getUniqID() {
73 return ++UniqID;
74 }
75
76 public:
David Greene71847812009-07-14 20:18:05 +000077 formatted_raw_ostream &Out;
Anton Korobeynikov099883f2007-03-21 21:38:25 +000078 Module* ModulePtr;
79 const TargetData* TD;
80 Mangler* Mang;
81 LoopInfo *LInfo;
82 std::vector<StaticInitializer>* InitListPtr;
83 std::map<const GlobalVariable*,std::vector<StaticInitializer> >
84 StaticInitList;
85 const std::set<const Type *>* UsedTypes;
Devang Patel19974732007-05-03 01:11:54 +000086 static char ID;
Chris Lattnerca1bafd2009-07-13 23:46:46 +000087 DenseMap<const Value*, unsigned> AnonValueNumbers;
88 unsigned NextAnonValueNumber;
89
Chris Lattner5473f072009-07-14 20:25:40 +000090 MSILWriter(formatted_raw_ostream &o) : FunctionPass(&ID), Out(o),
91 NextAnonValueNumber(0) {
Anton Korobeynikov099883f2007-03-21 21:38:25 +000092 UniqID = 0;
93 }
94
95 enum ValueType {
96 UndefVT,
97 GlobalVT,
98 InternalVT,
99 ArgumentVT,
100 LocalVT,
101 ConstVT,
102 ConstExprVT
103 };
104
105 bool isVariable(ValueType V) {
106 return V==GlobalVT || V==InternalVT || V==ArgumentVT || V==LocalVT;
107 }
108
109 bool isConstValue(ValueType V) {
110 return V==ConstVT || V==ConstExprVT;
111 }
112
113 virtual const char *getPassName() const { return "MSIL backend"; }
114
115 void getAnalysisUsage(AnalysisUsage &AU) const {
116 AU.addRequired<LoopInfo>();
117 AU.setPreservesAll();
118 }
119
120 bool runOnFunction(Function &F);
121
122 virtual bool doInitialization(Module &M);
123
124 virtual bool doFinalization(Module &M);
125
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000126 void printModuleStartup();
127
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000128 bool isZeroValue(const Value* V);
129
130 std::string getValueName(const Value* V);
131
132 std::string getLabelName(const Value* V);
133
134 std::string getLabelName(const std::string& Name);
135
136 std::string getConvModopt(unsigned CallingConvID);
137
138 std::string getArrayTypeName(Type::TypeID TyID, const Type* Ty);
139
140 std::string getPrimitiveTypeName(const Type* Ty, bool isSigned);
141
142 std::string getFunctionTypeName(const Type* Ty);
143
144 std::string getPointerTypeName(const Type* Ty);
145
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000146 std::string getTypeName(const Type* Ty, bool isSigned = false,
147 bool isNested = false);
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000148
149 ValueType getValueLocation(const Value* V);
150
151 std::string getTypePostfix(const Type* Ty, bool Expand,
152 bool isSigned = false);
153
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000154 void printConvToPtr();
155
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000156 void printPtrLoad(uint64_t N);
157
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000158 void printValuePtrLoad(const Value* V);
159
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000160 void printConstLoad(const Constant* C);
161
162 void printValueLoad(const Value* V);
163
164 void printValueSave(const Value* V);
165
166 void printBinaryInstruction(const char* Name, const Value* Left,
167 const Value* Right);
168
169 void printSimpleInstruction(const char* Inst, const char* Operand = NULL);
170
171 void printPHICopy(const BasicBlock* Src, const BasicBlock* Dst);
172
173 void printBranchToBlock(const BasicBlock* CurrBB,
174 const BasicBlock* TrueBB,
175 const BasicBlock* FalseBB);
176
177 void printBranchInstruction(const BranchInst* Inst);
178
179 void printSelectInstruction(const Value* Cond, const Value* VTrue,
180 const Value* VFalse);
181
182 void printIndirectLoad(const Value* V);
183
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000184 void printIndirectSave(const Value* Ptr, const Value* Val);
185
186 void printIndirectSave(const Type* Ty);
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000187
188 void printCastInstruction(unsigned int Op, const Value* V,
Anton Korobeynikov94ac0342009-07-14 09:53:14 +0000189 const Type* Ty, const Type* SrcTy=0);
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000190
191 void printGepInstruction(const Value* V, gep_type_iterator I,
192 gep_type_iterator E);
193
194 std::string getCallSignature(const FunctionType* Ty,
195 const Instruction* Inst,
196 std::string Name);
197
198 void printFunctionCall(const Value* FnVal, const Instruction* Inst);
199
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000200 void printIntrinsicCall(const IntrinsicInst* Inst);
201
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000202 void printCallInstruction(const Instruction* Inst);
203
204 void printICmpInstruction(unsigned Predicate, const Value* Left,
205 const Value* Right);
206
207 void printFCmpInstruction(unsigned Predicate, const Value* Left,
208 const Value* Right);
209
210 void printInvokeInstruction(const InvokeInst* Inst);
211
212 void printSwitchInstruction(const SwitchInst* Inst);
213
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000214 void printVAArgInstruction(const VAArgInst* Inst);
215
216 void printAllocaInstruction(const AllocaInst* Inst);
217
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000218 void printInstruction(const Instruction* Inst);
219
220 void printLoop(const Loop* L);
221
222 void printBasicBlock(const BasicBlock* BB);
223
224 void printLocalVariables(const Function& F);
225
226 void printFunctionBody(const Function& F);
227
228 void printConstantExpr(const ConstantExpr* CE);
229
230 void printStaticInitializerList();
231
232 void printFunction(const Function& F);
233
234 void printDeclarations(const TypeSymbolTable& ST);
235
236 unsigned int getBitWidth(const Type* Ty);
237
238 void printStaticConstant(const Constant* C, uint64_t& Offset);
239
240 void printStaticInitializer(const Constant* C, const std::string& Name);
241
242 void printVariableDefinition(const GlobalVariable* G);
243
244 void printGlobalVariables();
245
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000246 const char* getLibraryName(const Function* F);
247
248 const char* getLibraryName(const GlobalVariable* GV);
249
Daniel Dunbarbda96532009-07-21 08:57:31 +0000250 const char* getLibraryForSymbol(const StringRef &Name, bool isFunction,
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000251 unsigned CallingConv);
252
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000253 void printExternals();
254 };
Daniel Dunbar4cb1e132009-07-18 23:03:22 +0000255
Anton Korobeynikov099883f2007-03-21 21:38:25 +0000256}
257
258#endif
Anton Korobeynikovf13090c2007-05-06 20:13:33 +0000259