CGExprConstant.cpp revision 344779
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 "CGCXXABI.h" 16#include "CGObjCRuntime.h" 17#include "CGRecordLayout.h" 18#include "CodeGenModule.h" 19#include "ConstantEmitter.h" 20#include "TargetInfo.h" 21#include "clang/AST/APValue.h" 22#include "clang/AST/ASTContext.h" 23#include "clang/AST/RecordLayout.h" 24#include "clang/AST/StmtVisitor.h" 25#include "clang/Basic/Builtins.h" 26#include "llvm/IR/Constants.h" 27#include "llvm/IR/DataLayout.h" 28#include "llvm/IR/Function.h" 29#include "llvm/IR/GlobalVariable.h" 30using namespace clang; 31using namespace CodeGen; 32 33//===----------------------------------------------------------------------===// 34// ConstStructBuilder 35//===----------------------------------------------------------------------===// 36 37namespace { 38class ConstExprEmitter; 39class ConstStructBuilder { 40 CodeGenModule &CGM; 41 ConstantEmitter &Emitter; 42 43 bool Packed; 44 CharUnits NextFieldOffsetInChars; 45 CharUnits LLVMStructAlignment; 46 SmallVector<llvm::Constant *, 32> Elements; 47public: 48 static llvm::Constant *BuildStruct(ConstantEmitter &Emitter, 49 ConstExprEmitter *ExprEmitter, 50 llvm::Constant *Base, 51 InitListExpr *Updater, 52 QualType ValTy); 53 static llvm::Constant *BuildStruct(ConstantEmitter &Emitter, 54 InitListExpr *ILE, QualType StructTy); 55 static llvm::Constant *BuildStruct(ConstantEmitter &Emitter, 56 const APValue &Value, QualType ValTy); 57 58private: 59 ConstStructBuilder(ConstantEmitter &emitter) 60 : CGM(emitter.CGM), Emitter(emitter), Packed(false), 61 NextFieldOffsetInChars(CharUnits::Zero()), 62 LLVMStructAlignment(CharUnits::One()) { } 63 64 void AppendField(const FieldDecl *Field, uint64_t FieldOffset, 65 llvm::Constant *InitExpr); 66 67 void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst); 68 69 void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset, 70 llvm::ConstantInt *InitExpr); 71 72 void AppendPadding(CharUnits PadSize); 73 74 void AppendTailPadding(CharUnits RecordSize); 75 76 void ConvertStructToPacked(); 77 78 bool Build(InitListExpr *ILE); 79 bool Build(ConstExprEmitter *Emitter, llvm::Constant *Base, 80 InitListExpr *Updater); 81 bool Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase, 82 const CXXRecordDecl *VTableClass, CharUnits BaseOffset); 83 llvm::Constant *Finalize(QualType Ty); 84 85 CharUnits getAlignment(const llvm::Constant *C) const { 86 if (Packed) return CharUnits::One(); 87 return CharUnits::fromQuantity( 88 CGM.getDataLayout().getABITypeAlignment(C->getType())); 89 } 90 91 CharUnits getSizeInChars(const llvm::Constant *C) const { 92 return CharUnits::fromQuantity( 93 CGM.getDataLayout().getTypeAllocSize(C->getType())); 94 } 95}; 96 97void ConstStructBuilder:: 98AppendField(const FieldDecl *Field, uint64_t FieldOffset, 99 llvm::Constant *InitCst) { 100 const ASTContext &Context = CGM.getContext(); 101 102 CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset); 103 104 AppendBytes(FieldOffsetInChars, InitCst); 105} 106 107void ConstStructBuilder:: 108AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) { 109 110 assert(NextFieldOffsetInChars <= FieldOffsetInChars 111 && "Field offset mismatch!"); 112 113 CharUnits FieldAlignment = getAlignment(InitCst); 114 115 // Round up the field offset to the alignment of the field type. 116 CharUnits AlignedNextFieldOffsetInChars = 117 NextFieldOffsetInChars.alignTo(FieldAlignment); 118 119 if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) { 120 // We need to append padding. 121 AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars); 122 123 assert(NextFieldOffsetInChars == FieldOffsetInChars && 124 "Did not add enough padding!"); 125 126 AlignedNextFieldOffsetInChars = 127 NextFieldOffsetInChars.alignTo(FieldAlignment); 128 } 129 130 if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) { 131 assert(!Packed && "Alignment is wrong even with a packed struct!"); 132 133 // Convert the struct to a packed struct. 134 ConvertStructToPacked(); 135 136 // After we pack the struct, we may need to insert padding. 137 if (NextFieldOffsetInChars < FieldOffsetInChars) { 138 // We need to append padding. 139 AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars); 140 141 assert(NextFieldOffsetInChars == FieldOffsetInChars && 142 "Did not add enough padding!"); 143 } 144 AlignedNextFieldOffsetInChars = NextFieldOffsetInChars; 145 } 146 147 // Add the field. 148 Elements.push_back(InitCst); 149 NextFieldOffsetInChars = AlignedNextFieldOffsetInChars + 150 getSizeInChars(InitCst); 151 152 if (Packed) 153 assert(LLVMStructAlignment == CharUnits::One() && 154 "Packed struct not byte-aligned!"); 155 else 156 LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment); 157} 158 159void ConstStructBuilder::AppendBitField(const FieldDecl *Field, 160 uint64_t FieldOffset, 161 llvm::ConstantInt *CI) { 162 const ASTContext &Context = CGM.getContext(); 163 const uint64_t CharWidth = Context.getCharWidth(); 164 uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); 165 if (FieldOffset > NextFieldOffsetInBits) { 166 // We need to add padding. 167 CharUnits PadSize = Context.toCharUnitsFromBits( 168 llvm::alignTo(FieldOffset - NextFieldOffsetInBits, 169 Context.getTargetInfo().getCharAlign())); 170 171 AppendPadding(PadSize); 172 } 173 174 uint64_t FieldSize = Field->getBitWidthValue(Context); 175 176 llvm::APInt FieldValue = CI->getValue(); 177 178 // Promote the size of FieldValue if necessary 179 // FIXME: This should never occur, but currently it can because initializer 180 // constants are cast to bool, and because clang is not enforcing bitfield 181 // width limits. 182 if (FieldSize > FieldValue.getBitWidth()) 183 FieldValue = FieldValue.zext(FieldSize); 184 185 // Truncate the size of FieldValue to the bit field size. 186 if (FieldSize < FieldValue.getBitWidth()) 187 FieldValue = FieldValue.trunc(FieldSize); 188 189 NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); 190 if (FieldOffset < NextFieldOffsetInBits) { 191 // Either part of the field or the entire field can go into the previous 192 // byte. 193 assert(!Elements.empty() && "Elements can't be empty!"); 194 195 unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset; 196 197 bool FitsCompletelyInPreviousByte = 198 BitsInPreviousByte >= FieldValue.getBitWidth(); 199 200 llvm::APInt Tmp = FieldValue; 201 202 if (!FitsCompletelyInPreviousByte) { 203 unsigned NewFieldWidth = FieldSize - BitsInPreviousByte; 204 205 if (CGM.getDataLayout().isBigEndian()) { 206 Tmp.lshrInPlace(NewFieldWidth); 207 Tmp = Tmp.trunc(BitsInPreviousByte); 208 209 // We want the remaining high bits. 210 FieldValue = FieldValue.trunc(NewFieldWidth); 211 } else { 212 Tmp = Tmp.trunc(BitsInPreviousByte); 213 214 // We want the remaining low bits. 215 FieldValue.lshrInPlace(BitsInPreviousByte); 216 FieldValue = FieldValue.trunc(NewFieldWidth); 217 } 218 } 219 220 Tmp = Tmp.zext(CharWidth); 221 if (CGM.getDataLayout().isBigEndian()) { 222 if (FitsCompletelyInPreviousByte) 223 Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth()); 224 } else { 225 Tmp = Tmp.shl(CharWidth - BitsInPreviousByte); 226 } 227 228 // 'or' in the bits that go into the previous byte. 229 llvm::Value *LastElt = Elements.back(); 230 if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt)) 231 Tmp |= Val->getValue(); 232 else { 233 assert(isa<llvm::UndefValue>(LastElt)); 234 // If there is an undef field that we're adding to, it can either be a 235 // scalar undef (in which case, we just replace it with our field) or it 236 // is an array. If it is an array, we have to pull one byte off the 237 // array so that the other undef bytes stay around. 238 if (!isa<llvm::IntegerType>(LastElt->getType())) { 239 // The undef padding will be a multibyte array, create a new smaller 240 // padding and then an hole for our i8 to get plopped into. 241 assert(isa<llvm::ArrayType>(LastElt->getType()) && 242 "Expected array padding of undefs"); 243 llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType()); 244 assert(AT->getElementType()->isIntegerTy(CharWidth) && 245 AT->getNumElements() != 0 && 246 "Expected non-empty array padding of undefs"); 247 248 // Remove the padding array. 249 NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements()); 250 Elements.pop_back(); 251 252 // Add the padding back in two chunks. 253 AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1)); 254 AppendPadding(CharUnits::One()); 255 assert(isa<llvm::UndefValue>(Elements.back()) && 256 Elements.back()->getType()->isIntegerTy(CharWidth) && 257 "Padding addition didn't work right"); 258 } 259 } 260 261 Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp); 262 263 if (FitsCompletelyInPreviousByte) 264 return; 265 } 266 267 while (FieldValue.getBitWidth() > CharWidth) { 268 llvm::APInt Tmp; 269 270 if (CGM.getDataLayout().isBigEndian()) { 271 // We want the high bits. 272 Tmp = 273 FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth); 274 } else { 275 // We want the low bits. 276 Tmp = FieldValue.trunc(CharWidth); 277 278 FieldValue.lshrInPlace(CharWidth); 279 } 280 281 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp)); 282 ++NextFieldOffsetInChars; 283 284 FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth); 285 } 286 287 assert(FieldValue.getBitWidth() > 0 && 288 "Should have at least one bit left!"); 289 assert(FieldValue.getBitWidth() <= CharWidth && 290 "Should not have more than a byte left!"); 291 292 if (FieldValue.getBitWidth() < CharWidth) { 293 if (CGM.getDataLayout().isBigEndian()) { 294 unsigned BitWidth = FieldValue.getBitWidth(); 295 296 FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth); 297 } else 298 FieldValue = FieldValue.zext(CharWidth); 299 } 300 301 // Append the last element. 302 Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), 303 FieldValue)); 304 ++NextFieldOffsetInChars; 305} 306 307void ConstStructBuilder::AppendPadding(CharUnits PadSize) { 308 if (PadSize.isZero()) 309 return; 310 311 llvm::Type *Ty = CGM.Int8Ty; 312 if (PadSize > CharUnits::One()) 313 Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity()); 314 315 llvm::Constant *C = llvm::UndefValue::get(Ty); 316 Elements.push_back(C); 317 assert(getAlignment(C) == CharUnits::One() && 318 "Padding must have 1 byte alignment!"); 319 320 NextFieldOffsetInChars += getSizeInChars(C); 321} 322 323void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) { 324 assert(NextFieldOffsetInChars <= RecordSize && 325 "Size mismatch!"); 326 327 AppendPadding(RecordSize - NextFieldOffsetInChars); 328} 329 330void ConstStructBuilder::ConvertStructToPacked() { 331 SmallVector<llvm::Constant *, 16> PackedElements; 332 CharUnits ElementOffsetInChars = CharUnits::Zero(); 333 334 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 335 llvm::Constant *C = Elements[i]; 336 337 CharUnits ElementAlign = CharUnits::fromQuantity( 338 CGM.getDataLayout().getABITypeAlignment(C->getType())); 339 CharUnits AlignedElementOffsetInChars = 340 ElementOffsetInChars.alignTo(ElementAlign); 341 342 if (AlignedElementOffsetInChars > ElementOffsetInChars) { 343 // We need some padding. 344 CharUnits NumChars = 345 AlignedElementOffsetInChars - ElementOffsetInChars; 346 347 llvm::Type *Ty = CGM.Int8Ty; 348 if (NumChars > CharUnits::One()) 349 Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity()); 350 351 llvm::Constant *Padding = llvm::UndefValue::get(Ty); 352 PackedElements.push_back(Padding); 353 ElementOffsetInChars += getSizeInChars(Padding); 354 } 355 356 PackedElements.push_back(C); 357 ElementOffsetInChars += getSizeInChars(C); 358 } 359 360 assert(ElementOffsetInChars == NextFieldOffsetInChars && 361 "Packing the struct changed its size!"); 362 363 Elements.swap(PackedElements); 364 LLVMStructAlignment = CharUnits::One(); 365 Packed = true; 366} 367 368bool ConstStructBuilder::Build(InitListExpr *ILE) { 369 RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); 370 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 371 372 unsigned FieldNo = 0; 373 unsigned ElementNo = 0; 374 375 // Bail out if we have base classes. We could support these, but they only 376 // arise in C++1z where we will have already constant folded most interesting 377 // cases. FIXME: There are still a few more cases we can handle this way. 378 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) 379 if (CXXRD->getNumBases()) 380 return false; 381 382 for (RecordDecl::field_iterator Field = RD->field_begin(), 383 FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 384 // If this is a union, skip all the fields that aren't being initialized. 385 if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) 386 continue; 387 388 // Don't emit anonymous bitfields, they just affect layout. 389 if (Field->isUnnamedBitfield()) 390 continue; 391 392 // Get the initializer. A struct can include fields without initializers, 393 // we just use explicit null values for them. 394 llvm::Constant *EltInit; 395 if (ElementNo < ILE->getNumInits()) 396 EltInit = Emitter.tryEmitPrivateForMemory(ILE->getInit(ElementNo++), 397 Field->getType()); 398 else 399 EltInit = Emitter.emitNullForMemory(Field->getType()); 400 401 if (!EltInit) 402 return false; 403 404 if (!Field->isBitField()) { 405 // Handle non-bitfield members. 406 AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit); 407 } else { 408 // Otherwise we have a bitfield. 409 if (auto *CI = dyn_cast<llvm::ConstantInt>(EltInit)) { 410 AppendBitField(*Field, Layout.getFieldOffset(FieldNo), CI); 411 } else { 412 // We are trying to initialize a bitfield with a non-trivial constant, 413 // this must require run-time code. 414 return false; 415 } 416 } 417 } 418 419 return true; 420} 421 422namespace { 423struct BaseInfo { 424 BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index) 425 : Decl(Decl), Offset(Offset), Index(Index) { 426 } 427 428 const CXXRecordDecl *Decl; 429 CharUnits Offset; 430 unsigned Index; 431 432 bool operator<(const BaseInfo &O) const { return Offset < O.Offset; } 433}; 434} 435 436bool ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD, 437 bool IsPrimaryBase, 438 const CXXRecordDecl *VTableClass, 439 CharUnits Offset) { 440 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 441 442 if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) { 443 // Add a vtable pointer, if we need one and it hasn't already been added. 444 if (CD->isDynamicClass() && !IsPrimaryBase) { 445 llvm::Constant *VTableAddressPoint = 446 CGM.getCXXABI().getVTableAddressPointForConstExpr( 447 BaseSubobject(CD, Offset), VTableClass); 448 AppendBytes(Offset, VTableAddressPoint); 449 } 450 451 // Accumulate and sort bases, in order to visit them in address order, which 452 // may not be the same as declaration order. 453 SmallVector<BaseInfo, 8> Bases; 454 Bases.reserve(CD->getNumBases()); 455 unsigned BaseNo = 0; 456 for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(), 457 BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) { 458 assert(!Base->isVirtual() && "should not have virtual bases here"); 459 const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl(); 460 CharUnits BaseOffset = Layout.getBaseClassOffset(BD); 461 Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo)); 462 } 463 std::stable_sort(Bases.begin(), Bases.end()); 464 465 for (unsigned I = 0, N = Bases.size(); I != N; ++I) { 466 BaseInfo &Base = Bases[I]; 467 468 bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl; 469 Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase, 470 VTableClass, Offset + Base.Offset); 471 } 472 } 473 474 unsigned FieldNo = 0; 475 uint64_t OffsetBits = CGM.getContext().toBits(Offset); 476 477 for (RecordDecl::field_iterator Field = RD->field_begin(), 478 FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 479 // If this is a union, skip all the fields that aren't being initialized. 480 if (RD->isUnion() && Val.getUnionField() != *Field) 481 continue; 482 483 // Don't emit anonymous bitfields, they just affect layout. 484 if (Field->isUnnamedBitfield()) 485 continue; 486 487 // Emit the value of the initializer. 488 const APValue &FieldValue = 489 RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo); 490 llvm::Constant *EltInit = 491 Emitter.tryEmitPrivateForMemory(FieldValue, Field->getType()); 492 if (!EltInit) 493 return false; 494 495 if (!Field->isBitField()) { 496 // Handle non-bitfield members. 497 AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit); 498 } else { 499 // Otherwise we have a bitfield. 500 AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, 501 cast<llvm::ConstantInt>(EltInit)); 502 } 503 } 504 505 return true; 506} 507 508llvm::Constant *ConstStructBuilder::Finalize(QualType Ty) { 509 RecordDecl *RD = Ty->getAs<RecordType>()->getDecl(); 510 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 511 512 CharUnits LayoutSizeInChars = Layout.getSize(); 513 514 if (NextFieldOffsetInChars > LayoutSizeInChars) { 515 // If the struct is bigger than the size of the record type, 516 // we must have a flexible array member at the end. 517 assert(RD->hasFlexibleArrayMember() && 518 "Must have flexible array member if struct is bigger than type!"); 519 520 // No tail padding is necessary. 521 } else { 522 // Append tail padding if necessary. 523 CharUnits LLVMSizeInChars = 524 NextFieldOffsetInChars.alignTo(LLVMStructAlignment); 525 526 if (LLVMSizeInChars != LayoutSizeInChars) 527 AppendTailPadding(LayoutSizeInChars); 528 529 LLVMSizeInChars = NextFieldOffsetInChars.alignTo(LLVMStructAlignment); 530 531 // Check if we need to convert the struct to a packed struct. 532 if (NextFieldOffsetInChars <= LayoutSizeInChars && 533 LLVMSizeInChars > LayoutSizeInChars) { 534 assert(!Packed && "Size mismatch!"); 535 536 ConvertStructToPacked(); 537 assert(NextFieldOffsetInChars <= LayoutSizeInChars && 538 "Converting to packed did not help!"); 539 } 540 541 LLVMSizeInChars = NextFieldOffsetInChars.alignTo(LLVMStructAlignment); 542 543 assert(LayoutSizeInChars == LLVMSizeInChars && 544 "Tail padding mismatch!"); 545 } 546 547 // Pick the type to use. If the type is layout identical to the ConvertType 548 // type then use it, otherwise use whatever the builder produced for us. 549 llvm::StructType *STy = 550 llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(), 551 Elements, Packed); 552 llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty); 553 if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) { 554 if (ValSTy->isLayoutIdentical(STy)) 555 STy = ValSTy; 556 } 557 558 llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements); 559 560 assert(NextFieldOffsetInChars.alignTo(getAlignment(Result)) == 561 getSizeInChars(Result) && 562 "Size mismatch!"); 563 564 return Result; 565} 566 567llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter, 568 ConstExprEmitter *ExprEmitter, 569 llvm::Constant *Base, 570 InitListExpr *Updater, 571 QualType ValTy) { 572 ConstStructBuilder Builder(Emitter); 573 if (!Builder.Build(ExprEmitter, Base, Updater)) 574 return nullptr; 575 return Builder.Finalize(ValTy); 576} 577 578llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter, 579 InitListExpr *ILE, 580 QualType ValTy) { 581 ConstStructBuilder Builder(Emitter); 582 583 if (!Builder.Build(ILE)) 584 return nullptr; 585 586 return Builder.Finalize(ValTy); 587} 588 589llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter, 590 const APValue &Val, 591 QualType ValTy) { 592 ConstStructBuilder Builder(Emitter); 593 594 const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl(); 595 const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD); 596 if (!Builder.Build(Val, RD, false, CD, CharUnits::Zero())) 597 return nullptr; 598 599 return Builder.Finalize(ValTy); 600} 601 602 603//===----------------------------------------------------------------------===// 604// ConstExprEmitter 605//===----------------------------------------------------------------------===// 606 607static ConstantAddress tryEmitGlobalCompoundLiteral(CodeGenModule &CGM, 608 CodeGenFunction *CGF, 609 const CompoundLiteralExpr *E) { 610 CharUnits Align = CGM.getContext().getTypeAlignInChars(E->getType()); 611 if (llvm::GlobalVariable *Addr = 612 CGM.getAddrOfConstantCompoundLiteralIfEmitted(E)) 613 return ConstantAddress(Addr, Align); 614 615 LangAS addressSpace = E->getType().getAddressSpace(); 616 617 ConstantEmitter emitter(CGM, CGF); 618 llvm::Constant *C = emitter.tryEmitForInitializer(E->getInitializer(), 619 addressSpace, E->getType()); 620 if (!C) { 621 assert(!E->isFileScope() && 622 "file-scope compound literal did not have constant initializer!"); 623 return ConstantAddress::invalid(); 624 } 625 626 auto GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), 627 CGM.isTypeConstant(E->getType(), true), 628 llvm::GlobalValue::InternalLinkage, 629 C, ".compoundliteral", nullptr, 630 llvm::GlobalVariable::NotThreadLocal, 631 CGM.getContext().getTargetAddressSpace(addressSpace)); 632 emitter.finalize(GV); 633 GV->setAlignment(Align.getQuantity()); 634 CGM.setAddrOfConstantCompoundLiteral(E, GV); 635 return ConstantAddress(GV, Align); 636} 637 638static llvm::Constant * 639EmitArrayConstant(CodeGenModule &CGM, const ConstantArrayType *DestType, 640 llvm::Type *CommonElementType, unsigned ArrayBound, 641 SmallVectorImpl<llvm::Constant *> &Elements, 642 llvm::Constant *Filler) { 643 // Figure out how long the initial prefix of non-zero elements is. 644 unsigned NonzeroLength = ArrayBound; 645 if (Elements.size() < NonzeroLength && Filler->isNullValue()) 646 NonzeroLength = Elements.size(); 647 if (NonzeroLength == Elements.size()) { 648 while (NonzeroLength > 0 && Elements[NonzeroLength - 1]->isNullValue()) 649 --NonzeroLength; 650 } 651 652 if (NonzeroLength == 0) { 653 return llvm::ConstantAggregateZero::get( 654 CGM.getTypes().ConvertType(QualType(DestType, 0))); 655 } 656 657 // Add a zeroinitializer array filler if we have lots of trailing zeroes. 658 unsigned TrailingZeroes = ArrayBound - NonzeroLength; 659 if (TrailingZeroes >= 8) { 660 assert(Elements.size() >= NonzeroLength && 661 "missing initializer for non-zero element"); 662 663 // If all the elements had the same type up to the trailing zeroes, emit a 664 // struct of two arrays (the nonzero data and the zeroinitializer). 665 if (CommonElementType && NonzeroLength >= 8) { 666 llvm::Constant *Initial = llvm::ConstantArray::get( 667 llvm::ArrayType::get(CommonElementType, NonzeroLength), 668 makeArrayRef(Elements).take_front(NonzeroLength)); 669 Elements.resize(2); 670 Elements[0] = Initial; 671 } else { 672 Elements.resize(NonzeroLength + 1); 673 } 674 675 auto *FillerType = 676 CommonElementType 677 ? CommonElementType 678 : CGM.getTypes().ConvertType(DestType->getElementType()); 679 FillerType = llvm::ArrayType::get(FillerType, TrailingZeroes); 680 Elements.back() = llvm::ConstantAggregateZero::get(FillerType); 681 CommonElementType = nullptr; 682 } else if (Elements.size() != ArrayBound) { 683 // Otherwise pad to the right size with the filler if necessary. 684 Elements.resize(ArrayBound, Filler); 685 if (Filler->getType() != CommonElementType) 686 CommonElementType = nullptr; 687 } 688 689 // If all elements have the same type, just emit an array constant. 690 if (CommonElementType) 691 return llvm::ConstantArray::get( 692 llvm::ArrayType::get(CommonElementType, ArrayBound), Elements); 693 694 // We have mixed types. Use a packed struct. 695 llvm::SmallVector<llvm::Type *, 16> Types; 696 Types.reserve(Elements.size()); 697 for (llvm::Constant *Elt : Elements) 698 Types.push_back(Elt->getType()); 699 llvm::StructType *SType = 700 llvm::StructType::get(CGM.getLLVMContext(), Types, true); 701 return llvm::ConstantStruct::get(SType, Elements); 702} 703 704/// This class only needs to handle two cases: 705/// 1) Literals (this is used by APValue emission to emit literals). 706/// 2) Arrays, structs and unions (outside C++11 mode, we don't currently 707/// constant fold these types). 708class ConstExprEmitter : 709 public StmtVisitor<ConstExprEmitter, llvm::Constant*, QualType> { 710 CodeGenModule &CGM; 711 ConstantEmitter &Emitter; 712 llvm::LLVMContext &VMContext; 713public: 714 ConstExprEmitter(ConstantEmitter &emitter) 715 : CGM(emitter.CGM), Emitter(emitter), VMContext(CGM.getLLVMContext()) { 716 } 717 718 //===--------------------------------------------------------------------===// 719 // Visitor Methods 720 //===--------------------------------------------------------------------===// 721 722 llvm::Constant *VisitStmt(Stmt *S, QualType T) { 723 return nullptr; 724 } 725 726 llvm::Constant *VisitConstantExpr(ConstantExpr *CE, QualType T) { 727 return Visit(CE->getSubExpr(), T); 728 } 729 730 llvm::Constant *VisitParenExpr(ParenExpr *PE, QualType T) { 731 return Visit(PE->getSubExpr(), T); 732 } 733 734 llvm::Constant * 735 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE, 736 QualType T) { 737 return Visit(PE->getReplacement(), T); 738 } 739 740 llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE, 741 QualType T) { 742 return Visit(GE->getResultExpr(), T); 743 } 744 745 llvm::Constant *VisitChooseExpr(ChooseExpr *CE, QualType T) { 746 return Visit(CE->getChosenSubExpr(), T); 747 } 748 749 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E, QualType T) { 750 return Visit(E->getInitializer(), T); 751 } 752 753 llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) { 754 if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E)) 755 CGM.EmitExplicitCastExprType(ECE, Emitter.CGF); 756 Expr *subExpr = E->getSubExpr(); 757 758 switch (E->getCastKind()) { 759 case CK_ToUnion: { 760 // GCC cast to union extension 761 assert(E->getType()->isUnionType() && 762 "Destination type is not union type!"); 763 764 auto field = E->getTargetUnionField(); 765 766 auto C = Emitter.tryEmitPrivateForMemory(subExpr, field->getType()); 767 if (!C) return nullptr; 768 769 auto destTy = ConvertType(destType); 770 if (C->getType() == destTy) return C; 771 772 // Build a struct with the union sub-element as the first member, 773 // and padded to the appropriate size. 774 SmallVector<llvm::Constant*, 2> Elts; 775 SmallVector<llvm::Type*, 2> Types; 776 Elts.push_back(C); 777 Types.push_back(C->getType()); 778 unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType()); 779 unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destTy); 780 781 assert(CurSize <= TotalSize && "Union size mismatch!"); 782 if (unsigned NumPadBytes = TotalSize - CurSize) { 783 llvm::Type *Ty = CGM.Int8Ty; 784 if (NumPadBytes > 1) 785 Ty = llvm::ArrayType::get(Ty, NumPadBytes); 786 787 Elts.push_back(llvm::UndefValue::get(Ty)); 788 Types.push_back(Ty); 789 } 790 791 llvm::StructType *STy = llvm::StructType::get(VMContext, Types, false); 792 return llvm::ConstantStruct::get(STy, Elts); 793 } 794 795 case CK_AddressSpaceConversion: { 796 auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType()); 797 if (!C) return nullptr; 798 LangAS destAS = E->getType()->getPointeeType().getAddressSpace(); 799 LangAS srcAS = subExpr->getType()->getPointeeType().getAddressSpace(); 800 llvm::Type *destTy = ConvertType(E->getType()); 801 return CGM.getTargetCodeGenInfo().performAddrSpaceCast(CGM, C, srcAS, 802 destAS, destTy); 803 } 804 805 case CK_LValueToRValue: 806 case CK_AtomicToNonAtomic: 807 case CK_NonAtomicToAtomic: 808 case CK_NoOp: 809 case CK_ConstructorConversion: 810 return Visit(subExpr, destType); 811 812 case CK_IntToOCLSampler: 813 llvm_unreachable("global sampler variables are not generated"); 814 815 case CK_Dependent: llvm_unreachable("saw dependent cast!"); 816 817 case CK_BuiltinFnToFnPtr: 818 llvm_unreachable("builtin functions are handled elsewhere"); 819 820 case CK_ReinterpretMemberPointer: 821 case CK_DerivedToBaseMemberPointer: 822 case CK_BaseToDerivedMemberPointer: { 823 auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType()); 824 if (!C) return nullptr; 825 return CGM.getCXXABI().EmitMemberPointerConversion(E, C); 826 } 827 828 // These will never be supported. 829 case CK_ObjCObjectLValueCast: 830 case CK_ARCProduceObject: 831 case CK_ARCConsumeObject: 832 case CK_ARCReclaimReturnedObject: 833 case CK_ARCExtendBlockObject: 834 case CK_CopyAndAutoreleaseBlockObject: 835 return nullptr; 836 837 // These don't need to be handled here because Evaluate knows how to 838 // evaluate them in the cases where they can be folded. 839 case CK_BitCast: 840 case CK_ToVoid: 841 case CK_Dynamic: 842 case CK_LValueBitCast: 843 case CK_NullToMemberPointer: 844 case CK_UserDefinedConversion: 845 case CK_CPointerToObjCPointerCast: 846 case CK_BlockPointerToObjCPointerCast: 847 case CK_AnyPointerToBlockPointerCast: 848 case CK_ArrayToPointerDecay: 849 case CK_FunctionToPointerDecay: 850 case CK_BaseToDerived: 851 case CK_DerivedToBase: 852 case CK_UncheckedDerivedToBase: 853 case CK_MemberPointerToBoolean: 854 case CK_VectorSplat: 855 case CK_FloatingRealToComplex: 856 case CK_FloatingComplexToReal: 857 case CK_FloatingComplexToBoolean: 858 case CK_FloatingComplexCast: 859 case CK_FloatingComplexToIntegralComplex: 860 case CK_IntegralRealToComplex: 861 case CK_IntegralComplexToReal: 862 case CK_IntegralComplexToBoolean: 863 case CK_IntegralComplexCast: 864 case CK_IntegralComplexToFloatingComplex: 865 case CK_PointerToIntegral: 866 case CK_PointerToBoolean: 867 case CK_NullToPointer: 868 case CK_IntegralCast: 869 case CK_BooleanToSignedIntegral: 870 case CK_IntegralToPointer: 871 case CK_IntegralToBoolean: 872 case CK_IntegralToFloating: 873 case CK_FloatingToIntegral: 874 case CK_FloatingToBoolean: 875 case CK_FloatingCast: 876 case CK_FixedPointCast: 877 case CK_FixedPointToBoolean: 878 case CK_ZeroToOCLOpaqueType: 879 return nullptr; 880 } 881 llvm_unreachable("Invalid CastKind"); 882 } 883 884 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE, QualType T) { 885 return Visit(DAE->getExpr(), T); 886 } 887 888 llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) { 889 // No need for a DefaultInitExprScope: we don't handle 'this' in a 890 // constant expression. 891 return Visit(DIE->getExpr(), T); 892 } 893 894 llvm::Constant *VisitExprWithCleanups(ExprWithCleanups *E, QualType T) { 895 if (!E->cleanupsHaveSideEffects()) 896 return Visit(E->getSubExpr(), T); 897 return nullptr; 898 } 899 900 llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E, 901 QualType T) { 902 return Visit(E->GetTemporaryExpr(), T); 903 } 904 905 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, QualType T) { 906 auto *CAT = CGM.getContext().getAsConstantArrayType(ILE->getType()); 907 assert(CAT && "can't emit array init for non-constant-bound array"); 908 unsigned NumInitElements = ILE->getNumInits(); 909 unsigned NumElements = CAT->getSize().getZExtValue(); 910 911 // Initialising an array requires us to automatically 912 // initialise any elements that have not been initialised explicitly 913 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 914 915 QualType EltType = CAT->getElementType(); 916 917 // Initialize remaining array elements. 918 llvm::Constant *fillC = nullptr; 919 if (Expr *filler = ILE->getArrayFiller()) { 920 fillC = Emitter.tryEmitAbstractForMemory(filler, EltType); 921 if (!fillC) 922 return nullptr; 923 } 924 925 // Copy initializer elements. 926 SmallVector<llvm::Constant*, 16> Elts; 927 if (fillC && fillC->isNullValue()) 928 Elts.reserve(NumInitableElts + 1); 929 else 930 Elts.reserve(NumElements); 931 932 llvm::Type *CommonElementType = nullptr; 933 for (unsigned i = 0; i < NumInitableElts; ++i) { 934 Expr *Init = ILE->getInit(i); 935 llvm::Constant *C = Emitter.tryEmitPrivateForMemory(Init, EltType); 936 if (!C) 937 return nullptr; 938 if (i == 0) 939 CommonElementType = C->getType(); 940 else if (C->getType() != CommonElementType) 941 CommonElementType = nullptr; 942 Elts.push_back(C); 943 } 944 945 return EmitArrayConstant(CGM, CAT, CommonElementType, NumElements, Elts, 946 fillC); 947 } 948 949 llvm::Constant *EmitRecordInitialization(InitListExpr *ILE, QualType T) { 950 return ConstStructBuilder::BuildStruct(Emitter, ILE, T); 951 } 952 953 llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E, 954 QualType T) { 955 return CGM.EmitNullConstant(T); 956 } 957 958 llvm::Constant *VisitInitListExpr(InitListExpr *ILE, QualType T) { 959 if (ILE->isTransparent()) 960 return Visit(ILE->getInit(0), T); 961 962 if (ILE->getType()->isArrayType()) 963 return EmitArrayInitialization(ILE, T); 964 965 if (ILE->getType()->isRecordType()) 966 return EmitRecordInitialization(ILE, T); 967 968 return nullptr; 969 } 970 971 llvm::Constant *EmitDesignatedInitUpdater(llvm::Constant *Base, 972 InitListExpr *Updater, 973 QualType destType) { 974 if (auto destAT = CGM.getContext().getAsArrayType(destType)) { 975 llvm::ArrayType *AType = cast<llvm::ArrayType>(ConvertType(destType)); 976 llvm::Type *ElemType = AType->getElementType(); 977 978 unsigned NumInitElements = Updater->getNumInits(); 979 unsigned NumElements = AType->getNumElements(); 980 981 std::vector<llvm::Constant *> Elts; 982 Elts.reserve(NumElements); 983 984 QualType destElemType = destAT->getElementType(); 985 986 if (auto DataArray = dyn_cast<llvm::ConstantDataArray>(Base)) 987 for (unsigned i = 0; i != NumElements; ++i) 988 Elts.push_back(DataArray->getElementAsConstant(i)); 989 else if (auto Array = dyn_cast<llvm::ConstantArray>(Base)) 990 for (unsigned i = 0; i != NumElements; ++i) 991 Elts.push_back(Array->getOperand(i)); 992 else 993 return nullptr; // FIXME: other array types not implemented 994 995 llvm::Constant *fillC = nullptr; 996 if (Expr *filler = Updater->getArrayFiller()) 997 if (!isa<NoInitExpr>(filler)) 998 fillC = Emitter.tryEmitAbstractForMemory(filler, destElemType); 999 bool RewriteType = (fillC && fillC->getType() != ElemType); 1000 1001 for (unsigned i = 0; i != NumElements; ++i) { 1002 Expr *Init = nullptr; 1003 if (i < NumInitElements) 1004 Init = Updater->getInit(i); 1005 1006 if (!Init && fillC) 1007 Elts[i] = fillC; 1008 else if (!Init || isa<NoInitExpr>(Init)) 1009 ; // Do nothing. 1010 else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init)) 1011 Elts[i] = EmitDesignatedInitUpdater(Elts[i], ChildILE, destElemType); 1012 else 1013 Elts[i] = Emitter.tryEmitPrivateForMemory(Init, destElemType); 1014 1015 if (!Elts[i]) 1016 return nullptr; 1017 RewriteType |= (Elts[i]->getType() != ElemType); 1018 } 1019 1020 if (RewriteType) { 1021 std::vector<llvm::Type *> Types; 1022 Types.reserve(NumElements); 1023 for (unsigned i = 0; i != NumElements; ++i) 1024 Types.push_back(Elts[i]->getType()); 1025 llvm::StructType *SType = llvm::StructType::get(AType->getContext(), 1026 Types, true); 1027 return llvm::ConstantStruct::get(SType, Elts); 1028 } 1029 1030 return llvm::ConstantArray::get(AType, Elts); 1031 } 1032 1033 if (destType->isRecordType()) 1034 return ConstStructBuilder::BuildStruct(Emitter, this, Base, Updater, 1035 destType); 1036 1037 return nullptr; 1038 } 1039 1040 llvm::Constant *VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E, 1041 QualType destType) { 1042 auto C = Visit(E->getBase(), destType); 1043 if (!C) return nullptr; 1044 return EmitDesignatedInitUpdater(C, E->getUpdater(), destType); 1045 } 1046 1047 llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E, QualType Ty) { 1048 if (!E->getConstructor()->isTrivial()) 1049 return nullptr; 1050 1051 // FIXME: We should not have to call getBaseElementType here. 1052 const RecordType *RT = 1053 CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>(); 1054 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1055 1056 // If the class doesn't have a trivial destructor, we can't emit it as a 1057 // constant expr. 1058 if (!RD->hasTrivialDestructor()) 1059 return nullptr; 1060 1061 // Only copy and default constructors can be trivial. 1062 1063 1064 if (E->getNumArgs()) { 1065 assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument"); 1066 assert(E->getConstructor()->isCopyOrMoveConstructor() && 1067 "trivial ctor has argument but isn't a copy/move ctor"); 1068 1069 Expr *Arg = E->getArg(0); 1070 assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) && 1071 "argument to copy ctor is of wrong type"); 1072 1073 return Visit(Arg, Ty); 1074 } 1075 1076 return CGM.EmitNullConstant(Ty); 1077 } 1078 1079 llvm::Constant *VisitStringLiteral(StringLiteral *E, QualType T) { 1080 return CGM.GetConstantArrayFromStringLiteral(E); 1081 } 1082 1083 llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E, QualType T) { 1084 // This must be an @encode initializing an array in a static initializer. 1085 // Don't emit it as the address of the string, emit the string data itself 1086 // as an inline array. 1087 std::string Str; 1088 CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); 1089 const ConstantArrayType *CAT = CGM.getContext().getAsConstantArrayType(T); 1090 1091 // Resize the string to the right size, adding zeros at the end, or 1092 // truncating as needed. 1093 Str.resize(CAT->getSize().getZExtValue(), '\0'); 1094 return llvm::ConstantDataArray::getString(VMContext, Str, false); 1095 } 1096 1097 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E, QualType T) { 1098 return Visit(E->getSubExpr(), T); 1099 } 1100 1101 // Utility methods 1102 llvm::Type *ConvertType(QualType T) { 1103 return CGM.getTypes().ConvertType(T); 1104 } 1105}; 1106 1107} // end anonymous namespace. 1108 1109bool ConstStructBuilder::Build(ConstExprEmitter *ExprEmitter, 1110 llvm::Constant *Base, 1111 InitListExpr *Updater) { 1112 assert(Base && "base expression should not be empty"); 1113 1114 QualType ExprType = Updater->getType(); 1115 RecordDecl *RD = ExprType->getAs<RecordType>()->getDecl(); 1116 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 1117 const llvm::StructLayout *BaseLayout = CGM.getDataLayout().getStructLayout( 1118 cast<llvm::StructType>(Base->getType())); 1119 unsigned FieldNo = -1; 1120 unsigned ElementNo = 0; 1121 1122 // Bail out if we have base classes. We could support these, but they only 1123 // arise in C++1z where we will have already constant folded most interesting 1124 // cases. FIXME: There are still a few more cases we can handle this way. 1125 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) 1126 if (CXXRD->getNumBases()) 1127 return false; 1128 1129 for (FieldDecl *Field : RD->fields()) { 1130 ++FieldNo; 1131 1132 if (RD->isUnion() && Updater->getInitializedFieldInUnion() != Field) 1133 continue; 1134 1135 // Skip anonymous bitfields. 1136 if (Field->isUnnamedBitfield()) 1137 continue; 1138 1139 llvm::Constant *EltInit = Base->getAggregateElement(ElementNo); 1140 1141 // Bail out if the type of the ConstantStruct does not have the same layout 1142 // as the type of the InitListExpr. 1143 if (CGM.getTypes().ConvertType(Field->getType()) != EltInit->getType() || 1144 Layout.getFieldOffset(ElementNo) != 1145 BaseLayout->getElementOffsetInBits(ElementNo)) 1146 return false; 1147 1148 // Get the initializer. If we encounter an empty field or a NoInitExpr, 1149 // we use values from the base expression. 1150 Expr *Init = nullptr; 1151 if (ElementNo < Updater->getNumInits()) 1152 Init = Updater->getInit(ElementNo); 1153 1154 if (!Init || isa<NoInitExpr>(Init)) 1155 ; // Do nothing. 1156 else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init)) 1157 EltInit = ExprEmitter->EmitDesignatedInitUpdater(EltInit, ChildILE, 1158 Field->getType()); 1159 else 1160 EltInit = Emitter.tryEmitPrivateForMemory(Init, Field->getType()); 1161 1162 ++ElementNo; 1163 1164 if (!EltInit) 1165 return false; 1166 1167 if (!Field->isBitField()) 1168 AppendField(Field, Layout.getFieldOffset(FieldNo), EltInit); 1169 else if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(EltInit)) 1170 AppendBitField(Field, Layout.getFieldOffset(FieldNo), CI); 1171 else 1172 // Initializing a bitfield with a non-trivial constant? 1173 return false; 1174 } 1175 1176 return true; 1177} 1178 1179llvm::Constant *ConstantEmitter::validateAndPopAbstract(llvm::Constant *C, 1180 AbstractState saved) { 1181 Abstract = saved.OldValue; 1182 1183 assert(saved.OldPlaceholdersSize == PlaceholderAddresses.size() && 1184 "created a placeholder while doing an abstract emission?"); 1185 1186 // No validation necessary for now. 1187 // No cleanup to do for now. 1188 return C; 1189} 1190 1191llvm::Constant * 1192ConstantEmitter::tryEmitAbstractForInitializer(const VarDecl &D) { 1193 auto state = pushAbstract(); 1194 auto C = tryEmitPrivateForVarInit(D); 1195 return validateAndPopAbstract(C, state); 1196} 1197 1198llvm::Constant * 1199ConstantEmitter::tryEmitAbstract(const Expr *E, QualType destType) { 1200 auto state = pushAbstract(); 1201 auto C = tryEmitPrivate(E, destType); 1202 return validateAndPopAbstract(C, state); 1203} 1204 1205llvm::Constant * 1206ConstantEmitter::tryEmitAbstract(const APValue &value, QualType destType) { 1207 auto state = pushAbstract(); 1208 auto C = tryEmitPrivate(value, destType); 1209 return validateAndPopAbstract(C, state); 1210} 1211 1212llvm::Constant * 1213ConstantEmitter::emitAbstract(const Expr *E, QualType destType) { 1214 auto state = pushAbstract(); 1215 auto C = tryEmitPrivate(E, destType); 1216 C = validateAndPopAbstract(C, state); 1217 if (!C) { 1218 CGM.Error(E->getExprLoc(), 1219 "internal error: could not emit constant value \"abstractly\""); 1220 C = CGM.EmitNullConstant(destType); 1221 } 1222 return C; 1223} 1224 1225llvm::Constant * 1226ConstantEmitter::emitAbstract(SourceLocation loc, const APValue &value, 1227 QualType destType) { 1228 auto state = pushAbstract(); 1229 auto C = tryEmitPrivate(value, destType); 1230 C = validateAndPopAbstract(C, state); 1231 if (!C) { 1232 CGM.Error(loc, 1233 "internal error: could not emit constant value \"abstractly\""); 1234 C = CGM.EmitNullConstant(destType); 1235 } 1236 return C; 1237} 1238 1239llvm::Constant *ConstantEmitter::tryEmitForInitializer(const VarDecl &D) { 1240 initializeNonAbstract(D.getType().getAddressSpace()); 1241 return markIfFailed(tryEmitPrivateForVarInit(D)); 1242} 1243 1244llvm::Constant *ConstantEmitter::tryEmitForInitializer(const Expr *E, 1245 LangAS destAddrSpace, 1246 QualType destType) { 1247 initializeNonAbstract(destAddrSpace); 1248 return markIfFailed(tryEmitPrivateForMemory(E, destType)); 1249} 1250 1251llvm::Constant *ConstantEmitter::emitForInitializer(const APValue &value, 1252 LangAS destAddrSpace, 1253 QualType destType) { 1254 initializeNonAbstract(destAddrSpace); 1255 auto C = tryEmitPrivateForMemory(value, destType); 1256 assert(C && "couldn't emit constant value non-abstractly?"); 1257 return C; 1258} 1259 1260llvm::GlobalValue *ConstantEmitter::getCurrentAddrPrivate() { 1261 assert(!Abstract && "cannot get current address for abstract constant"); 1262 1263 1264 1265 // Make an obviously ill-formed global that should blow up compilation 1266 // if it survives. 1267 auto global = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8Ty, true, 1268 llvm::GlobalValue::PrivateLinkage, 1269 /*init*/ nullptr, 1270 /*name*/ "", 1271 /*before*/ nullptr, 1272 llvm::GlobalVariable::NotThreadLocal, 1273 CGM.getContext().getTargetAddressSpace(DestAddressSpace)); 1274 1275 PlaceholderAddresses.push_back(std::make_pair(nullptr, global)); 1276 1277 return global; 1278} 1279 1280void ConstantEmitter::registerCurrentAddrPrivate(llvm::Constant *signal, 1281 llvm::GlobalValue *placeholder) { 1282 assert(!PlaceholderAddresses.empty()); 1283 assert(PlaceholderAddresses.back().first == nullptr); 1284 assert(PlaceholderAddresses.back().second == placeholder); 1285 PlaceholderAddresses.back().first = signal; 1286} 1287 1288namespace { 1289 struct ReplacePlaceholders { 1290 CodeGenModule &CGM; 1291 1292 /// The base address of the global. 1293 llvm::Constant *Base; 1294 llvm::Type *BaseValueTy = nullptr; 1295 1296 /// The placeholder addresses that were registered during emission. 1297 llvm::DenseMap<llvm::Constant*, llvm::GlobalVariable*> PlaceholderAddresses; 1298 1299 /// The locations of the placeholder signals. 1300 llvm::DenseMap<llvm::GlobalVariable*, llvm::Constant*> Locations; 1301 1302 /// The current index stack. We use a simple unsigned stack because 1303 /// we assume that placeholders will be relatively sparse in the 1304 /// initializer, but we cache the index values we find just in case. 1305 llvm::SmallVector<unsigned, 8> Indices; 1306 llvm::SmallVector<llvm::Constant*, 8> IndexValues; 1307 1308 ReplacePlaceholders(CodeGenModule &CGM, llvm::Constant *base, 1309 ArrayRef<std::pair<llvm::Constant*, 1310 llvm::GlobalVariable*>> addresses) 1311 : CGM(CGM), Base(base), 1312 PlaceholderAddresses(addresses.begin(), addresses.end()) { 1313 } 1314 1315 void replaceInInitializer(llvm::Constant *init) { 1316 // Remember the type of the top-most initializer. 1317 BaseValueTy = init->getType(); 1318 1319 // Initialize the stack. 1320 Indices.push_back(0); 1321 IndexValues.push_back(nullptr); 1322 1323 // Recurse into the initializer. 1324 findLocations(init); 1325 1326 // Check invariants. 1327 assert(IndexValues.size() == Indices.size() && "mismatch"); 1328 assert(Indices.size() == 1 && "didn't pop all indices"); 1329 1330 // Do the replacement; this basically invalidates 'init'. 1331 assert(Locations.size() == PlaceholderAddresses.size() && 1332 "missed a placeholder?"); 1333 1334 // We're iterating over a hashtable, so this would be a source of 1335 // non-determinism in compiler output *except* that we're just 1336 // messing around with llvm::Constant structures, which never itself 1337 // does anything that should be visible in compiler output. 1338 for (auto &entry : Locations) { 1339 assert(entry.first->getParent() == nullptr && "not a placeholder!"); 1340 entry.first->replaceAllUsesWith(entry.second); 1341 entry.first->eraseFromParent(); 1342 } 1343 } 1344 1345 private: 1346 void findLocations(llvm::Constant *init) { 1347 // Recurse into aggregates. 1348 if (auto agg = dyn_cast<llvm::ConstantAggregate>(init)) { 1349 for (unsigned i = 0, e = agg->getNumOperands(); i != e; ++i) { 1350 Indices.push_back(i); 1351 IndexValues.push_back(nullptr); 1352 1353 findLocations(agg->getOperand(i)); 1354 1355 IndexValues.pop_back(); 1356 Indices.pop_back(); 1357 } 1358 return; 1359 } 1360 1361 // Otherwise, check for registered constants. 1362 while (true) { 1363 auto it = PlaceholderAddresses.find(init); 1364 if (it != PlaceholderAddresses.end()) { 1365 setLocation(it->second); 1366 break; 1367 } 1368 1369 // Look through bitcasts or other expressions. 1370 if (auto expr = dyn_cast<llvm::ConstantExpr>(init)) { 1371 init = expr->getOperand(0); 1372 } else { 1373 break; 1374 } 1375 } 1376 } 1377 1378 void setLocation(llvm::GlobalVariable *placeholder) { 1379 assert(Locations.find(placeholder) == Locations.end() && 1380 "already found location for placeholder!"); 1381 1382 // Lazily fill in IndexValues with the values from Indices. 1383 // We do this in reverse because we should always have a strict 1384 // prefix of indices from the start. 1385 assert(Indices.size() == IndexValues.size()); 1386 for (size_t i = Indices.size() - 1; i != size_t(-1); --i) { 1387 if (IndexValues[i]) { 1388#ifndef NDEBUG 1389 for (size_t j = 0; j != i + 1; ++j) { 1390 assert(IndexValues[j] && 1391 isa<llvm::ConstantInt>(IndexValues[j]) && 1392 cast<llvm::ConstantInt>(IndexValues[j])->getZExtValue() 1393 == Indices[j]); 1394 } 1395#endif 1396 break; 1397 } 1398 1399 IndexValues[i] = llvm::ConstantInt::get(CGM.Int32Ty, Indices[i]); 1400 } 1401 1402 // Form a GEP and then bitcast to the placeholder type so that the 1403 // replacement will succeed. 1404 llvm::Constant *location = 1405 llvm::ConstantExpr::getInBoundsGetElementPtr(BaseValueTy, 1406 Base, IndexValues); 1407 location = llvm::ConstantExpr::getBitCast(location, 1408 placeholder->getType()); 1409 1410 Locations.insert({placeholder, location}); 1411 } 1412 }; 1413} 1414 1415void ConstantEmitter::finalize(llvm::GlobalVariable *global) { 1416 assert(InitializedNonAbstract && 1417 "finalizing emitter that was used for abstract emission?"); 1418 assert(!Finalized && "finalizing emitter multiple times"); 1419 assert(global->getInitializer()); 1420 1421 // Note that we might also be Failed. 1422 Finalized = true; 1423 1424 if (!PlaceholderAddresses.empty()) { 1425 ReplacePlaceholders(CGM, global, PlaceholderAddresses) 1426 .replaceInInitializer(global->getInitializer()); 1427 PlaceholderAddresses.clear(); // satisfy 1428 } 1429} 1430 1431ConstantEmitter::~ConstantEmitter() { 1432 assert((!InitializedNonAbstract || Finalized || Failed) && 1433 "not finalized after being initialized for non-abstract emission"); 1434 assert(PlaceholderAddresses.empty() && "unhandled placeholders"); 1435} 1436 1437static QualType getNonMemoryType(CodeGenModule &CGM, QualType type) { 1438 if (auto AT = type->getAs<AtomicType>()) { 1439 return CGM.getContext().getQualifiedType(AT->getValueType(), 1440 type.getQualifiers()); 1441 } 1442 return type; 1443} 1444 1445llvm::Constant *ConstantEmitter::tryEmitPrivateForVarInit(const VarDecl &D) { 1446 // Make a quick check if variable can be default NULL initialized 1447 // and avoid going through rest of code which may do, for c++11, 1448 // initialization of memory to all NULLs. 1449 if (!D.hasLocalStorage()) { 1450 QualType Ty = CGM.getContext().getBaseElementType(D.getType()); 1451 if (Ty->isRecordType()) 1452 if (const CXXConstructExpr *E = 1453 dyn_cast_or_null<CXXConstructExpr>(D.getInit())) { 1454 const CXXConstructorDecl *CD = E->getConstructor(); 1455 if (CD->isTrivial() && CD->isDefaultConstructor()) 1456 return CGM.EmitNullConstant(D.getType()); 1457 } 1458 InConstantContext = true; 1459 } 1460 1461 QualType destType = D.getType(); 1462 1463 // Try to emit the initializer. Note that this can allow some things that 1464 // are not allowed by tryEmitPrivateForMemory alone. 1465 if (auto value = D.evaluateValue()) { 1466 return tryEmitPrivateForMemory(*value, destType); 1467 } 1468 1469 // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a 1470 // reference is a constant expression, and the reference binds to a temporary, 1471 // then constant initialization is performed. ConstExprEmitter will 1472 // incorrectly emit a prvalue constant in this case, and the calling code 1473 // interprets that as the (pointer) value of the reference, rather than the 1474 // desired value of the referee. 1475 if (destType->isReferenceType()) 1476 return nullptr; 1477 1478 const Expr *E = D.getInit(); 1479 assert(E && "No initializer to emit"); 1480 1481 auto nonMemoryDestType = getNonMemoryType(CGM, destType); 1482 auto C = 1483 ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), nonMemoryDestType); 1484 return (C ? emitForMemory(C, destType) : nullptr); 1485} 1486 1487llvm::Constant * 1488ConstantEmitter::tryEmitAbstractForMemory(const Expr *E, QualType destType) { 1489 auto nonMemoryDestType = getNonMemoryType(CGM, destType); 1490 auto C = tryEmitAbstract(E, nonMemoryDestType); 1491 return (C ? emitForMemory(C, destType) : nullptr); 1492} 1493 1494llvm::Constant * 1495ConstantEmitter::tryEmitAbstractForMemory(const APValue &value, 1496 QualType destType) { 1497 auto nonMemoryDestType = getNonMemoryType(CGM, destType); 1498 auto C = tryEmitAbstract(value, nonMemoryDestType); 1499 return (C ? emitForMemory(C, destType) : nullptr); 1500} 1501 1502llvm::Constant *ConstantEmitter::tryEmitPrivateForMemory(const Expr *E, 1503 QualType destType) { 1504 auto nonMemoryDestType = getNonMemoryType(CGM, destType); 1505 llvm::Constant *C = tryEmitPrivate(E, nonMemoryDestType); 1506 return (C ? emitForMemory(C, destType) : nullptr); 1507} 1508 1509llvm::Constant *ConstantEmitter::tryEmitPrivateForMemory(const APValue &value, 1510 QualType destType) { 1511 auto nonMemoryDestType = getNonMemoryType(CGM, destType); 1512 auto C = tryEmitPrivate(value, nonMemoryDestType); 1513 return (C ? emitForMemory(C, destType) : nullptr); 1514} 1515 1516llvm::Constant *ConstantEmitter::emitForMemory(CodeGenModule &CGM, 1517 llvm::Constant *C, 1518 QualType destType) { 1519 // For an _Atomic-qualified constant, we may need to add tail padding. 1520 if (auto AT = destType->getAs<AtomicType>()) { 1521 QualType destValueType = AT->getValueType(); 1522 C = emitForMemory(CGM, C, destValueType); 1523 1524 uint64_t innerSize = CGM.getContext().getTypeSize(destValueType); 1525 uint64_t outerSize = CGM.getContext().getTypeSize(destType); 1526 if (innerSize == outerSize) 1527 return C; 1528 1529 assert(innerSize < outerSize && "emitted over-large constant for atomic"); 1530 llvm::Constant *elts[] = { 1531 C, 1532 llvm::ConstantAggregateZero::get( 1533 llvm::ArrayType::get(CGM.Int8Ty, (outerSize - innerSize) / 8)) 1534 }; 1535 return llvm::ConstantStruct::getAnon(elts); 1536 } 1537 1538 // Zero-extend bool. 1539 if (C->getType()->isIntegerTy(1)) { 1540 llvm::Type *boolTy = CGM.getTypes().ConvertTypeForMem(destType); 1541 return llvm::ConstantExpr::getZExt(C, boolTy); 1542 } 1543 1544 return C; 1545} 1546 1547llvm::Constant *ConstantEmitter::tryEmitPrivate(const Expr *E, 1548 QualType destType) { 1549 Expr::EvalResult Result; 1550 1551 bool Success = false; 1552 1553 if (destType->isReferenceType()) 1554 Success = E->EvaluateAsLValue(Result, CGM.getContext()); 1555 else 1556 Success = E->EvaluateAsRValue(Result, CGM.getContext(), InConstantContext); 1557 1558 llvm::Constant *C; 1559 if (Success && !Result.HasSideEffects) 1560 C = tryEmitPrivate(Result.Val, destType); 1561 else 1562 C = ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), destType); 1563 1564 return C; 1565} 1566 1567llvm::Constant *CodeGenModule::getNullPointer(llvm::PointerType *T, QualType QT) { 1568 return getTargetCodeGenInfo().getNullPointer(*this, T, QT); 1569} 1570 1571namespace { 1572/// A struct which can be used to peephole certain kinds of finalization 1573/// that normally happen during l-value emission. 1574struct ConstantLValue { 1575 llvm::Constant *Value; 1576 bool HasOffsetApplied; 1577 1578 /*implicit*/ ConstantLValue(llvm::Constant *value, 1579 bool hasOffsetApplied = false) 1580 : Value(value), HasOffsetApplied(false) {} 1581 1582 /*implicit*/ ConstantLValue(ConstantAddress address) 1583 : ConstantLValue(address.getPointer()) {} 1584}; 1585 1586/// A helper class for emitting constant l-values. 1587class ConstantLValueEmitter : public ConstStmtVisitor<ConstantLValueEmitter, 1588 ConstantLValue> { 1589 CodeGenModule &CGM; 1590 ConstantEmitter &Emitter; 1591 const APValue &Value; 1592 QualType DestType; 1593 1594 // Befriend StmtVisitorBase so that we don't have to expose Visit*. 1595 friend StmtVisitorBase; 1596 1597public: 1598 ConstantLValueEmitter(ConstantEmitter &emitter, const APValue &value, 1599 QualType destType) 1600 : CGM(emitter.CGM), Emitter(emitter), Value(value), DestType(destType) {} 1601 1602 llvm::Constant *tryEmit(); 1603 1604private: 1605 llvm::Constant *tryEmitAbsolute(llvm::Type *destTy); 1606 ConstantLValue tryEmitBase(const APValue::LValueBase &base); 1607 1608 ConstantLValue VisitStmt(const Stmt *S) { return nullptr; } 1609 ConstantLValue VisitConstantExpr(const ConstantExpr *E); 1610 ConstantLValue VisitCompoundLiteralExpr(const CompoundLiteralExpr *E); 1611 ConstantLValue VisitStringLiteral(const StringLiteral *E); 1612 ConstantLValue VisitObjCEncodeExpr(const ObjCEncodeExpr *E); 1613 ConstantLValue VisitObjCStringLiteral(const ObjCStringLiteral *E); 1614 ConstantLValue VisitPredefinedExpr(const PredefinedExpr *E); 1615 ConstantLValue VisitAddrLabelExpr(const AddrLabelExpr *E); 1616 ConstantLValue VisitCallExpr(const CallExpr *E); 1617 ConstantLValue VisitBlockExpr(const BlockExpr *E); 1618 ConstantLValue VisitCXXTypeidExpr(const CXXTypeidExpr *E); 1619 ConstantLValue VisitCXXUuidofExpr(const CXXUuidofExpr *E); 1620 ConstantLValue VisitMaterializeTemporaryExpr( 1621 const MaterializeTemporaryExpr *E); 1622 1623 bool hasNonZeroOffset() const { 1624 return !Value.getLValueOffset().isZero(); 1625 } 1626 1627 /// Return the value offset. 1628 llvm::Constant *getOffset() { 1629 return llvm::ConstantInt::get(CGM.Int64Ty, 1630 Value.getLValueOffset().getQuantity()); 1631 } 1632 1633 /// Apply the value offset to the given constant. 1634 llvm::Constant *applyOffset(llvm::Constant *C) { 1635 if (!hasNonZeroOffset()) 1636 return C; 1637 1638 llvm::Type *origPtrTy = C->getType(); 1639 unsigned AS = origPtrTy->getPointerAddressSpace(); 1640 llvm::Type *charPtrTy = CGM.Int8Ty->getPointerTo(AS); 1641 C = llvm::ConstantExpr::getBitCast(C, charPtrTy); 1642 C = llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, C, getOffset()); 1643 C = llvm::ConstantExpr::getPointerCast(C, origPtrTy); 1644 return C; 1645 } 1646}; 1647 1648} 1649 1650llvm::Constant *ConstantLValueEmitter::tryEmit() { 1651 const APValue::LValueBase &base = Value.getLValueBase(); 1652 1653 // Certain special array initializers are represented in APValue 1654 // as l-values referring to the base expression which generates the 1655 // array. This happens with e.g. string literals. These should 1656 // probably just get their own representation kind in APValue. 1657 if (DestType->isArrayType()) { 1658 assert(!hasNonZeroOffset() && "offset on array initializer"); 1659 auto expr = const_cast<Expr*>(base.get<const Expr*>()); 1660 return ConstExprEmitter(Emitter).Visit(expr, DestType); 1661 } 1662 1663 // Otherwise, the destination type should be a pointer or reference 1664 // type, but it might also be a cast thereof. 1665 // 1666 // FIXME: the chain of casts required should be reflected in the APValue. 1667 // We need this in order to correctly handle things like a ptrtoint of a 1668 // non-zero null pointer and addrspace casts that aren't trivially 1669 // represented in LLVM IR. 1670 auto destTy = CGM.getTypes().ConvertTypeForMem(DestType); 1671 assert(isa<llvm::IntegerType>(destTy) || isa<llvm::PointerType>(destTy)); 1672 1673 // If there's no base at all, this is a null or absolute pointer, 1674 // possibly cast back to an integer type. 1675 if (!base) { 1676 return tryEmitAbsolute(destTy); 1677 } 1678 1679 // Otherwise, try to emit the base. 1680 ConstantLValue result = tryEmitBase(base); 1681 1682 // If that failed, we're done. 1683 llvm::Constant *value = result.Value; 1684 if (!value) return nullptr; 1685 1686 // Apply the offset if necessary and not already done. 1687 if (!result.HasOffsetApplied) { 1688 value = applyOffset(value); 1689 } 1690 1691 // Convert to the appropriate type; this could be an lvalue for 1692 // an integer. FIXME: performAddrSpaceCast 1693 if (isa<llvm::PointerType>(destTy)) 1694 return llvm::ConstantExpr::getPointerCast(value, destTy); 1695 1696 return llvm::ConstantExpr::getPtrToInt(value, destTy); 1697} 1698 1699/// Try to emit an absolute l-value, such as a null pointer or an integer 1700/// bitcast to pointer type. 1701llvm::Constant * 1702ConstantLValueEmitter::tryEmitAbsolute(llvm::Type *destTy) { 1703 auto offset = getOffset(); 1704 1705 // If we're producing a pointer, this is easy. 1706 if (auto destPtrTy = cast<llvm::PointerType>(destTy)) { 1707 if (Value.isNullPointer()) { 1708 // FIXME: integer offsets from non-zero null pointers. 1709 return CGM.getNullPointer(destPtrTy, DestType); 1710 } 1711 1712 // Convert the integer to a pointer-sized integer before converting it 1713 // to a pointer. 1714 // FIXME: signedness depends on the original integer type. 1715 auto intptrTy = CGM.getDataLayout().getIntPtrType(destPtrTy); 1716 llvm::Constant *C = offset; 1717 C = llvm::ConstantExpr::getIntegerCast(getOffset(), intptrTy, 1718 /*isSigned*/ false); 1719 C = llvm::ConstantExpr::getIntToPtr(C, destPtrTy); 1720 return C; 1721 } 1722 1723 // Otherwise, we're basically returning an integer constant. 1724 1725 // FIXME: this does the wrong thing with ptrtoint of a null pointer, 1726 // but since we don't know the original pointer type, there's not much 1727 // we can do about it. 1728 1729 auto C = getOffset(); 1730 C = llvm::ConstantExpr::getIntegerCast(C, destTy, /*isSigned*/ false); 1731 return C; 1732} 1733 1734ConstantLValue 1735ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) { 1736 // Handle values. 1737 if (const ValueDecl *D = base.dyn_cast<const ValueDecl*>()) { 1738 if (D->hasAttr<WeakRefAttr>()) 1739 return CGM.GetWeakRefReference(D).getPointer(); 1740 1741 if (auto FD = dyn_cast<FunctionDecl>(D)) 1742 return CGM.GetAddrOfFunction(FD); 1743 1744 if (auto VD = dyn_cast<VarDecl>(D)) { 1745 // We can never refer to a variable with local storage. 1746 if (!VD->hasLocalStorage()) { 1747 if (VD->isFileVarDecl() || VD->hasExternalStorage()) 1748 return CGM.GetAddrOfGlobalVar(VD); 1749 1750 if (VD->isLocalVarDecl()) { 1751 return CGM.getOrCreateStaticVarDecl( 1752 *VD, CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false)); 1753 } 1754 } 1755 } 1756 1757 return nullptr; 1758 } 1759 1760 // Otherwise, it must be an expression. 1761 return Visit(base.get<const Expr*>()); 1762} 1763 1764ConstantLValue 1765ConstantLValueEmitter::VisitConstantExpr(const ConstantExpr *E) { 1766 return Visit(E->getSubExpr()); 1767} 1768 1769ConstantLValue 1770ConstantLValueEmitter::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { 1771 return tryEmitGlobalCompoundLiteral(CGM, Emitter.CGF, E); 1772} 1773 1774ConstantLValue 1775ConstantLValueEmitter::VisitStringLiteral(const StringLiteral *E) { 1776 return CGM.GetAddrOfConstantStringFromLiteral(E); 1777} 1778 1779ConstantLValue 1780ConstantLValueEmitter::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { 1781 return CGM.GetAddrOfConstantStringFromObjCEncode(E); 1782} 1783 1784ConstantLValue 1785ConstantLValueEmitter::VisitObjCStringLiteral(const ObjCStringLiteral *E) { 1786 auto C = CGM.getObjCRuntime().GenerateConstantString(E->getString()); 1787 return C.getElementBitCast(CGM.getTypes().ConvertTypeForMem(E->getType())); 1788} 1789 1790ConstantLValue 1791ConstantLValueEmitter::VisitPredefinedExpr(const PredefinedExpr *E) { 1792 if (auto CGF = Emitter.CGF) { 1793 LValue Res = CGF->EmitPredefinedLValue(E); 1794 return cast<ConstantAddress>(Res.getAddress()); 1795 } 1796 1797 auto kind = E->getIdentKind(); 1798 if (kind == PredefinedExpr::PrettyFunction) { 1799 return CGM.GetAddrOfConstantCString("top level", ".tmp"); 1800 } 1801 1802 return CGM.GetAddrOfConstantCString("", ".tmp"); 1803} 1804 1805ConstantLValue 1806ConstantLValueEmitter::VisitAddrLabelExpr(const AddrLabelExpr *E) { 1807 assert(Emitter.CGF && "Invalid address of label expression outside function"); 1808 llvm::Constant *Ptr = Emitter.CGF->GetAddrOfLabel(E->getLabel()); 1809 Ptr = llvm::ConstantExpr::getBitCast(Ptr, 1810 CGM.getTypes().ConvertType(E->getType())); 1811 return Ptr; 1812} 1813 1814ConstantLValue 1815ConstantLValueEmitter::VisitCallExpr(const CallExpr *E) { 1816 unsigned builtin = E->getBuiltinCallee(); 1817 if (builtin != Builtin::BI__builtin___CFStringMakeConstantString && 1818 builtin != Builtin::BI__builtin___NSStringMakeConstantString) 1819 return nullptr; 1820 1821 auto literal = cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts()); 1822 if (builtin == Builtin::BI__builtin___NSStringMakeConstantString) { 1823 return CGM.getObjCRuntime().GenerateConstantString(literal); 1824 } else { 1825 // FIXME: need to deal with UCN conversion issues. 1826 return CGM.GetAddrOfConstantCFString(literal); 1827 } 1828} 1829 1830ConstantLValue 1831ConstantLValueEmitter::VisitBlockExpr(const BlockExpr *E) { 1832 StringRef functionName; 1833 if (auto CGF = Emitter.CGF) 1834 functionName = CGF->CurFn->getName(); 1835 else 1836 functionName = "global"; 1837 1838 return CGM.GetAddrOfGlobalBlock(E, functionName); 1839} 1840 1841ConstantLValue 1842ConstantLValueEmitter::VisitCXXTypeidExpr(const CXXTypeidExpr *E) { 1843 QualType T; 1844 if (E->isTypeOperand()) 1845 T = E->getTypeOperand(CGM.getContext()); 1846 else 1847 T = E->getExprOperand()->getType(); 1848 return CGM.GetAddrOfRTTIDescriptor(T); 1849} 1850 1851ConstantLValue 1852ConstantLValueEmitter::VisitCXXUuidofExpr(const CXXUuidofExpr *E) { 1853 return CGM.GetAddrOfUuidDescriptor(E); 1854} 1855 1856ConstantLValue 1857ConstantLValueEmitter::VisitMaterializeTemporaryExpr( 1858 const MaterializeTemporaryExpr *E) { 1859 assert(E->getStorageDuration() == SD_Static); 1860 SmallVector<const Expr *, 2> CommaLHSs; 1861 SmallVector<SubobjectAdjustment, 2> Adjustments; 1862 const Expr *Inner = E->GetTemporaryExpr() 1863 ->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); 1864 return CGM.GetAddrOfGlobalTemporary(E, Inner); 1865} 1866 1867llvm::Constant *ConstantEmitter::tryEmitPrivate(const APValue &Value, 1868 QualType DestType) { 1869 switch (Value.getKind()) { 1870 case APValue::Uninitialized: 1871 llvm_unreachable("Constant expressions should be initialized."); 1872 case APValue::LValue: 1873 return ConstantLValueEmitter(*this, Value, DestType).tryEmit(); 1874 case APValue::Int: 1875 return llvm::ConstantInt::get(CGM.getLLVMContext(), Value.getInt()); 1876 case APValue::ComplexInt: { 1877 llvm::Constant *Complex[2]; 1878 1879 Complex[0] = llvm::ConstantInt::get(CGM.getLLVMContext(), 1880 Value.getComplexIntReal()); 1881 Complex[1] = llvm::ConstantInt::get(CGM.getLLVMContext(), 1882 Value.getComplexIntImag()); 1883 1884 // FIXME: the target may want to specify that this is packed. 1885 llvm::StructType *STy = 1886 llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType()); 1887 return llvm::ConstantStruct::get(STy, Complex); 1888 } 1889 case APValue::Float: { 1890 const llvm::APFloat &Init = Value.getFloat(); 1891 if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf() && 1892 !CGM.getContext().getLangOpts().NativeHalfType && 1893 CGM.getContext().getTargetInfo().useFP16ConversionIntrinsics()) 1894 return llvm::ConstantInt::get(CGM.getLLVMContext(), 1895 Init.bitcastToAPInt()); 1896 else 1897 return llvm::ConstantFP::get(CGM.getLLVMContext(), Init); 1898 } 1899 case APValue::ComplexFloat: { 1900 llvm::Constant *Complex[2]; 1901 1902 Complex[0] = llvm::ConstantFP::get(CGM.getLLVMContext(), 1903 Value.getComplexFloatReal()); 1904 Complex[1] = llvm::ConstantFP::get(CGM.getLLVMContext(), 1905 Value.getComplexFloatImag()); 1906 1907 // FIXME: the target may want to specify that this is packed. 1908 llvm::StructType *STy = 1909 llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType()); 1910 return llvm::ConstantStruct::get(STy, Complex); 1911 } 1912 case APValue::Vector: { 1913 unsigned NumElts = Value.getVectorLength(); 1914 SmallVector<llvm::Constant *, 4> Inits(NumElts); 1915 1916 for (unsigned I = 0; I != NumElts; ++I) { 1917 const APValue &Elt = Value.getVectorElt(I); 1918 if (Elt.isInt()) 1919 Inits[I] = llvm::ConstantInt::get(CGM.getLLVMContext(), Elt.getInt()); 1920 else if (Elt.isFloat()) 1921 Inits[I] = llvm::ConstantFP::get(CGM.getLLVMContext(), Elt.getFloat()); 1922 else 1923 llvm_unreachable("unsupported vector element type"); 1924 } 1925 return llvm::ConstantVector::get(Inits); 1926 } 1927 case APValue::AddrLabelDiff: { 1928 const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS(); 1929 const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS(); 1930 llvm::Constant *LHS = tryEmitPrivate(LHSExpr, LHSExpr->getType()); 1931 llvm::Constant *RHS = tryEmitPrivate(RHSExpr, RHSExpr->getType()); 1932 if (!LHS || !RHS) return nullptr; 1933 1934 // Compute difference 1935 llvm::Type *ResultType = CGM.getTypes().ConvertType(DestType); 1936 LHS = llvm::ConstantExpr::getPtrToInt(LHS, CGM.IntPtrTy); 1937 RHS = llvm::ConstantExpr::getPtrToInt(RHS, CGM.IntPtrTy); 1938 llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS); 1939 1940 // LLVM is a bit sensitive about the exact format of the 1941 // address-of-label difference; make sure to truncate after 1942 // the subtraction. 1943 return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType); 1944 } 1945 case APValue::Struct: 1946 case APValue::Union: 1947 return ConstStructBuilder::BuildStruct(*this, Value, DestType); 1948 case APValue::Array: { 1949 const ConstantArrayType *CAT = 1950 CGM.getContext().getAsConstantArrayType(DestType); 1951 unsigned NumElements = Value.getArraySize(); 1952 unsigned NumInitElts = Value.getArrayInitializedElts(); 1953 1954 // Emit array filler, if there is one. 1955 llvm::Constant *Filler = nullptr; 1956 if (Value.hasArrayFiller()) { 1957 Filler = tryEmitAbstractForMemory(Value.getArrayFiller(), 1958 CAT->getElementType()); 1959 if (!Filler) 1960 return nullptr; 1961 } 1962 1963 // Emit initializer elements. 1964 SmallVector<llvm::Constant*, 16> Elts; 1965 if (Filler && Filler->isNullValue()) 1966 Elts.reserve(NumInitElts + 1); 1967 else 1968 Elts.reserve(NumElements); 1969 1970 llvm::Type *CommonElementType = nullptr; 1971 for (unsigned I = 0; I < NumInitElts; ++I) { 1972 llvm::Constant *C = tryEmitPrivateForMemory( 1973 Value.getArrayInitializedElt(I), CAT->getElementType()); 1974 if (!C) return nullptr; 1975 1976 if (I == 0) 1977 CommonElementType = C->getType(); 1978 else if (C->getType() != CommonElementType) 1979 CommonElementType = nullptr; 1980 Elts.push_back(C); 1981 } 1982 1983 // This means that the array type is probably "IncompleteType" or some 1984 // type that is not ConstantArray. 1985 if (CAT == nullptr && CommonElementType == nullptr && !NumInitElts) { 1986 const ArrayType *AT = CGM.getContext().getAsArrayType(DestType); 1987 CommonElementType = CGM.getTypes().ConvertType(AT->getElementType()); 1988 llvm::ArrayType *AType = llvm::ArrayType::get(CommonElementType, 1989 NumElements); 1990 return llvm::ConstantAggregateZero::get(AType); 1991 } 1992 1993 return EmitArrayConstant(CGM, CAT, CommonElementType, NumElements, Elts, 1994 Filler); 1995 } 1996 case APValue::MemberPointer: 1997 return CGM.getCXXABI().EmitMemberPointer(Value, DestType); 1998 } 1999 llvm_unreachable("Unknown APValue kind"); 2000} 2001 2002llvm::GlobalVariable *CodeGenModule::getAddrOfConstantCompoundLiteralIfEmitted( 2003 const CompoundLiteralExpr *E) { 2004 return EmittedCompoundLiterals.lookup(E); 2005} 2006 2007void CodeGenModule::setAddrOfConstantCompoundLiteral( 2008 const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV) { 2009 bool Ok = EmittedCompoundLiterals.insert(std::make_pair(CLE, GV)).second; 2010 (void)Ok; 2011 assert(Ok && "CLE has already been emitted!"); 2012} 2013 2014ConstantAddress 2015CodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) { 2016 assert(E->isFileScope() && "not a file-scope compound literal expr"); 2017 return tryEmitGlobalCompoundLiteral(*this, nullptr, E); 2018} 2019 2020llvm::Constant * 2021CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) { 2022 // Member pointer constants always have a very particular form. 2023 const MemberPointerType *type = cast<MemberPointerType>(uo->getType()); 2024 const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl(); 2025 2026 // A member function pointer. 2027 if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl)) 2028 return getCXXABI().EmitMemberFunctionPointer(method); 2029 2030 // Otherwise, a member data pointer. 2031 uint64_t fieldOffset = getContext().getFieldOffset(decl); 2032 CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset); 2033 return getCXXABI().EmitMemberDataPointer(type, chars); 2034} 2035 2036static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, 2037 llvm::Type *baseType, 2038 const CXXRecordDecl *base); 2039 2040static llvm::Constant *EmitNullConstant(CodeGenModule &CGM, 2041 const RecordDecl *record, 2042 bool asCompleteObject) { 2043 const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record); 2044 llvm::StructType *structure = 2045 (asCompleteObject ? layout.getLLVMType() 2046 : layout.getBaseSubobjectLLVMType()); 2047 2048 unsigned numElements = structure->getNumElements(); 2049 std::vector<llvm::Constant *> elements(numElements); 2050 2051 auto CXXR = dyn_cast<CXXRecordDecl>(record); 2052 // Fill in all the bases. 2053 if (CXXR) { 2054 for (const auto &I : CXXR->bases()) { 2055 if (I.isVirtual()) { 2056 // Ignore virtual bases; if we're laying out for a complete 2057 // object, we'll lay these out later. 2058 continue; 2059 } 2060 2061 const CXXRecordDecl *base = 2062 cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl()); 2063 2064 // Ignore empty bases. 2065 if (base->isEmpty() || 2066 CGM.getContext().getASTRecordLayout(base).getNonVirtualSize() 2067 .isZero()) 2068 continue; 2069 2070 unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base); 2071 llvm::Type *baseType = structure->getElementType(fieldIndex); 2072 elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); 2073 } 2074 } 2075 2076 // Fill in all the fields. 2077 for (const auto *Field : record->fields()) { 2078 // Fill in non-bitfields. (Bitfields always use a zero pattern, which we 2079 // will fill in later.) 2080 if (!Field->isBitField()) { 2081 unsigned fieldIndex = layout.getLLVMFieldNo(Field); 2082 elements[fieldIndex] = CGM.EmitNullConstant(Field->getType()); 2083 } 2084 2085 // For unions, stop after the first named field. 2086 if (record->isUnion()) { 2087 if (Field->getIdentifier()) 2088 break; 2089 if (const auto *FieldRD = Field->getType()->getAsRecordDecl()) 2090 if (FieldRD->findFirstNamedDataMember()) 2091 break; 2092 } 2093 } 2094 2095 // Fill in the virtual bases, if we're working with the complete object. 2096 if (CXXR && asCompleteObject) { 2097 for (const auto &I : CXXR->vbases()) { 2098 const CXXRecordDecl *base = 2099 cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl()); 2100 2101 // Ignore empty bases. 2102 if (base->isEmpty()) 2103 continue; 2104 2105 unsigned fieldIndex = layout.getVirtualBaseIndex(base); 2106 2107 // We might have already laid this field out. 2108 if (elements[fieldIndex]) continue; 2109 2110 llvm::Type *baseType = structure->getElementType(fieldIndex); 2111 elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); 2112 } 2113 } 2114 2115 // Now go through all other fields and zero them out. 2116 for (unsigned i = 0; i != numElements; ++i) { 2117 if (!elements[i]) 2118 elements[i] = llvm::Constant::getNullValue(structure->getElementType(i)); 2119 } 2120 2121 return llvm::ConstantStruct::get(structure, elements); 2122} 2123 2124/// Emit the null constant for a base subobject. 2125static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, 2126 llvm::Type *baseType, 2127 const CXXRecordDecl *base) { 2128 const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base); 2129 2130 // Just zero out bases that don't have any pointer to data members. 2131 if (baseLayout.isZeroInitializableAsBase()) 2132 return llvm::Constant::getNullValue(baseType); 2133 2134 // Otherwise, we can just use its null constant. 2135 return EmitNullConstant(CGM, base, /*asCompleteObject=*/false); 2136} 2137 2138llvm::Constant *ConstantEmitter::emitNullForMemory(CodeGenModule &CGM, 2139 QualType T) { 2140 return emitForMemory(CGM, CGM.EmitNullConstant(T), T); 2141} 2142 2143llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { 2144 if (T->getAs<PointerType>()) 2145 return getNullPointer( 2146 cast<llvm::PointerType>(getTypes().ConvertTypeForMem(T)), T); 2147 2148 if (getTypes().isZeroInitializable(T)) 2149 return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); 2150 2151 if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) { 2152 llvm::ArrayType *ATy = 2153 cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T)); 2154 2155 QualType ElementTy = CAT->getElementType(); 2156 2157 llvm::Constant *Element = 2158 ConstantEmitter::emitNullForMemory(*this, ElementTy); 2159 unsigned NumElements = CAT->getSize().getZExtValue(); 2160 SmallVector<llvm::Constant *, 8> Array(NumElements, Element); 2161 return llvm::ConstantArray::get(ATy, Array); 2162 } 2163 2164 if (const RecordType *RT = T->getAs<RecordType>()) 2165 return ::EmitNullConstant(*this, RT->getDecl(), /*complete object*/ true); 2166 2167 assert(T->isMemberDataPointerType() && 2168 "Should only see pointers to data members here!"); 2169 2170 return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>()); 2171} 2172 2173llvm::Constant * 2174CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) { 2175 return ::EmitNullConstant(*this, Record, false); 2176} 2177