CGExprConstant.cpp revision aa432560efb1ff10aec504a68fe909cd9ae7c1a2
1//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This contains code to emit Constant Expr nodes as LLVM code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CodeGenFunction.h" 15#include "CodeGenModule.h" 16#include "CGObjCRuntime.h" 17#include "clang/AST/APValue.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/StmtVisitor.h" 20#include "llvm/Constants.h" 21#include "llvm/Function.h" 22#include "llvm/GlobalVariable.h" 23#include "llvm/Support/Compiler.h" 24#include "llvm/Target/TargetData.h" 25using namespace clang; 26using namespace CodeGen; 27 28namespace { 29class VISIBILITY_HIDDEN ConstExprEmitter : 30 public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 31 CodeGenModule &CGM; 32 CodeGenFunction *CGF; 33public: 34 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 35 : CGM(cgm), CGF(cgf) { 36 } 37 38 //===--------------------------------------------------------------------===// 39 // Visitor Methods 40 //===--------------------------------------------------------------------===// 41 42 llvm::Constant *VisitStmt(Stmt *S) { 43 CGM.ErrorUnsupported(S, "constant expression"); 44 QualType T = cast<Expr>(S)->getType(); 45 return llvm::UndefValue::get(CGM.getTypes().ConvertType(T)); 46 } 47 48 llvm::Constant *VisitParenExpr(ParenExpr *PE) { 49 return Visit(PE->getSubExpr()); 50 } 51 52 // Leaves 53 llvm::Constant *VisitIntegerLiteral(const IntegerLiteral *E) { 54 return llvm::ConstantInt::get(E->getValue()); 55 } 56 llvm::Constant *VisitFloatingLiteral(const FloatingLiteral *E) { 57 return llvm::ConstantFP::get(E->getValue()); 58 } 59 llvm::Constant *VisitCharacterLiteral(const CharacterLiteral *E) { 60 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 61 } 62 llvm::Constant *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 63 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 64 } 65 llvm::Constant *VisitCXXZeroInitValueExpr(const CXXZeroInitValueExpr *E) { 66 return llvm::Constant::getNullValue(ConvertType(E->getType())); 67 } 68 llvm::Constant *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 69 std::string S(E->getString()->getStrData(), 70 E->getString()->getByteLength()); 71 llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(S); 72 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 73 } 74 75 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 76 return Visit(E->getInitializer()); 77 } 78 79 llvm::Constant *VisitCastExpr(CastExpr* E) { 80 llvm::Constant *C = Visit(E->getSubExpr()); 81 82 return EmitConversion(C, E->getSubExpr()->getType(), E->getType()); 83 } 84 85 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 86 return Visit(DAE->getExpr()); 87 } 88 89 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 90 std::vector<llvm::Constant*> Elts; 91 const llvm::ArrayType *AType = 92 cast<llvm::ArrayType>(ConvertType(ILE->getType())); 93 unsigned NumInitElements = ILE->getNumInits(); 94 // FIXME: Check for wide strings 95 if (NumInitElements > 0 && isa<StringLiteral>(ILE->getInit(0)) && 96 ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType()) 97 return Visit(ILE->getInit(0)); 98 const llvm::Type *ElemTy = AType->getElementType(); 99 unsigned NumElements = AType->getNumElements(); 100 101 // Initialising an array requires us to automatically 102 // initialise any elements that have not been initialised explicitly 103 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 104 105 // Copy initializer elements. 106 unsigned i = 0; 107 bool RewriteType = false; 108 for (; i < NumInitableElts; ++i) { 109 llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF); 110 RewriteType |= (C->getType() != ElemTy); 111 Elts.push_back(C); 112 } 113 114 // Initialize remaining array elements. 115 for (; i < NumElements; ++i) 116 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 117 118 if (RewriteType) { 119 // FIXME: Try to avoid packing the array 120 std::vector<const llvm::Type*> Types; 121 for (unsigned i = 0; i < Elts.size(); ++i) 122 Types.push_back(Elts[i]->getType()); 123 const llvm::StructType *SType = llvm::StructType::get(Types, true); 124 return llvm::ConstantStruct::get(SType, Elts); 125 } 126 127 return llvm::ConstantArray::get(AType, Elts); 128 } 129 130 void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts, 131 FieldDecl* Field, Expr* E) { 132 // Calculate the value to insert 133 llvm::Constant *C = CGM.EmitConstantExpr(E, CGF); 134 llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C); 135 if (!CI) { 136 CGM.ErrorUnsupported(E, "bitfield initialization"); 137 return; 138 } 139 llvm::APInt V = CI->getValue(); 140 141 // Calculate information about the relevant field 142 const llvm::Type* Ty = CI->getType(); 143 const llvm::TargetData &TD = CGM.getTypes().getTargetData(); 144 unsigned size = TD.getTypeStoreSizeInBits(Ty); 145 unsigned fieldOffset = CGM.getTypes().getLLVMFieldNo(Field) * size; 146 CodeGenTypes::BitFieldInfo bitFieldInfo = 147 CGM.getTypes().getBitFieldInfo(Field); 148 fieldOffset += bitFieldInfo.Begin; 149 150 // Find where to start the insertion 151 // FIXME: This is O(n^2) in the number of bit-fields! 152 // FIXME: This won't work if the struct isn't completely packed! 153 unsigned offset = 0, i = 0; 154 while (offset < (fieldOffset & -8)) 155 offset += TD.getTypeStoreSizeInBits(Elts[i++]->getType()); 156 157 // Advance over 0 sized elements (must terminate in bounds since 158 // the bitfield must have a size). 159 while (TD.getTypeStoreSizeInBits(Elts[i]->getType()) == 0) 160 ++i; 161 162 // Promote the size of V if necessary 163 // FIXME: This should never occur, but currently it can because 164 // initializer constants are cast to bool, and because clang is 165 // not enforcing bitfield width limits. 166 if (bitFieldInfo.Size > V.getBitWidth()) 167 V.zext(bitFieldInfo.Size); 168 169 // Insert the bits into the struct 170 // FIXME: This algorthm is only correct on X86! 171 // FIXME: THis algorthm assumes bit-fields only have byte-size elements! 172 unsigned bitsToInsert = bitFieldInfo.Size; 173 unsigned curBits = std::min(8 - (fieldOffset & 7), bitsToInsert); 174 unsigned byte = V.getLoBits(curBits).getZExtValue() << (fieldOffset & 7); 175 do { 176 llvm::Constant* byteC = llvm::ConstantInt::get(llvm::Type::Int8Ty, byte); 177 Elts[i] = llvm::ConstantExpr::getOr(Elts[i], byteC); 178 ++i; 179 V = V.lshr(curBits); 180 bitsToInsert -= curBits; 181 182 if (!bitsToInsert) 183 break; 184 185 curBits = bitsToInsert > 8 ? 8 : bitsToInsert; 186 byte = V.getLoBits(curBits).getZExtValue(); 187 } while (true); 188 } 189 190 llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { 191 const llvm::StructType *SType = 192 cast<llvm::StructType>(ConvertType(ILE->getType())); 193 RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 194 std::vector<llvm::Constant*> Elts; 195 196 // Initialize the whole structure to zero. 197 for (unsigned i = 0; i < SType->getNumElements(); ++i) { 198 const llvm::Type *FieldTy = SType->getElementType(i); 199 Elts.push_back(llvm::Constant::getNullValue(FieldTy)); 200 } 201 202 // Copy initializer elements. Skip padding fields. 203 unsigned EltNo = 0; // Element no in ILE 204 int FieldNo = 0; // Field no in RecordDecl 205 bool RewriteType = false; 206 while (EltNo < ILE->getNumInits() && FieldNo < RD->getNumMembers()) { 207 FieldDecl* curField = RD->getMember(FieldNo); 208 FieldNo++; 209 if (!curField->getIdentifier()) 210 continue; 211 212 if (curField->isBitField()) { 213 InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(EltNo)); 214 } else { 215 unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(curField); 216 llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), CGF); 217 RewriteType |= (C->getType() != Elts[FieldNo]->getType()); 218 Elts[FieldNo] = C; 219 } 220 EltNo++; 221 } 222 223 if (RewriteType) { 224 // FIXME: Make this work for non-packed structs 225 assert(SType->isPacked() && "Cannot recreate unpacked structs"); 226 std::vector<const llvm::Type*> Types; 227 for (unsigned i = 0; i < Elts.size(); ++i) 228 Types.push_back(Elts[i]->getType()); 229 SType = llvm::StructType::get(Types, true); 230 } 231 232 return llvm::ConstantStruct::get(SType, Elts); 233 } 234 235 llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) { 236 RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 237 const llvm::Type *Ty = ConvertType(ILE->getType()); 238 239 // Find the field decl we're initializing, if any 240 int FieldNo = 0; // Field no in RecordDecl 241 FieldDecl* curField = 0; 242 while (FieldNo < RD->getNumMembers()) { 243 curField = RD->getMember(FieldNo); 244 FieldNo++; 245 if (curField->getIdentifier()) 246 break; 247 } 248 249 if (!curField || !curField->getIdentifier() || ILE->getNumInits() == 0) 250 return llvm::Constant::getNullValue(Ty); 251 252 if (curField->isBitField()) { 253 // Create a dummy struct for bit-field insertion 254 unsigned NumElts = CGM.getTargetData().getABITypeSize(Ty) / 8; 255 llvm::Constant* NV = llvm::Constant::getNullValue(llvm::Type::Int8Ty); 256 std::vector<llvm::Constant*> Elts(NumElts, NV); 257 258 InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0)); 259 const llvm::ArrayType *RetTy = 260 llvm::ArrayType::get(NV->getType(), NumElts); 261 return llvm::ConstantArray::get(RetTy, Elts); 262 } 263 264 llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(0), CGF); 265 266 // Build a struct with the union sub-element as the first member, 267 // and padded to the appropriate size 268 std::vector<llvm::Constant*> Elts; 269 std::vector<const llvm::Type*> Types; 270 Elts.push_back(C); 271 Types.push_back(C->getType()); 272 unsigned CurSize = CGM.getTargetData().getTypeStoreSize(C->getType()); 273 unsigned TotalSize = CGM.getTargetData().getTypeStoreSize(Ty); 274 while (CurSize < TotalSize) { 275 Elts.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty)); 276 Types.push_back(llvm::Type::Int8Ty); 277 CurSize++; 278 } 279 280 // This always generates a packed struct 281 // FIXME: Try to generate an unpacked struct when we can 282 llvm::StructType* STy = llvm::StructType::get(Types, true); 283 return llvm::ConstantStruct::get(STy, Elts); 284 } 285 286 llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) { 287 const llvm::VectorType *VType = 288 cast<llvm::VectorType>(ConvertType(ILE->getType())); 289 const llvm::Type *ElemTy = VType->getElementType(); 290 std::vector<llvm::Constant*> Elts; 291 unsigned NumElements = VType->getNumElements(); 292 unsigned NumInitElements = ILE->getNumInits(); 293 294 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 295 296 // Copy initializer elements. 297 unsigned i = 0; 298 for (; i < NumInitableElts; ++i) { 299 llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF); 300 Elts.push_back(C); 301 } 302 303 for (; i < NumElements; ++i) 304 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 305 306 return llvm::ConstantVector::get(VType, Elts); 307 } 308 309 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 310 if (ILE->getType()->isScalarType()) { 311 // We have a scalar in braces. Just use the first element. 312 if (ILE->getNumInits() > 0) 313 return CGM.EmitConstantExpr(ILE->getInit(0), CGF); 314 315 const llvm::Type* RetTy = CGM.getTypes().ConvertType(ILE->getType()); 316 return llvm::Constant::getNullValue(RetTy); 317 } 318 319 // FIXME: We don't codegen or sema designators yet. 320 if (ILE->hadDesignators()) { 321 CGM.ErrorUnsupported(ILE, "initializer list with designators"); 322 return llvm::UndefValue::get(ConvertType(ILE->getType())); 323 } 324 325 if (ILE->getType()->isArrayType()) 326 return EmitArrayInitialization(ILE); 327 328 if (ILE->getType()->isStructureType()) 329 return EmitStructInitialization(ILE); 330 331 if (ILE->getType()->isUnionType()) 332 return EmitUnionInitialization(ILE); 333 334 if (ILE->getType()->isVectorType()) 335 return EmitVectorInitialization(ILE); 336 337 assert(0 && "Unable to handle InitListExpr"); 338 // Get rid of control reaches end of void function warning. 339 // Not reached. 340 return 0; 341 } 342 343 llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) { 344 Expr* SExpr = ICExpr->getSubExpr(); 345 QualType SType = SExpr->getType(); 346 llvm::Constant *C; // the intermediate expression 347 QualType T; // the type of the intermediate expression 348 if (SType->isArrayType()) { 349 // Arrays decay to a pointer to the first element 350 // VLAs would require special handling, but they can't occur here 351 C = EmitLValue(SExpr); 352 llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 353 llvm::Constant *Ops[] = {Idx0, Idx0}; 354 C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 355 T = CGM.getContext().getArrayDecayedType(SType); 356 } else if (SType->isFunctionType()) { 357 // Function types decay to a pointer to the function 358 C = EmitLValue(SExpr); 359 T = CGM.getContext().getPointerType(SType); 360 } else { 361 C = Visit(SExpr); 362 T = SType; 363 } 364 365 // Perform the conversion; note that an implicit cast can both promote 366 // and convert an array/function 367 return EmitConversion(C, T, ICExpr->getType()); 368 } 369 370 llvm::Constant *VisitStringLiteral(StringLiteral *E) { 371 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 372 373 // Otherwise this must be a string initializing an array in a static 374 // initializer. Don't emit it as the address of the string, emit the string 375 // data itself as an inline array. 376 return llvm::ConstantArray::get(CGM.GetStringForStringLiteral(E), false); 377 } 378 379 llvm::Constant *VisitDeclRefExpr(DeclRefExpr *E) { 380 const NamedDecl *Decl = E->getDecl(); 381 if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(Decl)) 382 return llvm::ConstantInt::get(EC->getInitVal()); 383 assert(0 && "Unsupported decl ref type!"); 384 return 0; 385 } 386 387 llvm::Constant *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 388 return EmitSizeAlignOf(E->getTypeOfArgument(), E->getType(), E->isSizeOf()); 389 } 390 391 llvm::Constant *VisitAddrLabelExpr(const AddrLabelExpr *E) { 392 assert(CGF && "Invalid address of label expression outside function."); 393 llvm::Constant *C = 394 llvm::ConstantInt::get(llvm::Type::Int32Ty, 395 CGF->GetIDForAddrOfLabel(E->getLabel())); 396 return llvm::ConstantExpr::getIntToPtr(C, ConvertType(E->getType())); 397 } 398 399 // Unary operators 400 llvm::Constant *VisitUnaryPlus(const UnaryOperator *E) { 401 return Visit(E->getSubExpr()); 402 } 403 llvm::Constant *VisitUnaryMinus(const UnaryOperator *E) { 404 return llvm::ConstantExpr::getNeg(Visit(E->getSubExpr())); 405 } 406 llvm::Constant *VisitUnaryNot(const UnaryOperator *E) { 407 return llvm::ConstantExpr::getNot(Visit(E->getSubExpr())); 408 } 409 llvm::Constant *VisitUnaryLNot(const UnaryOperator *E) { 410 llvm::Constant *SubExpr = Visit(E->getSubExpr()); 411 412 if (E->getSubExpr()->getType()->isRealFloatingType()) { 413 // Compare against 0.0 for fp scalars. 414 llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType()); 415 SubExpr = llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UEQ, SubExpr, 416 Zero); 417 } else { 418 assert((E->getSubExpr()->getType()->isIntegerType() || 419 E->getSubExpr()->getType()->isPointerType()) && 420 "Unknown scalar type to convert"); 421 // Compare against an integer or pointer null. 422 llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType()); 423 SubExpr = llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, SubExpr, 424 Zero); 425 } 426 427 return llvm::ConstantExpr::getZExt(SubExpr, ConvertType(E->getType())); 428 } 429 llvm::Constant *VisitUnaryAddrOf(const UnaryOperator *E) { 430 return EmitLValue(E->getSubExpr()); 431 } 432 llvm::Constant *VisitUnaryOffsetOf(const UnaryOperator *E) { 433 int64_t Val = E->evaluateOffsetOf(CGM.getContext()); 434 435 assert(E->getType()->isIntegerType() && "Result type must be an integer!"); 436 437 uint32_t ResultWidth = 438 static_cast<uint32_t>(CGM.getContext().getTypeSize(E->getType())); 439 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 440 } 441 442 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 443 return Visit(E->getSubExpr()); 444 } 445 446 // Binary operators 447 llvm::Constant *VisitBinOr(const BinaryOperator *E) { 448 llvm::Constant *LHS = Visit(E->getLHS()); 449 llvm::Constant *RHS = Visit(E->getRHS()); 450 451 return llvm::ConstantExpr::getOr(LHS, RHS); 452 } 453 llvm::Constant *VisitBinSub(const BinaryOperator *E) { 454 llvm::Constant *LHS = Visit(E->getLHS()); 455 llvm::Constant *RHS = Visit(E->getRHS()); 456 457 if (!isa<llvm::PointerType>(RHS->getType())) { 458 // pointer - int 459 if (isa<llvm::PointerType>(LHS->getType())) { 460 llvm::Constant *Idx = llvm::ConstantExpr::getNeg(RHS); 461 462 return llvm::ConstantExpr::getGetElementPtr(LHS, &Idx, 1); 463 } 464 465 // int - int 466 return llvm::ConstantExpr::getSub(LHS, RHS); 467 } 468 469 assert(isa<llvm::PointerType>(LHS->getType())); 470 471 const llvm::Type *ResultType = ConvertType(E->getType()); 472 const QualType Type = E->getLHS()->getType(); 473 const QualType ElementType = Type->getAsPointerType()->getPointeeType(); 474 475 LHS = llvm::ConstantExpr::getPtrToInt(LHS, ResultType); 476 RHS = llvm::ConstantExpr::getPtrToInt(RHS, ResultType); 477 478 llvm::Constant *sub = llvm::ConstantExpr::getSub(LHS, RHS); 479 llvm::Constant *size = EmitSizeAlignOf(ElementType, E->getType(), true); 480 return llvm::ConstantExpr::getSDiv(sub, size); 481 } 482 483 llvm::Constant *VisitBinShl(const BinaryOperator *E) { 484 llvm::Constant *LHS = Visit(E->getLHS()); 485 llvm::Constant *RHS = Visit(E->getRHS()); 486 487 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 488 // RHS to the same size as the LHS. 489 if (LHS->getType() != RHS->getType()) 490 RHS = llvm::ConstantExpr::getIntegerCast(RHS, LHS->getType(), false); 491 492 return llvm::ConstantExpr::getShl(LHS, RHS); 493 } 494 495 llvm::Constant *VisitBinMul(const BinaryOperator *E) { 496 llvm::Constant *LHS = Visit(E->getLHS()); 497 llvm::Constant *RHS = Visit(E->getRHS()); 498 499 return llvm::ConstantExpr::getMul(LHS, RHS); 500 } 501 502 llvm::Constant *VisitBinDiv(const BinaryOperator *E) { 503 llvm::Constant *LHS = Visit(E->getLHS()); 504 llvm::Constant *RHS = Visit(E->getRHS()); 505 506 if (LHS->getType()->isFPOrFPVector()) 507 return llvm::ConstantExpr::getFDiv(LHS, RHS); 508 else if (E->getType()->isUnsignedIntegerType()) 509 return llvm::ConstantExpr::getUDiv(LHS, RHS); 510 else 511 return llvm::ConstantExpr::getSDiv(LHS, RHS); 512 } 513 514 llvm::Constant *VisitBinAdd(const BinaryOperator *E) { 515 llvm::Constant *LHS = Visit(E->getLHS()); 516 llvm::Constant *RHS = Visit(E->getRHS()); 517 518 if (!E->getType()->isPointerType()) 519 return llvm::ConstantExpr::getAdd(LHS, RHS); 520 521 llvm::Constant *Ptr, *Idx; 522 if (isa<llvm::PointerType>(LHS->getType())) { // pointer + int 523 Ptr = LHS; 524 Idx = RHS; 525 } else { // int + pointer 526 Ptr = RHS; 527 Idx = LHS; 528 } 529 530 return llvm::ConstantExpr::getGetElementPtr(Ptr, &Idx, 1); 531 } 532 533 llvm::Constant *VisitBinAnd(const BinaryOperator *E) { 534 llvm::Constant *LHS = Visit(E->getLHS()); 535 llvm::Constant *RHS = Visit(E->getRHS()); 536 537 return llvm::ConstantExpr::getAnd(LHS, RHS); 538 } 539 540 llvm::Constant *EmitCmp(const BinaryOperator *E, 541 llvm::CmpInst::Predicate SignedPred, 542 llvm::CmpInst::Predicate UnsignedPred, 543 llvm::CmpInst::Predicate FloatPred) { 544 llvm::Constant *LHS = Visit(E->getLHS()); 545 llvm::Constant *RHS = Visit(E->getRHS()); 546 llvm::Constant *Result; 547 if (LHS->getType()->isInteger() || 548 isa<llvm::PointerType>(LHS->getType())) { 549 if (E->getLHS()->getType()->isSignedIntegerType()) 550 Result = llvm::ConstantExpr::getICmp(SignedPred, LHS, RHS); 551 else 552 Result = llvm::ConstantExpr::getICmp(UnsignedPred, LHS, RHS); 553 } else if (LHS->getType()->isFloatingPoint()) { 554 Result = llvm::ConstantExpr::getFCmp(FloatPred, LHS, RHS); 555 } else { 556 CGM.ErrorUnsupported(E, "constant expression"); 557 Result = llvm::ConstantInt::getFalse(); 558 } 559 560 const llvm::Type* ResultType = ConvertType(E->getType()); 561 return llvm::ConstantExpr::getZExtOrBitCast(Result, ResultType); 562 } 563 564 llvm::Constant *VisitBinNE(const BinaryOperator *E) { 565 return EmitCmp(E, llvm::CmpInst::ICMP_NE, llvm::CmpInst::ICMP_NE, 566 llvm::CmpInst::FCMP_ONE); 567 } 568 569 llvm::Constant *VisitBinEQ(const BinaryOperator *E) { 570 return EmitCmp(E, llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_EQ, 571 llvm::CmpInst::FCMP_OEQ); 572 } 573 574 llvm::Constant *VisitBinLT(const BinaryOperator *E) { 575 return EmitCmp(E, llvm::CmpInst::ICMP_SLT, llvm::CmpInst::ICMP_ULT, 576 llvm::CmpInst::FCMP_OLT); 577 } 578 579 llvm::Constant *VisitBinLE(const BinaryOperator *E) { 580 return EmitCmp(E, llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_ULE, 581 llvm::CmpInst::FCMP_OLE); 582 } 583 584 llvm::Constant *VisitBinGT(const BinaryOperator *E) { 585 return EmitCmp(E, llvm::CmpInst::ICMP_SGT, llvm::CmpInst::ICMP_UGT, 586 llvm::CmpInst::FCMP_OGT); 587 } 588 589 llvm::Constant *VisitBinGE(const BinaryOperator *E) { 590 return EmitCmp(E, llvm::CmpInst::ICMP_SGE, llvm::CmpInst::ICMP_SGE, 591 llvm::CmpInst::FCMP_OGE); 592 } 593 594 llvm::Constant *VisitConditionalOperator(const ConditionalOperator *E) { 595 llvm::Constant *Cond = Visit(E->getCond()); 596 llvm::Constant *CondVal = EmitConversionToBool(Cond, E->getType()); 597 llvm::ConstantInt *CondValInt = dyn_cast<llvm::ConstantInt>(CondVal); 598 if (!CondValInt) { 599 CGM.ErrorUnsupported(E, "constant expression"); 600 return llvm::Constant::getNullValue(ConvertType(E->getType())); 601 } 602 if (CondValInt->isOne()) { 603 if (E->getLHS()) 604 return Visit(E->getLHS()); 605 return Cond; 606 } 607 608 return Visit(E->getRHS()); 609 } 610 611 llvm::Constant *VisitCallExpr(const CallExpr *E) { 612 APValue Result; 613 if (E->Evaluate(Result, CGM.getContext())) { 614 if (Result.isInt()) 615 return llvm::ConstantInt::get(Result.getInt()); 616 if (Result.isFloat()) 617 return llvm::ConstantFP::get(Result.getFloat()); 618 } 619 620 // Handle __builtin___CFStringMakeConstantString. 621 if (E->isBuiltinCall() ==Builtin::BI__builtin___CFStringMakeConstantString){ 622 const Expr *Arg = E->getArg(0)->IgnoreParenCasts(); 623 624 const StringLiteral *Literal = cast<StringLiteral>(Arg); 625 std::string S(Literal->getStrData(), Literal->getByteLength()); 626 return CGM.GetAddrOfConstantCFString(S); 627 } 628 629 CGM.ErrorUnsupported(E, "constant call expression"); 630 return llvm::Constant::getNullValue(ConvertType(E->getType())); 631 } 632 633 // Utility methods 634 const llvm::Type *ConvertType(QualType T) { 635 return CGM.getTypes().ConvertType(T); 636 } 637 638 llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) { 639 assert(SrcType->isCanonical() && "EmitConversion strips typedefs"); 640 641 if (SrcType->isRealFloatingType()) { 642 // Compare against 0.0 for fp scalars. 643 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 644 return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero); 645 } 646 647 assert((SrcType->isIntegerType() || SrcType->isPointerType()) && 648 "Unknown scalar type to convert"); 649 650 // Compare against an integer or pointer null. 651 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 652 return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero); 653 } 654 655 llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType, 656 QualType DstType) { 657 SrcType = CGM.getContext().getCanonicalType(SrcType); 658 DstType = CGM.getContext().getCanonicalType(DstType); 659 if (SrcType == DstType) return Src; 660 661 // Handle conversions to bool first, they are special: comparisons against 0. 662 if (DstType->isBooleanType()) 663 return EmitConversionToBool(Src, SrcType); 664 665 const llvm::Type *DstTy = ConvertType(DstType); 666 667 // Ignore conversions like int -> uint. 668 if (Src->getType() == DstTy) 669 return Src; 670 671 // Handle pointer conversions next: pointers can only be converted to/from 672 // other pointers and integers. 673 if (isa<llvm::PointerType>(DstTy)) { 674 // The source value may be an integer, or a pointer. 675 if (isa<llvm::PointerType>(Src->getType())) 676 return llvm::ConstantExpr::getBitCast(Src, DstTy); 677 assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?"); 678 return llvm::ConstantExpr::getIntToPtr(Src, DstTy); 679 } 680 681 if (isa<llvm::PointerType>(Src->getType())) { 682 // Must be an ptr to int cast. 683 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 684 return llvm::ConstantExpr::getPtrToInt(Src, DstTy); 685 } 686 687 // A scalar source can be splatted to a vector of the same element type 688 if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) { 689 assert((cast<llvm::VectorType>(DstTy)->getElementType() 690 == Src->getType()) && 691 "Vector element type must match scalar type to splat."); 692 unsigned NumElements = DstType->getAsVectorType()->getNumElements(); 693 llvm::SmallVector<llvm::Constant*, 16> Elements; 694 for (unsigned i = 0; i < NumElements; i++) 695 Elements.push_back(Src); 696 697 return llvm::ConstantVector::get(&Elements[0], NumElements); 698 } 699 700 if (isa<llvm::VectorType>(Src->getType()) || 701 isa<llvm::VectorType>(DstTy)) { 702 return llvm::ConstantExpr::getBitCast(Src, DstTy); 703 } 704 705 // Finally, we have the arithmetic types: real int/float. 706 if (isa<llvm::IntegerType>(Src->getType())) { 707 bool InputSigned = SrcType->isSignedIntegerType(); 708 if (isa<llvm::IntegerType>(DstTy)) 709 return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned); 710 else if (InputSigned) 711 return llvm::ConstantExpr::getSIToFP(Src, DstTy); 712 else 713 return llvm::ConstantExpr::getUIToFP(Src, DstTy); 714 } 715 716 assert(Src->getType()->isFloatingPoint() && "Unknown real conversion"); 717 if (isa<llvm::IntegerType>(DstTy)) { 718 if (DstType->isSignedIntegerType()) 719 return llvm::ConstantExpr::getFPToSI(Src, DstTy); 720 else 721 return llvm::ConstantExpr::getFPToUI(Src, DstTy); 722 } 723 724 assert(DstTy->isFloatingPoint() && "Unknown real conversion"); 725 if (DstTy->getTypeID() < Src->getType()->getTypeID()) 726 return llvm::ConstantExpr::getFPTrunc(Src, DstTy); 727 else 728 return llvm::ConstantExpr::getFPExtend(Src, DstTy); 729 } 730 731 llvm::Constant *EmitSizeAlignOf(QualType TypeToSize, 732 QualType RetType, bool isSizeOf) { 733 std::pair<uint64_t, unsigned> Info = 734 CGM.getContext().getTypeInfo(TypeToSize); 735 736 uint64_t Val = isSizeOf ? Info.first : Info.second; 737 Val /= 8; // Return size in bytes, not bits. 738 739 assert(RetType->isIntegerType() && "Result type must be an integer!"); 740 741 uint32_t ResultWidth = 742 static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType)); 743 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 744 } 745 746public: 747 llvm::Constant *EmitLValue(Expr *E) { 748 switch (E->getStmtClass()) { 749 default: break; 750 case Expr::ParenExprClass: 751 // Elide parenthesis 752 return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 753 case Expr::CompoundLiteralExprClass: { 754 // Note that due to the nature of compound literals, this is guaranteed 755 // to be the only use of the variable, so we just generate it here. 756 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 757 llvm::Constant* C = Visit(CLE->getInitializer()); 758 C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(), 759 llvm::GlobalValue::InternalLinkage, 760 C, ".compoundliteral", &CGM.getModule()); 761 return C; 762 } 763 case Expr::DeclRefExprClass: { 764 NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 765 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 766 return CGM.GetAddrOfFunction(FD); 767 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 768 if (VD->isFileVarDecl()) 769 return CGM.GetAddrOfGlobalVar(VD); 770 else if (VD->isBlockVarDecl()) { 771 assert(CGF && "Can't access static local vars without CGF"); 772 return CGF->GetAddrOfStaticLocalVar(VD); 773 } 774 } 775 break; 776 } 777 case Expr::MemberExprClass: { 778 MemberExpr* ME = cast<MemberExpr>(E); 779 llvm::Constant *Base; 780 if (ME->isArrow()) 781 Base = Visit(ME->getBase()); 782 else 783 Base = EmitLValue(ME->getBase()); 784 785 unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl()); 786 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 787 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 788 FieldNumber); 789 llvm::Value *Ops[] = {Zero, Idx}; 790 return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2); 791 } 792 case Expr::ArraySubscriptExprClass: { 793 ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E); 794 llvm::Constant *Base = Visit(ASExpr->getBase()); 795 llvm::Constant *Index = Visit(ASExpr->getIdx()); 796 assert(!ASExpr->getBase()->getType()->isVectorType() && 797 "Taking the address of a vector component is illegal!"); 798 return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1); 799 } 800 case Expr::StringLiteralClass: 801 return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 802 case Expr::ObjCStringLiteralClass: { 803 ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 804 std::string S(SL->getString()->getStrData(), 805 SL->getString()->getByteLength()); 806 llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(S); 807 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 808 } 809 case Expr::UnaryOperatorClass: { 810 UnaryOperator *Exp = cast<UnaryOperator>(E); 811 switch (Exp->getOpcode()) { 812 default: break; 813 case UnaryOperator::Extension: 814 // Extension is just a wrapper for expressions 815 return EmitLValue(Exp->getSubExpr()); 816 case UnaryOperator::Real: 817 case UnaryOperator::Imag: { 818 // The address of __real or __imag is just a GEP off the address 819 // of the internal expression 820 llvm::Constant* C = EmitLValue(Exp->getSubExpr()); 821 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 822 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 823 Exp->getOpcode() == UnaryOperator::Imag); 824 llvm::Value *Ops[] = {Zero, Idx}; 825 return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 826 } 827 case UnaryOperator::Deref: 828 // The address of a deref is just the value of the expression 829 return Visit(Exp->getSubExpr()); 830 } 831 break; 832 } 833 } 834 CGM.ErrorUnsupported(E, "constant l-value expression"); 835 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 836 return llvm::UndefValue::get(Ty); 837 } 838}; 839 840} // end anonymous namespace. 841 842llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 843 CodeGenFunction *CGF) { 844 QualType type = Context.getCanonicalType(E->getType()); 845 846#ifdef USE_TRY_EVALUATE 847 APValue V; 848 if (E->Evaluate(V, Context)) { 849 // FIXME: Assert that the value doesn't have any side effects. 850 switch (V.getKind()) { 851 default: assert(0 && "unhandled value kind!"); 852 case APValue::LValue: { 853 llvm::Constant *Offset = llvm::ConstantInt::get(llvm::Type::Int64Ty, 854 V.getLValueOffset()); 855 856 if (const Expr *LVBase = V.getLValueBase()) { 857 llvm::Constant *C = 858 ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase)); 859 860 const llvm::Type *Type = 861 llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 862 const llvm::Type *DestType = C->getType(); 863 864 // FIXME: It's a little ugly that we need to cast to a pointer, 865 // apply the GEP and then cast back. 866 C = llvm::ConstantExpr::getBitCast(C, Type); 867 C = llvm::ConstantExpr::getGetElementPtr(C, &Offset, 1); 868 869 return llvm::ConstantExpr::getBitCast(C, DestType); 870 } 871 872 return llvm::ConstantExpr::getIntToPtr(Offset, 873 getTypes().ConvertType(type)); 874 } 875 case APValue::Int: 876 llvm::Constant *C = llvm::ConstantInt::get(V.getInt()); 877 878 if (C->getType() == llvm::Type::Int1Ty) { 879 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 880 C = llvm::ConstantExpr::getZExt(C, BoolTy); 881 } 882 return C; 883 case APValue::Float: 884 return llvm::ConstantFP::get(V.getFloat()); 885 case APValue::ComplexFloat: { 886 llvm::Constant *Complex[2]; 887 888 Complex[0] = llvm::ConstantFP::get(V.getComplexFloatReal()); 889 Complex[1] = llvm::ConstantFP::get(V.getComplexFloatImag()); 890 891 return llvm::ConstantStruct::get(Complex, 2); 892 } 893 } 894 } 895#else 896 if (type->isIntegerType()) { 897 llvm::APSInt Value(static_cast<uint32_t>(Context.getTypeSize(type))); 898 if (E->isIntegerConstantExpr(Value, Context)) { 899 return llvm::ConstantInt::get(Value); 900 } 901 } 902#endif 903 904 llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 905 if (C->getType() == llvm::Type::Int1Ty) { 906 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 907 C = llvm::ConstantExpr::getZExt(C, BoolTy); 908 } 909 return C; 910} 911