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