CGExprConstant.cpp revision ef648c76745ee5e4105eec22dbc97fac18145bd6
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" 21using namespace clang; 22using namespace CodeGen; 23 24namespace { 25class VISIBILITY_HIDDEN ConstExprEmitter : 26 public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 27 CodeGenModule &CGM; 28 CodeGenFunction *CGF; 29public: 30 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 31 : CGM(cgm), CGF(cgf) { 32 } 33 34 //===--------------------------------------------------------------------===// 35 // Visitor Methods 36 //===--------------------------------------------------------------------===// 37 38 llvm::Constant *VisitStmt(Stmt *S) { 39 CGM.WarnUnsupported(S, "constant expression"); 40 QualType T = cast<Expr>(S)->getType(); 41 return llvm::UndefValue::get(CGM.getTypes().ConvertType(T)); 42 } 43 44 llvm::Constant *VisitParenExpr(ParenExpr *PE) { 45 return Visit(PE->getSubExpr()); 46 } 47 48 // Leaves 49 llvm::Constant *VisitIntegerLiteral(const IntegerLiteral *E) { 50 return llvm::ConstantInt::get(E->getValue()); 51 } 52 llvm::Constant *VisitFloatingLiteral(const FloatingLiteral *E) { 53 return llvm::ConstantFP::get(E->getValue()); 54 } 55 llvm::Constant *VisitCharacterLiteral(const CharacterLiteral *E) { 56 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 57 } 58 llvm::Constant *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 59 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 60 } 61 62 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 63 return Visit(E->getInitializer()); 64 } 65 66 llvm::Constant *VisitCastExpr(const CastExpr* E) { 67 llvm::Constant *C = Visit(E->getSubExpr()); 68 69 return EmitConversion(C, E->getSubExpr()->getType(), E->getType()); 70 } 71 72 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 73 return Visit(DAE->getExpr()); 74 } 75 76 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, 77 const llvm::ArrayType *AType) { 78 std::vector<llvm::Constant*> Elts; 79 unsigned NumInitElements = ILE->getNumInits(); 80 // FIXME: Check for wide strings 81 if (NumInitElements > 0 && isa<StringLiteral>(ILE->getInit(0)) && 82 ILE->getType()->getAsArrayType()->getElementType()->isCharType()) 83 return Visit(ILE->getInit(0)); 84 const llvm::Type *ElemTy = AType->getElementType(); 85 unsigned NumElements = AType->getNumElements(); 86 87 // Initialising an array requires us to automatically 88 // initialise any elements that have not been initialised explicitly 89 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 90 91 // Copy initializer elements. 92 unsigned i = 0; 93 for (; i < NumInitableElts; ++i) { 94 95 llvm::Constant *C = Visit(ILE->getInit(i)); 96 assert (C && "Failed to create initializer expression"); 97 Elts.push_back(C); 98 } 99 100 // Initialize remaining array elements. 101 for (; i < NumElements; ++i) 102 Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 103 104 return llvm::ConstantArray::get(AType, Elts); 105 } 106 107 llvm::Constant *EmitStructInitialization(InitListExpr *ILE, 108 const llvm::StructType *SType) { 109 110 TagDecl *TD = ILE->getType()->getAsRecordType()->getDecl(); 111 std::vector<llvm::Constant*> Elts; 112 const CGRecordLayout *CGR = CGM.getTypes().getCGRecordLayout(TD); 113 unsigned NumInitElements = ILE->getNumInits(); 114 unsigned NumElements = SType->getNumElements(); 115 116 // Initialising an structure requires us to automatically 117 // initialise any elements that have not been initialised explicitly 118 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 119 120 // Copy initializer elements. Skip padding fields. 121 unsigned EltNo = 0; // Element no in ILE 122 unsigned FieldNo = 0; // Field no in SType 123 while (EltNo < NumInitableElts) { 124 125 // Zero initialize padding field. 126 if (CGR->isPaddingField(FieldNo)) { 127 const llvm::Type *FieldTy = SType->getElementType(FieldNo); 128 Elts.push_back(llvm::Constant::getNullValue(FieldTy)); 129 FieldNo++; 130 continue; 131 } 132 133 llvm::Constant *C = Visit(ILE->getInit(EltNo)); 134 assert (C && "Failed to create initializer expression"); 135 Elts.push_back(C); 136 EltNo++; 137 FieldNo++; 138 } 139 140 // Initialize remaining structure elements. 141 for (unsigned i = Elts.size(); i < NumElements; ++i) { 142 const llvm::Type *FieldTy = SType->getElementType(i); 143 Elts.push_back(llvm::Constant::getNullValue(FieldTy)); 144 } 145 146 return llvm::ConstantStruct::get(SType, Elts); 147 } 148 149 llvm::Constant *EmitVectorInitialization(InitListExpr *ILE, 150 const llvm::VectorType *VType) { 151 152 std::vector<llvm::Constant*> Elts; 153 unsigned NumInitElements = ILE->getNumInits(); 154 unsigned NumElements = VType->getNumElements(); 155 156 assert (NumInitElements == NumElements 157 && "Unsufficient vector init elelments"); 158 // Copy initializer elements. 159 unsigned i = 0; 160 for (; i < NumElements; ++i) { 161 162 llvm::Constant *C = Visit(ILE->getInit(i)); 163 assert (C && "Failed to create initializer expression"); 164 Elts.push_back(C); 165 } 166 167 return llvm::ConstantVector::get(VType, Elts); 168 } 169 170 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 171 const llvm::CompositeType *CType = 172 dyn_cast<llvm::CompositeType>(ConvertType(ILE->getType())); 173 174 if (!CType) { 175 // We have a scalar in braces. Just use the first element. 176 return Visit(ILE->getInit(0)); 177 } 178 179 if (const llvm::ArrayType *AType = dyn_cast<llvm::ArrayType>(CType)) 180 return EmitArrayInitialization(ILE, AType); 181 182 if (const llvm::StructType *SType = dyn_cast<llvm::StructType>(CType)) 183 return EmitStructInitialization(ILE, SType); 184 185 if (const llvm::VectorType *VType = dyn_cast<llvm::VectorType>(CType)) 186 return EmitVectorInitialization(ILE, VType); 187 188 // Make sure we have an array at this point 189 assert(0 && "Unable to handle InitListExpr"); 190 // Get rid of control reaches end of void function warning. 191 // Not reached. 192 return 0; 193 } 194 195 llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) { 196 Expr* SExpr = ICExpr->getSubExpr(); 197 QualType SType = SExpr->getType(); 198 llvm::Constant *C; // the intermediate expression 199 QualType T; // the type of the intermediate expression 200 if (SType->isArrayType()) { 201 // Arrays decay to a pointer to the first element 202 // VLAs would require special handling, but they can't occur here 203 C = EmitLValue(SExpr); 204 llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 205 llvm::Constant *Ops[] = {Idx0, Idx0}; 206 C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 207 208 QualType ElemType = SType->getAsArrayType()->getElementType(); 209 T = CGM.getContext().getPointerType(ElemType); 210 } else if (SType->isFunctionType()) { 211 // Function types decay to a pointer to the function 212 C = EmitLValue(SExpr); 213 T = CGM.getContext().getPointerType(SType); 214 } else { 215 C = Visit(SExpr); 216 T = SType; 217 } 218 219 // Perform the conversion; note that an implicit cast can both promote 220 // and convert an array/function 221 return EmitConversion(C, T, ICExpr->getType()); 222 } 223 224 llvm::Constant *VisitStringLiteral(StringLiteral *E) { 225 const char *StrData = E->getStrData(); 226 unsigned Len = E->getByteLength(); 227 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 228 229 // Otherwise this must be a string initializing an array in a static 230 // initializer. Don't emit it as the address of the string, emit the string 231 // data itself as an inline array. 232 const ConstantArrayType *CAT = E->getType()->getAsConstantArrayType(); 233 assert(CAT && "String isn't pointer or array!"); 234 235 std::string Str(StrData, StrData + Len); 236 // Null terminate the string before potentially truncating it. 237 // FIXME: What about wchar_t strings? 238 Str.push_back(0); 239 240 uint64_t RealLen = CAT->getSize().getZExtValue(); 241 // String or grow the initializer to the required size. 242 if (RealLen != Str.size()) 243 Str.resize(RealLen); 244 245 return llvm::ConstantArray::get(Str, false); 246 } 247 248 llvm::Constant *VisitDeclRefExpr(DeclRefExpr *E) { 249 const ValueDecl *Decl = E->getDecl(); 250 if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(Decl)) 251 return llvm::ConstantInt::get(EC->getInitVal()); 252 assert(0 && "Unsupported decl ref type!"); 253 return 0; 254 } 255 256 llvm::Constant *VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) { 257 return EmitSizeAlignOf(E->getArgumentType(), E->getType(), E->isSizeOf()); 258 } 259 260 // Unary operators 261 llvm::Constant *VisitUnaryPlus(const UnaryOperator *E) { 262 return Visit(E->getSubExpr()); 263 } 264 llvm::Constant *VisitUnaryMinus(const UnaryOperator *E) { 265 return llvm::ConstantExpr::getNeg(Visit(E->getSubExpr())); 266 } 267 llvm::Constant *VisitUnaryNot(const UnaryOperator *E) { 268 return llvm::ConstantExpr::getNot(Visit(E->getSubExpr())); 269 } 270 llvm::Constant *VisitUnaryLNot(const UnaryOperator *E) { 271 llvm::Constant *SubExpr = Visit(E->getSubExpr()); 272 273 if (E->getSubExpr()->getType()->isRealFloatingType()) { 274 // Compare against 0.0 for fp scalars. 275 llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType()); 276 SubExpr = llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UEQ, SubExpr, 277 Zero); 278 } else { 279 assert((E->getSubExpr()->getType()->isIntegerType() || 280 E->getSubExpr()->getType()->isPointerType()) && 281 "Unknown scalar type to convert"); 282 // Compare against an integer or pointer null. 283 llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType()); 284 SubExpr = llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, SubExpr, 285 Zero); 286 } 287 288 return llvm::ConstantExpr::getZExt(SubExpr, ConvertType(E->getType())); 289 } 290 llvm::Constant *VisitUnarySizeOf(const UnaryOperator *E) { 291 return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), true); 292 } 293 llvm::Constant *VisitUnaryAlignOf(const UnaryOperator *E) { 294 return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), false); 295 } 296 llvm::Constant *VisitUnaryAddrOf(const UnaryOperator *E) { 297 return EmitLValue(E->getSubExpr()); 298 } 299 llvm::Constant *VisitUnaryOffsetOf(const UnaryOperator *E) { 300 int64_t Val = E->evaluateOffsetOf(CGM.getContext()); 301 302 assert(E->getType()->isIntegerType() && "Result type must be an integer!"); 303 304 uint32_t ResultWidth = 305 static_cast<uint32_t>(CGM.getContext().getTypeSize(E->getType())); 306 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 307 } 308 309 // Binary operators 310 llvm::Constant *VisitBinOr(const BinaryOperator *E) { 311 llvm::Constant *LHS = Visit(E->getLHS()); 312 llvm::Constant *RHS = Visit(E->getRHS()); 313 314 return llvm::ConstantExpr::getOr(LHS, RHS); 315 } 316 llvm::Constant *VisitBinSub(const BinaryOperator *E) { 317 llvm::Constant *LHS = Visit(E->getLHS()); 318 llvm::Constant *RHS = Visit(E->getRHS()); 319 320 if (!isa<llvm::PointerType>(RHS->getType())) { 321 // pointer - int 322 if (isa<llvm::PointerType>(LHS->getType())) { 323 llvm::Constant *Idx = llvm::ConstantExpr::getNeg(RHS); 324 325 return llvm::ConstantExpr::getGetElementPtr(LHS, &Idx, 1); 326 } 327 328 // int - int 329 return llvm::ConstantExpr::getSub(LHS, RHS); 330 } 331 332 assert(0 && "Unhandled bin sub case!"); 333 return 0; 334 } 335 336 llvm::Constant *VisitBinShl(const BinaryOperator *E) { 337 llvm::Constant *LHS = Visit(E->getLHS()); 338 llvm::Constant *RHS = Visit(E->getRHS()); 339 340 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 341 // RHS to the same size as the LHS. 342 if (LHS->getType() != RHS->getType()) 343 RHS = llvm::ConstantExpr::getIntegerCast(RHS, LHS->getType(), false); 344 345 return llvm::ConstantExpr::getShl(LHS, RHS); 346 } 347 348 llvm::Constant *VisitBinMul(const BinaryOperator *E) { 349 llvm::Constant *LHS = Visit(E->getLHS()); 350 llvm::Constant *RHS = Visit(E->getRHS()); 351 352 return llvm::ConstantExpr::getMul(LHS, RHS); 353 } 354 355 llvm::Constant *VisitBinDiv(const BinaryOperator *E) { 356 llvm::Constant *LHS = Visit(E->getLHS()); 357 llvm::Constant *RHS = Visit(E->getRHS()); 358 359 if (LHS->getType()->isFPOrFPVector()) 360 return llvm::ConstantExpr::getFDiv(LHS, RHS); 361 else if (E->getType()->isUnsignedIntegerType()) 362 return llvm::ConstantExpr::getUDiv(LHS, RHS); 363 else 364 return llvm::ConstantExpr::getSDiv(LHS, RHS); 365 } 366 367 llvm::Constant *VisitBinAdd(const BinaryOperator *E) { 368 llvm::Constant *LHS = Visit(E->getLHS()); 369 llvm::Constant *RHS = Visit(E->getRHS()); 370 371 if (!E->getType()->isPointerType()) 372 return llvm::ConstantExpr::getAdd(LHS, RHS); 373 374 llvm::Constant *Ptr, *Idx; 375 if (isa<llvm::PointerType>(LHS->getType())) { // pointer + int 376 Ptr = LHS; 377 Idx = RHS; 378 } else { // int + pointer 379 Ptr = RHS; 380 Idx = LHS; 381 } 382 383 return llvm::ConstantExpr::getGetElementPtr(Ptr, &Idx, 1); 384 } 385 386 llvm::Constant *VisitBinAnd(const BinaryOperator *E) { 387 llvm::Constant *LHS = Visit(E->getLHS()); 388 llvm::Constant *RHS = Visit(E->getRHS()); 389 390 return llvm::ConstantExpr::getAnd(LHS, RHS); 391 } 392 393 // Utility methods 394 const llvm::Type *ConvertType(QualType T) { 395 return CGM.getTypes().ConvertType(T); 396 } 397 398 llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) { 399 assert(SrcType->isCanonical() && "EmitConversion strips typedefs"); 400 401 if (SrcType->isRealFloatingType()) { 402 // Compare against 0.0 for fp scalars. 403 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 404 return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero); 405 } 406 407 assert((SrcType->isIntegerType() || SrcType->isPointerType()) && 408 "Unknown scalar type to convert"); 409 410 // Compare against an integer or pointer null. 411 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType()); 412 return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero); 413 } 414 415 llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType, 416 QualType DstType) { 417 SrcType = SrcType.getCanonicalType(); 418 DstType = DstType.getCanonicalType(); 419 if (SrcType == DstType) return Src; 420 421 // Handle conversions to bool first, they are special: comparisons against 0. 422 if (DstType->isBooleanType()) 423 return EmitConversionToBool(Src, SrcType); 424 425 const llvm::Type *DstTy = ConvertType(DstType); 426 427 // Ignore conversions like int -> uint. 428 if (Src->getType() == DstTy) 429 return Src; 430 431 // Handle pointer conversions next: pointers can only be converted to/from 432 // other pointers and integers. 433 if (isa<PointerType>(DstType)) { 434 // The source value may be an integer, or a pointer. 435 if (isa<llvm::PointerType>(Src->getType())) 436 return llvm::ConstantExpr::getBitCast(Src, DstTy); 437 assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?"); 438 return llvm::ConstantExpr::getIntToPtr(Src, DstTy); 439 } 440 441 if (isa<PointerType>(SrcType)) { 442 // Must be an ptr to int cast. 443 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 444 return llvm::ConstantExpr::getPtrToInt(Src, DstTy); 445 } 446 447 // A scalar source can be splatted to a vector of the same element type 448 if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) { 449 const llvm::VectorType *VT = cast<llvm::VectorType>(DstTy); 450 assert((VT->getElementType() == Src->getType()) && 451 "Vector element type must match scalar type to splat."); 452 unsigned NumElements = DstType->getAsVectorType()->getNumElements(); 453 llvm::SmallVector<llvm::Constant*, 16> Elements; 454 for (unsigned i = 0; i < NumElements; i++) 455 Elements.push_back(Src); 456 457 return llvm::ConstantVector::get(&Elements[0], NumElements); 458 } 459 460 if (isa<llvm::VectorType>(Src->getType()) || 461 isa<llvm::VectorType>(DstTy)) { 462 return llvm::ConstantExpr::getBitCast(Src, DstTy); 463 } 464 465 // Finally, we have the arithmetic types: real int/float. 466 if (isa<llvm::IntegerType>(Src->getType())) { 467 bool InputSigned = SrcType->isSignedIntegerType(); 468 if (isa<llvm::IntegerType>(DstTy)) 469 return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned); 470 else if (InputSigned) 471 return llvm::ConstantExpr::getSIToFP(Src, DstTy); 472 else 473 return llvm::ConstantExpr::getUIToFP(Src, DstTy); 474 } 475 476 assert(Src->getType()->isFloatingPoint() && "Unknown real conversion"); 477 if (isa<llvm::IntegerType>(DstTy)) { 478 if (DstType->isSignedIntegerType()) 479 return llvm::ConstantExpr::getFPToSI(Src, DstTy); 480 else 481 return llvm::ConstantExpr::getFPToUI(Src, DstTy); 482 } 483 484 assert(DstTy->isFloatingPoint() && "Unknown real conversion"); 485 if (DstTy->getTypeID() < Src->getType()->getTypeID()) 486 return llvm::ConstantExpr::getFPTrunc(Src, DstTy); 487 else 488 return llvm::ConstantExpr::getFPExtend(Src, DstTy); 489 } 490 491 llvm::Constant *EmitSizeAlignOf(QualType TypeToSize, 492 QualType RetType, bool isSizeOf) { 493 std::pair<uint64_t, unsigned> Info = 494 CGM.getContext().getTypeInfo(TypeToSize); 495 496 uint64_t Val = isSizeOf ? Info.first : Info.second; 497 Val /= 8; // Return size in bytes, not bits. 498 499 assert(RetType->isIntegerType() && "Result type must be an integer!"); 500 501 uint32_t ResultWidth = 502 static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType)); 503 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 504 } 505 506 llvm::Constant *EmitLValue(Expr *E) { 507 switch (E->getStmtClass()) { 508 default: break; 509 case Expr::ParenExprClass: 510 // Elide parenthesis 511 return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 512 case Expr::CompoundLiteralExprClass: { 513 // Note that due to the nature of compound literals, this is guaranteed 514 // to be the only use of the variable, so we just generate it here. 515 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 516 llvm::Constant* C = Visit(CLE->getInitializer()); 517 C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(), 518 llvm::GlobalValue::InternalLinkage, 519 C, ".compoundliteral", &CGM.getModule()); 520 return C; 521 } 522 case Expr::DeclRefExprClass: { 523 ValueDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 524 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 525 return CGM.GetAddrOfFunctionDecl(FD, false); 526 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 527 if (VD->isFileVarDecl()) 528 return CGM.GetAddrOfGlobalVar(VD, false); 529 else if (VD->isBlockVarDecl()) { 530 assert(CGF && "Can't access static local vars without CGF"); 531 return CGF->GetAddrOfStaticLocalVar(VD); 532 } 533 } 534 break; 535 } 536 case Expr::MemberExprClass: { 537 MemberExpr* ME = cast<MemberExpr>(E); 538 llvm::Constant *Base; 539 if (ME->isArrow()) 540 Base = Visit(ME->getBase()); 541 else 542 Base = EmitLValue(ME->getBase()); 543 544 unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl()); 545 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 546 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 547 FieldNumber); 548 llvm::Value *Ops[] = {Zero, Idx}; 549 return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2); 550 } 551 case Expr::ArraySubscriptExprClass: { 552 ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E); 553 llvm::Constant *Base = Visit(ASExpr->getBase()); 554 llvm::Constant *Index = Visit(ASExpr->getIdx()); 555 assert(!ASExpr->getBase()->getType()->isVectorType() && 556 "Taking the address of a vector component is illegal!"); 557 return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1); 558 } 559 case Expr::StringLiteralClass: { 560 StringLiteral *String = cast<StringLiteral>(E); 561 assert(!String->isWide() && "Cannot codegen wide strings yet"); 562 const char *StrData = String->getStrData(); 563 unsigned Len = String->getByteLength(); 564 565 return CGM.GetAddrOfConstantString(std::string(StrData, StrData + Len)); 566 } 567 case Expr::UnaryOperatorClass: { 568 UnaryOperator *Exp = cast<UnaryOperator>(E); 569 switch (Exp->getOpcode()) { 570 default: break; 571 case UnaryOperator::Extension: 572 // Extension is just a wrapper for expressions 573 return EmitLValue(Exp->getSubExpr()); 574 case UnaryOperator::Real: 575 case UnaryOperator::Imag: { 576 // The address of __real or __imag is just a GEP off the address 577 // of the internal expression 578 llvm::Constant* C = EmitLValue(Exp->getSubExpr()); 579 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 580 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 581 Exp->getOpcode() == UnaryOperator::Imag); 582 llvm::Value *Ops[] = {Zero, Idx}; 583 return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2); 584 } 585 case UnaryOperator::Deref: 586 // The address of a deref is just the value of the expression 587 return Visit(Exp->getSubExpr()); 588 } 589 break; 590 } 591 } 592 CGM.WarnUnsupported(E, "constant l-value expression"); 593 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 594 return llvm::UndefValue::get(Ty); 595 } 596 597}; 598 599} // end anonymous namespace. 600 601 602llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 603 CodeGenFunction *CGF) 604{ 605 QualType type = E->getType().getCanonicalType(); 606 607 if (type->isIntegerType()) { 608 llvm::APSInt Value(static_cast<uint32_t>(Context.getTypeSize(type))); 609 if (E->isIntegerConstantExpr(Value, Context)) { 610 return llvm::ConstantInt::get(Value); 611 } 612 } 613 614 return ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 615} 616