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