1 //===-- CBackend.cpp - Library for converting LLVM code to C --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This library converts LLVM code to C code, compilable by GCC and other C
13 //===----------------------------------------------------------------------===//
15 #include "CTargetMachine.h"
16 #include "llvm/CallingConv.h"
17 #include "llvm/Constants.h"
18 #include "llvm/DerivedTypes.h"
19 #include "llvm/Module.h"
20 #include "llvm/Instructions.h"
21 #include "llvm/Pass.h"
22 #include "llvm/PassManager.h"
23 #include "llvm/TypeSymbolTable.h"
24 #include "llvm/Intrinsics.h"
25 #include "llvm/IntrinsicInst.h"
26 #include "llvm/InlineAsm.h"
27 #include "llvm/ADT/StringExtras.h"
28 #include "llvm/ADT/SmallString.h"
29 #include "llvm/ADT/STLExtras.h"
30 #include "llvm/Analysis/ConstantsScanner.h"
31 #include "llvm/Analysis/FindUsedTypes.h"
32 #include "llvm/Analysis/LoopInfo.h"
33 #include "llvm/Analysis/ValueTracking.h"
34 #include "llvm/CodeGen/Passes.h"
35 #include "llvm/CodeGen/IntrinsicLowering.h"
36 #include "llvm/Transforms/Scalar.h"
37 #include "llvm/MC/MCAsmInfo.h"
38 #include "llvm/Target/TargetData.h"
39 #include "llvm/Target/TargetRegistry.h"
40 #include "llvm/Support/CallSite.h"
41 #include "llvm/Support/CFG.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/FormattedStream.h"
44 #include "llvm/Support/GetElementPtrTypeIterator.h"
45 #include "llvm/Support/InstVisitor.h"
46 #include "llvm/Support/Mangler.h"
47 #include "llvm/Support/MathExtras.h"
48 #include "llvm/System/Host.h"
49 #include "llvm/Config/config.h"
54 extern "C" void LLVMInitializeCBackendTarget() {
55 // Register the target.
56 RegisterTargetMachine<CTargetMachine> X(TheCBackendTarget);
60 /// CBackendNameAllUsedStructsAndMergeFunctions - This pass inserts names for
61 /// any unnamed structure types that are used by the program, and merges
62 /// external functions with the same name.
64 class CBackendNameAllUsedStructsAndMergeFunctions : public ModulePass {
67 CBackendNameAllUsedStructsAndMergeFunctions()
69 void getAnalysisUsage(AnalysisUsage &AU) const {
70 AU.addRequired<FindUsedTypes>();
73 virtual const char *getPassName() const {
74 return "C backend type canonicalizer";
77 virtual bool runOnModule(Module &M);
80 char CBackendNameAllUsedStructsAndMergeFunctions::ID = 0;
82 /// CWriter - This class is the main chunk of code that converts an LLVM
83 /// module to a C translation unit.
84 class CWriter : public FunctionPass, public InstVisitor<CWriter> {
85 formatted_raw_ostream &Out;
86 IntrinsicLowering *IL;
89 const Module *TheModule;
90 const MCAsmInfo* TAsm;
92 std::map<const Type *, std::string> TypeNames;
93 std::map<const ConstantFP *, unsigned> FPConstantMap;
94 std::set<Function*> intrinsicPrototypesAlreadyGenerated;
95 std::set<const Argument*> ByValParams;
97 unsigned OpaqueCounter;
98 DenseMap<const Value*, unsigned> AnonValueNumbers;
99 unsigned NextAnonValueNumber;
103 explicit CWriter(formatted_raw_ostream &o)
104 : FunctionPass(&ID), Out(o), IL(0), Mang(0), LI(0),
105 TheModule(0), TAsm(0), TD(0), OpaqueCounter(0), NextAnonValueNumber(0) {
109 virtual const char *getPassName() const { return "C backend"; }
111 void getAnalysisUsage(AnalysisUsage &AU) const {
112 AU.addRequired<LoopInfo>();
113 AU.setPreservesAll();
116 virtual bool doInitialization(Module &M);
118 bool runOnFunction(Function &F) {
119 // Do not codegen any 'available_externally' functions at all, they have
120 // definitions outside the translation unit.
121 if (F.hasAvailableExternallyLinkage())
124 LI = &getAnalysis<LoopInfo>();
126 // Get rid of intrinsics we can't handle.
129 // Output all floating point constants that cannot be printed accurately.
130 printFloatingPointConstants(F);
136 virtual bool doFinalization(Module &M) {
141 FPConstantMap.clear();
144 intrinsicPrototypesAlreadyGenerated.clear();
148 raw_ostream &printType(formatted_raw_ostream &Out,
150 bool isSigned = false,
151 const std::string &VariableName = "",
152 bool IgnoreName = false,
153 const AttrListPtr &PAL = AttrListPtr());
154 std::ostream &printType(std::ostream &Out, const Type *Ty,
155 bool isSigned = false,
156 const std::string &VariableName = "",
157 bool IgnoreName = false,
158 const AttrListPtr &PAL = AttrListPtr());
159 raw_ostream &printSimpleType(formatted_raw_ostream &Out,
162 const std::string &NameSoFar = "");
163 std::ostream &printSimpleType(std::ostream &Out, const Type *Ty,
165 const std::string &NameSoFar = "");
167 void printStructReturnPointerFunctionType(formatted_raw_ostream &Out,
168 const AttrListPtr &PAL,
169 const PointerType *Ty);
171 /// writeOperandDeref - Print the result of dereferencing the specified
172 /// operand with '*'. This is equivalent to printing '*' then using
173 /// writeOperand, but avoids excess syntax in some cases.
174 void writeOperandDeref(Value *Operand) {
175 if (isAddressExposed(Operand)) {
176 // Already something with an address exposed.
177 writeOperandInternal(Operand);
180 writeOperand(Operand);
185 void writeOperand(Value *Operand, bool Static = false);
186 void writeInstComputationInline(Instruction &I);
187 void writeOperandInternal(Value *Operand, bool Static = false);
188 void writeOperandWithCast(Value* Operand, unsigned Opcode);
189 void writeOperandWithCast(Value* Operand, const ICmpInst &I);
190 bool writeInstructionCast(const Instruction &I);
192 void writeMemoryAccess(Value *Operand, const Type *OperandType,
193 bool IsVolatile, unsigned Alignment);
196 std::string InterpretASMConstraint(InlineAsm::ConstraintInfo& c);
198 void lowerIntrinsics(Function &F);
200 void printModule(Module *M);
201 void printModuleTypes(const TypeSymbolTable &ST);
202 void printContainedStructs(const Type *Ty, std::set<const Type *> &);
203 void printFloatingPointConstants(Function &F);
204 void printFloatingPointConstants(const Constant *C);
205 void printFunctionSignature(const Function *F, bool Prototype);
207 void printFunction(Function &);
208 void printBasicBlock(BasicBlock *BB);
209 void printLoop(Loop *L);
211 void printCast(unsigned opcode, const Type *SrcTy, const Type *DstTy);
212 void printConstant(Constant *CPV, bool Static);
213 void printConstantWithCast(Constant *CPV, unsigned Opcode);
214 bool printConstExprCast(const ConstantExpr *CE, bool Static);
215 void printConstantArray(ConstantArray *CPA, bool Static);
216 void printConstantVector(ConstantVector *CV, bool Static);
218 /// isAddressExposed - Return true if the specified value's name needs to
219 /// have its address taken in order to get a C value of the correct type.
220 /// This happens for global variables, byval parameters, and direct allocas.
221 bool isAddressExposed(const Value *V) const {
222 if (const Argument *A = dyn_cast<Argument>(V))
223 return ByValParams.count(A);
224 return isa<GlobalVariable>(V) || isDirectAlloca(V);
227 // isInlinableInst - Attempt to inline instructions into their uses to build
228 // trees as much as possible. To do this, we have to consistently decide
229 // what is acceptable to inline, so that variable declarations don't get
230 // printed and an extra copy of the expr is not emitted.
232 static bool isInlinableInst(const Instruction &I) {
233 // Always inline cmp instructions, even if they are shared by multiple
234 // expressions. GCC generates horrible code if we don't.
238 // Must be an expression, must be used exactly once. If it is dead, we
239 // emit it inline where it would go.
240 if (I.getType() == Type::getVoidTy(I.getContext()) || !I.hasOneUse() ||
241 isa<TerminatorInst>(I) || isa<CallInst>(I) || isa<PHINode>(I) ||
242 isa<LoadInst>(I) || isa<VAArgInst>(I) || isa<InsertElementInst>(I) ||
243 isa<InsertValueInst>(I))
244 // Don't inline a load across a store or other bad things!
247 // Must not be used in inline asm, extractelement, or shufflevector.
249 const Instruction &User = cast<Instruction>(*I.use_back());
250 if (isInlineAsm(User) || isa<ExtractElementInst>(User) ||
251 isa<ShuffleVectorInst>(User))
255 // Only inline instruction it if it's use is in the same BB as the inst.
256 return I.getParent() == cast<Instruction>(I.use_back())->getParent();
259 // isDirectAlloca - Define fixed sized allocas in the entry block as direct
260 // variables which are accessed with the & operator. This causes GCC to
261 // generate significantly better code than to emit alloca calls directly.
263 static const AllocaInst *isDirectAlloca(const Value *V) {
264 const AllocaInst *AI = dyn_cast<AllocaInst>(V);
265 if (!AI) return false;
266 if (AI->isArrayAllocation())
267 return 0; // FIXME: we can also inline fixed size array allocas!
268 if (AI->getParent() != &AI->getParent()->getParent()->getEntryBlock())
273 // isInlineAsm - Check if the instruction is a call to an inline asm chunk
274 static bool isInlineAsm(const Instruction& I) {
275 if (isa<CallInst>(&I) && isa<InlineAsm>(I.getOperand(0)))
280 // Instruction visitation functions
281 friend class InstVisitor<CWriter>;
283 void visitReturnInst(ReturnInst &I);
284 void visitBranchInst(BranchInst &I);
285 void visitSwitchInst(SwitchInst &I);
286 void visitIndirectBrInst(IndirectBrInst &I);
287 void visitInvokeInst(InvokeInst &I) {
288 llvm_unreachable("Lowerinvoke pass didn't work!");
291 void visitUnwindInst(UnwindInst &I) {
292 llvm_unreachable("Lowerinvoke pass didn't work!");
294 void visitUnreachableInst(UnreachableInst &I);
296 void visitPHINode(PHINode &I);
297 void visitBinaryOperator(Instruction &I);
298 void visitICmpInst(ICmpInst &I);
299 void visitFCmpInst(FCmpInst &I);
301 void visitCastInst (CastInst &I);
302 void visitSelectInst(SelectInst &I);
303 void visitCallInst (CallInst &I);
304 void visitInlineAsm(CallInst &I);
305 bool visitBuiltinCall(CallInst &I, Intrinsic::ID ID, bool &WroteCallee);
307 void visitAllocaInst(AllocaInst &I);
308 void visitLoadInst (LoadInst &I);
309 void visitStoreInst (StoreInst &I);
310 void visitGetElementPtrInst(GetElementPtrInst &I);
311 void visitVAArgInst (VAArgInst &I);
313 void visitInsertElementInst(InsertElementInst &I);
314 void visitExtractElementInst(ExtractElementInst &I);
315 void visitShuffleVectorInst(ShuffleVectorInst &SVI);
317 void visitInsertValueInst(InsertValueInst &I);
318 void visitExtractValueInst(ExtractValueInst &I);
320 void visitInstruction(Instruction &I) {
322 errs() << "C Writer does not know about " << I;
327 void outputLValue(Instruction *I) {
328 Out << " " << GetValueName(I) << " = ";
331 bool isGotoCodeNecessary(BasicBlock *From, BasicBlock *To);
332 void printPHICopiesForSuccessor(BasicBlock *CurBlock,
333 BasicBlock *Successor, unsigned Indent);
334 void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
336 void printGEPExpression(Value *Ptr, gep_type_iterator I,
337 gep_type_iterator E, bool Static);
339 std::string GetValueName(const Value *Operand);
343 char CWriter::ID = 0;
346 static bool isAcceptableChar(char C) {
347 if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') &&
348 (C < '0' || C > '9') && C != '_' && C != '$' && C != '@')
353 static char HexDigit(int V) {
354 return V < 10 ? V+'0' : V+'A'-10;
357 static std::string Mangle(const std::string &S) {
360 for (unsigned i = 0, e = S.size(); i != e; ++i)
361 if (isAcceptableChar(S[i]))
365 Result += HexDigit((S[i] >> 4) & 15);
366 Result += HexDigit(S[i] & 15);
374 /// This method inserts names for any unnamed structure types that are used by
375 /// the program, and removes names from structure types that are not used by the
378 bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) {
379 // Get a set of types that are used by the program...
380 std::set<const Type *> UT = getAnalysis<FindUsedTypes>().getTypes();
382 // Loop over the module symbol table, removing types from UT that are
383 // already named, and removing names for types that are not used.
385 TypeSymbolTable &TST = M.getTypeSymbolTable();
386 for (TypeSymbolTable::iterator TI = TST.begin(), TE = TST.end();
388 TypeSymbolTable::iterator I = TI++;
390 // If this isn't a struct or array type, remove it from our set of types
391 // to name. This simplifies emission later.
392 if (!isa<StructType>(I->second) && !isa<OpaqueType>(I->second) &&
393 !isa<ArrayType>(I->second)) {
396 // If this is not used, remove it from the symbol table.
397 std::set<const Type *>::iterator UTI = UT.find(I->second);
401 UT.erase(UTI); // Only keep one name for this type.
405 // UT now contains types that are not named. Loop over it, naming
408 bool Changed = false;
409 unsigned RenameCounter = 0;
410 for (std::set<const Type *>::const_iterator I = UT.begin(), E = UT.end();
412 if (isa<StructType>(*I) || isa<ArrayType>(*I)) {
413 while (M.addTypeName("unnamed"+utostr(RenameCounter), *I))
419 // Loop over all external functions and globals. If we have two with
420 // identical names, merge them.
421 // FIXME: This code should disappear when we don't allow values with the same
422 // names when they have different types!
423 std::map<std::string, GlobalValue*> ExtSymbols;
424 for (Module::iterator I = M.begin(), E = M.end(); I != E;) {
426 if (GV->isDeclaration() && GV->hasName()) {
427 std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
428 = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
430 // Found a conflict, replace this global with the previous one.
431 GlobalValue *OldGV = X.first->second;
432 GV->replaceAllUsesWith(ConstantExpr::getBitCast(OldGV, GV->getType()));
433 GV->eraseFromParent();
438 // Do the same for globals.
439 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
441 GlobalVariable *GV = I++;
442 if (GV->isDeclaration() && GV->hasName()) {
443 std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
444 = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
446 // Found a conflict, replace this global with the previous one.
447 GlobalValue *OldGV = X.first->second;
448 GV->replaceAllUsesWith(ConstantExpr::getBitCast(OldGV, GV->getType()));
449 GV->eraseFromParent();
458 /// printStructReturnPointerFunctionType - This is like printType for a struct
459 /// return type, except, instead of printing the type as void (*)(Struct*, ...)
460 /// print it as "Struct (*)(...)", for struct return functions.
461 void CWriter::printStructReturnPointerFunctionType(formatted_raw_ostream &Out,
462 const AttrListPtr &PAL,
463 const PointerType *TheTy) {
464 const FunctionType *FTy = cast<FunctionType>(TheTy->getElementType());
465 std::stringstream FunctionInnards;
466 FunctionInnards << " (*) (";
467 bool PrintedType = false;
469 FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end();
470 const Type *RetTy = cast<PointerType>(I->get())->getElementType();
472 for (++I, ++Idx; I != E; ++I, ++Idx) {
474 FunctionInnards << ", ";
475 const Type *ArgTy = *I;
476 if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
477 assert(isa<PointerType>(ArgTy));
478 ArgTy = cast<PointerType>(ArgTy)->getElementType();
480 printType(FunctionInnards, ArgTy,
481 /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), "");
484 if (FTy->isVarArg()) {
486 FunctionInnards << ", ...";
487 } else if (!PrintedType) {
488 FunctionInnards << "void";
490 FunctionInnards << ')';
491 std::string tstr = FunctionInnards.str();
492 printType(Out, RetTy,
493 /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), tstr);
497 CWriter::printSimpleType(formatted_raw_ostream &Out, const Type *Ty,
499 const std::string &NameSoFar) {
500 assert((Ty->isPrimitiveType() || Ty->isInteger() || isa<VectorType>(Ty)) &&
501 "Invalid type for printSimpleType");
502 switch (Ty->getTypeID()) {
503 case Type::VoidTyID: return Out << "void " << NameSoFar;
504 case Type::IntegerTyID: {
505 unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
507 return Out << "bool " << NameSoFar;
508 else if (NumBits <= 8)
509 return Out << (isSigned?"signed":"unsigned") << " char " << NameSoFar;
510 else if (NumBits <= 16)
511 return Out << (isSigned?"signed":"unsigned") << " short " << NameSoFar;
512 else if (NumBits <= 32)
513 return Out << (isSigned?"signed":"unsigned") << " int " << NameSoFar;
514 else if (NumBits <= 64)
515 return Out << (isSigned?"signed":"unsigned") << " long long "<< NameSoFar;
517 assert(NumBits <= 128 && "Bit widths > 128 not implemented yet");
518 return Out << (isSigned?"llvmInt128":"llvmUInt128") << " " << NameSoFar;
521 case Type::FloatTyID: return Out << "float " << NameSoFar;
522 case Type::DoubleTyID: return Out << "double " << NameSoFar;
523 // Lacking emulation of FP80 on PPC, etc., we assume whichever of these is
524 // present matches host 'long double'.
525 case Type::X86_FP80TyID:
526 case Type::PPC_FP128TyID:
527 case Type::FP128TyID: return Out << "long double " << NameSoFar;
529 case Type::VectorTyID: {
530 const VectorType *VTy = cast<VectorType>(Ty);
531 return printSimpleType(Out, VTy->getElementType(), isSigned,
532 " __attribute__((vector_size(" +
533 utostr(TD->getTypeAllocSize(VTy)) + " ))) " + NameSoFar);
538 errs() << "Unknown primitive type: " << *Ty << "\n";
545 CWriter::printSimpleType(std::ostream &Out, const Type *Ty, bool isSigned,
546 const std::string &NameSoFar) {
547 assert((Ty->isPrimitiveType() || Ty->isInteger() || isa<VectorType>(Ty)) &&
548 "Invalid type for printSimpleType");
549 switch (Ty->getTypeID()) {
550 case Type::VoidTyID: return Out << "void " << NameSoFar;
551 case Type::IntegerTyID: {
552 unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
554 return Out << "bool " << NameSoFar;
555 else if (NumBits <= 8)
556 return Out << (isSigned?"signed":"unsigned") << " char " << NameSoFar;
557 else if (NumBits <= 16)
558 return Out << (isSigned?"signed":"unsigned") << " short " << NameSoFar;
559 else if (NumBits <= 32)
560 return Out << (isSigned?"signed":"unsigned") << " int " << NameSoFar;
561 else if (NumBits <= 64)
562 return Out << (isSigned?"signed":"unsigned") << " long long "<< NameSoFar;
564 assert(NumBits <= 128 && "Bit widths > 128 not implemented yet");
565 return Out << (isSigned?"llvmInt128":"llvmUInt128") << " " << NameSoFar;
568 case Type::FloatTyID: return Out << "float " << NameSoFar;
569 case Type::DoubleTyID: return Out << "double " << NameSoFar;
570 // Lacking emulation of FP80 on PPC, etc., we assume whichever of these is
571 // present matches host 'long double'.
572 case Type::X86_FP80TyID:
573 case Type::PPC_FP128TyID:
574 case Type::FP128TyID: return Out << "long double " << NameSoFar;
576 case Type::VectorTyID: {
577 const VectorType *VTy = cast<VectorType>(Ty);
578 return printSimpleType(Out, VTy->getElementType(), isSigned,
579 " __attribute__((vector_size(" +
580 utostr(TD->getTypeAllocSize(VTy)) + " ))) " + NameSoFar);
585 errs() << "Unknown primitive type: " << *Ty << "\n";
591 // Pass the Type* and the variable name and this prints out the variable
594 raw_ostream &CWriter::printType(formatted_raw_ostream &Out,
596 bool isSigned, const std::string &NameSoFar,
597 bool IgnoreName, const AttrListPtr &PAL) {
598 if (Ty->isPrimitiveType() || Ty->isInteger() || isa<VectorType>(Ty)) {
599 printSimpleType(Out, Ty, isSigned, NameSoFar);
603 // Check to see if the type is named.
604 if (!IgnoreName || isa<OpaqueType>(Ty)) {
605 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
606 if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar;
609 switch (Ty->getTypeID()) {
610 case Type::FunctionTyID: {
611 const FunctionType *FTy = cast<FunctionType>(Ty);
612 std::stringstream FunctionInnards;
613 FunctionInnards << " (" << NameSoFar << ") (";
615 for (FunctionType::param_iterator I = FTy->param_begin(),
616 E = FTy->param_end(); I != E; ++I) {
617 const Type *ArgTy = *I;
618 if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
619 assert(isa<PointerType>(ArgTy));
620 ArgTy = cast<PointerType>(ArgTy)->getElementType();
622 if (I != FTy->param_begin())
623 FunctionInnards << ", ";
624 printType(FunctionInnards, ArgTy,
625 /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), "");
628 if (FTy->isVarArg()) {
629 if (FTy->getNumParams())
630 FunctionInnards << ", ...";
631 } else if (!FTy->getNumParams()) {
632 FunctionInnards << "void";
634 FunctionInnards << ')';
635 std::string tstr = FunctionInnards.str();
636 printType(Out, FTy->getReturnType(),
637 /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), tstr);
640 case Type::StructTyID: {
641 const StructType *STy = cast<StructType>(Ty);
642 Out << NameSoFar + " {\n";
644 for (StructType::element_iterator I = STy->element_begin(),
645 E = STy->element_end(); I != E; ++I) {
647 printType(Out, *I, false, "field" + utostr(Idx++));
652 Out << " __attribute__ ((packed))";
656 case Type::PointerTyID: {
657 const PointerType *PTy = cast<PointerType>(Ty);
658 std::string ptrName = "*" + NameSoFar;
660 if (isa<ArrayType>(PTy->getElementType()) ||
661 isa<VectorType>(PTy->getElementType()))
662 ptrName = "(" + ptrName + ")";
665 // Must be a function ptr cast!
666 return printType(Out, PTy->getElementType(), false, ptrName, true, PAL);
667 return printType(Out, PTy->getElementType(), false, ptrName);
670 case Type::ArrayTyID: {
671 const ArrayType *ATy = cast<ArrayType>(Ty);
672 unsigned NumElements = ATy->getNumElements();
673 if (NumElements == 0) NumElements = 1;
674 // Arrays are wrapped in structs to allow them to have normal
675 // value semantics (avoiding the array "decay").
676 Out << NameSoFar << " { ";
677 printType(Out, ATy->getElementType(), false,
678 "array[" + utostr(NumElements) + "]");
682 case Type::OpaqueTyID: {
683 std::string TyName = "struct opaque_" + itostr(OpaqueCounter++);
684 assert(TypeNames.find(Ty) == TypeNames.end());
685 TypeNames[Ty] = TyName;
686 return Out << TyName << ' ' << NameSoFar;
689 llvm_unreachable("Unhandled case in getTypeProps!");
695 // Pass the Type* and the variable name and this prints out the variable
698 std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty,
699 bool isSigned, const std::string &NameSoFar,
700 bool IgnoreName, const AttrListPtr &PAL) {
701 if (Ty->isPrimitiveType() || Ty->isInteger() || isa<VectorType>(Ty)) {
702 printSimpleType(Out, Ty, isSigned, NameSoFar);
706 // Check to see if the type is named.
707 if (!IgnoreName || isa<OpaqueType>(Ty)) {
708 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
709 if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar;
712 switch (Ty->getTypeID()) {
713 case Type::FunctionTyID: {
714 const FunctionType *FTy = cast<FunctionType>(Ty);
715 std::stringstream FunctionInnards;
716 FunctionInnards << " (" << NameSoFar << ") (";
718 for (FunctionType::param_iterator I = FTy->param_begin(),
719 E = FTy->param_end(); I != E; ++I) {
720 const Type *ArgTy = *I;
721 if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
722 assert(isa<PointerType>(ArgTy));
723 ArgTy = cast<PointerType>(ArgTy)->getElementType();
725 if (I != FTy->param_begin())
726 FunctionInnards << ", ";
727 printType(FunctionInnards, ArgTy,
728 /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), "");
731 if (FTy->isVarArg()) {
732 if (FTy->getNumParams())
733 FunctionInnards << ", ...";
734 } else if (!FTy->getNumParams()) {
735 FunctionInnards << "void";
737 FunctionInnards << ')';
738 std::string tstr = FunctionInnards.str();
739 printType(Out, FTy->getReturnType(),
740 /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), tstr);
743 case Type::StructTyID: {
744 const StructType *STy = cast<StructType>(Ty);
745 Out << NameSoFar + " {\n";
747 for (StructType::element_iterator I = STy->element_begin(),
748 E = STy->element_end(); I != E; ++I) {
750 printType(Out, *I, false, "field" + utostr(Idx++));
755 Out << " __attribute__ ((packed))";
759 case Type::PointerTyID: {
760 const PointerType *PTy = cast<PointerType>(Ty);
761 std::string ptrName = "*" + NameSoFar;
763 if (isa<ArrayType>(PTy->getElementType()) ||
764 isa<VectorType>(PTy->getElementType()))
765 ptrName = "(" + ptrName + ")";
768 // Must be a function ptr cast!
769 return printType(Out, PTy->getElementType(), false, ptrName, true, PAL);
770 return printType(Out, PTy->getElementType(), false, ptrName);
773 case Type::ArrayTyID: {
774 const ArrayType *ATy = cast<ArrayType>(Ty);
775 unsigned NumElements = ATy->getNumElements();
776 if (NumElements == 0) NumElements = 1;
777 // Arrays are wrapped in structs to allow them to have normal
778 // value semantics (avoiding the array "decay").
779 Out << NameSoFar << " { ";
780 printType(Out, ATy->getElementType(), false,
781 "array[" + utostr(NumElements) + "]");
785 case Type::OpaqueTyID: {
786 std::string TyName = "struct opaque_" + itostr(OpaqueCounter++);
787 assert(TypeNames.find(Ty) == TypeNames.end());
788 TypeNames[Ty] = TyName;
789 return Out << TyName << ' ' << NameSoFar;
792 llvm_unreachable("Unhandled case in getTypeProps!");
798 void CWriter::printConstantArray(ConstantArray *CPA, bool Static) {
800 // As a special case, print the array as a string if it is an array of
801 // ubytes or an array of sbytes with positive values.
803 const Type *ETy = CPA->getType()->getElementType();
804 bool isString = (ETy == Type::getInt8Ty(CPA->getContext()) ||
805 ETy == Type::getInt8Ty(CPA->getContext()));
807 // Make sure the last character is a null char, as automatically added by C
808 if (isString && (CPA->getNumOperands() == 0 ||
809 !cast<Constant>(*(CPA->op_end()-1))->isNullValue()))
814 // Keep track of whether the last number was a hexadecimal escape
815 bool LastWasHex = false;
817 // Do not include the last character, which we know is null
818 for (unsigned i = 0, e = CPA->getNumOperands()-1; i != e; ++i) {
819 unsigned char C = cast<ConstantInt>(CPA->getOperand(i))->getZExtValue();
821 // Print it out literally if it is a printable character. The only thing
822 // to be careful about is when the last letter output was a hex escape
823 // code, in which case we have to be careful not to print out hex digits
824 // explicitly (the C compiler thinks it is a continuation of the previous
825 // character, sheesh...)
827 if (isprint(C) && (!LastWasHex || !isxdigit(C))) {
829 if (C == '"' || C == '\\')
830 Out << "\\" << (char)C;
836 case '\n': Out << "\\n"; break;
837 case '\t': Out << "\\t"; break;
838 case '\r': Out << "\\r"; break;
839 case '\v': Out << "\\v"; break;
840 case '\a': Out << "\\a"; break;
841 case '\"': Out << "\\\""; break;
842 case '\'': Out << "\\\'"; break;
845 Out << (char)(( C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'));
846 Out << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
855 if (CPA->getNumOperands()) {
857 printConstant(cast<Constant>(CPA->getOperand(0)), Static);
858 for (unsigned i = 1, e = CPA->getNumOperands(); i != e; ++i) {
860 printConstant(cast<Constant>(CPA->getOperand(i)), Static);
867 void CWriter::printConstantVector(ConstantVector *CP, bool Static) {
869 if (CP->getNumOperands()) {
871 printConstant(cast<Constant>(CP->getOperand(0)), Static);
872 for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
874 printConstant(cast<Constant>(CP->getOperand(i)), Static);
880 // isFPCSafeToPrint - Returns true if we may assume that CFP may be written out
881 // textually as a double (rather than as a reference to a stack-allocated
882 // variable). We decide this by converting CFP to a string and back into a
883 // double, and then checking whether the conversion results in a bit-equal
884 // double to the original value of CFP. This depends on us and the target C
885 // compiler agreeing on the conversion process (which is pretty likely since we
886 // only deal in IEEE FP).
888 static bool isFPCSafeToPrint(const ConstantFP *CFP) {
890 // Do long doubles in hex for now.
891 if (CFP->getType() != Type::getFloatTy(CFP->getContext()) &&
892 CFP->getType() != Type::getDoubleTy(CFP->getContext()))
894 APFloat APF = APFloat(CFP->getValueAPF()); // copy
895 if (CFP->getType() == Type::getFloatTy(CFP->getContext()))
896 APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &ignored);
897 #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
899 sprintf(Buffer, "%a", APF.convertToDouble());
900 if (!strncmp(Buffer, "0x", 2) ||
901 !strncmp(Buffer, "-0x", 3) ||
902 !strncmp(Buffer, "+0x", 3))
903 return APF.bitwiseIsEqual(APFloat(atof(Buffer)));
906 std::string StrVal = ftostr(APF);
908 while (StrVal[0] == ' ')
909 StrVal.erase(StrVal.begin());
911 // Check to make sure that the stringized number is not some string like "Inf"
912 // or NaN. Check that the string matches the "[-+]?[0-9]" regex.
913 if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
914 ((StrVal[0] == '-' || StrVal[0] == '+') &&
915 (StrVal[1] >= '0' && StrVal[1] <= '9')))
916 // Reparse stringized version!
917 return APF.bitwiseIsEqual(APFloat(atof(StrVal.c_str())));
922 /// Print out the casting for a cast operation. This does the double casting
923 /// necessary for conversion to the destination type, if necessary.
924 /// @brief Print a cast
925 void CWriter::printCast(unsigned opc, const Type *SrcTy, const Type *DstTy) {
926 // Print the destination type cast
928 case Instruction::UIToFP:
929 case Instruction::SIToFP:
930 case Instruction::IntToPtr:
931 case Instruction::Trunc:
932 case Instruction::BitCast:
933 case Instruction::FPExt:
934 case Instruction::FPTrunc: // For these the DstTy sign doesn't matter
936 printType(Out, DstTy);
939 case Instruction::ZExt:
940 case Instruction::PtrToInt:
941 case Instruction::FPToUI: // For these, make sure we get an unsigned dest
943 printSimpleType(Out, DstTy, false);
946 case Instruction::SExt:
947 case Instruction::FPToSI: // For these, make sure we get a signed dest
949 printSimpleType(Out, DstTy, true);
953 llvm_unreachable("Invalid cast opcode");
956 // Print the source type cast
958 case Instruction::UIToFP:
959 case Instruction::ZExt:
961 printSimpleType(Out, SrcTy, false);
964 case Instruction::SIToFP:
965 case Instruction::SExt:
967 printSimpleType(Out, SrcTy, true);
970 case Instruction::IntToPtr:
971 case Instruction::PtrToInt:
972 // Avoid "cast to pointer from integer of different size" warnings
973 Out << "(unsigned long)";
975 case Instruction::Trunc:
976 case Instruction::BitCast:
977 case Instruction::FPExt:
978 case Instruction::FPTrunc:
979 case Instruction::FPToSI:
980 case Instruction::FPToUI:
981 break; // These don't need a source cast.
983 llvm_unreachable("Invalid cast opcode");
988 // printConstant - The LLVM Constant to C Constant converter.
989 void CWriter::printConstant(Constant *CPV, bool Static) {
990 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
991 switch (CE->getOpcode()) {
992 case Instruction::Trunc:
993 case Instruction::ZExt:
994 case Instruction::SExt:
995 case Instruction::FPTrunc:
996 case Instruction::FPExt:
997 case Instruction::UIToFP:
998 case Instruction::SIToFP:
999 case Instruction::FPToUI:
1000 case Instruction::FPToSI:
1001 case Instruction::PtrToInt:
1002 case Instruction::IntToPtr:
1003 case Instruction::BitCast:
1005 printCast(CE->getOpcode(), CE->getOperand(0)->getType(), CE->getType());
1006 if (CE->getOpcode() == Instruction::SExt &&
1007 CE->getOperand(0)->getType() == Type::getInt1Ty(CPV->getContext())) {
1008 // Make sure we really sext from bool here by subtracting from 0
1011 printConstant(CE->getOperand(0), Static);
1012 if (CE->getType() == Type::getInt1Ty(CPV->getContext()) &&
1013 (CE->getOpcode() == Instruction::Trunc ||
1014 CE->getOpcode() == Instruction::FPToUI ||
1015 CE->getOpcode() == Instruction::FPToSI ||
1016 CE->getOpcode() == Instruction::PtrToInt)) {
1017 // Make sure we really truncate to bool here by anding with 1
1023 case Instruction::GetElementPtr:
1025 printGEPExpression(CE->getOperand(0), gep_type_begin(CPV),
1026 gep_type_end(CPV), Static);
1029 case Instruction::Select:
1031 printConstant(CE->getOperand(0), Static);
1033 printConstant(CE->getOperand(1), Static);
1035 printConstant(CE->getOperand(2), Static);
1038 case Instruction::Add:
1039 case Instruction::FAdd:
1040 case Instruction::Sub:
1041 case Instruction::FSub:
1042 case Instruction::Mul:
1043 case Instruction::FMul:
1044 case Instruction::SDiv:
1045 case Instruction::UDiv:
1046 case Instruction::FDiv:
1047 case Instruction::URem:
1048 case Instruction::SRem:
1049 case Instruction::FRem:
1050 case Instruction::And:
1051 case Instruction::Or:
1052 case Instruction::Xor:
1053 case Instruction::ICmp:
1054 case Instruction::Shl:
1055 case Instruction::LShr:
1056 case Instruction::AShr:
1059 bool NeedsClosingParens = printConstExprCast(CE, Static);
1060 printConstantWithCast(CE->getOperand(0), CE->getOpcode());
1061 switch (CE->getOpcode()) {
1062 case Instruction::Add:
1063 case Instruction::FAdd: Out << " + "; break;
1064 case Instruction::Sub:
1065 case Instruction::FSub: Out << " - "; break;
1066 case Instruction::Mul:
1067 case Instruction::FMul: Out << " * "; break;
1068 case Instruction::URem:
1069 case Instruction::SRem:
1070 case Instruction::FRem: Out << " % "; break;
1071 case Instruction::UDiv:
1072 case Instruction::SDiv:
1073 case Instruction::FDiv: Out << " / "; break;
1074 case Instruction::And: Out << " & "; break;
1075 case Instruction::Or: Out << " | "; break;
1076 case Instruction::Xor: Out << " ^ "; break;
1077 case Instruction::Shl: Out << " << "; break;
1078 case Instruction::LShr:
1079 case Instruction::AShr: Out << " >> "; break;
1080 case Instruction::ICmp:
1081 switch (CE->getPredicate()) {
1082 case ICmpInst::ICMP_EQ: Out << " == "; break;
1083 case ICmpInst::ICMP_NE: Out << " != "; break;
1084 case ICmpInst::ICMP_SLT:
1085 case ICmpInst::ICMP_ULT: Out << " < "; break;
1086 case ICmpInst::ICMP_SLE:
1087 case ICmpInst::ICMP_ULE: Out << " <= "; break;
1088 case ICmpInst::ICMP_SGT:
1089 case ICmpInst::ICMP_UGT: Out << " > "; break;
1090 case ICmpInst::ICMP_SGE:
1091 case ICmpInst::ICMP_UGE: Out << " >= "; break;
1092 default: llvm_unreachable("Illegal ICmp predicate");
1095 default: llvm_unreachable("Illegal opcode here!");
1097 printConstantWithCast(CE->getOperand(1), CE->getOpcode());
1098 if (NeedsClosingParens)
1103 case Instruction::FCmp: {
1105 bool NeedsClosingParens = printConstExprCast(CE, Static);
1106 if (CE->getPredicate() == FCmpInst::FCMP_FALSE)
1108 else if (CE->getPredicate() == FCmpInst::FCMP_TRUE)
1112 switch (CE->getPredicate()) {
1113 default: llvm_unreachable("Illegal FCmp predicate");
1114 case FCmpInst::FCMP_ORD: op = "ord"; break;
1115 case FCmpInst::FCMP_UNO: op = "uno"; break;
1116 case FCmpInst::FCMP_UEQ: op = "ueq"; break;
1117 case FCmpInst::FCMP_UNE: op = "une"; break;
1118 case FCmpInst::FCMP_ULT: op = "ult"; break;
1119 case FCmpInst::FCMP_ULE: op = "ule"; break;
1120 case FCmpInst::FCMP_UGT: op = "ugt"; break;
1121 case FCmpInst::FCMP_UGE: op = "uge"; break;
1122 case FCmpInst::FCMP_OEQ: op = "oeq"; break;
1123 case FCmpInst::FCMP_ONE: op = "one"; break;
1124 case FCmpInst::FCMP_OLT: op = "olt"; break;
1125 case FCmpInst::FCMP_OLE: op = "ole"; break;
1126 case FCmpInst::FCMP_OGT: op = "ogt"; break;
1127 case FCmpInst::FCMP_OGE: op = "oge"; break;
1129 Out << "llvm_fcmp_" << op << "(";
1130 printConstantWithCast(CE->getOperand(0), CE->getOpcode());
1132 printConstantWithCast(CE->getOperand(1), CE->getOpcode());
1135 if (NeedsClosingParens)
1142 errs() << "CWriter Error: Unhandled constant expression: "
1145 llvm_unreachable(0);
1147 } else if (isa<UndefValue>(CPV) && CPV->getType()->isSingleValueType()) {
1149 printType(Out, CPV->getType()); // sign doesn't matter
1150 Out << ")/*UNDEF*/";
1151 if (!isa<VectorType>(CPV->getType())) {
1159 if (ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
1160 const Type* Ty = CI->getType();
1161 if (Ty == Type::getInt1Ty(CPV->getContext()))
1162 Out << (CI->getZExtValue() ? '1' : '0');
1163 else if (Ty == Type::getInt32Ty(CPV->getContext()))
1164 Out << CI->getZExtValue() << 'u';
1165 else if (Ty->getPrimitiveSizeInBits() > 32)
1166 Out << CI->getZExtValue() << "ull";
1169 printSimpleType(Out, Ty, false) << ')';
1170 if (CI->isMinValue(true))
1171 Out << CI->getZExtValue() << 'u';
1173 Out << CI->getSExtValue();
1179 switch (CPV->getType()->getTypeID()) {
1180 case Type::FloatTyID:
1181 case Type::DoubleTyID:
1182 case Type::X86_FP80TyID:
1183 case Type::PPC_FP128TyID:
1184 case Type::FP128TyID: {
1185 ConstantFP *FPC = cast<ConstantFP>(CPV);
1186 std::map<const ConstantFP*, unsigned>::iterator I = FPConstantMap.find(FPC);
1187 if (I != FPConstantMap.end()) {
1188 // Because of FP precision problems we must load from a stack allocated
1189 // value that holds the value in hex.
1190 Out << "(*(" << (FPC->getType() == Type::getFloatTy(CPV->getContext()) ?
1192 FPC->getType() == Type::getDoubleTy(CPV->getContext()) ?
1195 << "*)&FPConstant" << I->second << ')';
1198 if (FPC->getType() == Type::getFloatTy(CPV->getContext()))
1199 V = FPC->getValueAPF().convertToFloat();
1200 else if (FPC->getType() == Type::getDoubleTy(CPV->getContext()))
1201 V = FPC->getValueAPF().convertToDouble();
1203 // Long double. Convert the number to double, discarding precision.
1204 // This is not awesome, but it at least makes the CBE output somewhat
1206 APFloat Tmp = FPC->getValueAPF();
1208 Tmp.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &LosesInfo);
1209 V = Tmp.convertToDouble();
1215 // FIXME the actual NaN bits should be emitted.
1216 // The prefix for a quiet NaN is 0x7FF8. For a signalling NaN,
1218 const unsigned long QuietNaN = 0x7ff8UL;
1219 //const unsigned long SignalNaN = 0x7ff4UL;
1221 // We need to grab the first part of the FP #
1224 uint64_t ll = DoubleToBits(V);
1225 sprintf(Buffer, "0x%llx", static_cast<long long>(ll));
1227 std::string Num(&Buffer[0], &Buffer[6]);
1228 unsigned long Val = strtoul(Num.c_str(), 0, 16);
1230 if (FPC->getType() == Type::getFloatTy(FPC->getContext()))
1231 Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "F(\""
1232 << Buffer << "\") /*nan*/ ";
1234 Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "(\""
1235 << Buffer << "\") /*nan*/ ";
1236 } else if (IsInf(V)) {
1238 if (V < 0) Out << '-';
1239 Out << "LLVM_INF" <<
1240 (FPC->getType() == Type::getFloatTy(FPC->getContext()) ? "F" : "")
1244 #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
1245 // Print out the constant as a floating point number.
1247 sprintf(Buffer, "%a", V);
1250 Num = ftostr(FPC->getValueAPF());
1258 case Type::ArrayTyID:
1259 // Use C99 compound expression literal initializer syntax.
1262 printType(Out, CPV->getType());
1265 Out << "{ "; // Arrays are wrapped in struct types.
1266 if (ConstantArray *CA = dyn_cast<ConstantArray>(CPV)) {
1267 printConstantArray(CA, Static);
1269 assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV));
1270 const ArrayType *AT = cast<ArrayType>(CPV->getType());
1272 if (AT->getNumElements()) {
1274 Constant *CZ = Constant::getNullValue(AT->getElementType());
1275 printConstant(CZ, Static);
1276 for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
1278 printConstant(CZ, Static);
1283 Out << " }"; // Arrays are wrapped in struct types.
1286 case Type::VectorTyID:
1287 // Use C99 compound expression literal initializer syntax.
1290 printType(Out, CPV->getType());
1293 if (ConstantVector *CV = dyn_cast<ConstantVector>(CPV)) {
1294 printConstantVector(CV, Static);
1296 assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV));
1297 const VectorType *VT = cast<VectorType>(CPV->getType());
1299 Constant *CZ = Constant::getNullValue(VT->getElementType());
1300 printConstant(CZ, Static);
1301 for (unsigned i = 1, e = VT->getNumElements(); i != e; ++i) {
1303 printConstant(CZ, Static);
1309 case Type::StructTyID:
1310 // Use C99 compound expression literal initializer syntax.
1313 printType(Out, CPV->getType());
1316 if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
1317 const StructType *ST = cast<StructType>(CPV->getType());
1319 if (ST->getNumElements()) {
1321 printConstant(Constant::getNullValue(ST->getElementType(0)), Static);
1322 for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) {
1324 printConstant(Constant::getNullValue(ST->getElementType(i)), Static);
1330 if (CPV->getNumOperands()) {
1332 printConstant(cast<Constant>(CPV->getOperand(0)), Static);
1333 for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) {
1335 printConstant(cast<Constant>(CPV->getOperand(i)), Static);
1342 case Type::PointerTyID:
1343 if (isa<ConstantPointerNull>(CPV)) {
1345 printType(Out, CPV->getType()); // sign doesn't matter
1346 Out << ")/*NULL*/0)";
1348 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(CPV)) {
1349 writeOperand(GV, Static);
1355 errs() << "Unknown constant type: " << *CPV << "\n";
1357 llvm_unreachable(0);
1361 // Some constant expressions need to be casted back to the original types
1362 // because their operands were casted to the expected type. This function takes
1363 // care of detecting that case and printing the cast for the ConstantExpr.
1364 bool CWriter::printConstExprCast(const ConstantExpr* CE, bool Static) {
1365 bool NeedsExplicitCast = false;
1366 const Type *Ty = CE->getOperand(0)->getType();
1367 bool TypeIsSigned = false;
1368 switch (CE->getOpcode()) {
1369 case Instruction::Add:
1370 case Instruction::Sub:
1371 case Instruction::Mul:
1372 // We need to cast integer arithmetic so that it is always performed
1373 // as unsigned, to avoid undefined behavior on overflow.
1374 case Instruction::LShr:
1375 case Instruction::URem:
1376 case Instruction::UDiv: NeedsExplicitCast = true; break;
1377 case Instruction::AShr:
1378 case Instruction::SRem:
1379 case Instruction::SDiv: NeedsExplicitCast = true; TypeIsSigned = true; break;
1380 case Instruction::SExt:
1382 NeedsExplicitCast = true;
1383 TypeIsSigned = true;
1385 case Instruction::ZExt:
1386 case Instruction::Trunc:
1387 case Instruction::FPTrunc:
1388 case Instruction::FPExt:
1389 case Instruction::UIToFP:
1390 case Instruction::SIToFP:
1391 case Instruction::FPToUI:
1392 case Instruction::FPToSI:
1393 case Instruction::PtrToInt:
1394 case Instruction::IntToPtr:
1395 case Instruction::BitCast:
1397 NeedsExplicitCast = true;
1401 if (NeedsExplicitCast) {
1403 if (Ty->isInteger() && Ty != Type::getInt1Ty(Ty->getContext()))
1404 printSimpleType(Out, Ty, TypeIsSigned);
1406 printType(Out, Ty); // not integer, sign doesn't matter
1409 return NeedsExplicitCast;
1412 // Print a constant assuming that it is the operand for a given Opcode. The
1413 // opcodes that care about sign need to cast their operands to the expected
1414 // type before the operation proceeds. This function does the casting.
1415 void CWriter::printConstantWithCast(Constant* CPV, unsigned Opcode) {
1417 // Extract the operand's type, we'll need it.
1418 const Type* OpTy = CPV->getType();
1420 // Indicate whether to do the cast or not.
1421 bool shouldCast = false;
1422 bool typeIsSigned = false;
1424 // Based on the Opcode for which this Constant is being written, determine
1425 // the new type to which the operand should be casted by setting the value
1426 // of OpTy. If we change OpTy, also set shouldCast to true so it gets
1430 // for most instructions, it doesn't matter
1432 case Instruction::Add:
1433 case Instruction::Sub:
1434 case Instruction::Mul:
1435 // We need to cast integer arithmetic so that it is always performed
1436 // as unsigned, to avoid undefined behavior on overflow.
1437 case Instruction::LShr:
1438 case Instruction::UDiv:
1439 case Instruction::URem:
1442 case Instruction::AShr:
1443 case Instruction::SDiv:
1444 case Instruction::SRem:
1446 typeIsSigned = true;
1450 // Write out the casted constant if we should, otherwise just write the
1454 printSimpleType(Out, OpTy, typeIsSigned);
1456 printConstant(CPV, false);
1459 printConstant(CPV, false);
1462 std::string CWriter::GetValueName(const Value *Operand) {
1463 // Mangle globals with the standard mangler interface for LLC compatibility.
1464 if (const GlobalValue *GV = dyn_cast<GlobalValue>(Operand)) {
1465 SmallString<128> Str;
1466 Mang->getNameWithPrefix(Str, GV, false);
1467 return Mangle(Str.str().str());
1470 std::string Name = Operand->getName();
1472 if (Name.empty()) { // Assign unique names to local temporaries.
1473 unsigned &No = AnonValueNumbers[Operand];
1475 No = ++NextAnonValueNumber;
1476 Name = "tmp__" + utostr(No);
1479 std::string VarName;
1480 VarName.reserve(Name.capacity());
1482 for (std::string::iterator I = Name.begin(), E = Name.end();
1486 if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
1487 (ch >= '0' && ch <= '9') || ch == '_')) {
1489 sprintf(buffer, "_%x_", ch);
1495 return "llvm_cbe_" + VarName;
1498 /// writeInstComputationInline - Emit the computation for the specified
1499 /// instruction inline, with no destination provided.
1500 void CWriter::writeInstComputationInline(Instruction &I) {
1501 // We can't currently support integer types other than 1, 8, 16, 32, 64.
1503 const Type *Ty = I.getType();
1504 if (Ty->isInteger() && (Ty!=Type::getInt1Ty(I.getContext()) &&
1505 Ty!=Type::getInt8Ty(I.getContext()) &&
1506 Ty!=Type::getInt16Ty(I.getContext()) &&
1507 Ty!=Type::getInt32Ty(I.getContext()) &&
1508 Ty!=Type::getInt64Ty(I.getContext()))) {
1509 llvm_report_error("The C backend does not currently support integer "
1510 "types of widths other than 1, 8, 16, 32, 64.\n"
1511 "This is being tracked as PR 4158.");
1514 // If this is a non-trivial bool computation, make sure to truncate down to
1515 // a 1 bit value. This is important because we want "add i1 x, y" to return
1516 // "0" when x and y are true, not "2" for example.
1517 bool NeedBoolTrunc = false;
1518 if (I.getType() == Type::getInt1Ty(I.getContext()) &&
1519 !isa<ICmpInst>(I) && !isa<FCmpInst>(I))
1520 NeedBoolTrunc = true;
1532 void CWriter::writeOperandInternal(Value *Operand, bool Static) {
1533 if (Instruction *I = dyn_cast<Instruction>(Operand))
1534 // Should we inline this instruction to build a tree?
1535 if (isInlinableInst(*I) && !isDirectAlloca(I)) {
1537 writeInstComputationInline(*I);
1542 Constant* CPV = dyn_cast<Constant>(Operand);
1544 if (CPV && !isa<GlobalValue>(CPV))
1545 printConstant(CPV, Static);
1547 Out << GetValueName(Operand);
1550 void CWriter::writeOperand(Value *Operand, bool Static) {
1551 bool isAddressImplicit = isAddressExposed(Operand);
1552 if (isAddressImplicit)
1553 Out << "(&"; // Global variables are referenced as their addresses by llvm
1555 writeOperandInternal(Operand, Static);
1557 if (isAddressImplicit)
1561 // Some instructions need to have their result value casted back to the
1562 // original types because their operands were casted to the expected type.
1563 // This function takes care of detecting that case and printing the cast
1564 // for the Instruction.
1565 bool CWriter::writeInstructionCast(const Instruction &I) {
1566 const Type *Ty = I.getOperand(0)->getType();
1567 switch (I.getOpcode()) {
1568 case Instruction::Add:
1569 case Instruction::Sub:
1570 case Instruction::Mul:
1571 // We need to cast integer arithmetic so that it is always performed
1572 // as unsigned, to avoid undefined behavior on overflow.
1573 case Instruction::LShr:
1574 case Instruction::URem:
1575 case Instruction::UDiv:
1577 printSimpleType(Out, Ty, false);
1580 case Instruction::AShr:
1581 case Instruction::SRem:
1582 case Instruction::SDiv:
1584 printSimpleType(Out, Ty, true);
1592 // Write the operand with a cast to another type based on the Opcode being used.
1593 // This will be used in cases where an instruction has specific type
1594 // requirements (usually signedness) for its operands.
1595 void CWriter::writeOperandWithCast(Value* Operand, unsigned Opcode) {
1597 // Extract the operand's type, we'll need it.
1598 const Type* OpTy = Operand->getType();
1600 // Indicate whether to do the cast or not.
1601 bool shouldCast = false;
1603 // Indicate whether the cast should be to a signed type or not.
1604 bool castIsSigned = false;
1606 // Based on the Opcode for which this Operand is being written, determine
1607 // the new type to which the operand should be casted by setting the value
1608 // of OpTy. If we change OpTy, also set shouldCast to true.
1611 // for most instructions, it doesn't matter
1613 case Instruction::Add:
1614 case Instruction::Sub:
1615 case Instruction::Mul:
1616 // We need to cast integer arithmetic so that it is always performed
1617 // as unsigned, to avoid undefined behavior on overflow.
1618 case Instruction::LShr:
1619 case Instruction::UDiv:
1620 case Instruction::URem: // Cast to unsigned first
1622 castIsSigned = false;
1624 case Instruction::GetElementPtr:
1625 case Instruction::AShr:
1626 case Instruction::SDiv:
1627 case Instruction::SRem: // Cast to signed first
1629 castIsSigned = true;
1633 // Write out the casted operand if we should, otherwise just write the
1637 printSimpleType(Out, OpTy, castIsSigned);
1639 writeOperand(Operand);
1642 writeOperand(Operand);
1645 // Write the operand with a cast to another type based on the icmp predicate
1647 void CWriter::writeOperandWithCast(Value* Operand, const ICmpInst &Cmp) {
1648 // This has to do a cast to ensure the operand has the right signedness.
1649 // Also, if the operand is a pointer, we make sure to cast to an integer when
1650 // doing the comparison both for signedness and so that the C compiler doesn't
1651 // optimize things like "p < NULL" to false (p may contain an integer value
1653 bool shouldCast = Cmp.isRelational();
1655 // Write out the casted operand if we should, otherwise just write the
1658 writeOperand(Operand);
1662 // Should this be a signed comparison? If so, convert to signed.
1663 bool castIsSigned = Cmp.isSigned();
1665 // If the operand was a pointer, convert to a large integer type.
1666 const Type* OpTy = Operand->getType();
1667 if (isa<PointerType>(OpTy))
1668 OpTy = TD->getIntPtrType(Operand->getContext());
1671 printSimpleType(Out, OpTy, castIsSigned);
1673 writeOperand(Operand);
1677 // generateCompilerSpecificCode - This is where we add conditional compilation
1678 // directives to cater to specific compilers as need be.
1680 static void generateCompilerSpecificCode(formatted_raw_ostream& Out,
1681 const TargetData *TD) {
1682 // Alloca is hard to get, and we don't want to include stdlib.h here.
1683 Out << "/* get a declaration for alloca */\n"
1684 << "#if defined(__CYGWIN__) || defined(__MINGW32__)\n"
1685 << "#define alloca(x) __builtin_alloca((x))\n"
1686 << "#define _alloca(x) __builtin_alloca((x))\n"
1687 << "#elif defined(__APPLE__)\n"
1688 << "extern void *__builtin_alloca(unsigned long);\n"
1689 << "#define alloca(x) __builtin_alloca(x)\n"
1690 << "#define longjmp _longjmp\n"
1691 << "#define setjmp _setjmp\n"
1692 << "#elif defined(__sun__)\n"
1693 << "#if defined(__sparcv9)\n"
1694 << "extern void *__builtin_alloca(unsigned long);\n"
1696 << "extern void *__builtin_alloca(unsigned int);\n"
1698 << "#define alloca(x) __builtin_alloca(x)\n"
1699 << "#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__arm__)\n"
1700 << "#define alloca(x) __builtin_alloca(x)\n"
1701 << "#elif defined(_MSC_VER)\n"
1702 << "#define inline _inline\n"
1703 << "#define alloca(x) _alloca(x)\n"
1705 << "#include <alloca.h>\n"
1708 // We output GCC specific attributes to preserve 'linkonce'ness on globals.
1709 // If we aren't being compiled with GCC, just drop these attributes.
1710 Out << "#ifndef __GNUC__ /* Can only support \"linkonce\" vars with GCC */\n"
1711 << "#define __attribute__(X)\n"
1714 // On Mac OS X, "external weak" is spelled "__attribute__((weak_import))".
1715 Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1716 << "#define __EXTERNAL_WEAK__ __attribute__((weak_import))\n"
1717 << "#elif defined(__GNUC__)\n"
1718 << "#define __EXTERNAL_WEAK__ __attribute__((weak))\n"
1720 << "#define __EXTERNAL_WEAK__\n"
1723 // For now, turn off the weak linkage attribute on Mac OS X. (See above.)
1724 Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1725 << "#define __ATTRIBUTE_WEAK__\n"
1726 << "#elif defined(__GNUC__)\n"
1727 << "#define __ATTRIBUTE_WEAK__ __attribute__((weak))\n"
1729 << "#define __ATTRIBUTE_WEAK__\n"
1732 // Add hidden visibility support. FIXME: APPLE_CC?
1733 Out << "#if defined(__GNUC__)\n"
1734 << "#define __HIDDEN__ __attribute__((visibility(\"hidden\")))\n"
1737 // Define NaN and Inf as GCC builtins if using GCC, as 0 otherwise
1738 // From the GCC documentation:
1740 // double __builtin_nan (const char *str)
1742 // This is an implementation of the ISO C99 function nan.
1744 // Since ISO C99 defines this function in terms of strtod, which we do
1745 // not implement, a description of the parsing is in order. The string is
1746 // parsed as by strtol; that is, the base is recognized by leading 0 or
1747 // 0x prefixes. The number parsed is placed in the significand such that
1748 // the least significant bit of the number is at the least significant
1749 // bit of the significand. The number is truncated to fit the significand
1750 // field provided. The significand is forced to be a quiet NaN.
1752 // This function, if given a string literal, is evaluated early enough
1753 // that it is considered a compile-time constant.
1755 // float __builtin_nanf (const char *str)
1757 // Similar to __builtin_nan, except the return type is float.
1759 // double __builtin_inf (void)
1761 // Similar to __builtin_huge_val, except a warning is generated if the
1762 // target floating-point format does not support infinities. This
1763 // function is suitable for implementing the ISO C99 macro INFINITY.
1765 // float __builtin_inff (void)
1767 // Similar to __builtin_inf, except the return type is float.
1768 Out << "#ifdef __GNUC__\n"
1769 << "#define LLVM_NAN(NanStr) __builtin_nan(NanStr) /* Double */\n"
1770 << "#define LLVM_NANF(NanStr) __builtin_nanf(NanStr) /* Float */\n"
1771 << "#define LLVM_NANS(NanStr) __builtin_nans(NanStr) /* Double */\n"
1772 << "#define LLVM_NANSF(NanStr) __builtin_nansf(NanStr) /* Float */\n"
1773 << "#define LLVM_INF __builtin_inf() /* Double */\n"
1774 << "#define LLVM_INFF __builtin_inff() /* Float */\n"
1775 << "#define LLVM_PREFETCH(addr,rw,locality) "
1776 "__builtin_prefetch(addr,rw,locality)\n"
1777 << "#define __ATTRIBUTE_CTOR__ __attribute__((constructor))\n"
1778 << "#define __ATTRIBUTE_DTOR__ __attribute__((destructor))\n"
1779 << "#define LLVM_ASM __asm__\n"
1781 << "#define LLVM_NAN(NanStr) ((double)0.0) /* Double */\n"
1782 << "#define LLVM_NANF(NanStr) 0.0F /* Float */\n"
1783 << "#define LLVM_NANS(NanStr) ((double)0.0) /* Double */\n"
1784 << "#define LLVM_NANSF(NanStr) 0.0F /* Float */\n"
1785 << "#define LLVM_INF ((double)0.0) /* Double */\n"
1786 << "#define LLVM_INFF 0.0F /* Float */\n"
1787 << "#define LLVM_PREFETCH(addr,rw,locality) /* PREFETCH */\n"
1788 << "#define __ATTRIBUTE_CTOR__\n"
1789 << "#define __ATTRIBUTE_DTOR__\n"
1790 << "#define LLVM_ASM(X)\n"
1793 Out << "#if __GNUC__ < 4 /* Old GCC's, or compilers not GCC */ \n"
1794 << "#define __builtin_stack_save() 0 /* not implemented */\n"
1795 << "#define __builtin_stack_restore(X) /* noop */\n"
1798 // Output typedefs for 128-bit integers. If these are needed with a
1799 // 32-bit target or with a C compiler that doesn't support mode(TI),
1800 // more drastic measures will be needed.
1801 Out << "#if __GNUC__ && __LP64__ /* 128-bit integer types */\n"
1802 << "typedef int __attribute__((mode(TI))) llvmInt128;\n"
1803 << "typedef unsigned __attribute__((mode(TI))) llvmUInt128;\n"
1806 // Output target-specific code that should be inserted into main.
1807 Out << "#define CODE_FOR_MAIN() /* Any target-specific code for main()*/\n";
1810 /// FindStaticTors - Given a static ctor/dtor list, unpack its contents into
1811 /// the StaticTors set.
1812 static void FindStaticTors(GlobalVariable *GV, std::set<Function*> &StaticTors){
1813 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
1814 if (!InitList) return;
1816 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
1817 if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){
1818 if (CS->getNumOperands() != 2) return; // Not array of 2-element structs.
1820 if (CS->getOperand(1)->isNullValue())
1821 return; // Found a null terminator, exit printing.
1822 Constant *FP = CS->getOperand(1);
1823 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
1825 FP = CE->getOperand(0);
1826 if (Function *F = dyn_cast<Function>(FP))
1827 StaticTors.insert(F);
1831 enum SpecialGlobalClass {
1833 GlobalCtors, GlobalDtors,
1837 /// getGlobalVariableClass - If this is a global that is specially recognized
1838 /// by LLVM, return a code that indicates how we should handle it.
1839 static SpecialGlobalClass getGlobalVariableClass(const GlobalVariable *GV) {
1840 // If this is a global ctors/dtors list, handle it now.
1841 if (GV->hasAppendingLinkage() && GV->use_empty()) {
1842 if (GV->getName() == "llvm.global_ctors")
1844 else if (GV->getName() == "llvm.global_dtors")
1848 // Otherwise, it it is other metadata, don't print it. This catches things
1849 // like debug information.
1850 if (GV->getSection() == "llvm.metadata")
1856 // PrintEscapedString - Print each character of the specified string, escaping
1857 // it if it is not printable or if it is an escape char.
1858 static void PrintEscapedString(const char *Str, unsigned Length,
1860 for (unsigned i = 0; i != Length; ++i) {
1861 unsigned char C = Str[i];
1862 if (isprint(C) && C != '\\' && C != '"')
1871 Out << "\\x" << hexdigit(C >> 4) << hexdigit(C & 0x0F);
1875 // PrintEscapedString - Print each character of the specified string, escaping
1876 // it if it is not printable or if it is an escape char.
1877 static void PrintEscapedString(const std::string &Str, raw_ostream &Out) {
1878 PrintEscapedString(Str.c_str(), Str.size(), Out);
1881 bool CWriter::doInitialization(Module &M) {
1882 FunctionPass::doInitialization(M);
1887 TD = new TargetData(&M);
1888 IL = new IntrinsicLowering(*TD);
1889 IL->AddPrototypes(M);
1891 // Ensure that all structure types have names...
1892 Mang = new Mangler(M);
1894 // Keep track of which functions are static ctors/dtors so they can have
1895 // an attribute added to their prototypes.
1896 std::set<Function*> StaticCtors, StaticDtors;
1897 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1899 switch (getGlobalVariableClass(I)) {
1902 FindStaticTors(I, StaticCtors);
1905 FindStaticTors(I, StaticDtors);
1910 // get declaration for alloca
1911 Out << "/* Provide Declarations */\n";
1912 Out << "#include <stdarg.h>\n"; // Varargs support
1913 Out << "#include <setjmp.h>\n"; // Unwind support
1914 generateCompilerSpecificCode(Out, TD);
1916 // Provide a definition for `bool' if not compiling with a C++ compiler.
1918 << "#ifndef __cplusplus\ntypedef unsigned char bool;\n#endif\n"
1920 << "\n\n/* Support for floating point constants */\n"
1921 << "typedef unsigned long long ConstantDoubleTy;\n"
1922 << "typedef unsigned int ConstantFloatTy;\n"
1923 << "typedef struct { unsigned long long f1; unsigned short f2; "
1924 "unsigned short pad[3]; } ConstantFP80Ty;\n"
1925 // This is used for both kinds of 128-bit long double; meaning differs.
1926 << "typedef struct { unsigned long long f1; unsigned long long f2; }"
1927 " ConstantFP128Ty;\n"
1928 << "\n\n/* Global Declarations */\n";
1930 // First output all the declarations for the program, because C requires
1931 // Functions & globals to be declared before they are used.
1933 if (!M.getModuleInlineAsm().empty()) {
1934 Out << "/* Module asm statements */\n"
1937 // Split the string into lines, to make it easier to read the .ll file.
1938 std::string Asm = M.getModuleInlineAsm();
1940 size_t NewLine = Asm.find_first_of('\n', CurPos);
1941 while (NewLine != std::string::npos) {
1942 // We found a newline, print the portion of the asm string from the
1943 // last newline up to this newline.
1945 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine),
1949 NewLine = Asm.find_first_of('\n', CurPos);
1952 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out);
1954 << "/* End Module asm statements */\n";
1957 // Loop over the symbol table, emitting all named constants...
1958 printModuleTypes(M.getTypeSymbolTable());
1960 // Global variable declarations...
1961 if (!M.global_empty()) {
1962 Out << "\n/* External Global Variable Declarations */\n";
1963 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1966 if (I->hasExternalLinkage() || I->hasExternalWeakLinkage() ||
1967 I->hasCommonLinkage())
1969 else if (I->hasDLLImportLinkage())
1970 Out << "__declspec(dllimport) ";
1972 continue; // Internal Global
1974 // Thread Local Storage
1975 if (I->isThreadLocal())
1978 printType(Out, I->getType()->getElementType(), false, GetValueName(I));
1980 if (I->hasExternalWeakLinkage())
1981 Out << " __EXTERNAL_WEAK__";
1986 // Function declarations
1987 Out << "\n/* Function Declarations */\n";
1988 Out << "double fmod(double, double);\n"; // Support for FP rem
1989 Out << "float fmodf(float, float);\n";
1990 Out << "long double fmodl(long double, long double);\n";
1992 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
1993 // Don't print declarations for intrinsic functions.
1994 if (!I->isIntrinsic() && I->getName() != "setjmp" &&
1995 I->getName() != "longjmp" && I->getName() != "_setjmp") {
1996 if (I->hasExternalWeakLinkage())
1998 printFunctionSignature(I, true);
1999 if (I->hasWeakLinkage() || I->hasLinkOnceLinkage())
2000 Out << " __ATTRIBUTE_WEAK__";
2001 if (I->hasExternalWeakLinkage())
2002 Out << " __EXTERNAL_WEAK__";
2003 if (StaticCtors.count(I))
2004 Out << " __ATTRIBUTE_CTOR__";
2005 if (StaticDtors.count(I))
2006 Out << " __ATTRIBUTE_DTOR__";
2007 if (I->hasHiddenVisibility())
2008 Out << " __HIDDEN__";
2010 if (I->hasName() && I->getName()[0] == 1)
2011 Out << " LLVM_ASM(\"" << I->getName().substr(1) << "\")";
2017 // Output the global variable declarations
2018 if (!M.global_empty()) {
2019 Out << "\n\n/* Global Variable Declarations */\n";
2020 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
2022 if (!I->isDeclaration()) {
2023 // Ignore special globals, such as debug info.
2024 if (getGlobalVariableClass(I))
2027 if (I->hasLocalLinkage())
2032 // Thread Local Storage
2033 if (I->isThreadLocal())
2036 printType(Out, I->getType()->getElementType(), false,
2039 if (I->hasLinkOnceLinkage())
2040 Out << " __attribute__((common))";
2041 else if (I->hasCommonLinkage()) // FIXME is this right?
2042 Out << " __ATTRIBUTE_WEAK__";
2043 else if (I->hasWeakLinkage())
2044 Out << " __ATTRIBUTE_WEAK__";
2045 else if (I->hasExternalWeakLinkage())
2046 Out << " __EXTERNAL_WEAK__";
2047 if (I->hasHiddenVisibility())
2048 Out << " __HIDDEN__";
2053 // Output the global variable definitions and contents...
2054 if (!M.global_empty()) {
2055 Out << "\n\n/* Global Variable Definitions and Initialization */\n";
2056 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
2058 if (!I->isDeclaration()) {
2059 // Ignore special globals, such as debug info.
2060 if (getGlobalVariableClass(I))
2063 if (I->hasLocalLinkage())
2065 else if (I->hasDLLImportLinkage())
2066 Out << "__declspec(dllimport) ";
2067 else if (I->hasDLLExportLinkage())
2068 Out << "__declspec(dllexport) ";
2070 // Thread Local Storage
2071 if (I->isThreadLocal())
2074 printType(Out, I->getType()->getElementType(), false,
2076 if (I->hasLinkOnceLinkage())
2077 Out << " __attribute__((common))";
2078 else if (I->hasWeakLinkage())
2079 Out << " __ATTRIBUTE_WEAK__";
2080 else if (I->hasCommonLinkage())
2081 Out << " __ATTRIBUTE_WEAK__";
2083 if (I->hasHiddenVisibility())
2084 Out << " __HIDDEN__";
2086 // If the initializer is not null, emit the initializer. If it is null,
2087 // we try to avoid emitting large amounts of zeros. The problem with
2088 // this, however, occurs when the variable has weak linkage. In this
2089 // case, the assembler will complain about the variable being both weak
2090 // and common, so we disable this optimization.
2091 // FIXME common linkage should avoid this problem.
2092 if (!I->getInitializer()->isNullValue()) {
2094 writeOperand(I->getInitializer(), true);
2095 } else if (I->hasWeakLinkage()) {
2096 // We have to specify an initializer, but it doesn't have to be
2097 // complete. If the value is an aggregate, print out { 0 }, and let
2098 // the compiler figure out the rest of the zeros.
2100 if (isa<StructType>(I->getInitializer()->getType()) ||
2101 isa<VectorType>(I->getInitializer()->getType())) {
2103 } else if (isa<ArrayType>(I->getInitializer()->getType())) {
2104 // As with structs and vectors, but with an extra set of braces
2105 // because arrays are wrapped in structs.
2108 // Just print it out normally.
2109 writeOperand(I->getInitializer(), true);
2117 Out << "\n\n/* Function Bodies */\n";
2119 // Emit some helper functions for dealing with FCMP instruction's
2121 Out << "static inline int llvm_fcmp_ord(double X, double Y) { ";
2122 Out << "return X == X && Y == Y; }\n";
2123 Out << "static inline int llvm_fcmp_uno(double X, double Y) { ";
2124 Out << "return X != X || Y != Y; }\n";
2125 Out << "static inline int llvm_fcmp_ueq(double X, double Y) { ";
2126 Out << "return X == Y || llvm_fcmp_uno(X, Y); }\n";
2127 Out << "static inline int llvm_fcmp_une(double X, double Y) { ";
2128 Out << "return X != Y; }\n";
2129 Out << "static inline int llvm_fcmp_ult(double X, double Y) { ";
2130 Out << "return X < Y || llvm_fcmp_uno(X, Y); }\n";
2131 Out << "static inline int llvm_fcmp_ugt(double X, double Y) { ";
2132 Out << "return X > Y || llvm_fcmp_uno(X, Y); }\n";
2133 Out << "static inline int llvm_fcmp_ule(double X, double Y) { ";
2134 Out << "return X <= Y || llvm_fcmp_uno(X, Y); }\n";
2135 Out << "static inline int llvm_fcmp_uge(double X, double Y) { ";
2136 Out << "return X >= Y || llvm_fcmp_uno(X, Y); }\n";
2137 Out << "static inline int llvm_fcmp_oeq(double X, double Y) { ";
2138 Out << "return X == Y ; }\n";
2139 Out << "static inline int llvm_fcmp_one(double X, double Y) { ";
2140 Out << "return X != Y && llvm_fcmp_ord(X, Y); }\n";
2141 Out << "static inline int llvm_fcmp_olt(double X, double Y) { ";
2142 Out << "return X < Y ; }\n";
2143 Out << "static inline int llvm_fcmp_ogt(double X, double Y) { ";
2144 Out << "return X > Y ; }\n";
2145 Out << "static inline int llvm_fcmp_ole(double X, double Y) { ";
2146 Out << "return X <= Y ; }\n";
2147 Out << "static inline int llvm_fcmp_oge(double X, double Y) { ";
2148 Out << "return X >= Y ; }\n";
2153 /// Output all floating point constants that cannot be printed accurately...
2154 void CWriter::printFloatingPointConstants(Function &F) {
2155 // Scan the module for floating point constants. If any FP constant is used
2156 // in the function, we want to redirect it here so that we do not depend on
2157 // the precision of the printed form, unless the printed form preserves
2160 for (constant_iterator I = constant_begin(&F), E = constant_end(&F);
2162 printFloatingPointConstants(*I);
2167 void CWriter::printFloatingPointConstants(const Constant *C) {
2168 // If this is a constant expression, recursively check for constant fp values.
2169 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
2170 for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i)
2171 printFloatingPointConstants(CE->getOperand(i));
2175 // Otherwise, check for a FP constant that we need to print.
2176 const ConstantFP *FPC = dyn_cast<ConstantFP>(C);
2178 // Do not put in FPConstantMap if safe.
2179 isFPCSafeToPrint(FPC) ||
2180 // Already printed this constant?
2181 FPConstantMap.count(FPC))
2184 FPConstantMap[FPC] = FPCounter; // Number the FP constants
2186 if (FPC->getType() == Type::getDoubleTy(FPC->getContext())) {
2187 double Val = FPC->getValueAPF().convertToDouble();
2188 uint64_t i = FPC->getValueAPF().bitcastToAPInt().getZExtValue();
2189 Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
2190 << " = 0x" << utohexstr(i)
2191 << "ULL; /* " << Val << " */\n";
2192 } else if (FPC->getType() == Type::getFloatTy(FPC->getContext())) {
2193 float Val = FPC->getValueAPF().convertToFloat();
2194 uint32_t i = (uint32_t)FPC->getValueAPF().bitcastToAPInt().
2196 Out << "static const ConstantFloatTy FPConstant" << FPCounter++
2197 << " = 0x" << utohexstr(i)
2198 << "U; /* " << Val << " */\n";
2199 } else if (FPC->getType() == Type::getX86_FP80Ty(FPC->getContext())) {
2200 // api needed to prevent premature destruction
2201 APInt api = FPC->getValueAPF().bitcastToAPInt();
2202 const uint64_t *p = api.getRawData();
2203 Out << "static const ConstantFP80Ty FPConstant" << FPCounter++
2204 << " = { 0x" << utohexstr(p[0])
2205 << "ULL, 0x" << utohexstr((uint16_t)p[1]) << ",{0,0,0}"
2206 << "}; /* Long double constant */\n";
2207 } else if (FPC->getType() == Type::getPPC_FP128Ty(FPC->getContext()) ||
2208 FPC->getType() == Type::getFP128Ty(FPC->getContext())) {
2209 APInt api = FPC->getValueAPF().bitcastToAPInt();
2210 const uint64_t *p = api.getRawData();
2211 Out << "static const ConstantFP128Ty FPConstant" << FPCounter++
2213 << utohexstr(p[0]) << ", 0x" << utohexstr(p[1])
2214 << "}; /* Long double constant */\n";
2217 llvm_unreachable("Unknown float type!");
2223 /// printSymbolTable - Run through symbol table looking for type names. If a
2224 /// type name is found, emit its declaration...
2226 void CWriter::printModuleTypes(const TypeSymbolTable &TST) {
2227 Out << "/* Helper union for bitcasts */\n";
2228 Out << "typedef union {\n";
2229 Out << " unsigned int Int32;\n";
2230 Out << " unsigned long long Int64;\n";
2231 Out << " float Float;\n";
2232 Out << " double Double;\n";
2233 Out << "} llvmBitCastUnion;\n";
2235 // We are only interested in the type plane of the symbol table.
2236 TypeSymbolTable::const_iterator I = TST.begin();
2237 TypeSymbolTable::const_iterator End = TST.end();
2239 // If there are no type names, exit early.
2240 if (I == End) return;
2242 // Print out forward declarations for structure types before anything else!
2243 Out << "/* Structure forward decls */\n";
2244 for (; I != End; ++I) {
2245 std::string Name = "struct " + Mangle("l_"+I->first);
2246 Out << Name << ";\n";
2247 TypeNames.insert(std::make_pair(I->second, Name));
2252 // Now we can print out typedefs. Above, we guaranteed that this can only be
2253 // for struct or opaque types.
2254 Out << "/* Typedefs */\n";
2255 for (I = TST.begin(); I != End; ++I) {
2256 std::string Name = Mangle("l_"+I->first);
2258 printType(Out, I->second, false, Name);
2264 // Keep track of which structures have been printed so far...
2265 std::set<const Type *> StructPrinted;
2267 // Loop over all structures then push them into the stack so they are
2268 // printed in the correct order.
2270 Out << "/* Structure contents */\n";
2271 for (I = TST.begin(); I != End; ++I)
2272 if (isa<StructType>(I->second) || isa<ArrayType>(I->second))
2273 // Only print out used types!
2274 printContainedStructs(I->second, StructPrinted);
2277 // Push the struct onto the stack and recursively push all structs
2278 // this one depends on.
2280 // TODO: Make this work properly with vector types
2282 void CWriter::printContainedStructs(const Type *Ty,
2283 std::set<const Type*> &StructPrinted) {
2284 // Don't walk through pointers.
2285 if (isa<PointerType>(Ty) || Ty->isPrimitiveType() || Ty->isInteger()) return;
2287 // Print all contained types first.
2288 for (Type::subtype_iterator I = Ty->subtype_begin(),
2289 E = Ty->subtype_end(); I != E; ++I)
2290 printContainedStructs(*I, StructPrinted);
2292 if (isa<StructType>(Ty) || isa<ArrayType>(Ty)) {
2293 // Check to see if we have already printed this struct.
2294 if (StructPrinted.insert(Ty).second) {
2295 // Print structure type out.
2296 std::string Name = TypeNames[Ty];
2297 printType(Out, Ty, false, Name, true);
2303 void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
2304 /// isStructReturn - Should this function actually return a struct by-value?
2305 bool isStructReturn = F->hasStructRetAttr();
2307 if (F->hasLocalLinkage()) Out << "static ";
2308 if (F->hasDLLImportLinkage()) Out << "__declspec(dllimport) ";
2309 if (F->hasDLLExportLinkage()) Out << "__declspec(dllexport) ";
2310 switch (F->getCallingConv()) {
2311 case CallingConv::X86_StdCall:
2312 Out << "__attribute__((stdcall)) ";
2314 case CallingConv::X86_FastCall:
2315 Out << "__attribute__((fastcall)) ";
2321 // Loop over the arguments, printing them...
2322 const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
2323 const AttrListPtr &PAL = F->getAttributes();
2325 std::stringstream FunctionInnards;
2327 // Print out the name...
2328 FunctionInnards << GetValueName(F) << '(';
2330 bool PrintedArg = false;
2331 if (!F->isDeclaration()) {
2332 if (!F->arg_empty()) {
2333 Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
2336 // If this is a struct-return function, don't print the hidden
2337 // struct-return argument.
2338 if (isStructReturn) {
2339 assert(I != E && "Invalid struct return function!");
2344 std::string ArgName;
2345 for (; I != E; ++I) {
2346 if (PrintedArg) FunctionInnards << ", ";
2347 if (I->hasName() || !Prototype)
2348 ArgName = GetValueName(I);
2351 const Type *ArgTy = I->getType();
2352 if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
2353 ArgTy = cast<PointerType>(ArgTy)->getElementType();
2354 ByValParams.insert(I);
2356 printType(FunctionInnards, ArgTy,
2357 /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt),
2364 // Loop over the arguments, printing them.
2365 FunctionType::param_iterator I = FT->param_begin(), E = FT->param_end();
2368 // If this is a struct-return function, don't print the hidden
2369 // struct-return argument.
2370 if (isStructReturn) {
2371 assert(I != E && "Invalid struct return function!");
2376 for (; I != E; ++I) {
2377 if (PrintedArg) FunctionInnards << ", ";
2378 const Type *ArgTy = *I;
2379 if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
2380 assert(isa<PointerType>(ArgTy));
2381 ArgTy = cast<PointerType>(ArgTy)->getElementType();
2383 printType(FunctionInnards, ArgTy,
2384 /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt));
2390 // Finish printing arguments... if this is a vararg function, print the ...,
2391 // unless there are no known types, in which case, we just emit ().
2393 if (FT->isVarArg() && PrintedArg) {
2394 if (PrintedArg) FunctionInnards << ", ";
2395 FunctionInnards << "..."; // Output varargs portion of signature!
2396 } else if (!FT->isVarArg() && !PrintedArg) {
2397 FunctionInnards << "void"; // ret() -> ret(void) in C.
2399 FunctionInnards << ')';
2401 // Get the return tpe for the function.
2403 if (!isStructReturn)
2404 RetTy = F->getReturnType();
2406 // If this is a struct-return function, print the struct-return type.
2407 RetTy = cast<PointerType>(FT->getParamType(0))->getElementType();
2410 // Print out the return type and the signature built above.
2411 printType(Out, RetTy,
2412 /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt),
2413 FunctionInnards.str());
2416 static inline bool isFPIntBitCast(const Instruction &I) {
2417 if (!isa<BitCastInst>(I))
2419 const Type *SrcTy = I.getOperand(0)->getType();
2420 const Type *DstTy = I.getType();
2421 return (SrcTy->isFloatingPoint() && DstTy->isInteger()) ||
2422 (DstTy->isFloatingPoint() && SrcTy->isInteger());
2425 void CWriter::printFunction(Function &F) {
2426 /// isStructReturn - Should this function actually return a struct by-value?
2427 bool isStructReturn = F.hasStructRetAttr();
2429 printFunctionSignature(&F, false);
2432 // If this is a struct return function, handle the result with magic.
2433 if (isStructReturn) {
2434 const Type *StructTy =
2435 cast<PointerType>(F.arg_begin()->getType())->getElementType();
2437 printType(Out, StructTy, false, "StructReturn");
2438 Out << "; /* Struct return temporary */\n";
2441 printType(Out, F.arg_begin()->getType(), false,
2442 GetValueName(F.arg_begin()));
2443 Out << " = &StructReturn;\n";
2446 bool PrintedVar = false;
2448 // print local variable information for the function
2449 for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
2450 if (const AllocaInst *AI = isDirectAlloca(&*I)) {
2452 printType(Out, AI->getAllocatedType(), false, GetValueName(AI));
2453 Out << "; /* Address-exposed local */\n";
2455 } else if (I->getType() != Type::getVoidTy(F.getContext()) &&
2456 !isInlinableInst(*I)) {
2458 printType(Out, I->getType(), false, GetValueName(&*I));
2461 if (isa<PHINode>(*I)) { // Print out PHI node temporaries as well...
2463 printType(Out, I->getType(), false,
2464 GetValueName(&*I)+"__PHI_TEMPORARY");
2469 // We need a temporary for the BitCast to use so it can pluck a value out
2470 // of a union to do the BitCast. This is separate from the need for a
2471 // variable to hold the result of the BitCast.
2472 if (isFPIntBitCast(*I)) {
2473 Out << " llvmBitCastUnion " << GetValueName(&*I)
2474 << "__BITCAST_TEMPORARY;\n";
2482 if (F.hasExternalLinkage() && F.getName() == "main")
2483 Out << " CODE_FOR_MAIN();\n";
2485 // print the basic blocks
2486 for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
2487 if (Loop *L = LI->getLoopFor(BB)) {
2488 if (L->getHeader() == BB && L->getParentLoop() == 0)
2491 printBasicBlock(BB);
2498 void CWriter::printLoop(Loop *L) {
2499 Out << " do { /* Syntactic loop '" << L->getHeader()->getName()
2500 << "' to make GCC happy */\n";
2501 for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) {
2502 BasicBlock *BB = L->getBlocks()[i];
2503 Loop *BBLoop = LI->getLoopFor(BB);
2505 printBasicBlock(BB);
2506 else if (BB == BBLoop->getHeader() && BBLoop->getParentLoop() == L)
2509 Out << " } while (1); /* end of syntactic loop '"
2510 << L->getHeader()->getName() << "' */\n";
2513 void CWriter::printBasicBlock(BasicBlock *BB) {
2515 // Don't print the label for the basic block if there are no uses, or if
2516 // the only terminator use is the predecessor basic block's terminator.
2517 // We have to scan the use list because PHI nodes use basic blocks too but
2518 // do not require a label to be generated.
2520 bool NeedsLabel = false;
2521 for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
2522 if (isGotoCodeNecessary(*PI, BB)) {
2527 if (NeedsLabel) Out << GetValueName(BB) << ":\n";
2529 // Output all of the instructions in the basic block...
2530 for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E;
2532 if (!isInlinableInst(*II) && !isDirectAlloca(II)) {
2533 if (II->getType() != Type::getVoidTy(BB->getContext()) &&
2538 writeInstComputationInline(*II);
2543 // Don't emit prefix or suffix for the terminator.
2544 visit(*BB->getTerminator());
2548 // Specific Instruction type classes... note that all of the casts are
2549 // necessary because we use the instruction classes as opaque types...
2551 void CWriter::visitReturnInst(ReturnInst &I) {
2552 // If this is a struct return function, return the temporary struct.
2553 bool isStructReturn = I.getParent()->getParent()->hasStructRetAttr();
2555 if (isStructReturn) {
2556 Out << " return StructReturn;\n";
2560 // Don't output a void return if this is the last basic block in the function
2561 if (I.getNumOperands() == 0 &&
2562 &*--I.getParent()->getParent()->end() == I.getParent() &&
2563 !I.getParent()->size() == 1) {
2567 if (I.getNumOperands() > 1) {
2570 printType(Out, I.getParent()->getParent()->getReturnType());
2571 Out << " llvm_cbe_mrv_temp = {\n";
2572 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
2574 writeOperand(I.getOperand(i));
2580 Out << " return llvm_cbe_mrv_temp;\n";
2586 if (I.getNumOperands()) {
2588 writeOperand(I.getOperand(0));
2593 void CWriter::visitSwitchInst(SwitchInst &SI) {
2596 writeOperand(SI.getOperand(0));
2597 Out << ") {\n default:\n";
2598 printPHICopiesForSuccessor (SI.getParent(), SI.getDefaultDest(), 2);
2599 printBranchToBlock(SI.getParent(), SI.getDefaultDest(), 2);
2601 for (unsigned i = 2, e = SI.getNumOperands(); i != e; i += 2) {
2603 writeOperand(SI.getOperand(i));
2605 BasicBlock *Succ = cast<BasicBlock>(SI.getOperand(i+1));
2606 printPHICopiesForSuccessor (SI.getParent(), Succ, 2);
2607 printBranchToBlock(SI.getParent(), Succ, 2);
2608 if (Function::iterator(Succ) == llvm::next(Function::iterator(SI.getParent())))
2614 void CWriter::visitIndirectBrInst(IndirectBrInst &IBI) {
2615 Out << " goto *(void*)(";
2616 writeOperand(IBI.getOperand(0));
2620 void CWriter::visitUnreachableInst(UnreachableInst &I) {
2621 Out << " /*UNREACHABLE*/;\n";
2624 bool CWriter::isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) {
2625 /// FIXME: This should be reenabled, but loop reordering safe!!
2628 if (llvm::next(Function::iterator(From)) != Function::iterator(To))
2629 return true; // Not the direct successor, we need a goto.
2631 //isa<SwitchInst>(From->getTerminator())
2633 if (LI->getLoopFor(From) != LI->getLoopFor(To))
2638 void CWriter::printPHICopiesForSuccessor (BasicBlock *CurBlock,
2639 BasicBlock *Successor,
2641 for (BasicBlock::iterator I = Successor->begin(); isa<PHINode>(I); ++I) {
2642 PHINode *PN = cast<PHINode>(I);
2643 // Now we have to do the printing.
2644 Value *IV = PN->getIncomingValueForBlock(CurBlock);
2645 if (!isa<UndefValue>(IV)) {
2646 Out << std::string(Indent, ' ');
2647 Out << " " << GetValueName(I) << "__PHI_TEMPORARY = ";
2649 Out << "; /* for PHI node */\n";
2654 void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
2656 if (isGotoCodeNecessary(CurBB, Succ)) {
2657 Out << std::string(Indent, ' ') << " goto ";
2663 // Branch instruction printing - Avoid printing out a branch to a basic block
2664 // that immediately succeeds the current one.
2666 void CWriter::visitBranchInst(BranchInst &I) {
2668 if (I.isConditional()) {
2669 if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(0))) {
2671 writeOperand(I.getCondition());
2674 printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 2);
2675 printBranchToBlock(I.getParent(), I.getSuccessor(0), 2);
2677 if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(1))) {
2678 Out << " } else {\n";
2679 printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
2680 printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
2683 // First goto not necessary, assume second one is...
2685 writeOperand(I.getCondition());
2688 printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
2689 printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
2694 printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 0);
2695 printBranchToBlock(I.getParent(), I.getSuccessor(0), 0);
2700 // PHI nodes get copied into temporary values at the end of predecessor basic
2701 // blocks. We now need to copy these temporary values into the REAL value for
2703 void CWriter::visitPHINode(PHINode &I) {
2705 Out << "__PHI_TEMPORARY";
2709 void CWriter::visitBinaryOperator(Instruction &I) {
2710 // binary instructions, shift instructions, setCond instructions.
2711 assert(!isa<PointerType>(I.getType()));
2713 // We must cast the results of binary operations which might be promoted.
2714 bool needsCast = false;
2715 if ((I.getType() == Type::getInt8Ty(I.getContext())) ||
2716 (I.getType() == Type::getInt16Ty(I.getContext()))
2717 || (I.getType() == Type::getFloatTy(I.getContext()))) {
2720 printType(Out, I.getType(), false);
2724 // If this is a negation operation, print it out as such. For FP, we don't
2725 // want to print "-0.0 - X".
2726 if (BinaryOperator::isNeg(&I)) {
2728 writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I)));
2730 } else if (BinaryOperator::isFNeg(&I)) {
2732 writeOperand(BinaryOperator::getFNegArgument(cast<BinaryOperator>(&I)));
2734 } else if (I.getOpcode() == Instruction::FRem) {
2735 // Output a call to fmod/fmodf instead of emitting a%b
2736 if (I.getType() == Type::getFloatTy(I.getContext()))
2738 else if (I.getType() == Type::getDoubleTy(I.getContext()))
2740 else // all 3 flavors of long double
2742 writeOperand(I.getOperand(0));
2744 writeOperand(I.getOperand(1));
2748 // Write out the cast of the instruction's value back to the proper type
2750 bool NeedsClosingParens = writeInstructionCast(I);
2752 // Certain instructions require the operand to be forced to a specific type
2753 // so we use writeOperandWithCast here instead of writeOperand. Similarly
2754 // below for operand 1
2755 writeOperandWithCast(I.getOperand(0), I.getOpcode());
2757 switch (I.getOpcode()) {
2758 case Instruction::Add:
2759 case Instruction::FAdd: Out << " + "; break;
2760 case Instruction::Sub:
2761 case Instruction::FSub: Out << " - "; break;
2762 case Instruction::Mul:
2763 case Instruction::FMul: Out << " * "; break;
2764 case Instruction::URem:
2765 case Instruction::SRem:
2766 case Instruction::FRem: Out << " % "; break;
2767 case Instruction::UDiv:
2768 case Instruction::SDiv:
2769 case Instruction::FDiv: Out << " / "; break;
2770 case Instruction::And: Out << " & "; break;
2771 case Instruction::Or: Out << " | "; break;
2772 case Instruction::Xor: Out << " ^ "; break;
2773 case Instruction::Shl : Out << " << "; break;
2774 case Instruction::LShr:
2775 case Instruction::AShr: Out << " >> "; break;
2778 errs() << "Invalid operator type!" << I;
2780 llvm_unreachable(0);
2783 writeOperandWithCast(I.getOperand(1), I.getOpcode());
2784 if (NeedsClosingParens)
2793 void CWriter::visitICmpInst(ICmpInst &I) {
2794 // We must cast the results of icmp which might be promoted.
2795 bool needsCast = false;
2797 // Write out the cast of the instruction's value back to the proper type
2799 bool NeedsClosingParens = writeInstructionCast(I);
2801 // Certain icmp predicate require the operand to be forced to a specific type
2802 // so we use writeOperandWithCast here instead of writeOperand. Similarly
2803 // below for operand 1
2804 writeOperandWithCast(I.getOperand(0), I);
2806 switch (I.getPredicate()) {
2807 case ICmpInst::ICMP_EQ: Out << " == "; break;
2808 case ICmpInst::ICMP_NE: Out << " != "; break;
2809 case ICmpInst::ICMP_ULE:
2810 case ICmpInst::ICMP_SLE: Out << " <= "; break;
2811 case ICmpInst::ICMP_UGE:
2812 case ICmpInst::ICMP_SGE: Out << " >= "; break;
2813 case ICmpInst::ICMP_ULT:
2814 case ICmpInst::ICMP_SLT: Out << " < "; break;
2815 case ICmpInst::ICMP_UGT:
2816 case ICmpInst::ICMP_SGT: Out << " > "; break;
2819 errs() << "Invalid icmp predicate!" << I;
2821 llvm_unreachable(0);
2824 writeOperandWithCast(I.getOperand(1), I);
2825 if (NeedsClosingParens)
2833 void CWriter::visitFCmpInst(FCmpInst &I) {
2834 if (I.getPredicate() == FCmpInst::FCMP_FALSE) {
2838 if (I.getPredicate() == FCmpInst::FCMP_TRUE) {
2844 switch (I.getPredicate()) {
2845 default: llvm_unreachable("Illegal FCmp predicate");
2846 case FCmpInst::FCMP_ORD: op = "ord"; break;
2847 case FCmpInst::FCMP_UNO: op = "uno"; break;
2848 case FCmpInst::FCMP_UEQ: op = "ueq"; break;
2849 case FCmpInst::FCMP_UNE: op = "une"; break;
2850 case FCmpInst::FCMP_ULT: op = "ult"; break;
2851 case FCmpInst::FCMP_ULE: op = "ule"; break;
2852 case FCmpInst::FCMP_UGT: op = "ugt"; break;
2853 case FCmpInst::FCMP_UGE: op = "uge"; break;
2854 case FCmpInst::FCMP_OEQ: op = "oeq"; break;
2855 case FCmpInst::FCMP_ONE: op = "one"; break;
2856 case FCmpInst::FCMP_OLT: op = "olt"; break;
2857 case FCmpInst::FCMP_OLE: op = "ole"; break;
2858 case FCmpInst::FCMP_OGT: op = "ogt"; break;
2859 case FCmpInst::FCMP_OGE: op = "oge"; break;
2862 Out << "llvm_fcmp_" << op << "(";
2863 // Write the first operand
2864 writeOperand(I.getOperand(0));
2866 // Write the second operand
2867 writeOperand(I.getOperand(1));
2871 static const char * getFloatBitCastField(const Type *Ty) {
2872 switch (Ty->getTypeID()) {
2873 default: llvm_unreachable("Invalid Type");
2874 case Type::FloatTyID: return "Float";
2875 case Type::DoubleTyID: return "Double";
2876 case Type::IntegerTyID: {
2877 unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
2886 void CWriter::visitCastInst(CastInst &I) {
2887 const Type *DstTy = I.getType();
2888 const Type *SrcTy = I.getOperand(0)->getType();
2889 if (isFPIntBitCast(I)) {
2891 // These int<->float and long<->double casts need to be handled specially
2892 Out << GetValueName(&I) << "__BITCAST_TEMPORARY."
2893 << getFloatBitCastField(I.getOperand(0)->getType()) << " = ";
2894 writeOperand(I.getOperand(0));
2895 Out << ", " << GetValueName(&I) << "__BITCAST_TEMPORARY."
2896 << getFloatBitCastField(I.getType());
2902 printCast(I.getOpcode(), SrcTy, DstTy);
2904 // Make a sext from i1 work by subtracting the i1 from 0 (an int).
2905 if (SrcTy == Type::getInt1Ty(I.getContext()) &&
2906 I.getOpcode() == Instruction::SExt)
2909 writeOperand(I.getOperand(0));
2911 if (DstTy == Type::getInt1Ty(I.getContext()) &&
2912 (I.getOpcode() == Instruction::Trunc ||
2913 I.getOpcode() == Instruction::FPToUI ||
2914 I.getOpcode() == Instruction::FPToSI ||
2915 I.getOpcode() == Instruction::PtrToInt)) {
2916 // Make sure we really get a trunc to bool by anding the operand with 1
2922 void CWriter::visitSelectInst(SelectInst &I) {
2924 writeOperand(I.getCondition());
2926 writeOperand(I.getTrueValue());
2928 writeOperand(I.getFalseValue());
2933 void CWriter::lowerIntrinsics(Function &F) {
2934 // This is used to keep track of intrinsics that get generated to a lowered
2935 // function. We must generate the prototypes before the function body which
2936 // will only be expanded on first use (by the loop below).
2937 std::vector<Function*> prototypesToGen;
2939 // Examine all the instructions in this function to find the intrinsics that
2940 // need to be lowered.
2941 for (Function::iterator BB = F.begin(), EE = F.end(); BB != EE; ++BB)
2942 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
2943 if (CallInst *CI = dyn_cast<CallInst>(I++))
2944 if (Function *F = CI->getCalledFunction())
2945 switch (F->getIntrinsicID()) {
2946 case Intrinsic::not_intrinsic:
2947 case Intrinsic::memory_barrier:
2948 case Intrinsic::vastart:
2949 case Intrinsic::vacopy:
2950 case Intrinsic::vaend:
2951 case Intrinsic::returnaddress:
2952 case Intrinsic::frameaddress:
2953 case Intrinsic::setjmp:
2954 case Intrinsic::longjmp:
2955 case Intrinsic::prefetch:
2956 case Intrinsic::powi:
2957 case Intrinsic::x86_sse_cmp_ss:
2958 case Intrinsic::x86_sse_cmp_ps:
2959 case Intrinsic::x86_sse2_cmp_sd:
2960 case Intrinsic::x86_sse2_cmp_pd:
2961 case Intrinsic::ppc_altivec_lvsl:
2962 // We directly implement these intrinsics
2965 // If this is an intrinsic that directly corresponds to a GCC
2966 // builtin, we handle it.
2967 const char *BuiltinName = "";
2968 #define GET_GCC_BUILTIN_NAME
2969 #include "llvm/Intrinsics.gen"
2970 #undef GET_GCC_BUILTIN_NAME
2971 // If we handle it, don't lower it.
2972 if (BuiltinName[0]) break;
2974 // All other intrinsic calls we must lower.
2975 Instruction *Before = 0;
2976 if (CI != &BB->front())
2977 Before = prior(BasicBlock::iterator(CI));
2979 IL->LowerIntrinsicCall(CI);
2980 if (Before) { // Move iterator to instruction after call
2985 // If the intrinsic got lowered to another call, and that call has
2986 // a definition then we need to make sure its prototype is emitted
2987 // before any calls to it.
2988 if (CallInst *Call = dyn_cast<CallInst>(I))
2989 if (Function *NewF = Call->getCalledFunction())
2990 if (!NewF->isDeclaration())
2991 prototypesToGen.push_back(NewF);
2996 // We may have collected some prototypes to emit in the loop above.
2997 // Emit them now, before the function that uses them is emitted. But,
2998 // be careful not to emit them twice.
2999 std::vector<Function*>::iterator I = prototypesToGen.begin();
3000 std::vector<Function*>::iterator E = prototypesToGen.end();
3001 for ( ; I != E; ++I) {
3002 if (intrinsicPrototypesAlreadyGenerated.insert(*I).second) {
3004 printFunctionSignature(*I, true);
3010 void CWriter::visitCallInst(CallInst &I) {
3011 if (isa<InlineAsm>(I.getOperand(0)))
3012 return visitInlineAsm(I);
3014 bool WroteCallee = false;
3016 // Handle intrinsic function calls first...
3017 if (Function *F = I.getCalledFunction())
3018 if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
3019 if (visitBuiltinCall(I, ID, WroteCallee))
3022 Value *Callee = I.getCalledValue();
3024 const PointerType *PTy = cast<PointerType>(Callee->getType());
3025 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
3027 // If this is a call to a struct-return function, assign to the first
3028 // parameter instead of passing it to the call.
3029 const AttrListPtr &PAL = I.getAttributes();
3030 bool hasByVal = I.hasByValArgument();
3031 bool isStructRet = I.hasStructRetAttr();
3033 writeOperandDeref(I.getOperand(1));
3037 if (I.isTailCall()) Out << " /*tail*/ ";
3040 // If this is an indirect call to a struct return function, we need to cast
3041 // the pointer. Ditto for indirect calls with byval arguments.
3042 bool NeedsCast = (hasByVal || isStructRet) && !isa<Function>(Callee);
3044 // GCC is a real PITA. It does not permit codegening casts of functions to
3045 // function pointers if they are in a call (it generates a trap instruction
3046 // instead!). We work around this by inserting a cast to void* in between
3047 // the function and the function pointer cast. Unfortunately, we can't just
3048 // form the constant expression here, because the folder will immediately
3051 // Note finally, that this is completely unsafe. ANSI C does not guarantee
3052 // that void* and function pointers have the same size. :( To deal with this
3053 // in the common case, we handle casts where the number of arguments passed
3056 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Callee))
3058 if (Function *RF = dyn_cast<Function>(CE->getOperand(0))) {
3064 // Ok, just cast the pointer type.
3067 printStructReturnPointerFunctionType(Out, PAL,
3068 cast<PointerType>(I.getCalledValue()->getType()));
3070 printType(Out, I.getCalledValue()->getType(), false, "", true, PAL);
3072 printType(Out, I.getCalledValue()->getType());
3075 writeOperand(Callee);
3076 if (NeedsCast) Out << ')';
3081 unsigned NumDeclaredParams = FTy->getNumParams();
3083 CallSite::arg_iterator AI = I.op_begin()+1, AE = I.op_end();
3085 if (isStructRet) { // Skip struct return argument.
3090 bool PrintedArg = false;
3091 for (; AI != AE; ++AI, ++ArgNo) {
3092 if (PrintedArg) Out << ", ";
3093 if (ArgNo < NumDeclaredParams &&
3094 (*AI)->getType() != FTy->getParamType(ArgNo)) {
3096 printType(Out, FTy->getParamType(ArgNo),
3097 /*isSigned=*/PAL.paramHasAttr(ArgNo+1, Attribute::SExt));
3100 // Check if the argument is expected to be passed by value.
3101 if (I.paramHasAttr(ArgNo+1, Attribute::ByVal))
3102 writeOperandDeref(*AI);
3110 /// visitBuiltinCall - Handle the call to the specified builtin. Returns true
3111 /// if the entire call is handled, return false it it wasn't handled, and
3112 /// optionally set 'WroteCallee' if the callee has already been printed out.
3113 bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID,
3114 bool &WroteCallee) {
3117 // If this is an intrinsic that directly corresponds to a GCC
3118 // builtin, we emit it here.
3119 const char *BuiltinName = "";
3120 Function *F = I.getCalledFunction();
3121 #define GET_GCC_BUILTIN_NAME
3122 #include "llvm/Intrinsics.gen"
3123 #undef GET_GCC_BUILTIN_NAME
3124 assert(BuiltinName[0] && "Unknown LLVM intrinsic!");
3130 case Intrinsic::memory_barrier:
3131 Out << "__sync_synchronize()";
3133 case Intrinsic::vastart:
3136 Out << "va_start(*(va_list*)";
3137 writeOperand(I.getOperand(1));
3139 // Output the last argument to the enclosing function.
3140 if (I.getParent()->getParent()->arg_empty()) {
3142 raw_string_ostream Msg(msg);
3143 Msg << "The C backend does not currently support zero "
3144 << "argument varargs functions, such as '"
3145 << I.getParent()->getParent()->getName() << "'!";
3146 llvm_report_error(Msg.str());
3148 writeOperand(--I.getParent()->getParent()->arg_end());
3151 case Intrinsic::vaend:
3152 if (!isa<ConstantPointerNull>(I.getOperand(1))) {
3153 Out << "0; va_end(*(va_list*)";
3154 writeOperand(I.getOperand(1));
3157 Out << "va_end(*(va_list*)0)";
3160 case Intrinsic::vacopy:
3162 Out << "va_copy(*(va_list*)";
3163 writeOperand(I.getOperand(1));
3164 Out << ", *(va_list*)";
3165 writeOperand(I.getOperand(2));
3168 case Intrinsic::returnaddress:
3169 Out << "__builtin_return_address(";
3170 writeOperand(I.getOperand(1));
3173 case Intrinsic::frameaddress:
3174 Out << "__builtin_frame_address(";
3175 writeOperand(I.getOperand(1));
3178 case Intrinsic::powi:
3179 Out << "__builtin_powi(";
3180 writeOperand(I.getOperand(1));
3182 writeOperand(I.getOperand(2));
3185 case Intrinsic::setjmp:
3186 Out << "setjmp(*(jmp_buf*)";
3187 writeOperand(I.getOperand(1));
3190 case Intrinsic::longjmp:
3191 Out << "longjmp(*(jmp_buf*)";
3192 writeOperand(I.getOperand(1));
3194 writeOperand(I.getOperand(2));
3197 case Intrinsic::prefetch:
3198 Out << "LLVM_PREFETCH((const void *)";
3199 writeOperand(I.getOperand(1));
3201 writeOperand(I.getOperand(2));
3203 writeOperand(I.getOperand(3));
3206 case Intrinsic::stacksave:
3207 // Emit this as: Val = 0; *((void**)&Val) = __builtin_stack_save()
3208 // to work around GCC bugs (see PR1809).
3209 Out << "0; *((void**)&" << GetValueName(&I)
3210 << ") = __builtin_stack_save()";
3212 case Intrinsic::x86_sse_cmp_ss:
3213 case Intrinsic::x86_sse_cmp_ps:
3214 case Intrinsic::x86_sse2_cmp_sd:
3215 case Intrinsic::x86_sse2_cmp_pd:
3217 printType(Out, I.getType());
3219 // Multiple GCC builtins multiplex onto this intrinsic.
3220 switch (cast<ConstantInt>(I.getOperand(3))->getZExtValue()) {
3221 default: llvm_unreachable("Invalid llvm.x86.sse.cmp!");
3222 case 0: Out << "__builtin_ia32_cmpeq"; break;
3223 case 1: Out << "__builtin_ia32_cmplt"; break;
3224 case 2: Out << "__builtin_ia32_cmple"; break;
3225 case 3: Out << "__builtin_ia32_cmpunord"; break;
3226 case 4: Out << "__builtin_ia32_cmpneq"; break;
3227 case 5: Out << "__builtin_ia32_cmpnlt"; break;
3228 case 6: Out << "__builtin_ia32_cmpnle"; break;
3229 case 7: Out << "__builtin_ia32_cmpord"; break;
3231 if (ID == Intrinsic::x86_sse_cmp_ps || ID == Intrinsic::x86_sse2_cmp_pd)
3235 if (ID == Intrinsic::x86_sse_cmp_ss || ID == Intrinsic::x86_sse_cmp_ps)
3241 writeOperand(I.getOperand(1));
3243 writeOperand(I.getOperand(2));
3246 case Intrinsic::ppc_altivec_lvsl:
3248 printType(Out, I.getType());
3250 Out << "__builtin_altivec_lvsl(0, (void*)";
3251 writeOperand(I.getOperand(1));
3257 //This converts the llvm constraint string to something gcc is expecting.
3258 //TODO: work out platform independent constraints and factor those out
3259 // of the per target tables
3260 // handle multiple constraint codes
3261 std::string CWriter::InterpretASMConstraint(InlineAsm::ConstraintInfo& c) {
3263 assert(c.Codes.size() == 1 && "Too many asm constraint codes to handle");
3265 const char *const *table = 0;
3267 // Grab the translation table from MCAsmInfo if it exists.
3269 std::string Triple = TheModule->getTargetTriple();
3271 Triple = llvm::sys::getHostTriple();
3274 if (const Target *Match = TargetRegistry::lookupTarget(Triple, E))
3275 TAsm = Match->createAsmInfo(Triple);
3278 table = TAsm->getAsmCBE();
3280 // Search the translation table if it exists.
3281 for (int i = 0; table && table[i]; i += 2)
3282 if (c.Codes[0] == table[i])
3285 // Default is identity.
3289 //TODO: import logic from AsmPrinter.cpp
3290 static std::string gccifyAsm(std::string asmstr) {
3291 for (std::string::size_type i = 0; i != asmstr.size(); ++i)
3292 if (asmstr[i] == '\n')
3293 asmstr.replace(i, 1, "\\n");
3294 else if (asmstr[i] == '\t')
3295 asmstr.replace(i, 1, "\\t");
3296 else if (asmstr[i] == '$') {
3297 if (asmstr[i + 1] == '{') {
3298 std::string::size_type a = asmstr.find_first_of(':', i + 1);
3299 std::string::size_type b = asmstr.find_first_of('}', i + 1);
3300 std::string n = "%" +
3301 asmstr.substr(a + 1, b - a - 1) +
3302 asmstr.substr(i + 2, a - i - 2);
3303 asmstr.replace(i, b - i + 1, n);
3306 asmstr.replace(i, 1, "%");
3308 else if (asmstr[i] == '%')//grr
3309 { asmstr.replace(i, 1, "%%"); ++i;}
3314 //TODO: assumptions about what consume arguments from the call are likely wrong
3315 // handle communitivity
3316 void CWriter::visitInlineAsm(CallInst &CI) {
3317 InlineAsm* as = cast<InlineAsm>(CI.getOperand(0));
3318 std::vector<InlineAsm::ConstraintInfo> Constraints = as->ParseConstraints();
3320 std::vector<std::pair<Value*, int> > ResultVals;
3321 if (CI.getType() == Type::getVoidTy(CI.getContext()))
3323 else if (const StructType *ST = dyn_cast<StructType>(CI.getType())) {
3324 for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i)
3325 ResultVals.push_back(std::make_pair(&CI, (int)i));
3327 ResultVals.push_back(std::make_pair(&CI, -1));
3330 // Fix up the asm string for gcc and emit it.
3331 Out << "__asm__ volatile (\"" << gccifyAsm(as->getAsmString()) << "\"\n";
3334 unsigned ValueCount = 0;
3335 bool IsFirst = true;
3337 // Convert over all the output constraints.
3338 for (std::vector<InlineAsm::ConstraintInfo>::iterator I = Constraints.begin(),
3339 E = Constraints.end(); I != E; ++I) {
3341 if (I->Type != InlineAsm::isOutput) {
3343 continue; // Ignore non-output constraints.
3346 assert(I->Codes.size() == 1 && "Too many asm constraint codes to handle");
3347 std::string C = InterpretASMConstraint(*I);
3348 if (C.empty()) continue;
3359 if (ValueCount < ResultVals.size()) {
3360 DestVal = ResultVals[ValueCount].first;
3361 DestValNo = ResultVals[ValueCount].second;
3363 DestVal = CI.getOperand(ValueCount-ResultVals.size()+1);
3365 if (I->isEarlyClobber)
3368 Out << "\"=" << C << "\"(" << GetValueName(DestVal);
3369 if (DestValNo != -1)
3370 Out << ".field" << DestValNo; // Multiple retvals.
3376 // Convert over all the input constraints.
3380 for (std::vector<InlineAsm::ConstraintInfo>::iterator I = Constraints.begin(),
3381 E = Constraints.end(); I != E; ++I) {
3382 if (I->Type != InlineAsm::isInput) {
3384 continue; // Ignore non-input constraints.
3387 assert(I->Codes.size() == 1 && "Too many asm constraint codes to handle");
3388 std::string C = InterpretASMConstraint(*I);
3389 if (C.empty()) continue;
3396 assert(ValueCount >= ResultVals.size() && "Input can't refer to result");
3397 Value *SrcVal = CI.getOperand(ValueCount-ResultVals.size()+1);
3399 Out << "\"" << C << "\"(";
3401 writeOperand(SrcVal);
3403 writeOperandDeref(SrcVal);
3407 // Convert over the clobber constraints.
3409 for (std::vector<InlineAsm::ConstraintInfo>::iterator I = Constraints.begin(),
3410 E = Constraints.end(); I != E; ++I) {
3411 if (I->Type != InlineAsm::isClobber)
3412 continue; // Ignore non-input constraints.
3414 assert(I->Codes.size() == 1 && "Too many asm constraint codes to handle");
3415 std::string C = InterpretASMConstraint(*I);
3416 if (C.empty()) continue;
3423 Out << '\"' << C << '"';
3429 void CWriter::visitAllocaInst(AllocaInst &I) {
3431 printType(Out, I.getType());
3432 Out << ") alloca(sizeof(";
3433 printType(Out, I.getType()->getElementType());
3435 if (I.isArrayAllocation()) {
3437 writeOperand(I.getOperand(0));
3442 void CWriter::printGEPExpression(Value *Ptr, gep_type_iterator I,
3443 gep_type_iterator E, bool Static) {
3445 // If there are no indices, just print out the pointer.
3451 // Find out if the last index is into a vector. If so, we have to print this
3452 // specially. Since vectors can't have elements of indexable type, only the
3453 // last index could possibly be of a vector element.
3454 const VectorType *LastIndexIsVector = 0;
3456 for (gep_type_iterator TmpI = I; TmpI != E; ++TmpI)
3457 LastIndexIsVector = dyn_cast<VectorType>(*TmpI);
3462 // If the last index is into a vector, we can't print it as &a[i][j] because
3463 // we can't index into a vector with j in GCC. Instead, emit this as
3464 // (((float*)&a[i])+j)
3465 if (LastIndexIsVector) {
3467 printType(Out, PointerType::getUnqual(LastIndexIsVector->getElementType()));
3473 // If the first index is 0 (very typical) we can do a number of
3474 // simplifications to clean up the code.
3475 Value *FirstOp = I.getOperand();
3476 if (!isa<Constant>(FirstOp) || !cast<Constant>(FirstOp)->isNullValue()) {
3477 // First index isn't simple, print it the hard way.
3480 ++I; // Skip the zero index.
3482 // Okay, emit the first operand. If Ptr is something that is already address
3483 // exposed, like a global, avoid emitting (&foo)[0], just emit foo instead.
3484 if (isAddressExposed(Ptr)) {
3485 writeOperandInternal(Ptr, Static);
3486 } else if (I != E && isa<StructType>(*I)) {
3487 // If we didn't already emit the first operand, see if we can print it as
3488 // P->f instead of "P[0].f"
3490 Out << "->field" << cast<ConstantInt>(I.getOperand())->getZExtValue();
3491 ++I; // eat the struct index as well.
3493 // Instead of emitting P[0][1], emit (*P)[1], which is more idiomatic.
3500 for (; I != E; ++I) {
3501 if (isa<StructType>(*I)) {
3502 Out << ".field" << cast<ConstantInt>(I.getOperand())->getZExtValue();
3503 } else if (isa<ArrayType>(*I)) {
3505 writeOperandWithCast(I.getOperand(), Instruction::GetElementPtr);
3507 } else if (!isa<VectorType>(*I)) {
3509 writeOperandWithCast(I.getOperand(), Instruction::GetElementPtr);
3512 // If the last index is into a vector, then print it out as "+j)". This
3513 // works with the 'LastIndexIsVector' code above.
3514 if (isa<Constant>(I.getOperand()) &&
3515 cast<Constant>(I.getOperand())->isNullValue()) {
3516 Out << "))"; // avoid "+0".
3519 writeOperandWithCast(I.getOperand(), Instruction::GetElementPtr);
3527 void CWriter::writeMemoryAccess(Value *Operand, const Type *OperandType,
3528 bool IsVolatile, unsigned Alignment) {
3530 bool IsUnaligned = Alignment &&
3531 Alignment < TD->getABITypeAlignment(OperandType);
3535 if (IsVolatile || IsUnaligned) {
3538 Out << "struct __attribute__ ((packed, aligned(" << Alignment << "))) {";
3539 printType(Out, OperandType, false, IsUnaligned ? "data" : "volatile*");
3542 if (IsVolatile) Out << "volatile ";
3548 writeOperand(Operand);
3550 if (IsVolatile || IsUnaligned) {
3557 void CWriter::visitLoadInst(LoadInst &I) {
3558 writeMemoryAccess(I.getOperand(0), I.getType(), I.isVolatile(),
3563 void CWriter::visitStoreInst(StoreInst &I) {
3564 writeMemoryAccess(I.getPointerOperand(), I.getOperand(0)->getType(),
3565 I.isVolatile(), I.getAlignment());
3567 Value *Operand = I.getOperand(0);
3568 Constant *BitMask = 0;
3569 if (const IntegerType* ITy = dyn_cast<IntegerType>(Operand->getType()))
3570 if (!ITy->isPowerOf2ByteWidth())
3571 // We have a bit width that doesn't match an even power-of-2 byte
3572 // size. Consequently we must & the value with the type's bit mask
3573 BitMask = ConstantInt::get(ITy, ITy->getBitMask());
3576 writeOperand(Operand);
3579 printConstant(BitMask, false);
3584 void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) {
3585 printGEPExpression(I.getPointerOperand(), gep_type_begin(I),
3586 gep_type_end(I), false);
3589 void CWriter::visitVAArgInst(VAArgInst &I) {
3590 Out << "va_arg(*(va_list*)";
3591 writeOperand(I.getOperand(0));
3593 printType(Out, I.getType());
3597 void CWriter::visitInsertElementInst(InsertElementInst &I) {
3598 const Type *EltTy = I.getType()->getElementType();
3599 writeOperand(I.getOperand(0));
3602 printType(Out, PointerType::getUnqual(EltTy));
3603 Out << ")(&" << GetValueName(&I) << "))[";
3604 writeOperand(I.getOperand(2));
3606 writeOperand(I.getOperand(1));
3610 void CWriter::visitExtractElementInst(ExtractElementInst &I) {
3611 // We know that our operand is not inlined.
3614 cast<VectorType>(I.getOperand(0)->getType())->getElementType();
3615 printType(Out, PointerType::getUnqual(EltTy));
3616 Out << ")(&" << GetValueName(I.getOperand(0)) << "))[";
3617 writeOperand(I.getOperand(1));
3621 void CWriter::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
3623 printType(Out, SVI.getType());
3625 const VectorType *VT = SVI.getType();
3626 unsigned NumElts = VT->getNumElements();
3627 const Type *EltTy = VT->getElementType();
3629 for (unsigned i = 0; i != NumElts; ++i) {
3631 int SrcVal = SVI.getMaskValue(i);
3632 if ((unsigned)SrcVal >= NumElts*2) {
3633 Out << " 0/*undef*/ ";
3635 Value *Op = SVI.getOperand((unsigned)SrcVal >= NumElts);
3636 if (isa<Instruction>(Op)) {
3637 // Do an extractelement of this value from the appropriate input.
3639 printType(Out, PointerType::getUnqual(EltTy));
3640 Out << ")(&" << GetValueName(Op)
3641 << "))[" << (SrcVal & (NumElts-1)) << "]";
3642 } else if (isa<ConstantAggregateZero>(Op) || isa<UndefValue>(Op)) {
3645 printConstant(cast<ConstantVector>(Op)->getOperand(SrcVal &
3654 void CWriter::visitInsertValueInst(InsertValueInst &IVI) {
3655 // Start by copying the entire aggregate value into the result variable.
3656 writeOperand(IVI.getOperand(0));
3659 // Then do the insert to update the field.
3660 Out << GetValueName(&IVI);
3661 for (const unsigned *b = IVI.idx_begin(), *i = b, *e = IVI.idx_end();
3663 const Type *IndexedTy =
3664 ExtractValueInst::getIndexedType(IVI.getOperand(0)->getType(), b, i+1);
3665 if (isa<ArrayType>(IndexedTy))
3666 Out << ".array[" << *i << "]";
3668 Out << ".field" << *i;
3671 writeOperand(IVI.getOperand(1));
3674 void CWriter::visitExtractValueInst(ExtractValueInst &EVI) {
3676 if (isa<UndefValue>(EVI.getOperand(0))) {
3678 printType(Out, EVI.getType());
3679 Out << ") 0/*UNDEF*/";
3681 Out << GetValueName(EVI.getOperand(0));
3682 for (const unsigned *b = EVI.idx_begin(), *i = b, *e = EVI.idx_end();
3684 const Type *IndexedTy =
3685 ExtractValueInst::getIndexedType(EVI.getOperand(0)->getType(), b, i+1);
3686 if (isa<ArrayType>(IndexedTy))
3687 Out << ".array[" << *i << "]";
3689 Out << ".field" << *i;
3695 //===----------------------------------------------------------------------===//
3696 // External Interface declaration
3697 //===----------------------------------------------------------------------===//
3699 bool CTargetMachine::addPassesToEmitWholeFile(PassManager &PM,
3700 formatted_raw_ostream &o,
3701 CodeGenFileType FileType,
3702 CodeGenOpt::Level OptLevel) {
3703 if (FileType != TargetMachine::AssemblyFile) return true;
3705 PM.add(createGCLoweringPass());
3706 PM.add(createLowerInvokePass());
3707 PM.add(createCFGSimplificationPass()); // clean up after lower invoke.
3708 PM.add(new CBackendNameAllUsedStructsAndMergeFunctions());
3709 PM.add(new CWriter(o));
3710 PM.add(createGCInfoDeleter());