blob: 0c808131b602c7664463e6c9b0d5b6c7197f0479 [file] [log] [blame]
Reid Spencer76796932007-01-10 04:17:32 +00001//===-- CBackend.cpp - Library for converting LLVM code to C --------------===//
Misha Brukmand6a29a52005-04-20 16:05:03 +00002//
John Criswellb576c942003-10-20 19:43:21 +00003// The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source License. See LICENSE.TXT for details.
Misha Brukmand6a29a52005-04-20 16:05:03 +00007//
John Criswellb576c942003-10-20 19:43:21 +00008//===----------------------------------------------------------------------===//
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00009//
Chris Lattner897bf0d2004-02-13 06:18:21 +000010// This library converts LLVM code to C code, compilable by GCC and other C
11// compilers.
Chris Lattner16c7bb22002-05-09 02:28:59 +000012//
Chris Lattneredd8ce12003-05-03 03:14:35 +000013//===----------------------------------------------------------------------===//
Chris Lattner84e66652003-05-03 07:11:00 +000014
Chris Lattnerf31182a2004-02-13 23:18:48 +000015#include "CTargetMachine.h"
Chris Lattner0c54d892006-05-23 23:39:48 +000016#include "llvm/CallingConv.h"
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +000017#include "llvm/Constants.h"
Chris Lattner2f5f51a2002-05-09 03:28:37 +000018#include "llvm/DerivedTypes.h"
19#include "llvm/Module.h"
Chris Lattnera9f5e052003-04-22 20:19:52 +000020#include "llvm/Instructions.h"
Chris Lattner0e9f93e2002-08-31 00:29:16 +000021#include "llvm/Pass.h"
Chris Lattner94f4f8e2004-02-13 23:00:29 +000022#include "llvm/PassManager.h"
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +000023#include "llvm/SymbolTable.h"
Reid Spencer78d033e2007-01-06 07:24:44 +000024#include "llvm/TypeSymbolTable.h"
Chris Lattner18ac3c82003-05-08 18:41:45 +000025#include "llvm/Intrinsics.h"
Jim Laskey580418e2006-03-23 18:08:29 +000026#include "llvm/IntrinsicInst.h"
Andrew Lenharth29c277f2006-11-27 23:50:49 +000027#include "llvm/InlineAsm.h"
Chris Lattnerd1cf1b42002-09-20 23:26:33 +000028#include "llvm/Analysis/ConstantsScanner.h"
Chris Lattnercb3ad012004-05-09 20:41:32 +000029#include "llvm/Analysis/FindUsedTypes.h"
30#include "llvm/Analysis/LoopInfo.h"
Chris Lattner30483732004-06-20 07:49:54 +000031#include "llvm/CodeGen/IntrinsicLowering.h"
Chris Lattner94f4f8e2004-02-13 23:00:29 +000032#include "llvm/Transforms/Scalar.h"
Chris Lattnerd36c9702004-07-11 02:48:49 +000033#include "llvm/Target/TargetMachineRegistry.h"
Andrew Lenharthe0cf0752006-11-28 19:53:36 +000034#include "llvm/Target/TargetAsmInfo.h"
Chris Lattner23e90702003-11-25 20:49:55 +000035#include "llvm/Support/CallSite.h"
Chris Lattnera05e0ec2004-05-09 03:42:48 +000036#include "llvm/Support/CFG.h"
Chris Lattner23e90702003-11-25 20:49:55 +000037#include "llvm/Support/GetElementPtrTypeIterator.h"
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +000038#include "llvm/Support/InstVisitor.h"
Brian Gaeke49a178b2003-07-25 20:21:06 +000039#include "llvm/Support/Mangler.h"
Jim Laskeycb6682f2005-08-17 19:34:49 +000040#include "llvm/Support/MathExtras.h"
Reid Spencer551ccae2004-09-01 22:55:40 +000041#include "llvm/ADT/StringExtras.h"
Chris Lattner67c2d182005-03-18 16:12:37 +000042#include "llvm/ADT/STLExtras.h"
Reid Spencer551ccae2004-09-01 22:55:40 +000043#include "llvm/Support/MathExtras.h"
44#include "llvm/Config/config.h"
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +000045#include <algorithm>
Bill Wendling1a097e32006-12-07 23:41:45 +000046#include <sstream>
Chris Lattner897bf0d2004-02-13 06:18:21 +000047using namespace llvm;
Brian Gaeked0fde302003-11-11 22:41:34 +000048
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +000049namespace {
Chris Lattnerd36c9702004-07-11 02:48:49 +000050 // Register the target.
Chris Lattner71d24aa2004-07-11 03:27:42 +000051 RegisterTarget<CTargetMachine> X("c", " C backend");
Chris Lattnerd36c9702004-07-11 02:48:49 +000052
Chris Lattnerf9a05322006-02-13 22:22:42 +000053 /// CBackendNameAllUsedStructsAndMergeFunctions - This pass inserts names for
54 /// any unnamed structure types that are used by the program, and merges
55 /// external functions with the same name.
Chris Lattner68758072004-05-09 06:20:51 +000056 ///
Chris Lattnerf9a05322006-02-13 22:22:42 +000057 class CBackendNameAllUsedStructsAndMergeFunctions : public ModulePass {
Chris Lattner68758072004-05-09 06:20:51 +000058 void getAnalysisUsage(AnalysisUsage &AU) const {
59 AU.addRequired<FindUsedTypes>();
60 }
61
62 virtual const char *getPassName() const {
63 return "C backend type canonicalizer";
64 }
65
Chris Lattnerb12914b2004-09-20 04:48:05 +000066 virtual bool runOnModule(Module &M);
Chris Lattner68758072004-05-09 06:20:51 +000067 };
Misha Brukmand6a29a52005-04-20 16:05:03 +000068
Chris Lattner68758072004-05-09 06:20:51 +000069 /// CWriter - This class is the main chunk of code that converts an LLVM
70 /// module to a C translation unit.
71 class CWriter : public FunctionPass, public InstVisitor<CWriter> {
Misha Brukmand6a29a52005-04-20 16:05:03 +000072 std::ostream &Out;
Chris Lattnerb71fd782006-11-15 18:00:10 +000073 IntrinsicLowering IL;
Brian Gaeked9fb37a2003-07-24 20:20:44 +000074 Mangler *Mang;
Chris Lattnercb3ad012004-05-09 20:41:32 +000075 LoopInfo *LI;
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +000076 const Module *TheModule;
Andrew Lenharthe0cf0752006-11-28 19:53:36 +000077 const TargetAsmInfo* TAsm;
Chris Lattneredd8ce12003-05-03 03:14:35 +000078 std::map<const Type *, std::string> TypeNames;
Nick Hildenbrandt67aa2e22002-09-14 21:36:24 +000079
Chris Lattneredd8ce12003-05-03 03:14:35 +000080 std::map<const ConstantFP *, unsigned> FPConstantMap;
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +000081 public:
Andrew Lenharthe0cf0752006-11-28 19:53:36 +000082 CWriter(std::ostream &o) : Out(o), TAsm(0) {}
Chris Lattner0e9f93e2002-08-31 00:29:16 +000083
Chris Lattner94f4f8e2004-02-13 23:00:29 +000084 virtual const char *getPassName() const { return "C backend"; }
Chris Lattner0e9f93e2002-08-31 00:29:16 +000085
Chris Lattnercb3ad012004-05-09 20:41:32 +000086 void getAnalysisUsage(AnalysisUsage &AU) const {
87 AU.addRequired<LoopInfo>();
88 AU.setPreservesAll();
89 }
90
Chris Lattner68758072004-05-09 06:20:51 +000091 virtual bool doInitialization(Module &M);
Chris Lattner0e9f93e2002-08-31 00:29:16 +000092
Chris Lattner68758072004-05-09 06:20:51 +000093 bool runOnFunction(Function &F) {
Chris Lattnercb3ad012004-05-09 20:41:32 +000094 LI = &getAnalysis<LoopInfo>();
95
Chris Lattner3150e2d2004-12-05 06:49:44 +000096 // Get rid of intrinsics we can't handle.
97 lowerIntrinsics(F);
98
Chris Lattner68758072004-05-09 06:20:51 +000099 // Output all floating point constants that cannot be printed accurately.
100 printFloatingPointConstants(F);
Chris Lattner3150e2d2004-12-05 06:49:44 +0000101
Chris Lattner68758072004-05-09 06:20:51 +0000102 printFunction(F);
103 FPConstantMap.clear();
104 return false;
105 }
Chris Lattner0e9f93e2002-08-31 00:29:16 +0000106
Chris Lattner68758072004-05-09 06:20:51 +0000107 virtual bool doFinalization(Module &M) {
Chris Lattner0e9f93e2002-08-31 00:29:16 +0000108 // Free memory...
Brian Gaeked9fb37a2003-07-24 20:20:44 +0000109 delete Mang;
Chris Lattner0e9f93e2002-08-31 00:29:16 +0000110 TypeNames.clear();
Chris Lattnercb3ad012004-05-09 20:41:32 +0000111 return false;
Chris Lattner0e9f93e2002-08-31 00:29:16 +0000112 }
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +0000113
Reid Spencer0ae96932007-01-07 03:24:48 +0000114 std::ostream &printType(std::ostream &Out, const Type *Ty,
Reid Spencer251f2142007-01-09 17:09:09 +0000115 bool isSigned = false,
Chris Lattneredd8ce12003-05-03 03:14:35 +0000116 const std::string &VariableName = "",
Chris Lattner7635ea42003-11-03 01:01:59 +0000117 bool IgnoreName = false);
Reid Spencera54b7cb2007-01-12 07:05:14 +0000118 std::ostream &printSimpleType(std::ostream &Out, const Type *Ty,
Reid Spencere4d87aa2006-12-23 06:05:41 +0000119 bool isSigned,
120 const std::string &NameSoFar = "");
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +0000121
Chris Lattner0c54d892006-05-23 23:39:48 +0000122 void printStructReturnPointerFunctionType(std::ostream &Out,
123 const PointerType *Ty);
124
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000125 void writeOperand(Value *Operand);
Andrew Lenharth29c277f2006-11-27 23:50:49 +0000126 void writeOperandRaw(Value *Operand);
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000127 void writeOperandInternal(Value *Operand);
Reid Spencer1628cec2006-10-26 06:15:43 +0000128 void writeOperandWithCast(Value* Operand, unsigned Opcode);
Reid Spencere4d87aa2006-12-23 06:05:41 +0000129 void writeOperandWithCast(Value* Operand, ICmpInst::Predicate predicate);
Reid Spencer1628cec2006-10-26 06:15:43 +0000130 bool writeInstructionCast(const Instruction &I);
Chris Lattnerb5af06a2002-05-09 03:06:06 +0000131
Chris Lattner4fbf26d2002-05-09 20:53:56 +0000132 private :
Andrew Lenharthe0cf0752006-11-28 19:53:36 +0000133 std::string InterpretASMConstraint(InlineAsm::ConstraintInfo& c);
134
Chris Lattnerc2421432004-05-09 04:30:20 +0000135 void lowerIntrinsics(Function &F);
Chris Lattner4ef51372004-02-14 00:31:10 +0000136
Chris Lattner8c3c4bf2002-05-09 15:49:41 +0000137 void printModule(Module *M);
Reid Spencer78d033e2007-01-06 07:24:44 +0000138 void printModuleTypes(const TypeSymbolTable &ST);
Chris Lattner2c601a72002-09-20 15:05:40 +0000139 void printContainedStructs(const Type *Ty, std::set<const StructType *> &);
Chris Lattner68758072004-05-09 06:20:51 +0000140 void printFloatingPointConstants(Function &F);
Chris Lattner4cda8352002-08-20 16:55:48 +0000141 void printFunctionSignature(const Function *F, bool Prototype);
142
Chris Lattner94f4f8e2004-02-13 23:00:29 +0000143 void printFunction(Function &);
Chris Lattnercb3ad012004-05-09 20:41:32 +0000144 void printBasicBlock(BasicBlock *BB);
145 void printLoop(Loop *L);
Chris Lattnerb5af06a2002-05-09 03:06:06 +0000146
Reid Spencer3da59db2006-11-27 01:05:10 +0000147 void printCast(unsigned opcode, const Type *SrcTy, const Type *DstTy);
Chris Lattner6d492922002-08-19 21:32:41 +0000148 void printConstant(Constant *CPV);
Reid Spencer1628cec2006-10-26 06:15:43 +0000149 void printConstantWithCast(Constant *CPV, unsigned Opcode);
150 bool printConstExprCast(const ConstantExpr *CE);
Chris Lattner6d492922002-08-19 21:32:41 +0000151 void printConstantArray(ConstantArray *CPA);
Robert Bocchinob78e8382006-01-20 20:43:57 +0000152 void printConstantPacked(ConstantPacked *CP);
Chris Lattner6d492922002-08-19 21:32:41 +0000153
Chris Lattnerd0c668c2002-05-09 21:18:38 +0000154 // isInlinableInst - Attempt to inline instructions into their uses to build
155 // trees as much as possible. To do this, we have to consistently decide
156 // what is acceptable to inline, so that variable declarations don't get
157 // printed and an extra copy of the expr is not emitted.
158 //
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000159 static bool isInlinableInst(const Instruction &I) {
Reid Spencere4d87aa2006-12-23 06:05:41 +0000160 // Always inline cmp instructions, even if they are shared by multiple
Chris Lattner433e25a2004-05-20 20:25:50 +0000161 // expressions. GCC generates horrible code if we don't.
Reid Spencere4d87aa2006-12-23 06:05:41 +0000162 if (isa<CmpInst>(I))
163 return true;
Chris Lattner433e25a2004-05-20 20:25:50 +0000164
Chris Lattnerd0c668c2002-05-09 21:18:38 +0000165 // Must be an expression, must be used exactly once. If it is dead, we
166 // emit it inline where it would go.
Chris Lattnerfd059242003-10-15 16:48:29 +0000167 if (I.getType() == Type::VoidTy || !I.hasOneUse() ||
Misha Brukmand6a29a52005-04-20 16:05:03 +0000168 isa<TerminatorInst>(I) || isa<CallInst>(I) || isa<PHINode>(I) ||
Andrew Lenharth558bc882005-06-18 18:34:52 +0000169 isa<LoadInst>(I) || isa<VAArgInst>(I))
Chris Lattnerd4e8d312003-07-23 20:45:31 +0000170 // Don't inline a load across a store or other bad things!
Chris Lattnerd0c668c2002-05-09 21:18:38 +0000171 return false;
172
Andrew Lenharth29c277f2006-11-27 23:50:49 +0000173 // Must not be used in inline asm
174 if (I.hasOneUse() && isInlineAsm(*I.use_back())) return false;
175
Reid Spencer555a0b12006-12-11 20:39:15 +0000176 // Only inline instruction it if it's use is in the same BB as the inst.
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000177 return I.getParent() == cast<Instruction>(I.use_back())->getParent();
Chris Lattnerd0c668c2002-05-09 21:18:38 +0000178 }
179
Chris Lattnera8ab89e2003-06-17 04:39:14 +0000180 // isDirectAlloca - Define fixed sized allocas in the entry block as direct
181 // variables which are accessed with the & operator. This causes GCC to
182 // generate significantly better code than to emit alloca calls directly.
183 //
184 static const AllocaInst *isDirectAlloca(const Value *V) {
185 const AllocaInst *AI = dyn_cast<AllocaInst>(V);
186 if (!AI) return false;
187 if (AI->isArrayAllocation())
188 return 0; // FIXME: we can also inline fixed size array allocas!
Chris Lattner02a3be02003-09-20 14:39:18 +0000189 if (AI->getParent() != &AI->getParent()->getParent()->getEntryBlock())
Chris Lattnera8ab89e2003-06-17 04:39:14 +0000190 return 0;
191 return AI;
192 }
Andrew Lenharth29c277f2006-11-27 23:50:49 +0000193
194 // isInlineAsm - Check if the instruction is a call to an inline asm chunk
195 static bool isInlineAsm(const Instruction& I) {
196 if (isa<CallInst>(&I) && isa<InlineAsm>(I.getOperand(0)))
197 return true;
198 return false;
199 }
200
Chris Lattner4fbf26d2002-05-09 20:53:56 +0000201 // Instruction visitation functions
202 friend class InstVisitor<CWriter>;
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +0000203
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000204 void visitReturnInst(ReturnInst &I);
205 void visitBranchInst(BranchInst &I);
Chris Lattnera9f5e052003-04-22 20:19:52 +0000206 void visitSwitchInst(SwitchInst &I);
Chris Lattnercb3ad012004-05-09 20:41:32 +0000207 void visitInvokeInst(InvokeInst &I) {
208 assert(0 && "Lowerinvoke pass didn't work!");
209 }
210
211 void visitUnwindInst(UnwindInst &I) {
212 assert(0 && "Lowerinvoke pass didn't work!");
213 }
Chris Lattnera9d12c02004-10-16 18:12:13 +0000214 void visitUnreachableInst(UnreachableInst &I);
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +0000215
Chris Lattner84e66652003-05-03 07:11:00 +0000216 void visitPHINode(PHINode &I);
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000217 void visitBinaryOperator(Instruction &I);
Reid Spencere4d87aa2006-12-23 06:05:41 +0000218 void visitICmpInst(ICmpInst &I);
219 void visitFCmpInst(FCmpInst &I);
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +0000220
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000221 void visitCastInst (CastInst &I);
Chris Lattner9f24a072004-03-12 05:52:14 +0000222 void visitSelectInst(SelectInst &I);
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000223 void visitCallInst (CallInst &I);
Andrew Lenharth29c277f2006-11-27 23:50:49 +0000224 void visitInlineAsm(CallInst &I);
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000225 void visitShiftInst(ShiftInst &I) { visitBinaryOperator(I); }
Chris Lattner4fbf26d2002-05-09 20:53:56 +0000226
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000227 void visitMallocInst(MallocInst &I);
228 void visitAllocaInst(AllocaInst &I);
229 void visitFreeInst (FreeInst &I);
230 void visitLoadInst (LoadInst &I);
231 void visitStoreInst (StoreInst &I);
232 void visitGetElementPtrInst(GetElementPtrInst &I);
Chris Lattner4d45bd02003-10-18 05:57:43 +0000233 void visitVAArgInst (VAArgInst &I);
Chris Lattner2f5f51a2002-05-09 03:28:37 +0000234
Chris Lattnerbb03efd2002-06-25 15:57:03 +0000235 void visitInstruction(Instruction &I) {
Bill Wendlingf5da1332006-12-07 22:21:48 +0000236 cerr << "C Writer does not know about " << I;
Chris Lattner4fbf26d2002-05-09 20:53:56 +0000237 abort();
238 }
239
240 void outputLValue(Instruction *I) {
Brian Gaeked9fb37a2003-07-24 20:20:44 +0000241 Out << " " << Mang->getValueName(I) << " = ";
Chris Lattner4fbf26d2002-05-09 20:53:56 +0000242 }
Chris Lattnercb3ad012004-05-09 20:41:32 +0000243
244 bool isGotoCodeNecessary(BasicBlock *From, BasicBlock *To);
John Criswell57bbfce2004-10-20 14:38:39 +0000245 void printPHICopiesForSuccessor(BasicBlock *CurBlock,
246 BasicBlock *Successor, unsigned Indent);
Chris Lattner4fbf26d2002-05-09 20:53:56 +0000247 void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
248 unsigned Indent);
Chris Lattner23e90702003-11-25 20:49:55 +0000249 void printIndexingExpression(Value *Ptr, gep_type_iterator I,
250 gep_type_iterator E);
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +0000251 };
Chris Lattner4ef51372004-02-14 00:31:10 +0000252}
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +0000253
Chris Lattner68758072004-05-09 06:20:51 +0000254/// This method inserts names for any unnamed structure types that are used by
255/// the program, and removes names from structure types that are not used by the
256/// program.
257///
Chris Lattnerf9a05322006-02-13 22:22:42 +0000258bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) {
Chris Lattner68758072004-05-09 06:20:51 +0000259 // Get a set of types that are used by the program...
260 std::set<const Type *> UT = getAnalysis<FindUsedTypes>().getTypes();
Misha Brukmand6a29a52005-04-20 16:05:03 +0000261
Chris Lattner68758072004-05-09 06:20:51 +0000262 // Loop over the module symbol table, removing types from UT that are
Chris Lattnerdbf69f12005-03-08 16:19:59 +0000263 // already named, and removing names for types that are not used.
Chris Lattner68758072004-05-09 06:20:51 +0000264 //
Reid Spencer78d033e2007-01-06 07:24:44 +0000265 TypeSymbolTable &TST = M.getTypeSymbolTable();
266 for (TypeSymbolTable::iterator TI = TST.begin(), TE = TST.end();
Reid Spencer9231ac82004-05-25 08:53:40 +0000267 TI != TE; ) {
Reid Spencer78d033e2007-01-06 07:24:44 +0000268 TypeSymbolTable::iterator I = TI++;
Chris Lattner19e8b0c2007-01-16 07:22:23 +0000269
270 // If this isn't a struct type, remove it from our set of types to name.
271 // This simplifies emission later.
Chris Lattnera80cc932007-01-16 18:02:45 +0000272 if (!isa<StructType>(I->second) && !isa<OpaqueType>(I->second)) {
Reid Spencer78d033e2007-01-06 07:24:44 +0000273 TST.remove(I);
Chris Lattner19e8b0c2007-01-16 07:22:23 +0000274 } else {
275 // If this is not used, remove it from the symbol table.
276 std::set<const Type *>::iterator UTI = UT.find(I->second);
277 if (UTI == UT.end())
278 TST.remove(I);
279 else
280 UT.erase(UTI); // Only keep one name for this type.
281 }
Reid Spencer9231ac82004-05-25 08:53:40 +0000282 }
Chris Lattner68758072004-05-09 06:20:51 +0000283
284 // UT now contains types that are not named. Loop over it, naming
285 // structure types.
286 //
287 bool Changed = false;
Chris Lattner9d1af972004-05-28 05:47:27 +0000288 unsigned RenameCounter = 0;
Chris Lattner68758072004-05-09 06:20:51 +0000289 for (std::set<const Type *>::const_iterator I = UT.begin(), E = UT.end();
290 I != E; ++I)
291 if (const StructType *ST = dyn_cast<StructType>(*I)) {
Chris Lattner9d1af972004-05-28 05:47:27 +0000292 while (M.addTypeName("unnamed"+utostr(RenameCounter), ST))
293 ++RenameCounter;
Chris Lattner68758072004-05-09 06:20:51 +0000294 Changed = true;
295 }
Chris Lattnerf9a05322006-02-13 22:22:42 +0000296
297
298 // Loop over all external functions and globals. If we have two with
299 // identical names, merge them.
300 // FIXME: This code should disappear when we don't allow values with the same
301 // names when they have different types!
302 std::map<std::string, GlobalValue*> ExtSymbols;
303 for (Module::iterator I = M.begin(), E = M.end(); I != E;) {
304 Function *GV = I++;
305 if (GV->isExternal() && GV->hasName()) {
306 std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
307 = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
308 if (!X.second) {
309 // Found a conflict, replace this global with the previous one.
310 GlobalValue *OldGV = X.first->second;
Reid Spencer4da49122006-12-12 05:05:00 +0000311 GV->replaceAllUsesWith(ConstantExpr::getBitCast(OldGV, GV->getType()));
Chris Lattnerf9a05322006-02-13 22:22:42 +0000312 GV->eraseFromParent();
313 Changed = true;
314 }
315 }
316 }
317 // Do the same for globals.
318 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
319 I != E;) {
320 GlobalVariable *GV = I++;
321 if (GV->isExternal() && GV->hasName()) {
322 std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
323 = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
324 if (!X.second) {
325 // Found a conflict, replace this global with the previous one.
326 GlobalValue *OldGV = X.first->second;
Reid Spencer4da49122006-12-12 05:05:00 +0000327 GV->replaceAllUsesWith(ConstantExpr::getBitCast(OldGV, GV->getType()));
Chris Lattnerf9a05322006-02-13 22:22:42 +0000328 GV->eraseFromParent();
329 Changed = true;
330 }
331 }
332 }
333
Chris Lattner68758072004-05-09 06:20:51 +0000334 return Changed;
335}
336
Chris Lattner0c54d892006-05-23 23:39:48 +0000337/// printStructReturnPointerFunctionType - This is like printType for a struct
338/// return type, except, instead of printing the type as void (*)(Struct*, ...)
339/// print it as "Struct (*)(...)", for struct return functions.
340void CWriter::printStructReturnPointerFunctionType(std::ostream &Out,
341 const PointerType *TheTy) {
342 const FunctionType *FTy = cast<FunctionType>(TheTy->getElementType());
343 std::stringstream FunctionInnards;
344 FunctionInnards << " (*) (";
345 bool PrintedType = false;
346
347 FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end();
348 const Type *RetTy = cast<PointerType>(I->get())->getElementType();
Reid Spencer0ae96932007-01-07 03:24:48 +0000349 unsigned Idx = 1;
Chris Lattner0c54d892006-05-23 23:39:48 +0000350 for (++I; I != E; ++I) {
351 if (PrintedType)
352 FunctionInnards << ", ";
Reid Spencer0ae96932007-01-07 03:24:48 +0000353 printType(FunctionInnards, *I,
Reid Spencer251f2142007-01-09 17:09:09 +0000354 /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute), "");
Chris Lattner0c54d892006-05-23 23:39:48 +0000355 PrintedType = true;
356 }
357 if (FTy->isVarArg()) {
358 if (PrintedType)
359 FunctionInnards << ", ...";
360 } else if (!PrintedType) {
361 FunctionInnards << "void";
362 }
363 FunctionInnards << ')';
364 std::string tstr = FunctionInnards.str();
Reid Spencer0ae96932007-01-07 03:24:48 +0000365 printType(Out, RetTy,
Reid Spencer251f2142007-01-09 17:09:09 +0000366 /*isSigned=*/FTy->paramHasAttr(0, FunctionType::SExtAttribute), tstr);
Chris Lattner0c54d892006-05-23 23:39:48 +0000367}
368
Reid Spencere4d87aa2006-12-23 06:05:41 +0000369std::ostream &
Reid Spencera54b7cb2007-01-12 07:05:14 +0000370CWriter::printSimpleType(std::ostream &Out, const Type *Ty, bool isSigned,
Reid Spencere4d87aa2006-12-23 06:05:41 +0000371 const std::string &NameSoFar) {
Chris Lattner42a75512007-01-15 02:27:26 +0000372 assert((Ty->isPrimitiveType() || Ty->isInteger()) &&
Reid Spencera54b7cb2007-01-12 07:05:14 +0000373 "Invalid type for printSimpleType");
Reid Spencere4d87aa2006-12-23 06:05:41 +0000374 switch (Ty->getTypeID()) {
Reid Spencera54b7cb2007-01-12 07:05:14 +0000375 case Type::VoidTyID: return Out << "void " << NameSoFar;
376 case Type::IntegerTyID: {
377 unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
378 if (NumBits == 1)
379 return Out << "bool " << NameSoFar;
380 else if (NumBits <= 8)
381 return Out << (isSigned?"signed":"unsigned") << " char " << NameSoFar;
382 else if (NumBits <= 16)
383 return Out << (isSigned?"signed":"unsigned") << " short " << NameSoFar;
384 else if (NumBits <= 32)
385 return Out << (isSigned?"signed":"unsigned") << " int " << NameSoFar;
386 else {
387 assert(NumBits <= 64 && "Bit widths > 64 not implemented yet");
388 return Out << (isSigned?"signed":"unsigned") << " long long "<< NameSoFar;
389 }
390 }
391 case Type::FloatTyID: return Out << "float " << NameSoFar;
392 case Type::DoubleTyID: return Out << "double " << NameSoFar;
Reid Spencere4d87aa2006-12-23 06:05:41 +0000393 default :
394 cerr << "Unknown primitive type: " << *Ty << "\n";
395 abort();
396 }
397}
Chris Lattner68758072004-05-09 06:20:51 +0000398
Chris Lattner83c57752002-08-19 22:17:53 +0000399// Pass the Type* and the variable name and this prints out the variable
400// declaration.
401//
Chris Lattneredd8ce12003-05-03 03:14:35 +0000402std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty,
Reid Spencer0ae96932007-01-07 03:24:48 +0000403 bool isSigned, const std::string &NameSoFar,
Chris Lattner7635ea42003-11-03 01:01:59 +0000404 bool IgnoreName) {
Chris Lattner42a75512007-01-15 02:27:26 +0000405 if (Ty->isPrimitiveType() || Ty->isInteger()) {
Reid Spencera54b7cb2007-01-12 07:05:14 +0000406 printSimpleType(Out, Ty, isSigned, NameSoFar);
Reid Spencere4d87aa2006-12-23 06:05:41 +0000407 return Out;
408 }
Misha Brukmand6a29a52005-04-20 16:05:03 +0000409
Chris Lattner83c57752002-08-19 22:17:53 +0000410 // Check to see if the type is named.
Chris Lattner04b72c82002-10-16 00:08:22 +0000411 if (!IgnoreName || isa<OpaqueType>(Ty)) {
Chris Lattneredd8ce12003-05-03 03:14:35 +0000412 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000413 if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar;
Chris Lattner04b72c82002-10-16 00:08:22 +0000414 }
Chris Lattner83c57752002-08-19 22:17:53 +0000415
Chris Lattnerf70c22b2004-06-17 18:19:28 +0000416 switch (Ty->getTypeID()) {
Chris Lattner83c57752002-08-19 22:17:53 +0000417 case Type::FunctionTyID: {
Chris Lattner0c54d892006-05-23 23:39:48 +0000418 const FunctionType *FTy = cast<FunctionType>(Ty);
Misha Brukmand6a29a52005-04-20 16:05:03 +0000419 std::stringstream FunctionInnards;
Joel Stanley54f60322003-06-25 04:52:09 +0000420 FunctionInnards << " (" << NameSoFar << ") (";
Reid Spencer0ae96932007-01-07 03:24:48 +0000421 unsigned Idx = 1;
Chris Lattner0c54d892006-05-23 23:39:48 +0000422 for (FunctionType::param_iterator I = FTy->param_begin(),
423 E = FTy->param_end(); I != E; ++I) {
424 if (I != FTy->param_begin())
Joel Stanley54f60322003-06-25 04:52:09 +0000425 FunctionInnards << ", ";
Reid Spencer0ae96932007-01-07 03:24:48 +0000426 printType(FunctionInnards, *I,
Reid Spencer251f2142007-01-09 17:09:09 +0000427 /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute), "");
Reid Spencer0ae96932007-01-07 03:24:48 +0000428 ++Idx;
Chris Lattner83c57752002-08-19 22:17:53 +0000429 }
Chris Lattner0c54d892006-05-23 23:39:48 +0000430 if (FTy->isVarArg()) {
431 if (FTy->getNumParams())
Reid Spencer9231ac82004-05-25 08:53:40 +0000432 FunctionInnards << ", ...";
Chris Lattner0c54d892006-05-23 23:39:48 +0000433 } else if (!FTy->getNumParams()) {
Joel Stanley54f60322003-06-25 04:52:09 +0000434 FunctionInnards << "void";
Chris Lattner83c57752002-08-19 22:17:53 +0000435 }
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000436 FunctionInnards << ')';
Joel Stanley54f60322003-06-25 04:52:09 +0000437 std::string tstr = FunctionInnards.str();
Reid Spencer0ae96932007-01-07 03:24:48 +0000438 printType(Out, FTy->getReturnType(),
Reid Spencer251f2142007-01-09 17:09:09 +0000439 /*isSigned=*/FTy->paramHasAttr(0, FunctionType::SExtAttribute), tstr);
Nick Hildenbrandt98502372002-11-18 20:55:50 +0000440 return Out;
Chris Lattner83c57752002-08-19 22:17:53 +0000441 }
442 case Type::StructTyID: {
443 const StructType *STy = cast<StructType>(Ty);
444 Out << NameSoFar + " {\n";
445 unsigned Idx = 0;
Chris Lattnerd21cd802004-02-09 04:37:31 +0000446 for (StructType::element_iterator I = STy->element_begin(),
447 E = STy->element_end(); I != E; ++I) {
Chris Lattner83c57752002-08-19 22:17:53 +0000448 Out << " ";
Reid Spencer251f2142007-01-09 17:09:09 +0000449 printType(Out, *I, false, "field" + utostr(Idx++));
Chris Lattner83c57752002-08-19 22:17:53 +0000450 Out << ";\n";
451 }
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000452 return Out << '}';
Misha Brukmand6a29a52005-04-20 16:05:03 +0000453 }
Chris Lattner83c57752002-08-19 22:17:53 +0000454
455 case Type::PointerTyID: {
456 const PointerType *PTy = cast<PointerType>(Ty);
Vikram S. Adve969c4ad2002-08-25 20:00:08 +0000457 std::string ptrName = "*" + NameSoFar;
458
Robert Bocchinob78e8382006-01-20 20:43:57 +0000459 if (isa<ArrayType>(PTy->getElementType()) ||
460 isa<PackedType>(PTy->getElementType()))
Chris Lattner8917d362003-11-03 04:31:54 +0000461 ptrName = "(" + ptrName + ")";
Vikram S. Adve969c4ad2002-08-25 20:00:08 +0000462
Reid Spencer251f2142007-01-09 17:09:09 +0000463 return printType(Out, PTy->getElementType(), false, ptrName);
Misha Brukman8f9f9a22003-07-21 16:34:35 +0000464 }
Chris Lattner83c57752002-08-19 22:17:53 +0000465
466 case Type::ArrayTyID: {
467 const ArrayType *ATy = cast<ArrayType>(Ty);
468 unsigned NumElements = ATy->getNumElements();
Chris Lattner3e3b6f72004-12-15 23:13:15 +0000469 if (NumElements == 0) NumElements = 1;
Reid Spencer251f2142007-01-09 17:09:09 +0000470 return printType(Out, ATy->getElementType(), false,
Chris Lattner83c57752002-08-19 22:17:53 +0000471 NameSoFar + "[" + utostr(NumElements) + "]");
472 }
Chris Lattner04b72c82002-10-16 00:08:22 +0000473
Robert Bocchinob78e8382006-01-20 20:43:57 +0000474 case Type::PackedTyID: {
475 const PackedType *PTy = cast<PackedType>(Ty);
476 unsigned NumElements = PTy->getNumElements();
477 if (NumElements == 0) NumElements = 1;
Reid Spencer251f2142007-01-09 17:09:09 +0000478 return printType(Out, PTy->getElementType(), false,
Robert Bocchinob78e8382006-01-20 20:43:57 +0000479 NameSoFar + "[" + utostr(NumElements) + "]");
480 }
481
Chris Lattner04b72c82002-10-16 00:08:22 +0000482 case Type::OpaqueTyID: {
483 static int Count = 0;
Chris Lattneredd8ce12003-05-03 03:14:35 +0000484 std::string TyName = "struct opaque_" + itostr(Count++);
Chris Lattner04b72c82002-10-16 00:08:22 +0000485 assert(TypeNames.find(Ty) == TypeNames.end());
486 TypeNames[Ty] = TyName;
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000487 return Out << TyName << ' ' << NameSoFar;
Chris Lattner04b72c82002-10-16 00:08:22 +0000488 }
Chris Lattner83c57752002-08-19 22:17:53 +0000489 default:
490 assert(0 && "Unhandled case in getTypeProps!");
491 abort();
492 }
493
494 return Out;
495}
496
Chris Lattner6d492922002-08-19 21:32:41 +0000497void CWriter::printConstantArray(ConstantArray *CPA) {
498
499 // As a special case, print the array as a string if it is an array of
500 // ubytes or an array of sbytes with positive values.
Misha Brukmand6a29a52005-04-20 16:05:03 +0000501 //
Chris Lattner6d492922002-08-19 21:32:41 +0000502 const Type *ETy = CPA->getType()->getElementType();
Reid Spencer47857812006-12-31 05:55:36 +0000503 bool isString = (ETy == Type::Int8Ty || ETy == Type::Int8Ty);
Chris Lattner6d492922002-08-19 21:32:41 +0000504
505 // Make sure the last character is a null char, as automatically added by C
Chris Lattner02da6c02003-06-16 12:09:09 +0000506 if (isString && (CPA->getNumOperands() == 0 ||
507 !cast<Constant>(*(CPA->op_end()-1))->isNullValue()))
Chris Lattner6d492922002-08-19 21:32:41 +0000508 isString = false;
Misha Brukmand6a29a52005-04-20 16:05:03 +0000509
Chris Lattner6d492922002-08-19 21:32:41 +0000510 if (isString) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000511 Out << '\"';
Chris Lattner02da6c02003-06-16 12:09:09 +0000512 // Keep track of whether the last number was a hexadecimal escape
513 bool LastWasHex = false;
514
Chris Lattner6d492922002-08-19 21:32:41 +0000515 // Do not include the last character, which we know is null
516 for (unsigned i = 0, e = CPA->getNumOperands()-1; i != e; ++i) {
Reid Spencerb83eb642006-10-20 07:07:24 +0000517 unsigned char C = cast<ConstantInt>(CPA->getOperand(i))->getZExtValue();
Misha Brukmand6a29a52005-04-20 16:05:03 +0000518
Chris Lattner02da6c02003-06-16 12:09:09 +0000519 // Print it out literally if it is a printable character. The only thing
520 // to be careful about is when the last letter output was a hex escape
521 // code, in which case we have to be careful not to print out hex digits
Chris Lattnerda920902003-06-16 12:21:19 +0000522 // explicitly (the C compiler thinks it is a continuation of the previous
523 // character, sheesh...)
Chris Lattner02da6c02003-06-16 12:09:09 +0000524 //
525 if (isprint(C) && (!LastWasHex || !isxdigit(C))) {
526 LastWasHex = false;
Nick Hildenbrandt088b4722002-11-06 21:40:23 +0000527 if (C == '"' || C == '\\')
528 Out << "\\" << C;
Nick Hildenbrandtc3dd2af2002-09-30 21:11:55 +0000529 else
530 Out << C;
Chris Lattner6d492922002-08-19 21:32:41 +0000531 } else {
Chris Lattner02da6c02003-06-16 12:09:09 +0000532 LastWasHex = false;
Chris Lattner6d492922002-08-19 21:32:41 +0000533 switch (C) {
534 case '\n': Out << "\\n"; break;
535 case '\t': Out << "\\t"; break;
536 case '\r': Out << "\\r"; break;
537 case '\v': Out << "\\v"; break;
538 case '\a': Out << "\\a"; break;
Nick Hildenbrandtc3dd2af2002-09-30 21:11:55 +0000539 case '\"': Out << "\\\""; break;
Misha Brukmand6a29a52005-04-20 16:05:03 +0000540 case '\'': Out << "\\\'"; break;
Chris Lattner6d492922002-08-19 21:32:41 +0000541 default:
542 Out << "\\x";
Chris Lattner02da6c02003-06-16 12:09:09 +0000543 Out << (char)(( C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'));
544 Out << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
545 LastWasHex = true;
Chris Lattner6d492922002-08-19 21:32:41 +0000546 break;
547 }
548 }
549 }
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000550 Out << '\"';
Chris Lattner6d492922002-08-19 21:32:41 +0000551 } else {
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000552 Out << '{';
Chris Lattner6d492922002-08-19 21:32:41 +0000553 if (CPA->getNumOperands()) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000554 Out << ' ';
Chris Lattner6d492922002-08-19 21:32:41 +0000555 printConstant(cast<Constant>(CPA->getOperand(0)));
556 for (unsigned i = 1, e = CPA->getNumOperands(); i != e; ++i) {
557 Out << ", ";
558 printConstant(cast<Constant>(CPA->getOperand(i)));
559 }
560 }
561 Out << " }";
562 }
563}
564
Robert Bocchinob78e8382006-01-20 20:43:57 +0000565void CWriter::printConstantPacked(ConstantPacked *CP) {
566 Out << '{';
567 if (CP->getNumOperands()) {
568 Out << ' ';
569 printConstant(cast<Constant>(CP->getOperand(0)));
570 for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
571 Out << ", ";
572 printConstant(cast<Constant>(CP->getOperand(i)));
573 }
574 }
575 Out << " }";
576}
577
Chris Lattnerdd76aca2003-10-05 00:40:51 +0000578// isFPCSafeToPrint - Returns true if we may assume that CFP may be written out
579// textually as a double (rather than as a reference to a stack-allocated
580// variable). We decide this by converting CFP to a string and back into a
581// double, and then checking whether the conversion results in a bit-equal
582// double to the original value of CFP. This depends on us and the target C
583// compiler agreeing on the conversion process (which is pretty likely since we
584// only deal in IEEE FP).
585//
Chris Lattnercb3ad012004-05-09 20:41:32 +0000586static bool isFPCSafeToPrint(const ConstantFP *CFP) {
Reid Spencerbcf81242006-11-05 19:26:37 +0000587#if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
Chris Lattner5ef6ffd2003-10-12 08:12:58 +0000588 char Buffer[100];
589 sprintf(Buffer, "%a", CFP->getValue());
590
591 if (!strncmp(Buffer, "0x", 2) ||
592 !strncmp(Buffer, "-0x", 3) ||
593 !strncmp(Buffer, "+0x", 3))
594 return atof(Buffer) == CFP->getValue();
595 return false;
596#else
Brian Gaekeb471a232003-06-17 23:55:35 +0000597 std::string StrVal = ftostr(CFP->getValue());
Chris Lattner9860e772003-10-12 04:36:29 +0000598
599 while (StrVal[0] == ' ')
600 StrVal.erase(StrVal.begin());
601
Chris Lattnerdd76aca2003-10-05 00:40:51 +0000602 // Check to make sure that the stringized number is not some string like "Inf"
603 // or NaN. Check that the string matches the "[-+]?[0-9]" regex.
Brian Gaekeb471a232003-06-17 23:55:35 +0000604 if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
605 ((StrVal[0] == '-' || StrVal[0] == '+') &&
606 (StrVal[1] >= '0' && StrVal[1] <= '9')))
607 // Reparse stringized version!
Chris Lattnerdd76aca2003-10-05 00:40:51 +0000608 return atof(StrVal.c_str()) == CFP->getValue();
Brian Gaekeb471a232003-06-17 23:55:35 +0000609 return false;
Chris Lattner5ef6ffd2003-10-12 08:12:58 +0000610#endif
Brian Gaekeb471a232003-06-17 23:55:35 +0000611}
Chris Lattner6d492922002-08-19 21:32:41 +0000612
Reid Spencer3da59db2006-11-27 01:05:10 +0000613/// Print out the casting for a cast operation. This does the double casting
614/// necessary for conversion to the destination type, if necessary.
Reid Spencer3da59db2006-11-27 01:05:10 +0000615/// @brief Print a cast
616void CWriter::printCast(unsigned opc, const Type *SrcTy, const Type *DstTy) {
Reid Spencere4d87aa2006-12-23 06:05:41 +0000617 // Print the destination type cast
618 switch (opc) {
619 case Instruction::UIToFP:
620 case Instruction::SIToFP:
621 case Instruction::IntToPtr:
622 case Instruction::Trunc:
623 case Instruction::BitCast:
624 case Instruction::FPExt:
625 case Instruction::FPTrunc: // For these the DstTy sign doesn't matter
626 Out << '(';
627 printType(Out, DstTy);
628 Out << ')';
629 break;
630 case Instruction::ZExt:
631 case Instruction::PtrToInt:
632 case Instruction::FPToUI: // For these, make sure we get an unsigned dest
633 Out << '(';
Reid Spencera54b7cb2007-01-12 07:05:14 +0000634 printSimpleType(Out, DstTy, false);
Reid Spencere4d87aa2006-12-23 06:05:41 +0000635 Out << ')';
636 break;
637 case Instruction::SExt:
638 case Instruction::FPToSI: // For these, make sure we get a signed dest
639 Out << '(';
Reid Spencera54b7cb2007-01-12 07:05:14 +0000640 printSimpleType(Out, DstTy, true);
Reid Spencere4d87aa2006-12-23 06:05:41 +0000641 Out << ')';
642 break;
643 default:
644 assert(0 && "Invalid cast opcode");
645 }
646
647 // Print the source type cast
Reid Spencer3da59db2006-11-27 01:05:10 +0000648 switch (opc) {
649 case Instruction::UIToFP:
650 case Instruction::ZExt:
Reid Spencere4d87aa2006-12-23 06:05:41 +0000651 Out << '(';
Reid Spencera54b7cb2007-01-12 07:05:14 +0000652 printSimpleType(Out, SrcTy, false);
Reid Spencere4d87aa2006-12-23 06:05:41 +0000653 Out << ')';
Reid Spencer3da59db2006-11-27 01:05:10 +0000654 break;
655 case Instruction::SIToFP:
656 case Instruction::SExt:
Reid Spencere4d87aa2006-12-23 06:05:41 +0000657 Out << '(';
Reid Spencera54b7cb2007-01-12 07:05:14 +0000658 printSimpleType(Out, SrcTy, true);
Reid Spencere4d87aa2006-12-23 06:05:41 +0000659 Out << ')';
Reid Spencer3da59db2006-11-27 01:05:10 +0000660 break;
661 case Instruction::IntToPtr:
662 case Instruction::PtrToInt:
Reid Spencere4d87aa2006-12-23 06:05:41 +0000663 // Avoid "cast to pointer from integer of different size" warnings
664 Out << "(unsigned long)";
665 break;
Reid Spencer3da59db2006-11-27 01:05:10 +0000666 case Instruction::Trunc:
667 case Instruction::BitCast:
668 case Instruction::FPExt:
669 case Instruction::FPTrunc:
670 case Instruction::FPToSI:
671 case Instruction::FPToUI:
Reid Spencere4d87aa2006-12-23 06:05:41 +0000672 break; // These don't need a source cast.
Reid Spencer3da59db2006-11-27 01:05:10 +0000673 default:
Reid Spencere4d87aa2006-12-23 06:05:41 +0000674 assert(0 && "Invalid cast opcode");
Reid Spencer3da59db2006-11-27 01:05:10 +0000675 break;
676 }
677}
678
Chris Lattner6d492922002-08-19 21:32:41 +0000679// printConstant - The LLVM Constant to C Constant converter.
680void CWriter::printConstant(Constant *CPV) {
681 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
682 switch (CE->getOpcode()) {
Reid Spencer3da59db2006-11-27 01:05:10 +0000683 case Instruction::Trunc:
684 case Instruction::ZExt:
685 case Instruction::SExt:
686 case Instruction::FPTrunc:
687 case Instruction::FPExt:
688 case Instruction::UIToFP:
689 case Instruction::SIToFP:
690 case Instruction::FPToUI:
691 case Instruction::FPToSI:
692 case Instruction::PtrToInt:
693 case Instruction::IntToPtr:
694 case Instruction::BitCast:
695 Out << "(";
696 printCast(CE->getOpcode(), CE->getOperand(0)->getType(), CE->getType());
697 if (CE->getOpcode() == Instruction::SExt &&
Reid Spencer4fe16d62007-01-11 18:21:29 +0000698 CE->getOperand(0)->getType() == Type::Int1Ty) {
Reid Spencer3da59db2006-11-27 01:05:10 +0000699 // Make sure we really sext from bool here by subtracting from 0
700 Out << "0-";
701 }
Chris Lattner84c0d5e2003-05-14 17:50:19 +0000702 printConstant(CE->getOperand(0));
Reid Spencer4fe16d62007-01-11 18:21:29 +0000703 if (CE->getType() == Type::Int1Ty &&
Reid Spencer639cf7d2006-11-27 18:51:06 +0000704 (CE->getOpcode() == Instruction::Trunc ||
705 CE->getOpcode() == Instruction::FPToUI ||
706 CE->getOpcode() == Instruction::FPToSI ||
707 CE->getOpcode() == Instruction::PtrToInt)) {
Reid Spencer3da59db2006-11-27 01:05:10 +0000708 // Make sure we really truncate to bool here by anding with 1
709 Out << "&1u";
710 }
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000711 Out << ')';
Chris Lattnerdf35a1c2002-08-19 23:09:46 +0000712 return;
713
714 case Instruction::GetElementPtr:
Nick Hildenbrandtd2eb3862002-10-03 20:47:24 +0000715 Out << "(&(";
Chris Lattner23e90702003-11-25 20:49:55 +0000716 printIndexingExpression(CE->getOperand(0), gep_type_begin(CPV),
717 gep_type_end(CPV));
Nick Hildenbrandtd2eb3862002-10-03 20:47:24 +0000718 Out << "))";
Chris Lattnerdf35a1c2002-08-19 23:09:46 +0000719 return;
Chris Lattner6683dbf2004-04-01 05:28:26 +0000720 case Instruction::Select:
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000721 Out << '(';
Chris Lattner6683dbf2004-04-01 05:28:26 +0000722 printConstant(CE->getOperand(0));
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000723 Out << '?';
Chris Lattner6683dbf2004-04-01 05:28:26 +0000724 printConstant(CE->getOperand(1));
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000725 Out << ':';
Chris Lattner6683dbf2004-04-01 05:28:26 +0000726 printConstant(CE->getOperand(2));
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000727 Out << ')';
Chris Lattner6683dbf2004-04-01 05:28:26 +0000728 return;
Chris Lattnerdf35a1c2002-08-19 23:09:46 +0000729 case Instruction::Add:
Chris Lattnerdf35a1c2002-08-19 23:09:46 +0000730 case Instruction::Sub:
Chris Lattner29255922003-08-14 19:19:53 +0000731 case Instruction::Mul:
Reid Spencer1628cec2006-10-26 06:15:43 +0000732 case Instruction::SDiv:
733 case Instruction::UDiv:
734 case Instruction::FDiv:
Reid Spencer0a783f72006-11-02 01:53:59 +0000735 case Instruction::URem:
736 case Instruction::SRem:
737 case Instruction::FRem:
Chris Lattnerf376e5e2004-12-29 04:00:09 +0000738 case Instruction::And:
739 case Instruction::Or:
740 case Instruction::Xor:
Reid Spencere4d87aa2006-12-23 06:05:41 +0000741 case Instruction::ICmp:
Brian Gaeke0415b6c2003-11-22 05:02:56 +0000742 case Instruction::Shl:
Reid Spencer3822ff52006-11-08 06:47:33 +0000743 case Instruction::LShr:
744 case Instruction::AShr:
Reid Spencer72ddc212006-10-26 06:17:40 +0000745 {
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000746 Out << '(';
Reid Spencer1628cec2006-10-26 06:15:43 +0000747 bool NeedsClosingParens = printConstExprCast(CE);
748 printConstantWithCast(CE->getOperand(0), CE->getOpcode());
Chris Lattner29255922003-08-14 19:19:53 +0000749 switch (CE->getOpcode()) {
750 case Instruction::Add: Out << " + "; break;
751 case Instruction::Sub: Out << " - "; break;
752 case Instruction::Mul: Out << " * "; break;
Reid Spencer0a783f72006-11-02 01:53:59 +0000753 case Instruction::URem:
754 case Instruction::SRem:
755 case Instruction::FRem: Out << " % "; break;
Reid Spencer1628cec2006-10-26 06:15:43 +0000756 case Instruction::UDiv:
757 case Instruction::SDiv:
758 case Instruction::FDiv: Out << " / "; break;
Chris Lattnerf376e5e2004-12-29 04:00:09 +0000759 case Instruction::And: Out << " & "; break;
760 case Instruction::Or: Out << " | "; break;
761 case Instruction::Xor: Out << " ^ "; break;
Brian Gaeke0415b6c2003-11-22 05:02:56 +0000762 case Instruction::Shl: Out << " << "; break;
Reid Spencer3822ff52006-11-08 06:47:33 +0000763 case Instruction::LShr:
764 case Instruction::AShr: Out << " >> "; break;
Reid Spencere4d87aa2006-12-23 06:05:41 +0000765 case Instruction::ICmp:
766 switch (CE->getPredicate()) {
767 case ICmpInst::ICMP_EQ: Out << " == "; break;
768 case ICmpInst::ICMP_NE: Out << " != "; break;
769 case ICmpInst::ICMP_SLT:
770 case ICmpInst::ICMP_ULT: Out << " < "; break;
771 case ICmpInst::ICMP_SLE:
772 case ICmpInst::ICMP_ULE: Out << " <= "; break;
773 case ICmpInst::ICMP_SGT:
774 case ICmpInst::ICMP_UGT: Out << " > "; break;
775 case ICmpInst::ICMP_SGE:
776 case ICmpInst::ICMP_UGE: Out << " >= "; break;
777 default: assert(0 && "Illegal ICmp predicate");
778 }
779 break;
Chris Lattner29255922003-08-14 19:19:53 +0000780 default: assert(0 && "Illegal opcode here!");
781 }
Reid Spencer1628cec2006-10-26 06:15:43 +0000782 printConstantWithCast(CE->getOperand(1), CE->getOpcode());
783 if (NeedsClosingParens)
784 Out << "))";
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000785 Out << ')';
Chris Lattnerdf35a1c2002-08-19 23:09:46 +0000786 return;
Reid Spencer72ddc212006-10-26 06:17:40 +0000787 }
Reid Spencerb801a272007-01-08 06:58:32 +0000788 case Instruction::FCmp: {
789 Out << '(';
790 bool NeedsClosingParens = printConstExprCast(CE);
791 if (CE->getPredicate() == FCmpInst::FCMP_FALSE)
792 Out << "0";
793 else if (CE->getPredicate() == FCmpInst::FCMP_TRUE)
794 Out << "1";
795 else {
796 const char* op = 0;
797 switch (CE->getPredicate()) {
798 default: assert(0 && "Illegal FCmp predicate");
799 case FCmpInst::FCMP_ORD: op = "ord"; break;
800 case FCmpInst::FCMP_UNO: op = "uno"; break;
801 case FCmpInst::FCMP_UEQ: op = "ueq"; break;
802 case FCmpInst::FCMP_UNE: op = "une"; break;
803 case FCmpInst::FCMP_ULT: op = "ult"; break;
804 case FCmpInst::FCMP_ULE: op = "ule"; break;
805 case FCmpInst::FCMP_UGT: op = "ugt"; break;
806 case FCmpInst::FCMP_UGE: op = "uge"; break;
807 case FCmpInst::FCMP_OEQ: op = "oeq"; break;
808 case FCmpInst::FCMP_ONE: op = "one"; break;
809 case FCmpInst::FCMP_OLT: op = "olt"; break;
810 case FCmpInst::FCMP_OLE: op = "ole"; break;
811 case FCmpInst::FCMP_OGT: op = "ogt"; break;
812 case FCmpInst::FCMP_OGE: op = "oge"; break;
813 }
814 Out << "llvm_fcmp_" << op << "(";
815 printConstantWithCast(CE->getOperand(0), CE->getOpcode());
816 Out << ", ";
817 printConstantWithCast(CE->getOperand(1), CE->getOpcode());
818 Out << ")";
819 }
820 if (NeedsClosingParens)
821 Out << "))";
822 Out << ')';
823 }
Chris Lattner6d492922002-08-19 21:32:41 +0000824 default:
Bill Wendlingf5da1332006-12-07 22:21:48 +0000825 cerr << "CWriter Error: Unhandled constant expression: "
826 << *CE << "\n";
Chris Lattner6d492922002-08-19 21:32:41 +0000827 abort();
828 }
Chris Lattnera9d12c02004-10-16 18:12:13 +0000829 } else if (isa<UndefValue>(CPV) && CPV->getType()->isFirstClassType()) {
Chris Lattner665825e2004-10-17 17:48:59 +0000830 Out << "((";
Reid Spencere4d87aa2006-12-23 06:05:41 +0000831 printType(Out, CPV->getType()); // sign doesn't matter
Chris Lattner665825e2004-10-17 17:48:59 +0000832 Out << ")/*UNDEF*/0)";
Chris Lattnera9d12c02004-10-16 18:12:13 +0000833 return;
Chris Lattner6d492922002-08-19 21:32:41 +0000834 }
835
Reid Spencerfbe7ae92007-01-08 08:00:00 +0000836 if (ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
837 const Type* Ty = CI->getType();
Reid Spencer4fe16d62007-01-11 18:21:29 +0000838 if (Ty == Type::Int1Ty)
Reid Spencer579dca12007-01-12 04:24:46 +0000839 Out << (CI->getZExtValue() ? '1' : '0') ;
Zhou Sheng6b6b6ef2007-01-11 12:24:14 +0000840 else {
841 Out << "((";
Reid Spencera54b7cb2007-01-12 07:05:14 +0000842 printSimpleType(Out, Ty, false) << ')';
Zhou Sheng6b6b6ef2007-01-11 12:24:14 +0000843 if (CI->isMinValue(true))
844 Out << CI->getZExtValue() << 'u';
845 else
846 Out << CI->getSExtValue();
847 if (Ty->getPrimitiveSizeInBits() > 32)
848 Out << "ll";
849 Out << ')';
850 }
Reid Spencerfbe7ae92007-01-08 08:00:00 +0000851 return;
852 }
853
854 switch (CPV->getType()->getTypeID()) {
Chris Lattner6d492922002-08-19 21:32:41 +0000855 case Type::FloatTyID:
Chris Lattnerd1cf1b42002-09-20 23:26:33 +0000856 case Type::DoubleTyID: {
857 ConstantFP *FPC = cast<ConstantFP>(CPV);
Chris Lattneredd8ce12003-05-03 03:14:35 +0000858 std::map<const ConstantFP*, unsigned>::iterator I = FPConstantMap.find(FPC);
Chris Lattnerd1cf1b42002-09-20 23:26:33 +0000859 if (I != FPConstantMap.end()) {
860 // Because of FP precision problems we must load from a stack allocated
861 // value that holds the value in hex.
862 Out << "(*(" << (FPC->getType() == Type::FloatTy ? "float" : "double")
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000863 << "*)&FPConstant" << I->second << ')';
Chris Lattnerd1cf1b42002-09-20 23:26:33 +0000864 } else {
Brian Gaeke043c0bb2004-07-21 03:15:26 +0000865 if (IsNAN(FPC->getValue())) {
866 // The value is NaN
Misha Brukmand6a29a52005-04-20 16:05:03 +0000867
Brian Gaeke8a702e82004-08-25 19:00:42 +0000868 // The prefix for a quiet NaN is 0x7FF8. For a signalling NaN,
869 // it's 0x7ff4.
870 const unsigned long QuietNaN = 0x7ff8UL;
Reid Spencer3ed469c2006-11-02 20:25:50 +0000871 //const unsigned long SignalNaN = 0x7ff4UL;
Brian Gaeke8a702e82004-08-25 19:00:42 +0000872
873 // We need to grab the first part of the FP #
Brian Gaeke8a702e82004-08-25 19:00:42 +0000874 char Buffer[100];
875
Jim Laskeycb6682f2005-08-17 19:34:49 +0000876 uint64_t ll = DoubleToBits(FPC->getValue());
Reid Spencer2bc320d2006-05-31 22:26:11 +0000877 sprintf(Buffer, "0x%llx", static_cast<long long>(ll));
Brian Gaeke8a702e82004-08-25 19:00:42 +0000878
879 std::string Num(&Buffer[0], &Buffer[6]);
880 unsigned long Val = strtoul(Num.c_str(), 0, 16);
881
Brian Gaeke043c0bb2004-07-21 03:15:26 +0000882 if (FPC->getType() == Type::FloatTy)
Brian Gaeke8a702e82004-08-25 19:00:42 +0000883 Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "F(\""
884 << Buffer << "\") /*nan*/ ";
Brian Gaeke043c0bb2004-07-21 03:15:26 +0000885 else
Brian Gaeke8a702e82004-08-25 19:00:42 +0000886 Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "(\""
887 << Buffer << "\") /*nan*/ ";
Brian Gaeke043c0bb2004-07-21 03:15:26 +0000888 } else if (IsInf(FPC->getValue())) {
889 // The value is Inf
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000890 if (FPC->getValue() < 0) Out << '-';
Brian Gaeke8a702e82004-08-25 19:00:42 +0000891 Out << "LLVM_INF" << (FPC->getType() == Type::FloatTy ? "F" : "")
892 << " /*inf*/ ";
Brian Gaeke043c0bb2004-07-21 03:15:26 +0000893 } else {
Brian Gaeke07b52b32004-08-25 19:37:26 +0000894 std::string Num;
Reid Spencerbcf81242006-11-05 19:26:37 +0000895#if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
Brian Gaeke07b52b32004-08-25 19:37:26 +0000896 // Print out the constant as a floating point number.
897 char Buffer[100];
898 sprintf(Buffer, "%a", FPC->getValue());
899 Num = Buffer;
900#else
901 Num = ftostr(FPC->getValue());
902#endif
Brian Gaeke043c0bb2004-07-21 03:15:26 +0000903 Out << Num;
904 }
Chris Lattnerd1cf1b42002-09-20 23:26:33 +0000905 }
906 break;
907 }
Chris Lattner6d492922002-08-19 21:32:41 +0000908
909 case Type::ArrayTyID:
Chris Lattnera9d12c02004-10-16 18:12:13 +0000910 if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000911 const ArrayType *AT = cast<ArrayType>(CPV->getType());
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000912 Out << '{';
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000913 if (AT->getNumElements()) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000914 Out << ' ';
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000915 Constant *CZ = Constant::getNullValue(AT->getElementType());
916 printConstant(CZ);
917 for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
918 Out << ", ";
919 printConstant(CZ);
920 }
921 }
922 Out << " }";
923 } else {
924 printConstantArray(cast<ConstantArray>(CPV));
925 }
Chris Lattner6d492922002-08-19 21:32:41 +0000926 break;
927
Robert Bocchinob78e8382006-01-20 20:43:57 +0000928 case Type::PackedTyID:
929 if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
930 const PackedType *AT = cast<PackedType>(CPV->getType());
931 Out << '{';
932 if (AT->getNumElements()) {
933 Out << ' ';
934 Constant *CZ = Constant::getNullValue(AT->getElementType());
935 printConstant(CZ);
936 for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
937 Out << ", ";
938 printConstant(CZ);
939 }
940 }
941 Out << " }";
942 } else {
943 printConstantPacked(cast<ConstantPacked>(CPV));
944 }
945 break;
946
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000947 case Type::StructTyID:
Chris Lattnera9d12c02004-10-16 18:12:13 +0000948 if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000949 const StructType *ST = cast<StructType>(CPV->getType());
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000950 Out << '{';
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000951 if (ST->getNumElements()) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000952 Out << ' ';
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000953 printConstant(Constant::getNullValue(ST->getElementType(0)));
954 for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) {
955 Out << ", ";
956 printConstant(Constant::getNullValue(ST->getElementType(i)));
957 }
Chris Lattner6d492922002-08-19 21:32:41 +0000958 }
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000959 Out << " }";
960 } else {
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000961 Out << '{';
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000962 if (CPV->getNumOperands()) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +0000963 Out << ' ';
Chris Lattnercfb0fd22004-02-15 05:54:27 +0000964 printConstant(cast<Constant>(CPV->getOperand(0)));
965 for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) {
966 Out << ", ";
967 printConstant(cast<Constant>(CPV->getOperand(i)));
968 }
969 }
970 Out << " }";
Chris Lattner6d492922002-08-19 21:32:41 +0000971 }
Chris Lattner6d492922002-08-19 21:32:41 +0000972 break;
Chris Lattner6d492922002-08-19 21:32:41 +0000973
974 case Type::PointerTyID:
Chris Lattner4fbf26d2002-05-09 20:53:56 +0000975 if (isa<ConstantPointerNull>(CPV)) {
Chris Lattnercf135cb2003-06-02 03:10:53 +0000976 Out << "((";
Reid Spencere4d87aa2006-12-23 06:05:41 +0000977 printType(Out, CPV->getType()); // sign doesn't matter
Chris Lattnercf135cb2003-06-02 03:10:53 +0000978 Out << ")/*NULL*/0)";
Chris Lattner6d492922002-08-19 21:32:41 +0000979 break;
Reid Spencer518310c2004-07-18 00:44:37 +0000980 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(CPV)) {
981 writeOperand(GV);
Chris Lattner6d492922002-08-19 21:32:41 +0000982 break;
983 }
984 // FALL THROUGH
985 default:
Bill Wendlingf5da1332006-12-07 22:21:48 +0000986 cerr << "Unknown constant type: " << *CPV << "\n";
Chris Lattner6d492922002-08-19 21:32:41 +0000987 abort();
988 }
989}
990
Reid Spencer1628cec2006-10-26 06:15:43 +0000991// Some constant expressions need to be casted back to the original types
992// because their operands were casted to the expected type. This function takes
993// care of detecting that case and printing the cast for the ConstantExpr.
994bool CWriter::printConstExprCast(const ConstantExpr* CE) {
Reid Spencer3822ff52006-11-08 06:47:33 +0000995 bool NeedsExplicitCast = false;
Reid Spencer3da59db2006-11-27 01:05:10 +0000996 const Type *Ty = CE->getOperand(0)->getType();
Reid Spencere4d87aa2006-12-23 06:05:41 +0000997 bool TypeIsSigned = false;
Reid Spencer1628cec2006-10-26 06:15:43 +0000998 switch (CE->getOpcode()) {
Reid Spencer3822ff52006-11-08 06:47:33 +0000999 case Instruction::LShr:
Reid Spencer0a783f72006-11-02 01:53:59 +00001000 case Instruction::URem:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001001 case Instruction::UDiv: NeedsExplicitCast = true; break;
Reid Spencer3822ff52006-11-08 06:47:33 +00001002 case Instruction::AShr:
Reid Spencer0a783f72006-11-02 01:53:59 +00001003 case Instruction::SRem:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001004 case Instruction::SDiv: NeedsExplicitCast = true; TypeIsSigned = true; break;
Reid Spencer3da59db2006-11-27 01:05:10 +00001005 case Instruction::SExt:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001006 Ty = CE->getType();
1007 NeedsExplicitCast = true;
1008 TypeIsSigned = true;
1009 break;
1010 case Instruction::ZExt:
Reid Spencer3da59db2006-11-27 01:05:10 +00001011 case Instruction::Trunc:
1012 case Instruction::FPTrunc:
1013 case Instruction::FPExt:
1014 case Instruction::UIToFP:
1015 case Instruction::SIToFP:
1016 case Instruction::FPToUI:
1017 case Instruction::FPToSI:
1018 case Instruction::PtrToInt:
1019 case Instruction::IntToPtr:
1020 case Instruction::BitCast:
1021 Ty = CE->getType();
1022 NeedsExplicitCast = true;
1023 break;
Reid Spencer1628cec2006-10-26 06:15:43 +00001024 default: break;
1025 }
Reid Spencer3822ff52006-11-08 06:47:33 +00001026 if (NeedsExplicitCast) {
Reid Spencer1628cec2006-10-26 06:15:43 +00001027 Out << "((";
Chris Lattner42a75512007-01-15 02:27:26 +00001028 if (Ty->isInteger() && Ty != Type::Int1Ty)
Reid Spencera54b7cb2007-01-12 07:05:14 +00001029 printSimpleType(Out, Ty, TypeIsSigned);
Reid Spencere4d87aa2006-12-23 06:05:41 +00001030 else
Reid Spencer251f2142007-01-09 17:09:09 +00001031 printType(Out, Ty); // not integer, sign doesn't matter
Reid Spencer1628cec2006-10-26 06:15:43 +00001032 Out << ")(";
1033 }
Reid Spencer3822ff52006-11-08 06:47:33 +00001034 return NeedsExplicitCast;
Reid Spencer1628cec2006-10-26 06:15:43 +00001035}
1036
1037// Print a constant assuming that it is the operand for a given Opcode. The
1038// opcodes that care about sign need to cast their operands to the expected
1039// type before the operation proceeds. This function does the casting.
1040void CWriter::printConstantWithCast(Constant* CPV, unsigned Opcode) {
1041
1042 // Extract the operand's type, we'll need it.
1043 const Type* OpTy = CPV->getType();
1044
1045 // Indicate whether to do the cast or not.
1046 bool shouldCast = false;
Reid Spencere4d87aa2006-12-23 06:05:41 +00001047 bool typeIsSigned = false;
Reid Spencer1628cec2006-10-26 06:15:43 +00001048
1049 // Based on the Opcode for which this Constant is being written, determine
1050 // the new type to which the operand should be casted by setting the value
Reid Spencer3da59db2006-11-27 01:05:10 +00001051 // of OpTy. If we change OpTy, also set shouldCast to true so it gets
1052 // casted below.
Reid Spencer1628cec2006-10-26 06:15:43 +00001053 switch (Opcode) {
1054 default:
1055 // for most instructions, it doesn't matter
1056 break;
Reid Spencer3822ff52006-11-08 06:47:33 +00001057 case Instruction::LShr:
Reid Spencer1628cec2006-10-26 06:15:43 +00001058 case Instruction::UDiv:
Reid Spencer0a783f72006-11-02 01:53:59 +00001059 case Instruction::URem:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001060 shouldCast = true;
Reid Spencer1628cec2006-10-26 06:15:43 +00001061 break;
Reid Spencer3822ff52006-11-08 06:47:33 +00001062 case Instruction::AShr:
Reid Spencer1628cec2006-10-26 06:15:43 +00001063 case Instruction::SDiv:
Reid Spencer0a783f72006-11-02 01:53:59 +00001064 case Instruction::SRem:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001065 shouldCast = true;
1066 typeIsSigned = true;
Reid Spencer1628cec2006-10-26 06:15:43 +00001067 break;
1068 }
1069
Reid Spencer3da59db2006-11-27 01:05:10 +00001070 // Write out the casted constant if we should, otherwise just write the
Reid Spencer1628cec2006-10-26 06:15:43 +00001071 // operand.
1072 if (shouldCast) {
1073 Out << "((";
Reid Spencera54b7cb2007-01-12 07:05:14 +00001074 printSimpleType(Out, OpTy, typeIsSigned);
Reid Spencer1628cec2006-10-26 06:15:43 +00001075 Out << ")";
1076 printConstant(CPV);
1077 Out << ")";
1078 } else
Reid Spencere4d87aa2006-12-23 06:05:41 +00001079 printConstant(CPV);
Reid Spencer1628cec2006-10-26 06:15:43 +00001080}
1081
Chris Lattner6d492922002-08-19 21:32:41 +00001082void CWriter::writeOperandInternal(Value *Operand) {
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00001083 if (Instruction *I = dyn_cast<Instruction>(Operand))
Chris Lattnera8ab89e2003-06-17 04:39:14 +00001084 if (isInlinableInst(*I) && !isDirectAlloca(I)) {
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00001085 // Should we inline this instruction to build a tree?
Misha Brukmanb70aaa62005-02-14 18:52:35 +00001086 Out << '(';
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00001087 visit(*I);
Misha Brukmanb70aaa62005-02-14 18:52:35 +00001088 Out << ')';
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00001089 return;
1090 }
Misha Brukmand6a29a52005-04-20 16:05:03 +00001091
Reid Spencer518310c2004-07-18 00:44:37 +00001092 Constant* CPV = dyn_cast<Constant>(Operand);
1093 if (CPV && !isa<GlobalValue>(CPV)) {
Misha Brukmand6a29a52005-04-20 16:05:03 +00001094 printConstant(CPV);
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001095 } else {
Brian Gaeked9fb37a2003-07-24 20:20:44 +00001096 Out << Mang->getValueName(Operand);
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001097 }
Chris Lattnerd0c668c2002-05-09 21:18:38 +00001098}
1099
Andrew Lenharth29c277f2006-11-27 23:50:49 +00001100void CWriter::writeOperandRaw(Value *Operand) {
1101 Constant* CPV = dyn_cast<Constant>(Operand);
1102 if (CPV && !isa<GlobalValue>(CPV)) {
1103 printConstant(CPV);
1104 } else {
1105 Out << Mang->getValueName(Operand);
1106 }
1107}
1108
Chris Lattnerbb03efd2002-06-25 15:57:03 +00001109void CWriter::writeOperand(Value *Operand) {
Chris Lattnera8ab89e2003-06-17 04:39:14 +00001110 if (isa<GlobalVariable>(Operand) || isDirectAlloca(Operand))
Reid Spencer3da59db2006-11-27 01:05:10 +00001111 Out << "(&"; // Global variables are referenced as their addresses by llvm
Chris Lattnerd0c668c2002-05-09 21:18:38 +00001112
1113 writeOperandInternal(Operand);
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001114
Chris Lattnera8ab89e2003-06-17 04:39:14 +00001115 if (isa<GlobalVariable>(Operand) || isDirectAlloca(Operand))
Misha Brukmanb70aaa62005-02-14 18:52:35 +00001116 Out << ')';
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001117}
1118
Reid Spencer1628cec2006-10-26 06:15:43 +00001119// Some instructions need to have their result value casted back to the
1120// original types because their operands were casted to the expected type.
1121// This function takes care of detecting that case and printing the cast
1122// for the Instruction.
1123bool CWriter::writeInstructionCast(const Instruction &I) {
Reid Spencer3da59db2006-11-27 01:05:10 +00001124 const Type *Ty = I.getOperand(0)->getType();
Reid Spencer1628cec2006-10-26 06:15:43 +00001125 switch (I.getOpcode()) {
Reid Spencer3822ff52006-11-08 06:47:33 +00001126 case Instruction::LShr:
Reid Spencer0a783f72006-11-02 01:53:59 +00001127 case Instruction::URem:
Reid Spencer3da59db2006-11-27 01:05:10 +00001128 case Instruction::UDiv:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001129 Out << "((";
Reid Spencera54b7cb2007-01-12 07:05:14 +00001130 printSimpleType(Out, Ty, false);
Reid Spencere4d87aa2006-12-23 06:05:41 +00001131 Out << ")(";
1132 return true;
Reid Spencer3822ff52006-11-08 06:47:33 +00001133 case Instruction::AShr:
Reid Spencer0a783f72006-11-02 01:53:59 +00001134 case Instruction::SRem:
Reid Spencer3da59db2006-11-27 01:05:10 +00001135 case Instruction::SDiv:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001136 Out << "((";
Reid Spencera54b7cb2007-01-12 07:05:14 +00001137 printSimpleType(Out, Ty, true);
Reid Spencere4d87aa2006-12-23 06:05:41 +00001138 Out << ")(";
1139 return true;
Reid Spencer1628cec2006-10-26 06:15:43 +00001140 default: break;
1141 }
Reid Spencere4d87aa2006-12-23 06:05:41 +00001142 return false;
Reid Spencer1628cec2006-10-26 06:15:43 +00001143}
1144
1145// Write the operand with a cast to another type based on the Opcode being used.
1146// This will be used in cases where an instruction has specific type
1147// requirements (usually signedness) for its operands.
1148void CWriter::writeOperandWithCast(Value* Operand, unsigned Opcode) {
1149
1150 // Extract the operand's type, we'll need it.
1151 const Type* OpTy = Operand->getType();
1152
1153 // Indicate whether to do the cast or not.
1154 bool shouldCast = false;
1155
Reid Spencere4d87aa2006-12-23 06:05:41 +00001156 // Indicate whether the cast should be to a signed type or not.
1157 bool castIsSigned = false;
1158
Reid Spencer1628cec2006-10-26 06:15:43 +00001159 // Based on the Opcode for which this Operand is being written, determine
1160 // the new type to which the operand should be casted by setting the value
1161 // of OpTy. If we change OpTy, also set shouldCast to true.
1162 switch (Opcode) {
1163 default:
1164 // for most instructions, it doesn't matter
1165 break;
Reid Spencer3822ff52006-11-08 06:47:33 +00001166 case Instruction::LShr:
Reid Spencer1628cec2006-10-26 06:15:43 +00001167 case Instruction::UDiv:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001168 case Instruction::URem: // Cast to unsigned first
1169 shouldCast = true;
1170 castIsSigned = false;
Reid Spencer1628cec2006-10-26 06:15:43 +00001171 break;
Reid Spencer3822ff52006-11-08 06:47:33 +00001172 case Instruction::AShr:
Reid Spencer1628cec2006-10-26 06:15:43 +00001173 case Instruction::SDiv:
Reid Spencere4d87aa2006-12-23 06:05:41 +00001174 case Instruction::SRem: // Cast to signed first
1175 shouldCast = true;
1176 castIsSigned = true;
Reid Spencer1628cec2006-10-26 06:15:43 +00001177 break;
1178 }
1179
1180 // Write out the casted operand if we should, otherwise just write the
1181 // operand.
1182 if (shouldCast) {
1183 Out << "((";
Reid Spencera54b7cb2007-01-12 07:05:14 +00001184 printSimpleType(Out, OpTy, castIsSigned);
Reid Spencer1628cec2006-10-26 06:15:43 +00001185 Out << ")";
1186 writeOperand(Operand);
1187 Out << ")";
1188 } else
1189 writeOperand(Operand);
Reid Spencere4d87aa2006-12-23 06:05:41 +00001190}
Reid Spencer1628cec2006-10-26 06:15:43 +00001191
Reid Spencere4d87aa2006-12-23 06:05:41 +00001192// Write the operand with a cast to another type based on the icmp predicate
1193// being used.
1194void CWriter::writeOperandWithCast(Value* Operand, ICmpInst::Predicate predicate) {
1195
1196 // Extract the operand's type, we'll need it.
1197 const Type* OpTy = Operand->getType();
1198
1199 // Indicate whether to do the cast or not.
1200 bool shouldCast = false;
1201
1202 // Indicate whether the cast should be to a signed type or not.
1203 bool castIsSigned = false;
1204
1205 // Based on the Opcode for which this Operand is being written, determine
1206 // the new type to which the operand should be casted by setting the value
1207 // of OpTy. If we change OpTy, also set shouldCast to true.
1208 switch (predicate) {
1209 default:
1210 // for eq and ne, it doesn't matter
1211 break;
1212 case ICmpInst::ICMP_UGT:
1213 case ICmpInst::ICMP_UGE:
1214 case ICmpInst::ICMP_ULT:
1215 case ICmpInst::ICMP_ULE:
1216 shouldCast = true;
1217 break;
1218 case ICmpInst::ICMP_SGT:
1219 case ICmpInst::ICMP_SGE:
1220 case ICmpInst::ICMP_SLT:
1221 case ICmpInst::ICMP_SLE:
1222 shouldCast = true;
1223 castIsSigned = true;
1224 break;
1225 }
1226
1227 // Write out the casted operand if we should, otherwise just write the
1228 // operand.
1229 if (shouldCast) {
1230 Out << "((";
Chris Lattner42a75512007-01-15 02:27:26 +00001231 if (OpTy->isInteger() && OpTy != Type::Int1Ty)
Reid Spencera54b7cb2007-01-12 07:05:14 +00001232 printSimpleType(Out, OpTy, castIsSigned);
Reid Spencere4d87aa2006-12-23 06:05:41 +00001233 else
Reid Spencer251f2142007-01-09 17:09:09 +00001234 printType(Out, OpTy); // not integer, sign doesn't matter
Reid Spencere4d87aa2006-12-23 06:05:41 +00001235 Out << ")";
1236 writeOperand(Operand);
1237 Out << ")";
1238 } else
1239 writeOperand(Operand);
Reid Spencer1628cec2006-10-26 06:15:43 +00001240}
1241
Chris Lattner41488192003-06-28 17:15:12 +00001242// generateCompilerSpecificCode - This is where we add conditional compilation
1243// directives to cater to specific compilers as need be.
1244//
Chris Lattnerc59c1182003-11-16 22:06:14 +00001245static void generateCompilerSpecificCode(std::ostream& Out) {
Chris Lattner9a571ba2006-03-07 22:58:23 +00001246 // Alloca is hard to get, and we don't want to include stdlib.h here.
Chris Lattner41488192003-06-28 17:15:12 +00001247 Out << "/* get a declaration for alloca */\n"
Chris Lattnerd9477602006-06-02 18:54:01 +00001248 << "#if defined(__CYGWIN__) || defined(__MINGW32__)\n"
Reid Spencera8411a62005-01-23 04:32:47 +00001249 << "extern void *_alloca(unsigned long);\n"
1250 << "#define alloca(x) _alloca(x)\n"
1251 << "#elif defined(__APPLE__)\n"
Joel Stanleyecd78ac2003-02-12 20:45:00 +00001252 << "extern void *__builtin_alloca(unsigned long);\n"
1253 << "#define alloca(x) __builtin_alloca(x)\n"
Anton Korobeynikovd27a2582006-12-10 23:12:42 +00001254 << "#define longjmp _longjmp\n"
1255 << "#define setjmp _setjmp\n"
Brian Gaekece630052004-12-10 05:44:45 +00001256 << "#elif defined(__sun__)\n"
1257 << "#if defined(__sparcv9)\n"
1258 << "extern void *__builtin_alloca(unsigned long);\n"
1259 << "#else\n"
1260 << "extern void *__builtin_alloca(unsigned int);\n"
1261 << "#endif\n"
1262 << "#define alloca(x) __builtin_alloca(x)\n"
Jeff Cohen3c280bf2006-04-17 17:55:41 +00001263 << "#elif defined(__FreeBSD__) || defined(__OpenBSD__)\n"
Chris Lattner60e66742004-10-06 04:21:52 +00001264 << "#define alloca(x) __builtin_alloca(x)\n"
Jeff Cohend01f65a2005-01-06 04:21:49 +00001265 << "#elif !defined(_MSC_VER)\n"
Joel Stanleyecd78ac2003-02-12 20:45:00 +00001266 << "#include <alloca.h>\n"
1267 << "#endif\n\n";
Chris Lattner41488192003-06-28 17:15:12 +00001268
1269 // We output GCC specific attributes to preserve 'linkonce'ness on globals.
1270 // If we aren't being compiled with GCC, just drop these attributes.
Chris Lattner9bda5f52003-06-28 17:53:05 +00001271 Out << "#ifndef __GNUC__ /* Can only support \"linkonce\" vars with GCC */\n"
Chris Lattner41488192003-06-28 17:15:12 +00001272 << "#define __attribute__(X)\n"
Brian Gaeke27f7a712003-12-11 00:24:36 +00001273 << "#endif\n\n";
1274
Brian Gaeke27f7a712003-12-11 00:24:36 +00001275 // On Mac OS X, "external weak" is spelled "__attribute__((weak_import))".
1276 Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1277 << "#define __EXTERNAL_WEAK__ __attribute__((weak_import))\n"
1278 << "#elif defined(__GNUC__)\n"
1279 << "#define __EXTERNAL_WEAK__ __attribute__((weak))\n"
1280 << "#else\n"
1281 << "#define __EXTERNAL_WEAK__\n"
1282 << "#endif\n\n";
Brian Gaeke27f7a712003-12-11 00:24:36 +00001283
1284 // For now, turn off the weak linkage attribute on Mac OS X. (See above.)
1285 Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1286 << "#define __ATTRIBUTE_WEAK__\n"
1287 << "#elif defined(__GNUC__)\n"
1288 << "#define __ATTRIBUTE_WEAK__ __attribute__((weak))\n"
1289 << "#else\n"
1290 << "#define __ATTRIBUTE_WEAK__\n"
1291 << "#endif\n\n";
Brian Gaeke043c0bb2004-07-21 03:15:26 +00001292
Anton Korobeynikov7f705592007-01-12 19:20:47 +00001293 // Add hidden visibility support. FIXME: APPLE_CC?
1294 Out << "#if defined(__GNUC__)\n"
1295 << "#define __HIDDEN__ __attribute__((visibility(\"hidden\")))\n"
1296 << "#endif\n\n";
1297
Brian Gaeke043c0bb2004-07-21 03:15:26 +00001298 // Define NaN and Inf as GCC builtins if using GCC, as 0 otherwise
1299 // From the GCC documentation:
Misha Brukmand6a29a52005-04-20 16:05:03 +00001300 //
Brian Gaeke043c0bb2004-07-21 03:15:26 +00001301 // double __builtin_nan (const char *str)
1302 //
1303 // This is an implementation of the ISO C99 function nan.
1304 //
1305 // Since ISO C99 defines this function in terms of strtod, which we do
1306 // not implement, a description of the parsing is in order. The string is
1307 // parsed as by strtol; that is, the base is recognized by leading 0 or
1308 // 0x prefixes. The number parsed is placed in the significand such that
1309 // the least significant bit of the number is at the least significant
1310 // bit of the significand. The number is truncated to fit the significand
1311 // field provided. The significand is forced to be a quiet NaN.
1312 //
1313 // This function, if given a string literal, is evaluated early enough
1314 // that it is considered a compile-time constant.
1315 //
1316 // float __builtin_nanf (const char *str)
1317 //
1318 // Similar to __builtin_nan, except the return type is float.
1319 //
1320 // double __builtin_inf (void)
1321 //
1322 // Similar to __builtin_huge_val, except a warning is generated if the
1323 // target floating-point format does not support infinities. This
1324 // function is suitable for implementing the ISO C99 macro INFINITY.
1325 //
1326 // float __builtin_inff (void)
1327 //
1328 // Similar to __builtin_inf, except the return type is float.
1329 Out << "#ifdef __GNUC__\n"
Brian Gaeke8a702e82004-08-25 19:00:42 +00001330 << "#define LLVM_NAN(NanStr) __builtin_nan(NanStr) /* Double */\n"
1331 << "#define LLVM_NANF(NanStr) __builtin_nanf(NanStr) /* Float */\n"
1332 << "#define LLVM_NANS(NanStr) __builtin_nans(NanStr) /* Double */\n"
1333 << "#define LLVM_NANSF(NanStr) __builtin_nansf(NanStr) /* Float */\n"
1334 << "#define LLVM_INF __builtin_inf() /* Double */\n"
1335 << "#define LLVM_INFF __builtin_inff() /* Float */\n"
Chris Lattnerf9a05322006-02-13 22:22:42 +00001336 << "#define LLVM_PREFETCH(addr,rw,locality) "
1337 "__builtin_prefetch(addr,rw,locality)\n"
Chris Lattner9a571ba2006-03-07 22:58:23 +00001338 << "#define __ATTRIBUTE_CTOR__ __attribute__((constructor))\n"
1339 << "#define __ATTRIBUTE_DTOR__ __attribute__((destructor))\n"
Chris Lattnerdacbe7b2006-07-28 20:58:47 +00001340 << "#define LLVM_ASM __asm__\n"
Brian Gaeke043c0bb2004-07-21 03:15:26 +00001341 << "#else\n"
Brian Gaeke8a702e82004-08-25 19:00:42 +00001342 << "#define LLVM_NAN(NanStr) ((double)0.0) /* Double */\n"
1343 << "#define LLVM_NANF(NanStr) 0.0F /* Float */\n"
1344 << "#define LLVM_NANS(NanStr) ((double)0.0) /* Double */\n"
1345 << "#define LLVM_NANSF(NanStr) 0.0F /* Float */\n"
1346 << "#define LLVM_INF ((double)0.0) /* Double */\n"
1347 << "#define LLVM_INFF 0.0F /* Float */\n"
Chris Lattner50a8a172005-05-06 06:58:42 +00001348 << "#define LLVM_PREFETCH(addr,rw,locality) /* PREFETCH */\n"
Chris Lattner9a571ba2006-03-07 22:58:23 +00001349 << "#define __ATTRIBUTE_CTOR__\n"
1350 << "#define __ATTRIBUTE_DTOR__\n"
Chris Lattnerdacbe7b2006-07-28 20:58:47 +00001351 << "#define LLVM_ASM(X)\n"
Chris Lattner50a8a172005-05-06 06:58:42 +00001352 << "#endif\n\n";
1353
1354 // Output target-specific code that should be inserted into main.
1355 Out << "#define CODE_FOR_MAIN() /* Any target-specific code for main()*/\n";
1356 // On X86, set the FP control word to 64-bits of precision instead of 80 bits.
1357 Out << "#if defined(__GNUC__) && !defined(__llvm__)\n"
Evan Chenge3db4da2006-06-20 22:11:12 +00001358 << "#if defined(i386) || defined(__i386__) || defined(__i386) || "
1359 << "defined(__x86_64__)\n"
Chris Lattner50a8a172005-05-06 06:58:42 +00001360 << "#undef CODE_FOR_MAIN\n"
1361 << "#define CODE_FOR_MAIN() \\\n"
1362 << " {short F;__asm__ (\"fnstcw %0\" : \"=m\" (*&F)); \\\n"
1363 << " F=(F&~0x300)|0x200;__asm__(\"fldcw %0\"::\"m\"(*&F));}\n"
1364 << "#endif\n#endif\n";
1365
Joel Stanleyecd78ac2003-02-12 20:45:00 +00001366}
1367
Chris Lattner9a571ba2006-03-07 22:58:23 +00001368/// FindStaticTors - Given a static ctor/dtor list, unpack its contents into
1369/// the StaticTors set.
1370static void FindStaticTors(GlobalVariable *GV, std::set<Function*> &StaticTors){
1371 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
1372 if (!InitList) return;
1373
1374 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
1375 if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){
1376 if (CS->getNumOperands() != 2) return; // Not array of 2-element structs.
1377
1378 if (CS->getOperand(1)->isNullValue())
1379 return; // Found a null terminator, exit printing.
1380 Constant *FP = CS->getOperand(1);
1381 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
Reid Spencer3da59db2006-11-27 01:05:10 +00001382 if (CE->isCast())
Chris Lattner9a571ba2006-03-07 22:58:23 +00001383 FP = CE->getOperand(0);
1384 if (Function *F = dyn_cast<Function>(FP))
1385 StaticTors.insert(F);
1386 }
1387}
1388
1389enum SpecialGlobalClass {
1390 NotSpecial = 0,
1391 GlobalCtors, GlobalDtors,
1392 NotPrinted
1393};
1394
1395/// getGlobalVariableClass - If this is a global that is specially recognized
1396/// by LLVM, return a code that indicates how we should handle it.
1397static SpecialGlobalClass getGlobalVariableClass(const GlobalVariable *GV) {
1398 // If this is a global ctors/dtors list, handle it now.
1399 if (GV->hasAppendingLinkage() && GV->use_empty()) {
1400 if (GV->getName() == "llvm.global_ctors")
1401 return GlobalCtors;
1402 else if (GV->getName() == "llvm.global_dtors")
1403 return GlobalDtors;
1404 }
1405
1406 // Otherwise, it it is other metadata, don't print it. This catches things
1407 // like debug information.
1408 if (GV->getSection() == "llvm.metadata")
1409 return NotPrinted;
1410
1411 return NotSpecial;
1412}
1413
1414
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001415bool CWriter::doInitialization(Module &M) {
1416 // Initialize
1417 TheModule = &M;
Chris Lattnerc2421432004-05-09 04:30:20 +00001418
1419 IL.AddPrototypes(M);
Misha Brukmand6a29a52005-04-20 16:05:03 +00001420
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001421 // Ensure that all structure types have names...
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001422 Mang = new Mangler(M);
Chris Lattnerba9c6432005-11-10 21:39:29 +00001423 Mang->markCharUnacceptable('.');
Chris Lattnerc59c1182003-11-16 22:06:14 +00001424
Chris Lattner9a571ba2006-03-07 22:58:23 +00001425 // Keep track of which functions are static ctors/dtors so they can have
1426 // an attribute added to their prototypes.
1427 std::set<Function*> StaticCtors, StaticDtors;
1428 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1429 I != E; ++I) {
1430 switch (getGlobalVariableClass(I)) {
1431 default: break;
1432 case GlobalCtors:
1433 FindStaticTors(I, StaticCtors);
1434 break;
1435 case GlobalDtors:
1436 FindStaticTors(I, StaticDtors);
1437 break;
1438 }
1439 }
1440
Chris Lattner16c7bb22002-05-09 02:28:59 +00001441 // get declaration for alloca
Joel Stanleyecd78ac2003-02-12 20:45:00 +00001442 Out << "/* Provide Declarations */\n";
Chris Lattnerc59c1182003-11-16 22:06:14 +00001443 Out << "#include <stdarg.h>\n"; // Varargs support
1444 Out << "#include <setjmp.h>\n"; // Unwind support
Chris Lattner41488192003-06-28 17:15:12 +00001445 generateCompilerSpecificCode(Out);
Chris Lattnerc59c1182003-11-16 22:06:14 +00001446
Chris Lattnercf135cb2003-06-02 03:10:53 +00001447 // Provide a definition for `bool' if not compiling with a C++ compiler.
1448 Out << "\n"
Vikram S. Adve969c4ad2002-08-25 20:00:08 +00001449 << "#ifndef __cplusplus\ntypedef unsigned char bool;\n#endif\n"
Misha Brukmand6a29a52005-04-20 16:05:03 +00001450
Chris Lattnerd1cf1b42002-09-20 23:26:33 +00001451 << "\n\n/* Support for floating point constants */\n"
1452 << "typedef unsigned long long ConstantDoubleTy;\n"
Chris Lattnereb6f8c72002-11-07 19:43:59 +00001453 << "typedef unsigned int ConstantFloatTy;\n"
Misha Brukmand6a29a52005-04-20 16:05:03 +00001454
Chris Lattnera4d4a852002-08-19 21:48:40 +00001455 << "\n\n/* Global Declarations */\n";
1456
1457 // First output all the declarations for the program, because C requires
1458 // Functions & globals to be declared before they are used.
1459 //
Chris Lattner16c7bb22002-05-09 02:28:59 +00001460
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001461 // Loop over the symbol table, emitting all named constants...
Reid Spencer78d033e2007-01-06 07:24:44 +00001462 printModuleTypes(M.getTypeSymbolTable());
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001463
Chris Lattnera4d4a852002-08-19 21:48:40 +00001464 // Global variable declarations...
Chris Lattnere4d5c442005-03-15 04:54:21 +00001465 if (!M.global_empty()) {
Vikram S. Adve913bfbc2002-09-17 11:50:38 +00001466 Out << "\n/* External Global Variable Declarations */\n";
Chris Lattnerf9a05322006-02-13 22:22:42 +00001467 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1468 I != E; ++I) {
Vikram S. Adve913bfbc2002-09-17 11:50:38 +00001469 if (I->hasExternalLinkage()) {
1470 Out << "extern ";
Reid Spencer251f2142007-01-09 17:09:09 +00001471 printType(Out, I->getType()->getElementType(), false,
Reid Spencer0ae96932007-01-07 03:24:48 +00001472 Mang->getValueName(I));
Vikram S. Adve913bfbc2002-09-17 11:50:38 +00001473 Out << ";\n";
Anton Korobeynikovb74ed072006-09-14 18:23:27 +00001474 } else if (I->hasDLLImportLinkage()) {
1475 Out << "__declspec(dllimport) ";
Reid Spencer251f2142007-01-09 17:09:09 +00001476 printType(Out, I->getType()->getElementType(), false,
Reid Spencer0ae96932007-01-07 03:24:48 +00001477 Mang->getValueName(I));
Anton Korobeynikovb74ed072006-09-14 18:23:27 +00001478 Out << ";\n";
Anton Korobeynikov78ee7b72006-12-01 00:25:12 +00001479 } else if (I->hasExternalWeakLinkage()) {
1480 Out << "extern ";
Reid Spencer251f2142007-01-09 17:09:09 +00001481 printType(Out, I->getType()->getElementType(), false,
Reid Spencer0ae96932007-01-07 03:24:48 +00001482 Mang->getValueName(I));
Anton Korobeynikov78ee7b72006-12-01 00:25:12 +00001483 Out << " __EXTERNAL_WEAK__ ;\n";
1484 }
Chris Lattnerdeed7a52002-05-09 15:18:52 +00001485 }
Chris Lattnerdeed7a52002-05-09 15:18:52 +00001486 }
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001487
Chris Lattnera4d4a852002-08-19 21:48:40 +00001488 // Function declarations
Chris Lattner9a571ba2006-03-07 22:58:23 +00001489 Out << "\n/* Function Declarations */\n";
Chris Lattner57da2522005-08-23 20:22:50 +00001490 Out << "double fmod(double, double);\n"; // Support for FP rem
1491 Out << "float fmodf(float, float);\n";
1492
Chris Lattner9a571ba2006-03-07 22:58:23 +00001493 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
1494 // Don't print declarations for intrinsic functions.
Reid Spencer2cb46e12006-10-22 09:58:21 +00001495 if (!I->getIntrinsicID() && I->getName() != "setjmp" &&
1496 I->getName() != "longjmp" && I->getName() != "_setjmp") {
Anton Korobeynikov78ee7b72006-12-01 00:25:12 +00001497 if (I->hasExternalWeakLinkage())
1498 Out << "extern ";
Chris Lattner9a571ba2006-03-07 22:58:23 +00001499 printFunctionSignature(I, true);
1500 if (I->hasWeakLinkage() || I->hasLinkOnceLinkage())
1501 Out << " __ATTRIBUTE_WEAK__";
Anton Korobeynikov78ee7b72006-12-01 00:25:12 +00001502 if (I->hasExternalWeakLinkage())
1503 Out << " __EXTERNAL_WEAK__";
Chris Lattner9a571ba2006-03-07 22:58:23 +00001504 if (StaticCtors.count(I))
1505 Out << " __ATTRIBUTE_CTOR__";
1506 if (StaticDtors.count(I))
1507 Out << " __ATTRIBUTE_DTOR__";
Anton Korobeynikov7f705592007-01-12 19:20:47 +00001508 if (I->hasHiddenVisibility())
1509 Out << " __HIDDEN__";
Chris Lattnerdacbe7b2006-07-28 20:58:47 +00001510
1511 if (I->hasName() && I->getName()[0] == 1)
1512 Out << " LLVM_ASM(\"" << I->getName().c_str()+1 << "\")";
1513
Chris Lattner9a571ba2006-03-07 22:58:23 +00001514 Out << ";\n";
Chris Lattner4cda8352002-08-20 16:55:48 +00001515 }
Chris Lattnera4d4a852002-08-19 21:48:40 +00001516 }
1517
Joel Stanley54f60322003-06-25 04:52:09 +00001518 // Output the global variable declarations
Chris Lattnere4d5c442005-03-15 04:54:21 +00001519 if (!M.global_empty()) {
Joel Stanley54f60322003-06-25 04:52:09 +00001520 Out << "\n\n/* Global Variable Declarations */\n";
Chris Lattnerf9a05322006-02-13 22:22:42 +00001521 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1522 I != E; ++I)
Nick Hildenbrandt50de36a2002-10-28 19:05:12 +00001523 if (!I->isExternal()) {
Chris Lattner9a571ba2006-03-07 22:58:23 +00001524 // Ignore special globals, such as debug info.
1525 if (getGlobalVariableClass(I))
1526 continue;
1527
Chris Lattnercc16a8e2004-12-03 17:19:10 +00001528 if (I->hasInternalLinkage())
1529 Out << "static ";
1530 else
1531 Out << "extern ";
Reid Spencer251f2142007-01-09 17:09:09 +00001532 printType(Out, I->getType()->getElementType(), false,
Reid Spencer0ae96932007-01-07 03:24:48 +00001533 Mang->getValueName(I));
Chris Lattner2580d4f2003-11-03 17:32:38 +00001534
1535 if (I->hasLinkOnceLinkage())
1536 Out << " __attribute__((common))";
1537 else if (I->hasWeakLinkage())
Brian Gaeke27f7a712003-12-11 00:24:36 +00001538 Out << " __ATTRIBUTE_WEAK__";
Anton Korobeynikov78ee7b72006-12-01 00:25:12 +00001539 else if (I->hasExternalWeakLinkage())
1540 Out << " __EXTERNAL_WEAK__";
Anton Korobeynikov7f705592007-01-12 19:20:47 +00001541 if (I->hasHiddenVisibility())
1542 Out << " __HIDDEN__";
Nick Hildenbrandt50de36a2002-10-28 19:05:12 +00001543 Out << ";\n";
1544 }
1545 }
1546
Vikram S. Adve913bfbc2002-09-17 11:50:38 +00001547 // Output the global variable definitions and contents...
Chris Lattnere4d5c442005-03-15 04:54:21 +00001548 if (!M.global_empty()) {
Vikram S. Adve913bfbc2002-09-17 11:50:38 +00001549 Out << "\n\n/* Global Variable Definitions and Initialization */\n";
Chris Lattnerf9a05322006-02-13 22:22:42 +00001550 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1551 I != E; ++I)
Chris Lattnere8e035b2002-10-16 20:08:47 +00001552 if (!I->isExternal()) {
Chris Lattner9a571ba2006-03-07 22:58:23 +00001553 // Ignore special globals, such as debug info.
1554 if (getGlobalVariableClass(I))
1555 continue;
1556
Chris Lattnere8e035b2002-10-16 20:08:47 +00001557 if (I->hasInternalLinkage())
1558 Out << "static ";
Anton Korobeynikovb74ed072006-09-14 18:23:27 +00001559 else if (I->hasDLLImportLinkage())
1560 Out << "__declspec(dllimport) ";
1561 else if (I->hasDLLExportLinkage())
1562 Out << "__declspec(dllexport) ";
1563
Reid Spencer251f2142007-01-09 17:09:09 +00001564 printType(Out, I->getType()->getElementType(), false,
Reid Spencer0ae96932007-01-07 03:24:48 +00001565 Mang->getValueName(I));
Chris Lattner76d9f1b2003-06-28 17:08:36 +00001566 if (I->hasLinkOnceLinkage())
1567 Out << " __attribute__((common))";
Chris Lattner72ac148d2003-10-16 18:29:00 +00001568 else if (I->hasWeakLinkage())
Brian Gaeke27f7a712003-12-11 00:24:36 +00001569 Out << " __ATTRIBUTE_WEAK__";
Chris Lattner5ea326a2003-11-03 17:35:00 +00001570
Anton Korobeynikov7f705592007-01-12 19:20:47 +00001571 if (I->hasHiddenVisibility())
1572 Out << " __HIDDEN__";
1573
Chris Lattner5ea326a2003-11-03 17:35:00 +00001574 // If the initializer is not null, emit the initializer. If it is null,
1575 // we try to avoid emitting large amounts of zeros. The problem with
1576 // this, however, occurs when the variable has weak linkage. In this
1577 // case, the assembler will complain about the variable being both weak
1578 // and common, so we disable this optimization.
Chris Lattnerf358c5a2004-02-20 05:49:22 +00001579 if (!I->getInitializer()->isNullValue()) {
Chris Lattner940b08d2003-06-06 07:10:24 +00001580 Out << " = " ;
1581 writeOperand(I->getInitializer());
Chris Lattnerf358c5a2004-02-20 05:49:22 +00001582 } else if (I->hasWeakLinkage()) {
1583 // We have to specify an initializer, but it doesn't have to be
1584 // complete. If the value is an aggregate, print out { 0 }, and let
1585 // the compiler figure out the rest of the zeros.
1586 Out << " = " ;
1587 if (isa<StructType>(I->getInitializer()->getType()) ||
Robert Bocchinob78e8382006-01-20 20:43:57 +00001588 isa<ArrayType>(I->getInitializer()->getType()) ||
1589 isa<PackedType>(I->getInitializer()->getType())) {
Chris Lattnerf358c5a2004-02-20 05:49:22 +00001590 Out << "{ 0 }";
1591 } else {
1592 // Just print it out normally.
1593 writeOperand(I->getInitializer());
1594 }
Chris Lattner940b08d2003-06-06 07:10:24 +00001595 }
Chris Lattnere8e035b2002-10-16 20:08:47 +00001596 Out << ";\n";
Chris Lattnera4d4a852002-08-19 21:48:40 +00001597 }
Chris Lattnera4d4a852002-08-19 21:48:40 +00001598 }
1599
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001600 if (!M.empty())
Chris Lattnera4d4a852002-08-19 21:48:40 +00001601 Out << "\n\n/* Function Bodies */\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001602
1603 // Emit some helper functions for dealing with FCMP instruction's
1604 // predicates
1605 Out << "static inline int llvm_fcmp_ord(double X, double Y) { ";
1606 Out << "return X == X && Y == Y; }\n";
1607 Out << "static inline int llvm_fcmp_uno(double X, double Y) { ";
1608 Out << "return X != X || Y != Y; }\n";
1609 Out << "static inline int llvm_fcmp_ueq(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001610 Out << "return X == Y || llvm_fcmp_uno(X, Y); }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001611 Out << "static inline int llvm_fcmp_une(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001612 Out << "return X != Y; }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001613 Out << "static inline int llvm_fcmp_ult(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001614 Out << "return X < Y || llvm_fcmp_uno(X, Y); }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001615 Out << "static inline int llvm_fcmp_ugt(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001616 Out << "return X > Y || llvm_fcmp_uno(X, Y); }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001617 Out << "static inline int llvm_fcmp_ule(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001618 Out << "return X <= Y || llvm_fcmp_uno(X, Y); }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001619 Out << "static inline int llvm_fcmp_uge(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001620 Out << "return X >= Y || llvm_fcmp_uno(X, Y); }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001621 Out << "static inline int llvm_fcmp_oeq(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001622 Out << "return X == Y ; }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001623 Out << "static inline int llvm_fcmp_one(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001624 Out << "return X != Y && llvm_fcmp_ord(X, Y); }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001625 Out << "static inline int llvm_fcmp_olt(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001626 Out << "return X < Y ; }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001627 Out << "static inline int llvm_fcmp_ogt(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001628 Out << "return X > Y ; }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001629 Out << "static inline int llvm_fcmp_ole(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001630 Out << "return X <= Y ; }\n";
Reid Spencerb801a272007-01-08 06:58:32 +00001631 Out << "static inline int llvm_fcmp_oge(double X, double Y) { ";
Reid Spencerfbe7ae92007-01-08 08:00:00 +00001632 Out << "return X >= Y ; }\n";
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001633 return false;
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001634}
1635
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001636
Chris Lattner9860e772003-10-12 04:36:29 +00001637/// Output all floating point constants that cannot be printed accurately...
Chris Lattner68758072004-05-09 06:20:51 +00001638void CWriter::printFloatingPointConstants(Function &F) {
Chris Lattner9860e772003-10-12 04:36:29 +00001639 // Scan the module for floating point constants. If any FP constant is used
1640 // in the function, we want to redirect it here so that we do not depend on
1641 // the precision of the printed form, unless the printed form preserves
1642 // precision.
1643 //
Chris Lattner68758072004-05-09 06:20:51 +00001644 static unsigned FPCounter = 0;
1645 for (constant_iterator I = constant_begin(&F), E = constant_end(&F);
1646 I != E; ++I)
1647 if (const ConstantFP *FPC = dyn_cast<ConstantFP>(*I))
1648 if (!isFPCSafeToPrint(FPC) && // Do not put in FPConstantMap if safe.
1649 !FPConstantMap.count(FPC)) {
1650 double Val = FPC->getValue();
Misha Brukmand6a29a52005-04-20 16:05:03 +00001651
Chris Lattner68758072004-05-09 06:20:51 +00001652 FPConstantMap[FPC] = FPCounter; // Number the FP constants
Misha Brukmand6a29a52005-04-20 16:05:03 +00001653
Chris Lattner68758072004-05-09 06:20:51 +00001654 if (FPC->getType() == Type::DoubleTy) {
Chris Lattner68758072004-05-09 06:20:51 +00001655 Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
Jim Laskeycb6682f2005-08-17 19:34:49 +00001656 << " = 0x" << std::hex << DoubleToBits(Val) << std::dec
Chris Lattner68758072004-05-09 06:20:51 +00001657 << "ULL; /* " << Val << " */\n";
1658 } else if (FPC->getType() == Type::FloatTy) {
Chris Lattner68758072004-05-09 06:20:51 +00001659 Out << "static const ConstantFloatTy FPConstant" << FPCounter++
Jim Laskeycb6682f2005-08-17 19:34:49 +00001660 << " = 0x" << std::hex << FloatToBits(Val) << std::dec
Chris Lattner68758072004-05-09 06:20:51 +00001661 << "U; /* " << Val << " */\n";
1662 } else
1663 assert(0 && "Unknown float type!");
1664 }
Misha Brukmand6a29a52005-04-20 16:05:03 +00001665
Misha Brukmanb70aaa62005-02-14 18:52:35 +00001666 Out << '\n';
Chris Lattner68758072004-05-09 06:20:51 +00001667}
Chris Lattner9860e772003-10-12 04:36:29 +00001668
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001669
Chris Lattner2db41cd2002-09-20 15:12:13 +00001670/// printSymbolTable - Run through symbol table looking for type names. If a
Robert Bocchinob78e8382006-01-20 20:43:57 +00001671/// type name is found, emit its declaration...
Chris Lattnera4c047e2002-09-20 14:56:54 +00001672///
Reid Spencer78d033e2007-01-06 07:24:44 +00001673void CWriter::printModuleTypes(const TypeSymbolTable &TST) {
Reid Spencer555a0b12006-12-11 20:39:15 +00001674 Out << "/* Helper union for bitcasts */\n";
1675 Out << "typedef union {\n";
Reid Spencer47857812006-12-31 05:55:36 +00001676 Out << " unsigned int Int32;\n";
1677 Out << " unsigned long long Int64;\n";
Reid Spencer22b36fb2006-12-12 00:11:08 +00001678 Out << " float Float;\n";
1679 Out << " double Double;\n";
Reid Spencer555a0b12006-12-11 20:39:15 +00001680 Out << "} llvmBitCastUnion;\n";
1681
Chris Lattnerb15fde22005-03-06 02:28:23 +00001682 // We are only interested in the type plane of the symbol table.
Reid Spencer78d033e2007-01-06 07:24:44 +00001683 TypeSymbolTable::const_iterator I = TST.begin();
1684 TypeSymbolTable::const_iterator End = TST.end();
Chris Lattnerb15fde22005-03-06 02:28:23 +00001685
1686 // If there are no type names, exit early.
1687 if (I == End) return;
Misha Brukmand6a29a52005-04-20 16:05:03 +00001688
Chris Lattner58d04d42002-09-20 15:18:30 +00001689 // Print out forward declarations for structure types before anything else!
1690 Out << "/* Structure forward decls */\n";
Chris Lattnera80cc932007-01-16 18:02:45 +00001691 for (; I != End; ++I) {
1692 std::string Name = "struct l_" + Mang->makeNameProper(I->first);
1693 Out << Name << ";\n";
1694 TypeNames.insert(std::make_pair(I->second, Name));
1695 }
Chris Lattner58d04d42002-09-20 15:18:30 +00001696
Misha Brukmanb70aaa62005-02-14 18:52:35 +00001697 Out << '\n';
Chris Lattner58d04d42002-09-20 15:18:30 +00001698
Chris Lattner19e8b0c2007-01-16 07:22:23 +00001699 // Now we can print out typedefs. Above, we guaranteed that this can only be
Chris Lattnera80cc932007-01-16 18:02:45 +00001700 // for struct or opaque types.
Chris Lattner58d04d42002-09-20 15:18:30 +00001701 Out << "/* Typedefs */\n";
Reid Spencer78d033e2007-01-06 07:24:44 +00001702 for (I = TST.begin(); I != End; ++I) {
Chris Lattner36c975c2005-11-10 18:53:25 +00001703 std::string Name = "l_" + Mang->makeNameProper(I->first);
Chris Lattner68758072004-05-09 06:20:51 +00001704 Out << "typedef ";
Chris Lattnera80cc932007-01-16 18:02:45 +00001705 printType(Out, I->second, false, Name);
Chris Lattner68758072004-05-09 06:20:51 +00001706 Out << ";\n";
1707 }
Misha Brukmand6a29a52005-04-20 16:05:03 +00001708
Misha Brukmanb70aaa62005-02-14 18:52:35 +00001709 Out << '\n';
Chris Lattner3ef6dc72002-05-09 14:40:11 +00001710
Chris Lattner2c601a72002-09-20 15:05:40 +00001711 // Keep track of which structures have been printed so far...
1712 std::set<const StructType *> StructPrinted;
1713
Nick Hildenbrandt67aa2e22002-09-14 21:36:24 +00001714 // Loop over all structures then push them into the stack so they are
1715 // printed in the correct order.
Chris Lattner2db41cd2002-09-20 15:12:13 +00001716 //
Chris Lattner58d04d42002-09-20 15:18:30 +00001717 Out << "/* Structure contents */\n";
Reid Spencer78d033e2007-01-06 07:24:44 +00001718 for (I = TST.begin(); I != End; ++I)
Chris Lattner2db41cd2002-09-20 15:12:13 +00001719 if (const StructType *STy = dyn_cast<StructType>(I->second))
Chris Lattnerfa395ec2003-11-02 01:29:27 +00001720 // Only print out used types!
Chris Lattner68758072004-05-09 06:20:51 +00001721 printContainedStructs(STy, StructPrinted);
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001722}
1723
Nick Hildenbrandt67aa2e22002-09-14 21:36:24 +00001724// Push the struct onto the stack and recursively push all structs
1725// this one depends on.
Robert Bocchinob78e8382006-01-20 20:43:57 +00001726//
1727// TODO: Make this work properly with packed types
1728//
Chris Lattner2c601a72002-09-20 15:05:40 +00001729void CWriter::printContainedStructs(const Type *Ty,
1730 std::set<const StructType*> &StructPrinted){
Chris Lattner14d9b202006-01-20 18:57:03 +00001731 // Don't walk through pointers.
Chris Lattner42a75512007-01-15 02:27:26 +00001732 if (isa<PointerType>(Ty) || Ty->isPrimitiveType() || Ty->isInteger()) return;
Chris Lattner14d9b202006-01-20 18:57:03 +00001733
1734 // Print all contained types first.
1735 for (Type::subtype_iterator I = Ty->subtype_begin(),
1736 E = Ty->subtype_end(); I != E; ++I)
1737 printContainedStructs(*I, StructPrinted);
1738
Misha Brukmanac25de32003-07-09 17:33:50 +00001739 if (const StructType *STy = dyn_cast<StructType>(Ty)) {
Chris Lattner14d9b202006-01-20 18:57:03 +00001740 // Check to see if we have already printed this struct.
1741 if (StructPrinted.insert(STy).second) {
1742 // Print structure type out.
Misha Brukmand6a29a52005-04-20 16:05:03 +00001743 std::string Name = TypeNames[STy];
Reid Spencer251f2142007-01-09 17:09:09 +00001744 printType(Out, STy, false, Name, true);
Chris Lattner58d04d42002-09-20 15:18:30 +00001745 Out << ";\n\n";
Nick Hildenbrandt67aa2e22002-09-14 21:36:24 +00001746 }
Nick Hildenbrandt67aa2e22002-09-14 21:36:24 +00001747 }
1748}
1749
Chris Lattner4cda8352002-08-20 16:55:48 +00001750void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00001751 /// isStructReturn - Should this function actually return a struct by-value?
1752 bool isStructReturn = F->getFunctionType()->isStructReturn();
Chris Lattner0c54d892006-05-23 23:39:48 +00001753
Joel Stanley54f60322003-06-25 04:52:09 +00001754 if (F->hasInternalLinkage()) Out << "static ";
Anton Korobeynikovb74ed072006-09-14 18:23:27 +00001755 if (F->hasDLLImportLinkage()) Out << "__declspec(dllimport) ";
1756 if (F->hasDLLExportLinkage()) Out << "__declspec(dllexport) ";
Anton Korobeynikovbcb97702006-09-17 20:25:45 +00001757 switch (F->getCallingConv()) {
1758 case CallingConv::X86_StdCall:
1759 Out << "__stdcall ";
1760 break;
1761 case CallingConv::X86_FastCall:
1762 Out << "__fastcall ";
1763 break;
1764 }
1765
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001766 // Loop over the arguments, printing them...
Chris Lattner16c7bb22002-05-09 02:28:59 +00001767 const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
Misha Brukmand6a29a52005-04-20 16:05:03 +00001768
1769 std::stringstream FunctionInnards;
1770
Nick Hildenbrandt98502372002-11-18 20:55:50 +00001771 // Print out the name...
Misha Brukmanb70aaa62005-02-14 18:52:35 +00001772 FunctionInnards << Mang->getValueName(F) << '(';
Misha Brukmand6a29a52005-04-20 16:05:03 +00001773
Chris Lattner0c54d892006-05-23 23:39:48 +00001774 bool PrintedArg = false;
Chris Lattner16c7bb22002-05-09 02:28:59 +00001775 if (!F->isExternal()) {
Chris Lattnere4d5c442005-03-15 04:54:21 +00001776 if (!F->arg_empty()) {
Chris Lattner0c54d892006-05-23 23:39:48 +00001777 Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
1778
1779 // If this is a struct-return function, don't print the hidden
1780 // struct-return argument.
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00001781 if (isStructReturn) {
Chris Lattner0c54d892006-05-23 23:39:48 +00001782 assert(I != E && "Invalid struct return function!");
1783 ++I;
1784 }
1785
Chris Lattneredd8ce12003-05-03 03:14:35 +00001786 std::string ArgName;
Reid Spencer0ae96932007-01-07 03:24:48 +00001787 unsigned Idx = 1;
Chris Lattner0c54d892006-05-23 23:39:48 +00001788 for (; I != E; ++I) {
1789 if (PrintedArg) FunctionInnards << ", ";
Chris Lattner4cda8352002-08-20 16:55:48 +00001790 if (I->hasName() || !Prototype)
Brian Gaeked9fb37a2003-07-24 20:20:44 +00001791 ArgName = Mang->getValueName(I);
Misha Brukmand6a29a52005-04-20 16:05:03 +00001792 else
Chris Lattner4cda8352002-08-20 16:55:48 +00001793 ArgName = "";
Reid Spencer0ae96932007-01-07 03:24:48 +00001794 printType(FunctionInnards, I->getType(),
Reid Spencer251f2142007-01-09 17:09:09 +00001795 /*isSigned=*/FT->paramHasAttr(Idx, FunctionType::SExtAttribute),
Reid Spencer0ae96932007-01-07 03:24:48 +00001796 ArgName);
Chris Lattner0c54d892006-05-23 23:39:48 +00001797 PrintedArg = true;
Reid Spencer0ae96932007-01-07 03:24:48 +00001798 ++Idx;
Chris Lattnerdeed7a52002-05-09 15:18:52 +00001799 }
1800 }
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001801 } else {
Chris Lattner0c54d892006-05-23 23:39:48 +00001802 // Loop over the arguments, printing them.
1803 FunctionType::param_iterator I = FT->param_begin(), E = FT->param_end();
1804
1805 // If this is a struct-return function, don't print the hidden
1806 // struct-return argument.
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00001807 if (isStructReturn) {
Chris Lattner0c54d892006-05-23 23:39:48 +00001808 assert(I != E && "Invalid struct return function!");
1809 ++I;
1810 }
1811
Reid Spencer0ae96932007-01-07 03:24:48 +00001812 unsigned Idx = 1;
Chris Lattner0c54d892006-05-23 23:39:48 +00001813 for (; I != E; ++I) {
1814 if (PrintedArg) FunctionInnards << ", ";
Reid Spencer0ae96932007-01-07 03:24:48 +00001815 printType(FunctionInnards, *I,
Reid Spencer251f2142007-01-09 17:09:09 +00001816 /*isSigned=*/FT->paramHasAttr(Idx, FunctionType::SExtAttribute));
Chris Lattner0c54d892006-05-23 23:39:48 +00001817 PrintedArg = true;
Reid Spencer0ae96932007-01-07 03:24:48 +00001818 ++Idx;
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001819 }
1820 }
1821
Chris Lattner1f8c4a12002-09-20 22:32:30 +00001822 // Finish printing arguments... if this is a vararg function, print the ...,
1823 // unless there are no known types, in which case, we just emit ().
1824 //
Chris Lattner0c54d892006-05-23 23:39:48 +00001825 if (FT->isVarArg() && PrintedArg) {
1826 if (PrintedArg) FunctionInnards << ", ";
Joel Stanley54f60322003-06-25 04:52:09 +00001827 FunctionInnards << "..."; // Output varargs portion of signature!
Chris Lattner0c54d892006-05-23 23:39:48 +00001828 } else if (!FT->isVarArg() && !PrintedArg) {
Chris Lattner4f7e1732003-11-26 00:09:17 +00001829 FunctionInnards << "void"; // ret() -> ret(void) in C.
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001830 }
Misha Brukmanb70aaa62005-02-14 18:52:35 +00001831 FunctionInnards << ')';
Chris Lattner0c54d892006-05-23 23:39:48 +00001832
1833 // Get the return tpe for the function.
1834 const Type *RetTy;
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00001835 if (!isStructReturn)
Chris Lattner0c54d892006-05-23 23:39:48 +00001836 RetTy = F->getReturnType();
1837 else {
1838 // If this is a struct-return function, print the struct-return type.
1839 RetTy = cast<PointerType>(FT->getParamType(0))->getElementType();
1840 }
1841
1842 // Print out the return type and the signature built above.
Reid Spencer30f9e27f2007-01-09 06:38:06 +00001843 printType(Out, RetTy,
Reid Spencer251f2142007-01-09 17:09:09 +00001844 /*isSigned=*/FT->paramHasAttr(0, FunctionType::SExtAttribute),
Reid Spencer0ae96932007-01-07 03:24:48 +00001845 FunctionInnards.str());
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001846}
1847
Reid Spencer22586642006-12-17 20:24:50 +00001848static inline bool isFPIntBitCast(const Instruction &I) {
1849 if (!isa<BitCastInst>(I))
1850 return false;
1851 const Type *SrcTy = I.getOperand(0)->getType();
1852 const Type *DstTy = I.getType();
Chris Lattner42a75512007-01-15 02:27:26 +00001853 return (SrcTy->isFloatingPoint() && DstTy->isInteger()) ||
1854 (DstTy->isFloatingPoint() && SrcTy->isInteger());
Reid Spencer22586642006-12-17 20:24:50 +00001855}
1856
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001857void CWriter::printFunction(Function &F) {
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00001858 /// isStructReturn - Should this function actually return a struct by-value?
1859 bool isStructReturn = F.getFunctionType()->isStructReturn();
1860
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001861 printFunctionSignature(&F, false);
Chris Lattner8c3c4bf2002-05-09 15:49:41 +00001862 Out << " {\n";
Chris Lattner0c54d892006-05-23 23:39:48 +00001863
1864 // If this is a struct return function, handle the result with magic.
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00001865 if (isStructReturn) {
Chris Lattner0c54d892006-05-23 23:39:48 +00001866 const Type *StructTy =
1867 cast<PointerType>(F.arg_begin()->getType())->getElementType();
1868 Out << " ";
Reid Spencer251f2142007-01-09 17:09:09 +00001869 printType(Out, StructTy, false, "StructReturn");
Chris Lattner0c54d892006-05-23 23:39:48 +00001870 Out << "; /* Struct return temporary */\n";
Chris Lattner8c3c4bf2002-05-09 15:49:41 +00001871
Chris Lattner0c54d892006-05-23 23:39:48 +00001872 Out << " ";
Reid Spencer251f2142007-01-09 17:09:09 +00001873 printType(Out, F.arg_begin()->getType(), false,
Reid Spencer0ae96932007-01-07 03:24:48 +00001874 Mang->getValueName(F.arg_begin()));
Chris Lattner0c54d892006-05-23 23:39:48 +00001875 Out << " = &StructReturn;\n";
1876 }
1877
1878 bool PrintedVar = false;
1879
Chris Lattner497e19a2002-05-09 20:39:03 +00001880 // print local variable information for the function
Reid Spencer941cfda2006-12-17 18:50:51 +00001881 for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
Chris Lattner6ffe5512004-04-27 15:13:33 +00001882 if (const AllocaInst *AI = isDirectAlloca(&*I)) {
Chris Lattnera8ab89e2003-06-17 04:39:14 +00001883 Out << " ";
Reid Spencer251f2142007-01-09 17:09:09 +00001884 printType(Out, AI->getAllocatedType(), false, Mang->getValueName(AI));
Misha Brukman41ce39c2005-01-31 06:19:57 +00001885 Out << "; /* Address-exposed local */\n";
Chris Lattner0c54d892006-05-23 23:39:48 +00001886 PrintedVar = true;
Chris Lattner6ffe5512004-04-27 15:13:33 +00001887 } else if (I->getType() != Type::VoidTy && !isInlinableInst(*I)) {
Chris Lattner16c7bb22002-05-09 02:28:59 +00001888 Out << " ";
Reid Spencer251f2142007-01-09 17:09:09 +00001889 printType(Out, I->getType(), false, Mang->getValueName(&*I));
Chris Lattner16c7bb22002-05-09 02:28:59 +00001890 Out << ";\n";
Misha Brukmand6a29a52005-04-20 16:05:03 +00001891
Chris Lattner84e66652003-05-03 07:11:00 +00001892 if (isa<PHINode>(*I)) { // Print out PHI node temporaries as well...
1893 Out << " ";
Reid Spencer251f2142007-01-09 17:09:09 +00001894 printType(Out, I->getType(), false,
Chris Lattner6ffe5512004-04-27 15:13:33 +00001895 Mang->getValueName(&*I)+"__PHI_TEMPORARY");
Chris Lattner84e66652003-05-03 07:11:00 +00001896 Out << ";\n";
1897 }
Chris Lattner0c54d892006-05-23 23:39:48 +00001898 PrintedVar = true;
Reid Spencer941cfda2006-12-17 18:50:51 +00001899 }
1900 // We need a temporary for the BitCast to use so it can pluck a value out
Reid Spencere4d87aa2006-12-23 06:05:41 +00001901 // of a union to do the BitCast. This is separate from the need for a
Reid Spencer941cfda2006-12-17 18:50:51 +00001902 // variable to hold the result of the BitCast.
Reid Spencer22586642006-12-17 20:24:50 +00001903 if (isFPIntBitCast(*I)) {
Reid Spencer555a0b12006-12-11 20:39:15 +00001904 Out << " llvmBitCastUnion " << Mang->getValueName(&*I)
1905 << "__BITCAST_TEMPORARY;\n";
Reid Spencer941cfda2006-12-17 18:50:51 +00001906 PrintedVar = true;
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001907 }
Reid Spencer941cfda2006-12-17 18:50:51 +00001908 }
Chris Lattnerd1cf1b42002-09-20 23:26:33 +00001909
Chris Lattner0c54d892006-05-23 23:39:48 +00001910 if (PrintedVar)
1911 Out << '\n';
Chris Lattnerd1cf1b42002-09-20 23:26:33 +00001912
Chris Lattner395fd592004-12-13 21:52:52 +00001913 if (F.hasExternalLinkage() && F.getName() == "main")
Chris Lattner50a8a172005-05-06 06:58:42 +00001914 Out << " CODE_FOR_MAIN();\n";
Chris Lattner395fd592004-12-13 21:52:52 +00001915
Chris Lattner16c7bb22002-05-09 02:28:59 +00001916 // print the basic blocks
Chris Lattner94f4f8e2004-02-13 23:00:29 +00001917 for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
Chris Lattnercb3ad012004-05-09 20:41:32 +00001918 if (Loop *L = LI->getLoopFor(BB)) {
1919 if (L->getHeader() == BB && L->getParentLoop() == 0)
1920 printLoop(L);
1921 } else {
1922 printBasicBlock(BB);
Chris Lattnerd0c668c2002-05-09 21:18:38 +00001923 }
Chris Lattner8c3c4bf2002-05-09 15:49:41 +00001924 }
Misha Brukmand6a29a52005-04-20 16:05:03 +00001925
Chris Lattner8c3c4bf2002-05-09 15:49:41 +00001926 Out << "}\n\n";
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00001927}
1928
Chris Lattnercb3ad012004-05-09 20:41:32 +00001929void CWriter::printLoop(Loop *L) {
1930 Out << " do { /* Syntactic loop '" << L->getHeader()->getName()
1931 << "' to make GCC happy */\n";
1932 for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) {
1933 BasicBlock *BB = L->getBlocks()[i];
1934 Loop *BBLoop = LI->getLoopFor(BB);
1935 if (BBLoop == L)
1936 printBasicBlock(BB);
1937 else if (BB == BBLoop->getHeader() && BBLoop->getParentLoop() == L)
Misha Brukmand6a29a52005-04-20 16:05:03 +00001938 printLoop(BBLoop);
Chris Lattnercb3ad012004-05-09 20:41:32 +00001939 }
1940 Out << " } while (1); /* end of syntactic loop '"
1941 << L->getHeader()->getName() << "' */\n";
1942}
1943
1944void CWriter::printBasicBlock(BasicBlock *BB) {
1945
1946 // Don't print the label for the basic block if there are no uses, or if
1947 // the only terminator use is the predecessor basic block's terminator.
1948 // We have to scan the use list because PHI nodes use basic blocks too but
1949 // do not require a label to be generated.
1950 //
1951 bool NeedsLabel = false;
1952 for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
1953 if (isGotoCodeNecessary(*PI, BB)) {
1954 NeedsLabel = true;
1955 break;
1956 }
Misha Brukmand6a29a52005-04-20 16:05:03 +00001957
Chris Lattnercb3ad012004-05-09 20:41:32 +00001958 if (NeedsLabel) Out << Mang->getValueName(BB) << ":\n";
Misha Brukmand6a29a52005-04-20 16:05:03 +00001959
Chris Lattnercb3ad012004-05-09 20:41:32 +00001960 // Output all of the instructions in the basic block...
1961 for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E;
1962 ++II) {
1963 if (!isInlinableInst(*II) && !isDirectAlloca(II)) {
Andrew Lenharth29c277f2006-11-27 23:50:49 +00001964 if (II->getType() != Type::VoidTy && !isInlineAsm(*II))
Chris Lattnercb3ad012004-05-09 20:41:32 +00001965 outputLValue(II);
1966 else
1967 Out << " ";
1968 visit(*II);
1969 Out << ";\n";
1970 }
1971 }
Misha Brukmand6a29a52005-04-20 16:05:03 +00001972
Chris Lattnercb3ad012004-05-09 20:41:32 +00001973 // Don't emit prefix or suffix for the terminator...
1974 visit(*BB->getTerminator());
1975}
1976
1977
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001978// Specific Instruction type classes... note that all of the casts are
Misha Brukman5560c9d2003-08-18 14:43:39 +00001979// necessary because we use the instruction classes as opaque types...
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001980//
Chris Lattnerbb03efd2002-06-25 15:57:03 +00001981void CWriter::visitReturnInst(ReturnInst &I) {
Chris Lattner0c54d892006-05-23 23:39:48 +00001982 // If this is a struct return function, return the temporary struct.
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00001983 bool isStructReturn = I.getParent()->getParent()->
1984 getFunctionType()->isStructReturn();
1985
1986 if (isStructReturn) {
Chris Lattner0c54d892006-05-23 23:39:48 +00001987 Out << " return StructReturn;\n";
1988 return;
1989 }
1990
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001991 // Don't output a void return if this is the last basic block in the function
Misha Brukmand6a29a52005-04-20 16:05:03 +00001992 if (I.getNumOperands() == 0 &&
Chris Lattnerbb03efd2002-06-25 15:57:03 +00001993 &*--I.getParent()->getParent()->end() == I.getParent() &&
1994 !I.getParent()->size() == 1) {
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001995 return;
Chris Lattner963b70b2002-05-21 18:05:19 +00001996 }
Chris Lattner44408262002-05-09 03:50:42 +00001997
Chris Lattner4fbf26d2002-05-09 20:53:56 +00001998 Out << " return";
Chris Lattnerbb03efd2002-06-25 15:57:03 +00001999 if (I.getNumOperands()) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002000 Out << ' ';
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002001 writeOperand(I.getOperand(0));
Chris Lattner16c7bb22002-05-09 02:28:59 +00002002 }
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002003 Out << ";\n";
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00002004}
2005
Chris Lattnera9f5e052003-04-22 20:19:52 +00002006void CWriter::visitSwitchInst(SwitchInst &SI) {
Chris Lattnera05e0ec2004-05-09 03:42:48 +00002007
Chris Lattnera9f5e052003-04-22 20:19:52 +00002008 Out << " switch (";
2009 writeOperand(SI.getOperand(0));
Chris Lattnerf1acd962003-04-23 19:15:13 +00002010 Out << ") {\n default:\n";
John Criswell30cc2272004-10-25 18:30:09 +00002011 printPHICopiesForSuccessor (SI.getParent(), SI.getDefaultDest(), 2);
Chris Lattnerf1acd962003-04-23 19:15:13 +00002012 printBranchToBlock(SI.getParent(), SI.getDefaultDest(), 2);
Chris Lattnera9f5e052003-04-22 20:19:52 +00002013 Out << ";\n";
2014 for (unsigned i = 2, e = SI.getNumOperands(); i != e; i += 2) {
2015 Out << " case ";
2016 writeOperand(SI.getOperand(i));
2017 Out << ":\n";
2018 BasicBlock *Succ = cast<BasicBlock>(SI.getOperand(i+1));
John Criswell30cc2272004-10-25 18:30:09 +00002019 printPHICopiesForSuccessor (SI.getParent(), Succ, 2);
Chris Lattnera9f5e052003-04-22 20:19:52 +00002020 printBranchToBlock(SI.getParent(), Succ, 2);
Chris Lattnerefd02c72005-03-19 17:35:11 +00002021 if (Function::iterator(Succ) == next(Function::iterator(SI.getParent())))
Chris Lattnera9f5e052003-04-22 20:19:52 +00002022 Out << " break;\n";
2023 }
2024 Out << " }\n";
2025}
2026
Chris Lattnera9d12c02004-10-16 18:12:13 +00002027void CWriter::visitUnreachableInst(UnreachableInst &I) {
Chris Lattner963869e2004-10-17 23:49:11 +00002028 Out << " /*UNREACHABLE*/;\n";
Chris Lattnera9d12c02004-10-16 18:12:13 +00002029}
2030
Chris Lattnercb3ad012004-05-09 20:41:32 +00002031bool CWriter::isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) {
2032 /// FIXME: This should be reenabled, but loop reordering safe!!
2033 return true;
2034
Chris Lattner67c2d182005-03-18 16:12:37 +00002035 if (next(Function::iterator(From)) != Function::iterator(To))
2036 return true; // Not the direct successor, we need a goto.
Chris Lattnercb3ad012004-05-09 20:41:32 +00002037
2038 //isa<SwitchInst>(From->getTerminator())
Chris Lattner9bda5f52003-06-28 17:53:05 +00002039
Chris Lattnercb3ad012004-05-09 20:41:32 +00002040 if (LI->getLoopFor(From) != LI->getLoopFor(To))
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002041 return true;
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002042 return false;
2043}
2044
John Criswell57bbfce2004-10-20 14:38:39 +00002045void CWriter::printPHICopiesForSuccessor (BasicBlock *CurBlock,
Misha Brukmand6a29a52005-04-20 16:05:03 +00002046 BasicBlock *Successor,
John Criswell57bbfce2004-10-20 14:38:39 +00002047 unsigned Indent) {
2048 for (BasicBlock::iterator I = Successor->begin(); isa<PHINode>(I); ++I) {
2049 PHINode *PN = cast<PHINode>(I);
2050 // Now we have to do the printing.
2051 Value *IV = PN->getIncomingValueForBlock(CurBlock);
2052 if (!isa<UndefValue>(IV)) {
2053 Out << std::string(Indent, ' ');
2054 Out << " " << Mang->getValueName(I) << "__PHI_TEMPORARY = ";
2055 writeOperand(IV);
2056 Out << "; /* for PHI node */\n";
2057 }
2058 }
2059}
2060
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002061void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
Chris Lattner9bda5f52003-06-28 17:53:05 +00002062 unsigned Indent) {
Chris Lattnercb3ad012004-05-09 20:41:32 +00002063 if (isGotoCodeNecessary(CurBB, Succ)) {
Chris Lattneredd8ce12003-05-03 03:14:35 +00002064 Out << std::string(Indent, ' ') << " goto ";
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002065 writeOperand(Succ);
2066 Out << ";\n";
2067 }
2068}
2069
Misha Brukman37f92e22003-09-11 22:34:13 +00002070// Branch instruction printing - Avoid printing out a branch to a basic block
2071// that immediately succeeds the current one.
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002072//
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002073void CWriter::visitBranchInst(BranchInst &I) {
Chris Lattnera05e0ec2004-05-09 03:42:48 +00002074
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002075 if (I.isConditional()) {
Chris Lattner5ef6ffd2003-10-12 08:12:58 +00002076 if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(0))) {
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002077 Out << " if (";
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002078 writeOperand(I.getCondition());
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002079 Out << ") {\n";
Misha Brukmand6a29a52005-04-20 16:05:03 +00002080
John Criswell57bbfce2004-10-20 14:38:39 +00002081 printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 2);
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002082 printBranchToBlock(I.getParent(), I.getSuccessor(0), 2);
Misha Brukmand6a29a52005-04-20 16:05:03 +00002083
Chris Lattner5ef6ffd2003-10-12 08:12:58 +00002084 if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(1))) {
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002085 Out << " } else {\n";
John Criswell57bbfce2004-10-20 14:38:39 +00002086 printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002087 printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002088 }
2089 } else {
Misha Brukman5560c9d2003-08-18 14:43:39 +00002090 // First goto not necessary, assume second one is...
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002091 Out << " if (!";
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002092 writeOperand(I.getCondition());
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002093 Out << ") {\n";
2094
John Criswell57bbfce2004-10-20 14:38:39 +00002095 printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002096 printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002097 }
2098
2099 Out << " }\n";
2100 } else {
John Criswell57bbfce2004-10-20 14:38:39 +00002101 printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 0);
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002102 printBranchToBlock(I.getParent(), I.getSuccessor(0), 0);
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002103 }
2104 Out << "\n";
2105}
2106
Chris Lattner84e66652003-05-03 07:11:00 +00002107// PHI nodes get copied into temporary values at the end of predecessor basic
2108// blocks. We now need to copy these temporary values into the REAL value for
2109// the PHI.
2110void CWriter::visitPHINode(PHINode &I) {
2111 writeOperand(&I);
2112 Out << "__PHI_TEMPORARY";
2113}
2114
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002115
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002116void CWriter::visitBinaryOperator(Instruction &I) {
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002117 // binary instructions, shift instructions, setCond instructions.
Chris Lattnerf5612b762003-04-23 19:09:22 +00002118 assert(!isa<PointerType>(I.getType()));
Brian Gaeke031a1122003-06-23 20:00:51 +00002119
2120 // We must cast the results of binary operations which might be promoted.
2121 bool needsCast = false;
Reid Spencer47857812006-12-31 05:55:36 +00002122 if ((I.getType() == Type::Int8Ty) || (I.getType() == Type::Int16Ty)
Brian Gaekee99f4cf2003-06-25 03:05:33 +00002123 || (I.getType() == Type::FloatTy)) {
Brian Gaeke031a1122003-06-23 20:00:51 +00002124 needsCast = true;
2125 Out << "((";
Reid Spencer251f2142007-01-09 17:09:09 +00002126 printType(Out, I.getType(), false);
Brian Gaeke031a1122003-06-23 20:00:51 +00002127 Out << ")(";
2128 }
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002129
Chris Lattner6d9b69f2005-03-03 21:12:04 +00002130 // If this is a negation operation, print it out as such. For FP, we don't
2131 // want to print "-0.0 - X".
2132 if (BinaryOperator::isNeg(&I)) {
John Criswellce4e1e42005-07-14 19:41:16 +00002133 Out << "-(";
Chris Lattner6d9b69f2005-03-03 21:12:04 +00002134 writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I)));
John Criswellce4e1e42005-07-14 19:41:16 +00002135 Out << ")";
Reid Spencer0a783f72006-11-02 01:53:59 +00002136 } else if (I.getOpcode() == Instruction::FRem) {
Chris Lattner57da2522005-08-23 20:22:50 +00002137 // Output a call to fmod/fmodf instead of emitting a%b
2138 if (I.getType() == Type::FloatTy)
2139 Out << "fmodf(";
2140 else
2141 Out << "fmod(";
2142 writeOperand(I.getOperand(0));
2143 Out << ", ";
2144 writeOperand(I.getOperand(1));
2145 Out << ")";
Chris Lattner6d9b69f2005-03-03 21:12:04 +00002146 } else {
Reid Spencer1628cec2006-10-26 06:15:43 +00002147
2148 // Write out the cast of the instruction's value back to the proper type
2149 // if necessary.
2150 bool NeedsClosingParens = writeInstructionCast(I);
2151
2152 // Certain instructions require the operand to be forced to a specific type
2153 // so we use writeOperandWithCast here instead of writeOperand. Similarly
2154 // below for operand 1
2155 writeOperandWithCast(I.getOperand(0), I.getOpcode());
Chris Lattner6d9b69f2005-03-03 21:12:04 +00002156
2157 switch (I.getOpcode()) {
2158 case Instruction::Add: Out << " + "; break;
2159 case Instruction::Sub: Out << " - "; break;
2160 case Instruction::Mul: Out << '*'; break;
Reid Spencer0a783f72006-11-02 01:53:59 +00002161 case Instruction::URem:
2162 case Instruction::SRem:
2163 case Instruction::FRem: Out << '%'; break;
Reid Spencer1628cec2006-10-26 06:15:43 +00002164 case Instruction::UDiv:
2165 case Instruction::SDiv:
2166 case Instruction::FDiv: Out << '/'; break;
Chris Lattner6d9b69f2005-03-03 21:12:04 +00002167 case Instruction::And: Out << " & "; break;
2168 case Instruction::Or: Out << " | "; break;
2169 case Instruction::Xor: Out << " ^ "; break;
Chris Lattner6d9b69f2005-03-03 21:12:04 +00002170 case Instruction::Shl : Out << " << "; break;
Reid Spencer3822ff52006-11-08 06:47:33 +00002171 case Instruction::LShr:
2172 case Instruction::AShr: Out << " >> "; break;
Bill Wendlingf5da1332006-12-07 22:21:48 +00002173 default: cerr << "Invalid operator type!" << I; abort();
Chris Lattner6d9b69f2005-03-03 21:12:04 +00002174 }
2175
Reid Spencer1628cec2006-10-26 06:15:43 +00002176 writeOperandWithCast(I.getOperand(1), I.getOpcode());
2177 if (NeedsClosingParens)
2178 Out << "))";
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002179 }
2180
Brian Gaeke031a1122003-06-23 20:00:51 +00002181 if (needsCast) {
2182 Out << "))";
2183 }
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002184}
2185
Reid Spencere4d87aa2006-12-23 06:05:41 +00002186void CWriter::visitICmpInst(ICmpInst &I) {
2187 // We must cast the results of icmp which might be promoted.
2188 bool needsCast = false;
2189
2190 // Write out the cast of the instruction's value back to the proper type
2191 // if necessary.
2192 bool NeedsClosingParens = writeInstructionCast(I);
2193
2194 // Certain icmp predicate require the operand to be forced to a specific type
2195 // so we use writeOperandWithCast here instead of writeOperand. Similarly
2196 // below for operand 1
2197 writeOperandWithCast(I.getOperand(0), I.getPredicate());
2198
2199 switch (I.getPredicate()) {
2200 case ICmpInst::ICMP_EQ: Out << " == "; break;
2201 case ICmpInst::ICMP_NE: Out << " != "; break;
2202 case ICmpInst::ICMP_ULE:
2203 case ICmpInst::ICMP_SLE: Out << " <= "; break;
2204 case ICmpInst::ICMP_UGE:
2205 case ICmpInst::ICMP_SGE: Out << " >= "; break;
2206 case ICmpInst::ICMP_ULT:
2207 case ICmpInst::ICMP_SLT: Out << " < "; break;
2208 case ICmpInst::ICMP_UGT:
2209 case ICmpInst::ICMP_SGT: Out << " > "; break;
2210 default: cerr << "Invalid icmp predicate!" << I; abort();
2211 }
2212
2213 writeOperandWithCast(I.getOperand(1), I.getPredicate());
2214 if (NeedsClosingParens)
2215 Out << "))";
2216
2217 if (needsCast) {
2218 Out << "))";
2219 }
2220}
2221
2222void CWriter::visitFCmpInst(FCmpInst &I) {
Reid Spencerb801a272007-01-08 06:58:32 +00002223 if (I.getPredicate() == FCmpInst::FCMP_FALSE) {
2224 Out << "0";
2225 return;
2226 }
2227 if (I.getPredicate() == FCmpInst::FCMP_TRUE) {
2228 Out << "1";
2229 return;
2230 }
2231
2232 const char* op = 0;
2233 switch (I.getPredicate()) {
2234 default: assert(0 && "Illegal FCmp predicate");
2235 case FCmpInst::FCMP_ORD: op = "ord"; break;
2236 case FCmpInst::FCMP_UNO: op = "uno"; break;
2237 case FCmpInst::FCMP_UEQ: op = "ueq"; break;
2238 case FCmpInst::FCMP_UNE: op = "une"; break;
2239 case FCmpInst::FCMP_ULT: op = "ult"; break;
2240 case FCmpInst::FCMP_ULE: op = "ule"; break;
2241 case FCmpInst::FCMP_UGT: op = "ugt"; break;
2242 case FCmpInst::FCMP_UGE: op = "uge"; break;
2243 case FCmpInst::FCMP_OEQ: op = "oeq"; break;
2244 case FCmpInst::FCMP_ONE: op = "one"; break;
2245 case FCmpInst::FCMP_OLT: op = "olt"; break;
2246 case FCmpInst::FCMP_OLE: op = "ole"; break;
2247 case FCmpInst::FCMP_OGT: op = "ogt"; break;
2248 case FCmpInst::FCMP_OGE: op = "oge"; break;
2249 }
2250
2251 Out << "llvm_fcmp_" << op << "(";
Reid Spencere4d87aa2006-12-23 06:05:41 +00002252 // Write the first operand
2253 writeOperand(I.getOperand(0));
Reid Spencerb801a272007-01-08 06:58:32 +00002254 Out << ", ";
Reid Spencere4d87aa2006-12-23 06:05:41 +00002255 // Write the second operand
2256 writeOperand(I.getOperand(1));
Reid Spencerb801a272007-01-08 06:58:32 +00002257 Out << ")";
Reid Spencere4d87aa2006-12-23 06:05:41 +00002258}
2259
Reid Spencer555a0b12006-12-11 20:39:15 +00002260static const char * getFloatBitCastField(const Type *Ty) {
2261 switch (Ty->getTypeID()) {
2262 default: assert(0 && "Invalid Type");
Reid Spencer47857812006-12-31 05:55:36 +00002263 case Type::FloatTyID: return "Float";
Reid Spencer47857812006-12-31 05:55:36 +00002264 case Type::DoubleTyID: return "Double";
Reid Spencera54b7cb2007-01-12 07:05:14 +00002265 case Type::IntegerTyID: {
2266 unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
2267 if (NumBits <= 32)
2268 return "Int32";
2269 else
2270 return "Int64";
2271 }
Reid Spencer555a0b12006-12-11 20:39:15 +00002272 }
2273}
2274
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002275void CWriter::visitCastInst(CastInst &I) {
Reid Spencer3da59db2006-11-27 01:05:10 +00002276 const Type *DstTy = I.getType();
2277 const Type *SrcTy = I.getOperand(0)->getType();
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002278 Out << '(';
Reid Spencer22586642006-12-17 20:24:50 +00002279 if (isFPIntBitCast(I)) {
Reid Spencer555a0b12006-12-11 20:39:15 +00002280 // These int<->float and long<->double casts need to be handled specially
2281 Out << Mang->getValueName(&I) << "__BITCAST_TEMPORARY."
2282 << getFloatBitCastField(I.getOperand(0)->getType()) << " = ";
2283 writeOperand(I.getOperand(0));
2284 Out << ", " << Mang->getValueName(&I) << "__BITCAST_TEMPORARY."
2285 << getFloatBitCastField(I.getType());
2286 } else {
2287 printCast(I.getOpcode(), SrcTy, DstTy);
Reid Spencer4fe16d62007-01-11 18:21:29 +00002288 if (I.getOpcode() == Instruction::SExt && SrcTy == Type::Int1Ty) {
Reid Spencer555a0b12006-12-11 20:39:15 +00002289 // Make sure we really get a sext from bool by subtracing the bool from 0
2290 Out << "0-";
2291 }
2292 writeOperand(I.getOperand(0));
Reid Spencer4fe16d62007-01-11 18:21:29 +00002293 if (DstTy == Type::Int1Ty &&
Reid Spencer555a0b12006-12-11 20:39:15 +00002294 (I.getOpcode() == Instruction::Trunc ||
2295 I.getOpcode() == Instruction::FPToUI ||
2296 I.getOpcode() == Instruction::FPToSI ||
2297 I.getOpcode() == Instruction::PtrToInt)) {
2298 // Make sure we really get a trunc to bool by anding the operand with 1
2299 Out << "&1u";
2300 }
Reid Spencer3da59db2006-11-27 01:05:10 +00002301 }
2302 Out << ')';
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002303}
2304
Chris Lattner9f24a072004-03-12 05:52:14 +00002305void CWriter::visitSelectInst(SelectInst &I) {
2306 Out << "((";
2307 writeOperand(I.getCondition());
2308 Out << ") ? (";
2309 writeOperand(I.getTrueValue());
2310 Out << ") : (";
2311 writeOperand(I.getFalseValue());
Misha Brukmand6a29a52005-04-20 16:05:03 +00002312 Out << "))";
Chris Lattner9f24a072004-03-12 05:52:14 +00002313}
2314
2315
Chris Lattnerc2421432004-05-09 04:30:20 +00002316void CWriter::lowerIntrinsics(Function &F) {
2317 for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
2318 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
2319 if (CallInst *CI = dyn_cast<CallInst>(I++))
2320 if (Function *F = CI->getCalledFunction())
2321 switch (F->getIntrinsicID()) {
2322 case Intrinsic::not_intrinsic:
2323 case Intrinsic::vastart:
2324 case Intrinsic::vacopy:
2325 case Intrinsic::vaend:
2326 case Intrinsic::returnaddress:
2327 case Intrinsic::frameaddress:
2328 case Intrinsic::setjmp:
2329 case Intrinsic::longjmp:
Chris Lattner33e9d292005-02-28 19:29:46 +00002330 case Intrinsic::prefetch:
Jim Laskey7075d6f2006-03-08 19:31:15 +00002331 case Intrinsic::dbg_stoppoint:
Chris Lattner1e142892006-09-09 06:17:12 +00002332 case Intrinsic::powi_f32:
2333 case Intrinsic::powi_f64:
Chris Lattnerc2421432004-05-09 04:30:20 +00002334 // We directly implement these intrinsics
2335 break;
2336 default:
Chris Lattner87242152006-03-13 23:09:05 +00002337 // If this is an intrinsic that directly corresponds to a GCC
2338 // builtin, we handle it.
2339 const char *BuiltinName = "";
2340#define GET_GCC_BUILTIN_NAME
2341#include "llvm/Intrinsics.gen"
2342#undef GET_GCC_BUILTIN_NAME
2343 // If we handle it, don't lower it.
2344 if (BuiltinName[0]) break;
2345
Chris Lattnerc2421432004-05-09 04:30:20 +00002346 // All other intrinsic calls we must lower.
Chris Lattner67c2d182005-03-18 16:12:37 +00002347 Instruction *Before = 0;
Misha Brukmand6a29a52005-04-20 16:05:03 +00002348 if (CI != &BB->front())
Chris Lattner67c2d182005-03-18 16:12:37 +00002349 Before = prior(BasicBlock::iterator(CI));
Misha Brukmand6a29a52005-04-20 16:05:03 +00002350
Chris Lattnerc2421432004-05-09 04:30:20 +00002351 IL.LowerIntrinsicCall(CI);
2352 if (Before) { // Move iterator to instruction after call
2353 I = Before; ++I;
2354 } else {
2355 I = BB->begin();
Chris Lattner4ef51372004-02-14 00:31:10 +00002356 }
Chris Lattner87242152006-03-13 23:09:05 +00002357 break;
Chris Lattnerc2421432004-05-09 04:30:20 +00002358 }
Chris Lattner4ef51372004-02-14 00:31:10 +00002359}
2360
2361
2362
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002363void CWriter::visitCallInst(CallInst &I) {
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002364 //check if we have inline asm
2365 if (isInlineAsm(I)) {
2366 visitInlineAsm(I);
2367 return;
2368 }
2369
Chris Lattner87242152006-03-13 23:09:05 +00002370 bool WroteCallee = false;
2371
Chris Lattner18ac3c82003-05-08 18:41:45 +00002372 // Handle intrinsic function calls first...
2373 if (Function *F = I.getCalledFunction())
Brian Gaeked0fde302003-11-11 22:41:34 +00002374 if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) {
Chris Lattner18ac3c82003-05-08 18:41:45 +00002375 switch (ID) {
Chris Lattner87242152006-03-13 23:09:05 +00002376 default: {
2377 // If this is an intrinsic that directly corresponds to a GCC
2378 // builtin, we emit it here.
2379 const char *BuiltinName = "";
2380#define GET_GCC_BUILTIN_NAME
2381#include "llvm/Intrinsics.gen"
2382#undef GET_GCC_BUILTIN_NAME
2383 assert(BuiltinName[0] && "Unknown LLVM intrinsic!");
2384
2385 Out << BuiltinName;
2386 WroteCallee = true;
2387 break;
2388 }
Misha Brukmand6a29a52005-04-20 16:05:03 +00002389 case Intrinsic::vastart:
Chris Lattner4d45bd02003-10-18 05:57:43 +00002390 Out << "0; ";
Misha Brukmand6a29a52005-04-20 16:05:03 +00002391
Andrew Lenharth558bc882005-06-18 18:34:52 +00002392 Out << "va_start(*(va_list*)";
2393 writeOperand(I.getOperand(1));
2394 Out << ", ";
Chris Lattner18ac3c82003-05-08 18:41:45 +00002395 // Output the last argument to the enclosing function...
Chris Lattnere4d5c442005-03-15 04:54:21 +00002396 if (I.getParent()->getParent()->arg_empty()) {
Bill Wendlingf5da1332006-12-07 22:21:48 +00002397 cerr << "The C backend does not currently support zero "
2398 << "argument varargs functions, such as '"
2399 << I.getParent()->getParent()->getName() << "'!\n";
Chris Lattner4065ef92003-10-23 18:39:22 +00002400 abort();
2401 }
Chris Lattnerc5e7df12005-03-15 04:59:17 +00002402 writeOperand(--I.getParent()->getParent()->arg_end());
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002403 Out << ')';
Chris Lattner18ac3c82003-05-08 18:41:45 +00002404 return;
Chris Lattner317201d2004-03-13 00:24:00 +00002405 case Intrinsic::vaend:
Chris Lattnerf8e6f4f2004-08-10 00:19:16 +00002406 if (!isa<ConstantPointerNull>(I.getOperand(1))) {
Andrew Lenharth558bc882005-06-18 18:34:52 +00002407 Out << "0; va_end(*(va_list*)";
Chris Lattnerf8e6f4f2004-08-10 00:19:16 +00002408 writeOperand(I.getOperand(1));
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002409 Out << ')';
Chris Lattnerf8e6f4f2004-08-10 00:19:16 +00002410 } else {
2411 Out << "va_end(*(va_list*)0)";
2412 }
Chris Lattner18ac3c82003-05-08 18:41:45 +00002413 return;
Chris Lattner317201d2004-03-13 00:24:00 +00002414 case Intrinsic::vacopy:
Andrew Lenharth558bc882005-06-18 18:34:52 +00002415 Out << "0; ";
2416 Out << "va_copy(*(va_list*)";
Chris Lattner18ac3c82003-05-08 18:41:45 +00002417 writeOperand(I.getOperand(1));
Andrew Lenharth213e5572005-06-22 21:04:42 +00002418 Out << ", *(va_list*)";
Andrew Lenharth558bc882005-06-18 18:34:52 +00002419 writeOperand(I.getOperand(2));
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002420 Out << ')';
Chris Lattner18ac3c82003-05-08 18:41:45 +00002421 return;
Chris Lattnerfe1554a2004-02-14 02:55:36 +00002422 case Intrinsic::returnaddress:
2423 Out << "__builtin_return_address(";
2424 writeOperand(I.getOperand(1));
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002425 Out << ')';
Chris Lattnerfe1554a2004-02-14 02:55:36 +00002426 return;
2427 case Intrinsic::frameaddress:
2428 Out << "__builtin_frame_address(";
2429 writeOperand(I.getOperand(1));
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002430 Out << ')';
Chris Lattnerfe1554a2004-02-14 02:55:36 +00002431 return;
Chris Lattner1e142892006-09-09 06:17:12 +00002432 case Intrinsic::powi_f32:
2433 case Intrinsic::powi_f64:
2434 Out << "__builtin_powi(";
2435 writeOperand(I.getOperand(1));
2436 Out << ", ";
2437 writeOperand(I.getOperand(2));
2438 Out << ')';
2439 return;
Chris Lattnere42cde22004-02-15 22:51:47 +00002440 case Intrinsic::setjmp:
2441 Out << "setjmp(*(jmp_buf*)";
2442 writeOperand(I.getOperand(1));
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002443 Out << ')';
Chris Lattnere42cde22004-02-15 22:51:47 +00002444 return;
2445 case Intrinsic::longjmp:
2446 Out << "longjmp(*(jmp_buf*)";
2447 writeOperand(I.getOperand(1));
2448 Out << ", ";
2449 writeOperand(I.getOperand(2));
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002450 Out << ')';
Chris Lattnere42cde22004-02-15 22:51:47 +00002451 return;
Chris Lattner33e9d292005-02-28 19:29:46 +00002452 case Intrinsic::prefetch:
Chris Lattnerca76f352005-02-28 19:36:15 +00002453 Out << "LLVM_PREFETCH((const void *)";
Chris Lattner33e9d292005-02-28 19:29:46 +00002454 writeOperand(I.getOperand(1));
2455 Out << ", ";
2456 writeOperand(I.getOperand(2));
2457 Out << ", ";
2458 writeOperand(I.getOperand(3));
2459 Out << ")";
Chris Lattnerca76f352005-02-28 19:36:15 +00002460 return;
Jim Laskey7075d6f2006-03-08 19:31:15 +00002461 case Intrinsic::dbg_stoppoint: {
2462 // If we use writeOperand directly we get a "u" suffix which is rejected
2463 // by gcc.
Jim Laskey580418e2006-03-23 18:08:29 +00002464 DbgStopPointInst &SPI = cast<DbgStopPointInst>(I);
Jim Laskey7075d6f2006-03-08 19:31:15 +00002465
2466 Out << "\n#line "
Jim Laskey580418e2006-03-23 18:08:29 +00002467 << SPI.getLine()
2468 << " \"" << SPI.getDirectory()
2469 << SPI.getFileName() << "\"\n";
Jim Laskey7075d6f2006-03-08 19:31:15 +00002470 return;
2471 }
Chris Lattner18ac3c82003-05-08 18:41:45 +00002472 }
2473 }
2474
Chris Lattner4394d512004-11-13 22:21:56 +00002475 Value *Callee = I.getCalledValue();
Misha Brukmand6a29a52005-04-20 16:05:03 +00002476
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00002477 const PointerType *PTy = cast<PointerType>(Callee->getType());
2478 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
2479
Chris Lattner0c54d892006-05-23 23:39:48 +00002480 // If this is a call to a struct-return function, assign to the first
2481 // parameter instead of passing it to the call.
Anton Korobeynikovb10308e2007-01-28 13:31:35 +00002482 bool isStructRet = FTy->isStructReturn();
Chris Lattner0c54d892006-05-23 23:39:48 +00002483 if (isStructRet) {
2484 Out << "*(";
2485 writeOperand(I.getOperand(1));
2486 Out << ") = ";
2487 }
2488
Chris Lattnerfe673d92005-05-06 06:53:07 +00002489 if (I.isTailCall()) Out << " /*tail*/ ";
Chris Lattner0c54d892006-05-23 23:39:48 +00002490
2491 if (!WroteCallee) {
2492 // If this is an indirect call to a struct return function, we need to cast
2493 // the pointer.
2494 bool NeedsCast = isStructRet && !isa<Function>(Callee);
Misha Brukmand6a29a52005-04-20 16:05:03 +00002495
Chris Lattner0c54d892006-05-23 23:39:48 +00002496 // GCC is a real PITA. It does not permit codegening casts of functions to
2497 // function pointers if they are in a call (it generates a trap instruction
2498 // instead!). We work around this by inserting a cast to void* in between
2499 // the function and the function pointer cast. Unfortunately, we can't just
2500 // form the constant expression here, because the folder will immediately
2501 // nuke it.
2502 //
2503 // Note finally, that this is completely unsafe. ANSI C does not guarantee
2504 // that void* and function pointers have the same size. :( To deal with this
2505 // in the common case, we handle casts where the number of arguments passed
2506 // match exactly.
2507 //
2508 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Callee))
Reid Spencer3da59db2006-11-27 01:05:10 +00002509 if (CE->isCast())
Chris Lattner0c54d892006-05-23 23:39:48 +00002510 if (Function *RF = dyn_cast<Function>(CE->getOperand(0))) {
2511 NeedsCast = true;
2512 Callee = RF;
2513 }
2514
2515 if (NeedsCast) {
2516 // Ok, just cast the pointer type.
2517 Out << "((";
2518 if (!isStructRet)
2519 printType(Out, I.getCalledValue()->getType());
2520 else
2521 printStructReturnPointerFunctionType(Out,
2522 cast<PointerType>(I.getCalledValue()->getType()));
2523 Out << ")(void*)";
2524 }
2525 writeOperand(Callee);
2526 if (NeedsCast) Out << ')';
2527 }
2528
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002529 Out << '(';
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002530
Chris Lattner4394d512004-11-13 22:21:56 +00002531 unsigned NumDeclaredParams = FTy->getNumParams();
2532
Chris Lattner0c54d892006-05-23 23:39:48 +00002533 CallSite::arg_iterator AI = I.op_begin()+1, AE = I.op_end();
2534 unsigned ArgNo = 0;
2535 if (isStructRet) { // Skip struct return argument.
2536 ++AI;
2537 ++ArgNo;
2538 }
2539
2540 bool PrintedArg = false;
Reid Spencer0ae96932007-01-07 03:24:48 +00002541 unsigned Idx = 1;
2542 for (; AI != AE; ++AI, ++ArgNo, ++Idx) {
Chris Lattner0c54d892006-05-23 23:39:48 +00002543 if (PrintedArg) Out << ", ";
2544 if (ArgNo < NumDeclaredParams &&
2545 (*AI)->getType() != FTy->getParamType(ArgNo)) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002546 Out << '(';
Reid Spencer0ae96932007-01-07 03:24:48 +00002547 printType(Out, FTy->getParamType(ArgNo),
Reid Spencer251f2142007-01-09 17:09:09 +00002548 /*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute));
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002549 Out << ')';
Chris Lattner4394d512004-11-13 22:21:56 +00002550 }
Chris Lattner9bda5f52003-06-28 17:53:05 +00002551 writeOperand(*AI);
Chris Lattner0c54d892006-05-23 23:39:48 +00002552 PrintedArg = true;
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002553 }
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002554 Out << ')';
Misha Brukmand6a29a52005-04-20 16:05:03 +00002555}
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002556
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002557
2558//This converts the llvm constraint string to something gcc is expecting.
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002559//TODO: work out platform independent constraints and factor those out
Andrew Lenharth238581f2006-11-28 19:56:02 +00002560// of the per target tables
2561// handle multiple constraint codes
Andrew Lenharthe0cf0752006-11-28 19:53:36 +00002562std::string CWriter::InterpretASMConstraint(InlineAsm::ConstraintInfo& c) {
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002563
2564 assert(c.Codes.size() == 1 && "Too many asm constraint codes to handle");
2565
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002566 const char** table = 0;
Andrew Lenharthe0cf0752006-11-28 19:53:36 +00002567
2568 //Grab the translation table from TargetAsmInfo if it exists
2569 if (!TAsm) {
2570 std::string E;
2571 const TargetMachineRegistry::Entry* Match =
2572 TargetMachineRegistry::getClosestStaticTargetForModule(*TheModule, E);
2573 if (Match) {
2574 //Per platform Target Machines don't exist, so create it
2575 // this must be done only once
2576 const TargetMachine* TM = Match->CtorFn(*TheModule, "");
2577 TAsm = TM->getTargetAsmInfo();
2578 }
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002579 }
Andrew Lenharthe0cf0752006-11-28 19:53:36 +00002580 if (TAsm)
2581 table = TAsm->getAsmCBE();
2582
2583 //Search the translation table if it exists
2584 for (int i = 0; table && table[i]; i += 2)
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002585 if (c.Codes[0] == table[i])
2586 return table[i+1];
2587
Andrew Lenharth85f22282006-11-28 22:25:32 +00002588 //default is identity
2589 return c.Codes[0];
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002590}
2591
2592//TODO: import logic from AsmPrinter.cpp
Andrew Lenharthe0cf0752006-11-28 19:53:36 +00002593static std::string gccifyAsm(std::string asmstr) {
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002594 for (std::string::size_type i = 0; i != asmstr.size(); ++i)
2595 if (asmstr[i] == '\n')
2596 asmstr.replace(i, 1, "\\n");
2597 else if (asmstr[i] == '\t')
2598 asmstr.replace(i, 1, "\\t");
2599 else if (asmstr[i] == '$') {
2600 if (asmstr[i + 1] == '{') {
2601 std::string::size_type a = asmstr.find_first_of(':', i + 1);
2602 std::string::size_type b = asmstr.find_first_of('}', i + 1);
2603 std::string n = "%" +
2604 asmstr.substr(a + 1, b - a - 1) +
2605 asmstr.substr(i + 2, a - i - 2);
2606 asmstr.replace(i, b - i + 1, n);
2607 i += n.size() - 1;
2608 } else
2609 asmstr.replace(i, 1, "%");
2610 }
2611 else if (asmstr[i] == '%')//grr
2612 { asmstr.replace(i, 1, "%%"); ++i;}
2613
2614 return asmstr;
2615}
2616
Andrew Lenharth238581f2006-11-28 19:56:02 +00002617//TODO: assumptions about what consume arguments from the call are likely wrong
2618// handle communitivity
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002619void CWriter::visitInlineAsm(CallInst &CI) {
2620 InlineAsm* as = cast<InlineAsm>(CI.getOperand(0));
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002621 std::vector<InlineAsm::ConstraintInfo> Constraints = as->ParseConstraints();
2622 std::vector<std::pair<std::string, Value*> > Input;
2623 std::vector<std::pair<std::string, Value*> > Output;
2624 std::string Clobber;
2625 int count = CI.getType() == Type::VoidTy ? 1 : 0;
2626 for (std::vector<InlineAsm::ConstraintInfo>::iterator I = Constraints.begin(),
2627 E = Constraints.end(); I != E; ++I) {
2628 assert(I->Codes.size() == 1 && "Too many asm constraint codes to handle");
2629 std::string c =
Andrew Lenharthe0cf0752006-11-28 19:53:36 +00002630 InterpretASMConstraint(*I);
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002631 switch(I->Type) {
2632 default:
2633 assert(0 && "Unknown asm constraint");
2634 break;
2635 case InlineAsm::isInput: {
2636 if (c.size()) {
2637 Input.push_back(std::make_pair(c, count ? CI.getOperand(count) : &CI));
2638 ++count; //consume arg
2639 }
2640 break;
2641 }
2642 case InlineAsm::isOutput: {
2643 if (c.size()) {
2644 Output.push_back(std::make_pair("="+((I->isEarlyClobber ? "&" : "")+c),
2645 count ? CI.getOperand(count) : &CI));
2646 ++count; //consume arg
2647 }
2648 break;
2649 }
2650 case InlineAsm::isClobber: {
2651 if (c.size())
2652 Clobber += ",\"" + c + "\"";
2653 break;
2654 }
2655 }
2656 }
2657
2658 //fix up the asm string for gcc
Andrew Lenharthe0cf0752006-11-28 19:53:36 +00002659 std::string asmstr = gccifyAsm(as->getAsmString());
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002660
2661 Out << "__asm__ volatile (\"" << asmstr << "\"\n";
2662 Out << " :";
2663 for (std::vector<std::pair<std::string, Value*> >::iterator I = Output.begin(),
2664 E = Output.end(); I != E; ++I) {
2665 Out << "\"" << I->first << "\"(";
2666 writeOperandRaw(I->second);
2667 Out << ")";
2668 if (I + 1 != E)
2669 Out << ",";
2670 }
2671 Out << "\n :";
2672 for (std::vector<std::pair<std::string, Value*> >::iterator I = Input.begin(),
2673 E = Input.end(); I != E; ++I) {
2674 Out << "\"" << I->first << "\"(";
2675 writeOperandRaw(I->second);
2676 Out << ")";
2677 if (I + 1 != E)
2678 Out << ",";
2679 }
Andrew Lenharthf45148e2006-11-28 23:07:32 +00002680 if (Clobber.size())
2681 Out << "\n :" << Clobber.substr(1);
2682 Out << ")";
Andrew Lenharth29c277f2006-11-27 23:50:49 +00002683}
2684
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002685void CWriter::visitMallocInst(MallocInst &I) {
Chris Lattnerf31182a2004-02-13 23:18:48 +00002686 assert(0 && "lowerallocations pass didn't work!");
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002687}
2688
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002689void CWriter::visitAllocaInst(AllocaInst &I) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002690 Out << '(';
Nick Hildenbrandt98502372002-11-18 20:55:50 +00002691 printType(Out, I.getType());
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002692 Out << ") alloca(sizeof(";
Nick Hildenbrandt98502372002-11-18 20:55:50 +00002693 printType(Out, I.getType()->getElementType());
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002694 Out << ')';
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002695 if (I.isArrayAllocation()) {
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002696 Out << " * " ;
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002697 writeOperand(I.getOperand(0));
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002698 }
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002699 Out << ')';
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002700}
2701
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002702void CWriter::visitFreeInst(FreeInst &I) {
Chris Lattnerf31182a2004-02-13 23:18:48 +00002703 assert(0 && "lowerallocations pass didn't work!");
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002704}
2705
Chris Lattner23e90702003-11-25 20:49:55 +00002706void CWriter::printIndexingExpression(Value *Ptr, gep_type_iterator I,
2707 gep_type_iterator E) {
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00002708 bool HasImplicitAddress = false;
2709 // If accessing a global value with no indexing, avoid *(&GV) syndrome
Reid Spencer3ed469c2006-11-02 20:25:50 +00002710 if (isa<GlobalValue>(Ptr)) {
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00002711 HasImplicitAddress = true;
Chris Lattnera8ab89e2003-06-17 04:39:14 +00002712 } else if (isDirectAlloca(Ptr)) {
2713 HasImplicitAddress = true;
Chris Lattnerd0c668c2002-05-09 21:18:38 +00002714 }
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002715
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00002716 if (I == E) {
2717 if (!HasImplicitAddress)
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002718 Out << '*'; // Implicit zero first argument: '*x' is equivalent to 'x[0]'
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002719
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00002720 writeOperandInternal(Ptr);
2721 return;
2722 }
2723
Chris Lattner23e90702003-11-25 20:49:55 +00002724 const Constant *CI = dyn_cast<Constant>(I.getOperand());
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00002725 if (HasImplicitAddress && (!CI || !CI->isNullValue()))
2726 Out << "(&";
2727
2728 writeOperandInternal(Ptr);
2729
Nick Hildenbrandte548f002002-09-25 20:29:26 +00002730 if (HasImplicitAddress && (!CI || !CI->isNullValue())) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002731 Out << ')';
Nick Hildenbrandte548f002002-09-25 20:29:26 +00002732 HasImplicitAddress = false; // HIA is only true if we haven't addressed yet
2733 }
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002734
Nick Hildenbrandte548f002002-09-25 20:29:26 +00002735 assert(!HasImplicitAddress || (CI && CI->isNullValue()) &&
2736 "Can only have implicit address with direct accessing");
2737
2738 if (HasImplicitAddress) {
2739 ++I;
Chris Lattner23e90702003-11-25 20:49:55 +00002740 } else if (CI && CI->isNullValue()) {
2741 gep_type_iterator TmpI = I; ++TmpI;
2742
Nick Hildenbrandte548f002002-09-25 20:29:26 +00002743 // Print out the -> operator if possible...
Chris Lattner23e90702003-11-25 20:49:55 +00002744 if (TmpI != E && isa<StructType>(*TmpI)) {
Chris Lattnerdf35a1c2002-08-19 23:09:46 +00002745 Out << (HasImplicitAddress ? "." : "->");
Reid Spencerb83eb642006-10-20 07:07:24 +00002746 Out << "field" << cast<ConstantInt>(TmpI.getOperand())->getZExtValue();
Chris Lattner23e90702003-11-25 20:49:55 +00002747 I = ++TmpI;
2748 }
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002749 }
Chris Lattner5dfe7672002-08-22 22:48:55 +00002750
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002751 for (; I != E; ++I)
Chris Lattner23e90702003-11-25 20:49:55 +00002752 if (isa<StructType>(*I)) {
Reid Spencerb83eb642006-10-20 07:07:24 +00002753 Out << ".field" << cast<ConstantInt>(I.getOperand())->getZExtValue();
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002754 } else {
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002755 Out << '[';
Chris Lattner23e90702003-11-25 20:49:55 +00002756 writeOperand(I.getOperand());
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002757 Out << ']';
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002758 }
2759}
2760
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002761void CWriter::visitLoadInst(LoadInst &I) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002762 Out << '*';
Chris Lattner9d30e222005-02-14 16:47:52 +00002763 if (I.isVolatile()) {
Chris Lattner8399e022005-02-15 05:52:14 +00002764 Out << "((";
Reid Spencer251f2142007-01-09 17:09:09 +00002765 printType(Out, I.getType(), false, "volatile*");
Chris Lattnerb94388a2005-09-27 20:52:44 +00002766 Out << ")";
Chris Lattner9d30e222005-02-14 16:47:52 +00002767 }
2768
Chris Lattner5dfe7672002-08-22 22:48:55 +00002769 writeOperand(I.getOperand(0));
Chris Lattner9d30e222005-02-14 16:47:52 +00002770
2771 if (I.isVolatile())
Misha Brukman23ba0c52005-03-08 00:26:08 +00002772 Out << ')';
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002773}
2774
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002775void CWriter::visitStoreInst(StoreInst &I) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002776 Out << '*';
Chris Lattner9d30e222005-02-14 16:47:52 +00002777 if (I.isVolatile()) {
Chris Lattner8399e022005-02-15 05:52:14 +00002778 Out << "((";
Reid Spencer251f2142007-01-09 17:09:09 +00002779 printType(Out, I.getOperand(0)->getType(), false, " volatile*");
Chris Lattnerb94388a2005-09-27 20:52:44 +00002780 Out << ")";
Chris Lattner9d30e222005-02-14 16:47:52 +00002781 }
Chris Lattner5dfe7672002-08-22 22:48:55 +00002782 writeOperand(I.getPointerOperand());
Misha Brukman23ba0c52005-03-08 00:26:08 +00002783 if (I.isVolatile()) Out << ')';
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002784 Out << " = ";
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002785 writeOperand(I.getOperand(0));
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002786}
2787
Chris Lattnerbb03efd2002-06-25 15:57:03 +00002788void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) {
Misha Brukmanb70aaa62005-02-14 18:52:35 +00002789 Out << '&';
Chris Lattner23e90702003-11-25 20:49:55 +00002790 printIndexingExpression(I.getPointerOperand(), gep_type_begin(I),
2791 gep_type_end(I));
Chris Lattner4fbf26d2002-05-09 20:53:56 +00002792}
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00002793
Chris Lattner4d45bd02003-10-18 05:57:43 +00002794void CWriter::visitVAArgInst(VAArgInst &I) {
Andrew Lenharth558bc882005-06-18 18:34:52 +00002795 Out << "va_arg(*(va_list*)";
Chris Lattner4d45bd02003-10-18 05:57:43 +00002796 writeOperand(I.getOperand(0));
Andrew Lenharth558bc882005-06-18 18:34:52 +00002797 Out << ", ";
Chris Lattner7635ea42003-11-03 01:01:59 +00002798 printType(Out, I.getType());
Andrew Lenharth558bc882005-06-18 18:34:52 +00002799 Out << ");\n ";
Chris Lattner4d45bd02003-10-18 05:57:43 +00002800}
2801
Sumant Kowshik9ddc86c2002-05-08 18:09:58 +00002802//===----------------------------------------------------------------------===//
2803// External Interface declaration
2804//===----------------------------------------------------------------------===//
2805
Chris Lattner1911fd42006-09-04 04:14:57 +00002806bool CTargetMachine::addPassesToEmitWholeFile(PassManager &PM,
2807 std::ostream &o,
2808 CodeGenFileType FileType,
2809 bool Fast) {
Chris Lattner0431c962005-06-25 02:48:37 +00002810 if (FileType != TargetMachine::AssemblyFile) return true;
2811
Chris Lattner99c59e82004-05-23 21:23:35 +00002812 PM.add(createLowerGCPass());
Chris Lattnerf7fe4942005-03-03 01:04:50 +00002813 PM.add(createLowerAllocationsPass(true));
Chris Lattner94f4f8e2004-02-13 23:00:29 +00002814 PM.add(createLowerInvokePass());
Chris Lattnerbad13eb2005-11-02 17:42:58 +00002815 PM.add(createCFGSimplificationPass()); // clean up after lower invoke.
Chris Lattnerf9a05322006-02-13 22:22:42 +00002816 PM.add(new CBackendNameAllUsedStructsAndMergeFunctions());
Chris Lattnerbc641b92006-03-23 05:43:16 +00002817 PM.add(new CWriter(o));
Chris Lattnerf31182a2004-02-13 23:18:48 +00002818 return false;
2819}