CGExprConstant.cpp revision af2f62ce32e462f256855cd24b06dec4755d2827
13b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// 23b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 33b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// The LLVM Compiler Infrastructure 43b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 53b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// This file is distributed under the University of Illinois Open Source 63b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// License. See LICENSE.TXT for details. 73b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 83b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson//===----------------------------------------------------------------------===// 93b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 103b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// This contains code to emit Constant Expr nodes as LLVM code. 113b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 123b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson//===----------------------------------------------------------------------===// 133b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 143b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "CodeGenFunction.h" 153b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "CodeGenModule.h" 16af2f62ce32e462f256855cd24b06dec4755d2827Daniel Dunbar#include "CGObjCRuntime.h" 17de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 18de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 193b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "llvm/Constants.h" 203b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "llvm/Function.h" 213b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "llvm/GlobalVariable.h" 223b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "llvm/Support/Compiler.h" 23a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman#include "llvm/Target/TargetData.h" 243b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonusing namespace clang; 253b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonusing namespace CodeGen; 263b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 273b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonnamespace { 2884005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlssonclass VISIBILITY_HIDDEN ConstExprEmitter : 2984005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 303b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson CodeGenModule &CGM; 31813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio CodeGenFunction *CGF; 323b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonpublic: 33813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 34813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio : CGM(cgm), CGF(cgf) { 353b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 363b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 373b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson //===--------------------------------------------------------------------===// 383b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Visitor Methods 393b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson //===--------------------------------------------------------------------===// 403b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 413b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitStmt(Stmt *S) { 423b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson CGM.WarnUnsupported(S, "constant expression"); 4398be4943e8dc4f3905629a7102668960873cf863Chris Lattner QualType T = cast<Expr>(S)->getType(); 4498be4943e8dc4f3905629a7102668960873cf863Chris Lattner return llvm::UndefValue::get(CGM.getTypes().ConvertType(T)); 453b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 463b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 473b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitParenExpr(ParenExpr *PE) { 483b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return Visit(PE->getSubExpr()); 493b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 503b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 513b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Leaves 523b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitIntegerLiteral(const IntegerLiteral *E) { 533b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantInt::get(E->getValue()); 543b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 553b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitFloatingLiteral(const FloatingLiteral *E) { 5659138ba7ce960888433546639deb45e2e03f8857Chris Lattner return llvm::ConstantFP::get(E->getValue()); 573b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 583b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitCharacterLiteral(const CharacterLiteral *E) { 593b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 603b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 613b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 623b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 633b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6413fd7e5111032f54b538dd66d035b0ccc1f82467Chris Lattner llvm::Constant *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 65bbce49b9e5c6d7f05926b89f8e6fd235ae01c250Daniel Dunbar std::string S(E->getString()->getStrData(), 66bbce49b9e5c6d7f05926b89f8e6fd235ae01c250Daniel Dunbar E->getString()->getByteLength()); 67bbce49b9e5c6d7f05926b89f8e6fd235ae01c250Daniel Dunbar llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(S); 68bbce49b9e5c6d7f05926b89f8e6fd235ae01c250Daniel Dunbar return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 6913fd7e5111032f54b538dd66d035b0ccc1f82467Chris Lattner } 703b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 713b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 723b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return Visit(E->getInitializer()); 733b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 743b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 753b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitCastExpr(const CastExpr* E) { 763b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *C = Visit(E->getSubExpr()); 773b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 783b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return EmitConversion(C, E->getSubExpr()->getType(), E->getType()); 793b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 80f6884ac7cfc4c5562c0678ad65b3460a38f56e23Anders Carlsson 8104421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 8204421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 8304421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 8404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner 85a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 864d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman std::vector<llvm::Constant*> Elts; 87a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::ArrayType *AType = 88a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman cast<llvm::ArrayType>(ConvertType(ILE->getType())); 894d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman unsigned NumInitElements = ILE->getNumInits(); 904d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman // FIXME: Check for wide strings 914d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman if (NumInitElements > 0 && isa<StringLiteral>(ILE->getInit(0)) && 92c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType()) 934d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman return Visit(ILE->getInit(0)); 94eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel const llvm::Type *ElemTy = AType->getElementType(); 95eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned NumElements = AType->getNumElements(); 96eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 97eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Initialising an array requires us to automatically 98eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // initialise any elements that have not been initialised explicitly 99eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned NumInitableElts = std::min(NumInitElements, NumElements); 100eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 101eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Copy initializer elements. 102eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned i = 0; 103a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman bool RewriteType = false; 104eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel for (; i < NumInitableElts; ++i) { 105eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::Constant *C = Visit(ILE->getInit(i)); 106a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman RewriteType |= (C->getType() != ElemTy); 107eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel Elts.push_back(C); 1083b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 109a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman 110eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Initialize remaining array elements. 111eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel for (; i < NumElements; ++i) 112eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 113eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 114a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman if (RewriteType) { 115a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman // FIXME: Try to avoid packing the array 116a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman std::vector<const llvm::Type*> Types; 117a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman for (unsigned i = 0; i < Elts.size(); ++i) 118a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman Types.push_back(Elts[i]->getType()); 119a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman const llvm::StructType *SType = llvm::StructType::get(Types, true); 120a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman return llvm::ConstantStruct::get(SType, Elts); 121a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman } 122a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman 123eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel return llvm::ConstantArray::get(AType, Elts); 124eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 125eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 126a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts, 127a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman FieldDecl* Field, Expr* E) { 128a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Calculate the value to insert 129a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *C = Visit(E); 130a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C); 131a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (!CI) { 132a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman CGM.WarnUnsupported(E, "bitfield initialization"); 133a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return; 134a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 135a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::APInt V = CI->getValue(); 136a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 137a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Calculate information about the relevant field 138a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::Type* Ty = CI->getType(); 1399ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar const llvm::TargetData &TD = CGM.getTypes().getTargetData(); 1409ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar unsigned size = TD.getTypeStoreSizeInBits(Ty); 141a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned fieldOffset = CGM.getTypes().getLLVMFieldNo(Field) * size; 142a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman CodeGenTypes::BitFieldInfo bitFieldInfo = 143a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman CGM.getTypes().getBitFieldInfo(Field); 144a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman fieldOffset += bitFieldInfo.Begin; 145a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 146a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Find where to start the insertion 147a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: This is O(n^2) in the number of bit-fields! 148a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: This won't work if the struct isn't completely packed! 149a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned offset = 0, i = 0; 150a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman while (offset < (fieldOffset & -8)) 1519ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar offset += TD.getTypeStoreSizeInBits(Elts[i++]->getType()); 1529ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar 1539ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar // Advance over 0 sized elements (must terminate in bounds since 1549ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar // the bitfield must have a size). 1559ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar while (TD.getTypeStoreSizeInBits(Elts[i]->getType()) == 0) 1569ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar ++i; 157a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 1581f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar // Promote the size of V if necessary 1591f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar // FIXME: This should never occur, but currently it can because 1601f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar // initializer constants are cast to bool, and because clang is 1611f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar // not enforcing bitfield width limits. 1621f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar if (bitFieldInfo.Size > V.getBitWidth()) 1631f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar V.zext(bitFieldInfo.Size); 1641f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar 165a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Insert the bits into the struct 166a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: This algorthm is only correct on X86! 167a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: THis algorthm assumes bit-fields only have byte-size elements! 168a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned bitsToInsert = bitFieldInfo.Size; 169a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned curBits = std::min(8 - (fieldOffset & 7), bitsToInsert); 170a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned byte = V.getLoBits(curBits).getZExtValue() << (fieldOffset & 7); 171a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman do { 172a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant* byteC = llvm::ConstantInt::get(llvm::Type::Int8Ty, byte); 173a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman Elts[i] = llvm::ConstantExpr::getOr(Elts[i], byteC); 174a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman ++i; 175a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman V = V.lshr(curBits); 176a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman bitsToInsert -= curBits; 177eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 178a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (!bitsToInsert) 179a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman break; 180a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 181a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman curBits = bitsToInsert > 8 ? 8 : bitsToInsert; 182a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman byte = V.getLoBits(curBits).getZExtValue(); 183a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } while (true); 184a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 185a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 186a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { 187a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::StructType *SType = 188a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman cast<llvm::StructType>(ConvertType(ILE->getType())); 189017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 190eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel std::vector<llvm::Constant*> Elts; 191017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman 192017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman // Initialize the whole structure to zero. 193017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman for (unsigned i = 0; i < SType->getNumElements(); ++i) { 194017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman const llvm::Type *FieldTy = SType->getElementType(i); 195017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman Elts.push_back(llvm::Constant::getNullValue(FieldTy)); 196017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman } 197eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 198eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Copy initializer elements. Skip padding fields. 199eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned EltNo = 0; // Element no in ILE 200017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman int FieldNo = 0; // Field no in RecordDecl 201a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman bool RewriteType = false; 202017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman while (EltNo < ILE->getNumInits() && FieldNo < RD->getNumMembers()) { 203017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman FieldDecl* curField = RD->getMember(FieldNo); 204017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman FieldNo++; 205017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman if (!curField->getIdentifier()) 206eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel continue; 207017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman 208017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman if (curField->isBitField()) { 209a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(EltNo)); 210017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman } else { 211a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(curField); 212a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman llvm::Constant* C = Visit(ILE->getInit(EltNo)); 213a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman RewriteType |= (C->getType() != Elts[FieldNo]->getType()); 214a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman Elts[FieldNo] = C; 215017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman } 216eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel EltNo++; 217eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 218017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman 219a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman if (RewriteType) { 220a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman // FIXME: Make this work for non-packed structs 221a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman assert(SType->isPacked() && "Cannot recreate unpacked structs"); 222a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman std::vector<const llvm::Type*> Types; 223a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman for (unsigned i = 0; i < Elts.size(); ++i) 224a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman Types.push_back(Elts[i]->getType()); 225a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman SType = llvm::StructType::get(Types, true); 226a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman } 227a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman 228eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel return llvm::ConstantStruct::get(SType, Elts); 229eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 23047fb6977509a285501d02611845e9f8e081a15e1Devang Patel 231a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) { 232a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 233a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::Type *Ty = ConvertType(ILE->getType()); 234a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 235a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Find the field decl we're initializing, if any 236a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman int FieldNo = 0; // Field no in RecordDecl 237c55f98dbdffb73894a8dbe7b0ce176604fe42127Eli Friedman FieldDecl* curField = 0; 238c55f98dbdffb73894a8dbe7b0ce176604fe42127Eli Friedman while (FieldNo < RD->getNumMembers()) { 239a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman curField = RD->getMember(FieldNo); 240a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman FieldNo++; 241c55f98dbdffb73894a8dbe7b0ce176604fe42127Eli Friedman if (curField->getIdentifier()) 242c55f98dbdffb73894a8dbe7b0ce176604fe42127Eli Friedman break; 243c55f98dbdffb73894a8dbe7b0ce176604fe42127Eli Friedman } 244a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 245c55f98dbdffb73894a8dbe7b0ce176604fe42127Eli Friedman if (!curField || !curField->getIdentifier() || ILE->getNumInits() == 0) 246a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return llvm::Constant::getNullValue(Ty); 247a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 248a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (curField->isBitField()) { 249a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Create a dummy struct for bit-field insertion 250a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned NumElts = CGM.getTargetData().getABITypeSize(Ty) / 8; 251a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant* NV = llvm::Constant::getNullValue(llvm::Type::Int8Ty); 252a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman std::vector<llvm::Constant*> Elts(NumElts, NV); 253eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 254a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0)); 255a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::ArrayType *RetTy = 256a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::ArrayType::get(NV->getType(), NumElts); 257a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return llvm::ConstantArray::get(RetTy, Elts); 258a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 259a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 260a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *C = Visit(ILE->getInit(0)); 261a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 262a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Build a struct with the union sub-element as the first member, 263a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // and padded to the appropriate size 264a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman std::vector<llvm::Constant*> Elts; 265a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman std::vector<const llvm::Type*> Types; 266a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman Elts.push_back(C); 267a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman Types.push_back(C->getType()); 268a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned CurSize = CGM.getTargetData().getTypeStoreSize(C->getType()); 269a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned TotalSize = CGM.getTargetData().getTypeStoreSize(Ty); 270a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman while (CurSize < TotalSize) { 271a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman Elts.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty)); 272a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman Types.push_back(llvm::Type::Int8Ty); 273a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman CurSize++; 274a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 275a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 276a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // This always generates a packed struct 277a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: Try to generate an unpacked struct when we can 278a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::StructType* STy = llvm::StructType::get(Types, true); 279a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return llvm::ConstantStruct::get(STy, Elts); 280a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 281a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 282a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) { 283a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::VectorType *VType = 284a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman cast<llvm::VectorType>(ConvertType(ILE->getType())); 285cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman const llvm::Type *ElemTy = VType->getElementType(); 286cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman std::vector<llvm::Constant*> Elts; 287eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned NumElements = VType->getNumElements(); 288cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman unsigned NumInitElements = ILE->getNumInits(); 289cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman 290cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman unsigned NumInitableElts = std::min(NumInitElements, NumElements); 29147fb6977509a285501d02611845e9f8e081a15e1Devang Patel 2923b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Copy initializer elements. 2933b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson unsigned i = 0; 294cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman for (; i < NumInitableElts; ++i) { 2953b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *C = Visit(ILE->getInit(i)); 2963b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson Elts.push_back(C); 2973b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 298eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 299cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman for (; i < NumElements; ++i) 300cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 301cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman 302eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel return llvm::ConstantVector::get(VType, Elts); 303eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 304eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 305eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 306a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isScalarType()) { 307a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // We have a scalar in braces. Just use the first element. 308a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getNumInits() > 0) 309eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel return Visit(ILE->getInit(0)); 310a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 311a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::Type* RetTy = CGM.getTypes().ConvertType(ILE->getType()); 312a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return llvm::Constant::getNullValue(RetTy); 31347fb6977509a285501d02611845e9f8e081a15e1Devang Patel } 31447fb6977509a285501d02611845e9f8e081a15e1Devang Patel 315a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isArrayType()) 316a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitArrayInitialization(ILE); 317a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 318a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isStructureType()) 319a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitStructInitialization(ILE); 320a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 321a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isUnionType()) 322a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitUnionInitialization(ILE); 323a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 324a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isVectorType()) 325a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitVectorInitialization(ILE); 32647fb6977509a285501d02611845e9f8e081a15e1Devang Patel 327eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel assert(0 && "Unable to handle InitListExpr"); 3282b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner // Get rid of control reaches end of void function warning. 3292b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner // Not reached. 3302b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner return 0; 3313b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3323b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman 3333b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) { 3343b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman Expr* SExpr = ICExpr->getSubExpr(); 3353b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman QualType SType = SExpr->getType(); 3363b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman llvm::Constant *C; // the intermediate expression 3373b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman QualType T; // the type of the intermediate expression 3383b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman if (SType->isArrayType()) { 3393b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman // Arrays decay to a pointer to the first element 3403b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman // VLAs would require special handling, but they can't occur here 3413b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman C = EmitLValue(SExpr); 3423b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 3433b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *Ops[] = {Idx0, Idx0}; 3443b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 345c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner T = CGM.getContext().getArrayDecayedType(SType); 3463b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman } else if (SType->isFunctionType()) { 3473b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman // Function types decay to a pointer to the function 3483b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman C = EmitLValue(SExpr); 3493b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman T = CGM.getContext().getPointerType(SType); 3503b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman } else { 3513b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman C = Visit(SExpr); 3523b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman T = SType; 3533b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3543b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman 3553b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman // Perform the conversion; note that an implicit cast can both promote 3563b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman // and convert an array/function 3573b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman return EmitConversion(C, T, ICExpr->getType()); 3583b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3593b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman 3603b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitStringLiteral(StringLiteral *E) { 361a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner assert(!E->getType()->isPointerType() && "Strings are always arrays"); 3623b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 3633b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Otherwise this must be a string initializing an array in a static 3643b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // initializer. Don't emit it as the address of the string, emit the string 3653b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // data itself as an inline array. 3661e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar return llvm::ConstantArray::get(CGM.getStringForStringLiteral(E), false); 3673b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3683b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 3693b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitDeclRefExpr(DeclRefExpr *E) { 3703b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson const ValueDecl *Decl = E->getDecl(); 371a3881fc62ac1ddbf9c236fffd47b637fb4745bbdAnders Carlsson if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(Decl)) 372a3881fc62ac1ddbf9c236fffd47b637fb4745bbdAnders Carlsson return llvm::ConstantInt::get(EC->getInitVal()); 3733b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert(0 && "Unsupported decl ref type!"); 3743b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return 0; 3753b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3763b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 3773b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) { 3783b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return EmitSizeAlignOf(E->getArgumentType(), E->getType(), E->isSizeOf()); 3793b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3803b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 3813b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Unary operators 3823b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitUnaryPlus(const UnaryOperator *E) { 3833b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return Visit(E->getSubExpr()); 3843b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3853b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitUnaryMinus(const UnaryOperator *E) { 3863b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getNeg(Visit(E->getSubExpr())); 3873b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3883b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitUnaryNot(const UnaryOperator *E) { 3893b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getNot(Visit(E->getSubExpr())); 3903b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3913b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitUnaryLNot(const UnaryOperator *E) { 3923b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *SubExpr = Visit(E->getSubExpr()); 3933b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 3943b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (E->getSubExpr()->getType()->isRealFloatingType()) { 3953b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Compare against 0.0 for fp scalars. 3963b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType()); 3973b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson SubExpr = llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UEQ, SubExpr, 3983b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson Zero); 3993b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } else { 4003b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert((E->getSubExpr()->getType()->isIntegerType() || 4013b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson E->getSubExpr()->getType()->isPointerType()) && 4023b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson "Unknown scalar type to convert"); 4033b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Compare against an integer or pointer null. 4043b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType()); 4053b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson SubExpr = llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, SubExpr, 4063b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson Zero); 4073b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 4083b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 4093b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getZExt(SubExpr, ConvertType(E->getType())); 4103b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 4113b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitUnarySizeOf(const UnaryOperator *E) { 4123b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), true); 4133b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 4143b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitUnaryAlignOf(const UnaryOperator *E) { 4153b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), false); 4163b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 417e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson llvm::Constant *VisitUnaryAddrOf(const UnaryOperator *E) { 418e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson return EmitLValue(E->getSubExpr()); 419e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 4205a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson llvm::Constant *VisitUnaryOffsetOf(const UnaryOperator *E) { 4215a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson int64_t Val = E->evaluateOffsetOf(CGM.getContext()); 4225a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 4235a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(E->getType()->isIntegerType() && "Result type must be an integer!"); 4245a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 42598be4943e8dc4f3905629a7102668960873cf863Chris Lattner uint32_t ResultWidth = 42698be4943e8dc4f3905629a7102668960873cf863Chris Lattner static_cast<uint32_t>(CGM.getContext().getTypeSize(E->getType())); 4275a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 4285a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } 429bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman 430bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 431bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman return Visit(E->getSubExpr()); 432bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman } 4333b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 434ce6237edf61ce3e5b8686f303513412c43e69058Anders Carlsson // Binary operators 435ce6237edf61ce3e5b8686f303513412c43e69058Anders Carlsson llvm::Constant *VisitBinOr(const BinaryOperator *E) { 436ce6237edf61ce3e5b8686f303513412c43e69058Anders Carlsson llvm::Constant *LHS = Visit(E->getLHS()); 437ce6237edf61ce3e5b8686f303513412c43e69058Anders Carlsson llvm::Constant *RHS = Visit(E->getRHS()); 438ce6237edf61ce3e5b8686f303513412c43e69058Anders Carlsson 439ce6237edf61ce3e5b8686f303513412c43e69058Anders Carlsson return llvm::ConstantExpr::getOr(LHS, RHS); 440ce6237edf61ce3e5b8686f303513412c43e69058Anders Carlsson } 4417be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *VisitBinSub(const BinaryOperator *E) { 4427be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *LHS = Visit(E->getLHS()); 4437be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *RHS = Visit(E->getRHS()); 4447be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4457be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson if (!isa<llvm::PointerType>(RHS->getType())) { 4467be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson // pointer - int 4477be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson if (isa<llvm::PointerType>(LHS->getType())) { 4487be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *Idx = llvm::ConstantExpr::getNeg(RHS); 4497be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4507be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getGetElementPtr(LHS, &Idx, 1); 4517be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson } 4527be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4537be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson // int - int 4547be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getSub(LHS, RHS); 4557be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson } 45677e1dfcffe9ed0078b015418182784b56532998cNuno Lopes 45777e1dfcffe9ed0078b015418182784b56532998cNuno Lopes assert(isa<llvm::PointerType>(LHS->getType())); 45877e1dfcffe9ed0078b015418182784b56532998cNuno Lopes 45977e1dfcffe9ed0078b015418182784b56532998cNuno Lopes const llvm::Type *ResultType = ConvertType(E->getType()); 46077e1dfcffe9ed0078b015418182784b56532998cNuno Lopes const QualType Type = E->getLHS()->getType(); 46177e1dfcffe9ed0078b015418182784b56532998cNuno Lopes const QualType ElementType = Type->getAsPointerType()->getPointeeType(); 46277e1dfcffe9ed0078b015418182784b56532998cNuno Lopes 46377e1dfcffe9ed0078b015418182784b56532998cNuno Lopes LHS = llvm::ConstantExpr::getPtrToInt(LHS, ResultType); 46477e1dfcffe9ed0078b015418182784b56532998cNuno Lopes RHS = llvm::ConstantExpr::getPtrToInt(RHS, ResultType); 46577e1dfcffe9ed0078b015418182784b56532998cNuno Lopes 46677e1dfcffe9ed0078b015418182784b56532998cNuno Lopes llvm::Constant *sub = llvm::ConstantExpr::getSub(LHS, RHS); 46777e1dfcffe9ed0078b015418182784b56532998cNuno Lopes llvm::Constant *size = EmitSizeAlignOf(ElementType, E->getType(), true); 46877e1dfcffe9ed0078b015418182784b56532998cNuno Lopes return llvm::ConstantExpr::getSDiv(sub, size); 4697be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson } 4707be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4717be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *VisitBinShl(const BinaryOperator *E) { 4727be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *LHS = Visit(E->getLHS()); 4737be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *RHS = Visit(E->getRHS()); 4747be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4757be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson // LLVM requires the LHS and RHS to be the same type: promote or truncate the 4767be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson // RHS to the same size as the LHS. 4777be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson if (LHS->getType() != RHS->getType()) 4787be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson RHS = llvm::ConstantExpr::getIntegerCast(RHS, LHS->getType(), false); 4797be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4807be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getShl(LHS, RHS); 4817be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson } 4827be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4837be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *VisitBinMul(const BinaryOperator *E) { 4847be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *LHS = Visit(E->getLHS()); 4857be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *RHS = Visit(E->getRHS()); 4867be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4877be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getMul(LHS, RHS); 4887be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson } 4897be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4907be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *VisitBinDiv(const BinaryOperator *E) { 4917be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *LHS = Visit(E->getLHS()); 4927be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *RHS = Visit(E->getRHS()); 4937be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 4947be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson if (LHS->getType()->isFPOrFPVector()) 4957be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getFDiv(LHS, RHS); 4967be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson else if (E->getType()->isUnsignedIntegerType()) 4977be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getUDiv(LHS, RHS); 4987be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson else 4997be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getSDiv(LHS, RHS); 5007be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson } 5017be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 5027be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *VisitBinAdd(const BinaryOperator *E) { 5037be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *LHS = Visit(E->getLHS()); 5047be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *RHS = Visit(E->getRHS()); 5057be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 5067be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson if (!E->getType()->isPointerType()) 5077be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getAdd(LHS, RHS); 5087be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 50987a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson llvm::Constant *Ptr, *Idx; 51087a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson if (isa<llvm::PointerType>(LHS->getType())) { // pointer + int 51187a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson Ptr = LHS; 51287a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson Idx = RHS; 51387a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson } else { // int + pointer 51487a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson Ptr = RHS; 51587a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson Idx = LHS; 51687a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson } 51787a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson 51887a98759d683d9ed23e09744207a4428c4ed5aceAnders Carlsson return llvm::ConstantExpr::getGetElementPtr(Ptr, &Idx, 1); 5197be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson } 5207be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 5217be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *VisitBinAnd(const BinaryOperator *E) { 5227be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *LHS = Visit(E->getLHS()); 5237be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson llvm::Constant *RHS = Visit(E->getRHS()); 524ce6237edf61ce3e5b8686f303513412c43e69058Anders Carlsson 5257be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson return llvm::ConstantExpr::getAnd(LHS, RHS); 5267be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson } 527bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman 528b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::Constant *EmitCmp(const BinaryOperator *E, 529b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::Predicate SignedPred, 530b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::Predicate UnsignedPred, 531b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::Predicate FloatPred) { 532bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::Constant *LHS = Visit(E->getLHS()); 533bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::Constant *RHS = Visit(E->getRHS()); 534b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::Constant *Result; 535b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman if (LHS->getType()->isInteger() || 536b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman isa<llvm::PointerType>(LHS->getType())) { 537b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman if (E->getLHS()->getType()->isSignedIntegerType()) 538b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman Result = llvm::ConstantExpr::getICmp(SignedPred, LHS, RHS); 539b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman else 540b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman Result = llvm::ConstantExpr::getICmp(UnsignedPred, LHS, RHS); 541b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman } else if (LHS->getType()->isFloatingPoint()) { 542b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman Result = llvm::ConstantExpr::getFCmp(FloatPred, LHS, RHS); 543b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman } else { 544bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman CGM.WarnUnsupported(E, "constant expression"); 545b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman Result = llvm::ConstantInt::getFalse(); 546bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman } 547b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman 548b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 549bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman return llvm::ConstantExpr::getZExtOrBitCast(Result, ResultType); 550bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman } 551bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman 552b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::Constant *VisitBinNE(const BinaryOperator *E) { 553b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman return EmitCmp(E, llvm::CmpInst::ICMP_NE, llvm::CmpInst::ICMP_NE, 554b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::FCMP_ONE); 555b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman } 556b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman 557b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::Constant *VisitBinEQ(const BinaryOperator *E) { 558b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman return EmitCmp(E, llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_EQ, 559b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::FCMP_OEQ); 560b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman } 561b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman 562b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::Constant *VisitBinLT(const BinaryOperator *E) { 563b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman return EmitCmp(E, llvm::CmpInst::ICMP_SLT, llvm::CmpInst::ICMP_ULT, 564b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::FCMP_OLT); 565b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman } 566b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman 567b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::Constant *VisitBinLE(const BinaryOperator *E) { 568b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman return EmitCmp(E, llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_ULE, 569b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::FCMP_OLE); 570b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman } 571b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman 572b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::Constant *VisitBinGT(const BinaryOperator *E) { 573b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman return EmitCmp(E, llvm::CmpInst::ICMP_SGT, llvm::CmpInst::ICMP_UGT, 574b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::FCMP_OGT); 575b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman } 576b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman 577b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::Constant *VisitBinGE(const BinaryOperator *E) { 578b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman return EmitCmp(E, llvm::CmpInst::ICMP_SGE, llvm::CmpInst::ICMP_SGE, 579b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman llvm::CmpInst::FCMP_OGE); 580b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman } 581b896596a94315485e1d5cfabfbc3f82fd7f96393Eli Friedman 582bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::Constant *VisitConditionalOperator(const ConditionalOperator *E) { 583bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::Constant *Cond = Visit(E->getCond()); 584bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::Constant *CondVal = EmitConversionToBool(Cond, E->getType()); 585bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::ConstantInt *CondValInt = dyn_cast<llvm::ConstantInt>(CondVal); 586bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman if (!CondValInt) { 587bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman CGM.WarnUnsupported(E, "constant expression"); 588bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman return llvm::Constant::getNullValue(ConvertType(E->getType())); 589bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman } 590bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman if (CondValInt->isOne()) { 591bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman if (E->getLHS()) 592bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman return Visit(E->getLHS()); 593bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman return Cond; 594bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman } 595bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman 596bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman return Visit(E->getRHS()); 597bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman } 5987be3d012323a6f1c22f2529823a533f25e84a697Anders Carlsson 5993b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Utility methods 6003b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson const llvm::Type *ConvertType(QualType T) { 6013b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return CGM.getTypes().ConvertType(T); 6023b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6033b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6043b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) { 6053b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert(SrcType->isCanonical() && "EmitConversion strips typedefs"); 6063b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6073b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (SrcType->isRealFloatingType()) { 6083b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Compare against 0.0 for fp scalars. 6093b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 6103b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero); 6113b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6123b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6133b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert((SrcType->isIntegerType() || SrcType->isPointerType()) && 6143b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson "Unknown scalar type to convert"); 6153b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6163b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Compare against an integer or pointer null. 6173b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 6183b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero); 6193b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6203b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6213b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType, 6223b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson QualType DstType) { 623d394cc6f0fca198ec8def0f1cfaf16b5df0d52faChris Lattner SrcType = CGM.getContext().getCanonicalType(SrcType); 624d394cc6f0fca198ec8def0f1cfaf16b5df0d52faChris Lattner DstType = CGM.getContext().getCanonicalType(DstType); 6253b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (SrcType == DstType) return Src; 6263b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6273b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Handle conversions to bool first, they are special: comparisons against 0. 6283b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (DstType->isBooleanType()) 6293b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return EmitConversionToBool(Src, SrcType); 6303b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6313b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson const llvm::Type *DstTy = ConvertType(DstType); 6323b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6333b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Ignore conversions like int -> uint. 6343b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (Src->getType() == DstTy) 6353b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return Src; 6363b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6373b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Handle pointer conversions next: pointers can only be converted to/from 6383b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // other pointers and integers. 639c53296eb6d97f37fc1326f3ab38c3c811390b838Eli Friedman if (isa<llvm::PointerType>(DstTy)) { 6403b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // The source value may be an integer, or a pointer. 6413b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (isa<llvm::PointerType>(Src->getType())) 6423b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getBitCast(Src, DstTy); 64384005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?"); 6443b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getIntToPtr(Src, DstTy); 6453b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6463b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 647c53296eb6d97f37fc1326f3ab38c3c811390b838Eli Friedman if (isa<llvm::PointerType>(Src->getType())) { 6483b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Must be an ptr to int cast. 6493b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 6503b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getPtrToInt(Src, DstTy); 6513b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6523b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6533b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // A scalar source can be splatted to a vector of the same element type 6543b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) { 6553b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson const llvm::VectorType *VT = cast<llvm::VectorType>(DstTy); 6563b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert((VT->getElementType() == Src->getType()) && 6573b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson "Vector element type must match scalar type to splat."); 6583b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson unsigned NumElements = DstType->getAsVectorType()->getNumElements(); 6593b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::SmallVector<llvm::Constant*, 16> Elements; 6603b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson for (unsigned i = 0; i < NumElements; i++) 6613b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson Elements.push_back(Src); 6623b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6633b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantVector::get(&Elements[0], NumElements); 6643b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6653b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6663b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 6673b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson isa<llvm::VectorType>(DstTy)) { 6683b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getBitCast(Src, DstTy); 6693b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6703b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6713b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Finally, we have the arithmetic types: real int/float. 6723b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (isa<llvm::IntegerType>(Src->getType())) { 6733b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson bool InputSigned = SrcType->isSignedIntegerType(); 6743b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (isa<llvm::IntegerType>(DstTy)) 6753b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned); 6763b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson else if (InputSigned) 6773b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getSIToFP(Src, DstTy); 6783b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson else 6793b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getUIToFP(Src, DstTy); 6803b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6813b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6823b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert(Src->getType()->isFloatingPoint() && "Unknown real conversion"); 6833b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (isa<llvm::IntegerType>(DstTy)) { 6843b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (DstType->isSignedIntegerType()) 6853b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getFPToSI(Src, DstTy); 6863b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson else 6873b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getFPToUI(Src, DstTy); 6883b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6893b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6903b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert(DstTy->isFloatingPoint() && "Unknown real conversion"); 6913b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 6923b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getFPTrunc(Src, DstTy); 6933b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson else 6943b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantExpr::getFPExtend(Src, DstTy); 6953b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6963b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 6973b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *EmitSizeAlignOf(QualType TypeToSize, 6983b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson QualType RetType, bool isSizeOf) { 6993b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson std::pair<uint64_t, unsigned> Info = 70098be4943e8dc4f3905629a7102668960873cf863Chris Lattner CGM.getContext().getTypeInfo(TypeToSize); 7013b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 7023b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson uint64_t Val = isSizeOf ? Info.first : Info.second; 7033b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson Val /= 8; // Return size in bytes, not bits. 7043b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 7053b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson assert(RetType->isIntegerType() && "Result type must be an integer!"); 7063b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 70798be4943e8dc4f3905629a7102668960873cf863Chris Lattner uint32_t ResultWidth = 70898be4943e8dc4f3905629a7102668960873cf863Chris Lattner static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType)); 7093b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 7103b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 71184005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson 71284005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant *EmitLValue(Expr *E) { 713e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson switch (E->getStmtClass()) { 714546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman default: break; 715e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson case Expr::ParenExprClass: 716e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson // Elide parenthesis 717e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 718e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson case Expr::CompoundLiteralExprClass: { 719e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson // Note that due to the nature of compound literals, this is guaranteed 720e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson // to be the only use of the variable, so we just generate it here. 72184005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 72284005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant* C = Visit(CLE->getInitializer()); 723a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(), 724e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson llvm::GlobalValue::InternalLinkage, 725e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson C, ".compoundliteral", &CGM.getModule()); 726e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson return C; 72784005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson } 728e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson case Expr::DeclRefExprClass: { 72984005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson ValueDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 730e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 731bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar return CGM.GetAddrOfFunction(FD); 732248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 733248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (VD->isFileVarDecl()) 734bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar return CGM.GetAddrOfGlobalVar(VD); 735248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff else if (VD->isBlockVarDecl()) { 736248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff assert(CGF && "Can't access static local vars without CGF"); 737248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff return CGF->GetAddrOfStaticLocalVar(VD); 738248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff } 739813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio } 740546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman break; 741e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 742e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson case Expr::MemberExprClass: { 74384005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson MemberExpr* ME = cast<MemberExpr>(E); 74484005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant *Base; 74584005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson if (ME->isArrow()) 74684005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson Base = Visit(ME->getBase()); 74784005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson else 74884005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson Base = EmitLValue(ME->getBase()); 7495bfe18c32f5df99daa14f42574cae1323dfb866aLauro Ramos Venancio 7505bfe18c32f5df99daa14f42574cae1323dfb866aLauro Ramos Venancio unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl()); 751e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 752e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 753e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson FieldNumber); 754e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson llvm::Value *Ops[] = {Zero, Idx}; 755e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2); 756e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 757e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson case Expr::ArraySubscriptExprClass: { 75884005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E); 75984005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant *Base = Visit(ASExpr->getBase()); 76084005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant *Index = Visit(ASExpr->getIdx()); 761e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson assert(!ASExpr->getBase()->getType()->isVectorType() && 762e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson "Taking the address of a vector component is illegal!"); 763e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1); 764e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 765e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson case Expr::StringLiteralClass: { 7661e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar StringLiteral *S = cast<StringLiteral>(E); 7671e04976fc2611d8cc06986a81deed4c42183b870Daniel Dunbar return CGM.GetAddrOfConstantString(CGM.getStringForStringLiteral(S)); 768e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 76984005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson case Expr::UnaryOperatorClass: { 77084005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson UnaryOperator *Exp = cast<UnaryOperator>(E); 77184005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson switch (Exp->getOpcode()) { 772546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman default: break; 773546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman case UnaryOperator::Extension: 77484005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson // Extension is just a wrapper for expressions 77584005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson return EmitLValue(Exp->getSubExpr()); 77684005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson case UnaryOperator::Real: 77784005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson case UnaryOperator::Imag: { 77884005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson // The address of __real or __imag is just a GEP off the address 77984005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson // of the internal expression 78084005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant* C = EmitLValue(Exp->getSubExpr()); 78184005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 78284005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 78384005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson Exp->getOpcode() == UnaryOperator::Imag); 78484005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Value *Ops[] = {Zero, Idx}; 78584005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 78684005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson } 78784005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson case UnaryOperator::Deref: 78884005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson // The address of a deref is just the value of the expression 78984005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson return Visit(Exp->getSubExpr()); 79084005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson } 791546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman break; 792e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 793546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman } 794546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman CGM.WarnUnsupported(E, "constant l-value expression"); 795546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 796546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman return llvm::UndefValue::get(Ty); 797e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 798e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson 799e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson}; 800e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson 8013b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson} // end anonymous namespace. 8023b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 8033b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 804813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venanciollvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 8059619662a1d42e2008b865d3459c0677e149dad1bChris Lattner CodeGenFunction *CGF) { 8069619662a1d42e2008b865d3459c0677e149dad1bChris Lattner QualType type = Context.getCanonicalType(E->getType()); 8077dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman 8083b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (type->isIntegerType()) { 80998be4943e8dc4f3905629a7102668960873cf863Chris Lattner llvm::APSInt Value(static_cast<uint32_t>(Context.getTypeSize(type))); 8103b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson if (E->isIntegerConstantExpr(Value, Context)) { 8113b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return llvm::ConstantInt::get(Value); 8123b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 8133b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 8147dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman 8157dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 8167dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman if (C->getType() == llvm::Type::Int1Ty) { 8177dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 8187dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman C = llvm::ConstantExpr::getZExt(C, BoolTy); 8197dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman } 8207dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman return C; 8213b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson} 822