1//===--- APValue.cpp - Union class for APFloat/APSInt/Complex -------------===// 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 file implements the APValue class. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/APValue.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/CharUnits.h" 17#include "clang/AST/DeclCXX.h" 18#include "clang/AST/Expr.h" 19#include "clang/AST/Type.h" 20#include "clang/Basic/Diagnostic.h" 21#include "llvm/ADT/SmallString.h" 22#include "llvm/Support/ErrorHandling.h" 23#include "llvm/Support/raw_ostream.h" 24using namespace clang; 25 26namespace { 27 struct LVBase { 28 llvm::PointerIntPair<APValue::LValueBase, 1, bool> BaseAndIsOnePastTheEnd; 29 CharUnits Offset; 30 unsigned PathLength; 31 unsigned CallIndex; 32 }; 33} 34 35struct APValue::LV : LVBase { 36 static const unsigned InlinePathSpace = 37 (MaxSize - sizeof(LVBase)) / sizeof(LValuePathEntry); 38 39 /// Path - The sequence of base classes, fields and array indices to follow to 40 /// walk from Base to the subobject. When performing GCC-style folding, there 41 /// may not be such a path. 42 union { 43 LValuePathEntry Path[InlinePathSpace]; 44 LValuePathEntry *PathPtr; 45 }; 46 47 LV() { PathLength = (unsigned)-1; } 48 ~LV() { resizePath(0); } 49 50 void resizePath(unsigned Length) { 51 if (Length == PathLength) 52 return; 53 if (hasPathPtr()) 54 delete [] PathPtr; 55 PathLength = Length; 56 if (hasPathPtr()) 57 PathPtr = new LValuePathEntry[Length]; 58 } 59 60 bool hasPath() const { return PathLength != (unsigned)-1; } 61 bool hasPathPtr() const { return hasPath() && PathLength > InlinePathSpace; } 62 63 LValuePathEntry *getPath() { return hasPathPtr() ? PathPtr : Path; } 64 const LValuePathEntry *getPath() const { 65 return hasPathPtr() ? PathPtr : Path; 66 } 67}; 68 69namespace { 70 struct MemberPointerBase { 71 llvm::PointerIntPair<const ValueDecl*, 1, bool> MemberAndIsDerivedMember; 72 unsigned PathLength; 73 }; 74} 75 76struct APValue::MemberPointerData : MemberPointerBase { 77 static const unsigned InlinePathSpace = 78 (MaxSize - sizeof(MemberPointerBase)) / sizeof(const CXXRecordDecl*); 79 typedef const CXXRecordDecl *PathElem; 80 union { 81 PathElem Path[InlinePathSpace]; 82 PathElem *PathPtr; 83 }; 84 85 MemberPointerData() { PathLength = 0; } 86 ~MemberPointerData() { resizePath(0); } 87 88 void resizePath(unsigned Length) { 89 if (Length == PathLength) 90 return; 91 if (hasPathPtr()) 92 delete [] PathPtr; 93 PathLength = Length; 94 if (hasPathPtr()) 95 PathPtr = new PathElem[Length]; 96 } 97 98 bool hasPathPtr() const { return PathLength > InlinePathSpace; } 99 100 PathElem *getPath() { return hasPathPtr() ? PathPtr : Path; } 101 const PathElem *getPath() const { 102 return hasPathPtr() ? PathPtr : Path; 103 } 104}; 105 106// FIXME: Reduce the malloc traffic here. 107 108APValue::Arr::Arr(unsigned NumElts, unsigned Size) : 109 Elts(new APValue[NumElts + (NumElts != Size ? 1 : 0)]), 110 NumElts(NumElts), ArrSize(Size) {} 111APValue::Arr::~Arr() { delete [] Elts; } 112 113APValue::StructData::StructData(unsigned NumBases, unsigned NumFields) : 114 Elts(new APValue[NumBases+NumFields]), 115 NumBases(NumBases), NumFields(NumFields) {} 116APValue::StructData::~StructData() { 117 delete [] Elts; 118} 119 120APValue::UnionData::UnionData() : Field(0), Value(new APValue) {} 121APValue::UnionData::~UnionData () { 122 delete Value; 123} 124 125APValue::APValue(const APValue &RHS) : Kind(Uninitialized) { 126 switch (RHS.getKind()) { 127 case Uninitialized: 128 break; 129 case Int: 130 MakeInt(); 131 setInt(RHS.getInt()); 132 break; 133 case Float: 134 MakeFloat(); 135 setFloat(RHS.getFloat()); 136 break; 137 case Vector: 138 MakeVector(); 139 setVector(((const Vec *)(const char *)RHS.Data)->Elts, 140 RHS.getVectorLength()); 141 break; 142 case ComplexInt: 143 MakeComplexInt(); 144 setComplexInt(RHS.getComplexIntReal(), RHS.getComplexIntImag()); 145 break; 146 case ComplexFloat: 147 MakeComplexFloat(); 148 setComplexFloat(RHS.getComplexFloatReal(), RHS.getComplexFloatImag()); 149 break; 150 case LValue: 151 MakeLValue(); 152 if (RHS.hasLValuePath()) 153 setLValue(RHS.getLValueBase(), RHS.getLValueOffset(), RHS.getLValuePath(), 154 RHS.isLValueOnePastTheEnd(), RHS.getLValueCallIndex()); 155 else 156 setLValue(RHS.getLValueBase(), RHS.getLValueOffset(), NoLValuePath(), 157 RHS.getLValueCallIndex()); 158 break; 159 case Array: 160 MakeArray(RHS.getArrayInitializedElts(), RHS.getArraySize()); 161 for (unsigned I = 0, N = RHS.getArrayInitializedElts(); I != N; ++I) 162 getArrayInitializedElt(I) = RHS.getArrayInitializedElt(I); 163 if (RHS.hasArrayFiller()) 164 getArrayFiller() = RHS.getArrayFiller(); 165 break; 166 case Struct: 167 MakeStruct(RHS.getStructNumBases(), RHS.getStructNumFields()); 168 for (unsigned I = 0, N = RHS.getStructNumBases(); I != N; ++I) 169 getStructBase(I) = RHS.getStructBase(I); 170 for (unsigned I = 0, N = RHS.getStructNumFields(); I != N; ++I) 171 getStructField(I) = RHS.getStructField(I); 172 break; 173 case Union: 174 MakeUnion(); 175 setUnion(RHS.getUnionField(), RHS.getUnionValue()); 176 break; 177 case MemberPointer: 178 MakeMemberPointer(RHS.getMemberPointerDecl(), 179 RHS.isMemberPointerToDerivedMember(), 180 RHS.getMemberPointerPath()); 181 break; 182 case AddrLabelDiff: 183 MakeAddrLabelDiff(); 184 setAddrLabelDiff(RHS.getAddrLabelDiffLHS(), RHS.getAddrLabelDiffRHS()); 185 break; 186 } 187} 188 189void APValue::DestroyDataAndMakeUninit() { 190 if (Kind == Int) 191 ((APSInt*)(char*)Data)->~APSInt(); 192 else if (Kind == Float) 193 ((APFloat*)(char*)Data)->~APFloat(); 194 else if (Kind == Vector) 195 ((Vec*)(char*)Data)->~Vec(); 196 else if (Kind == ComplexInt) 197 ((ComplexAPSInt*)(char*)Data)->~ComplexAPSInt(); 198 else if (Kind == ComplexFloat) 199 ((ComplexAPFloat*)(char*)Data)->~ComplexAPFloat(); 200 else if (Kind == LValue) 201 ((LV*)(char*)Data)->~LV(); 202 else if (Kind == Array) 203 ((Arr*)(char*)Data)->~Arr(); 204 else if (Kind == Struct) 205 ((StructData*)(char*)Data)->~StructData(); 206 else if (Kind == Union) 207 ((UnionData*)(char*)Data)->~UnionData(); 208 else if (Kind == MemberPointer) 209 ((MemberPointerData*)(char*)Data)->~MemberPointerData(); 210 else if (Kind == AddrLabelDiff) 211 ((AddrLabelDiffData*)(char*)Data)->~AddrLabelDiffData(); 212 Kind = Uninitialized; 213} 214 215void APValue::swap(APValue &RHS) { 216 std::swap(Kind, RHS.Kind); 217 char TmpData[MaxSize]; 218 memcpy(TmpData, Data, MaxSize); 219 memcpy(Data, RHS.Data, MaxSize); 220 memcpy(RHS.Data, TmpData, MaxSize); 221} 222 223void APValue::dump() const { 224 dump(llvm::errs()); 225 llvm::errs() << '\n'; 226} 227 228static double GetApproxValue(const llvm::APFloat &F) { 229 llvm::APFloat V = F; 230 bool ignored; 231 V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 232 &ignored); 233 return V.convertToDouble(); 234} 235 236void APValue::dump(raw_ostream &OS) const { 237 switch (getKind()) { 238 case Uninitialized: 239 OS << "Uninitialized"; 240 return; 241 case Int: 242 OS << "Int: " << getInt(); 243 return; 244 case Float: 245 OS << "Float: " << GetApproxValue(getFloat()); 246 return; 247 case Vector: 248 OS << "Vector: "; 249 getVectorElt(0).dump(OS); 250 for (unsigned i = 1; i != getVectorLength(); ++i) { 251 OS << ", "; 252 getVectorElt(i).dump(OS); 253 } 254 return; 255 case ComplexInt: 256 OS << "ComplexInt: " << getComplexIntReal() << ", " << getComplexIntImag(); 257 return; 258 case ComplexFloat: 259 OS << "ComplexFloat: " << GetApproxValue(getComplexFloatReal()) 260 << ", " << GetApproxValue(getComplexFloatImag()); 261 return; 262 case LValue: 263 OS << "LValue: <todo>"; 264 return; 265 case Array: 266 OS << "Array: "; 267 for (unsigned I = 0, N = getArrayInitializedElts(); I != N; ++I) { 268 getArrayInitializedElt(I).dump(OS); 269 if (I != getArraySize() - 1) OS << ", "; 270 } 271 if (hasArrayFiller()) { 272 OS << getArraySize() - getArrayInitializedElts() << " x "; 273 getArrayFiller().dump(OS); 274 } 275 return; 276 case Struct: 277 OS << "Struct "; 278 if (unsigned N = getStructNumBases()) { 279 OS << " bases: "; 280 getStructBase(0).dump(OS); 281 for (unsigned I = 1; I != N; ++I) { 282 OS << ", "; 283 getStructBase(I).dump(OS); 284 } 285 } 286 if (unsigned N = getStructNumFields()) { 287 OS << " fields: "; 288 getStructField(0).dump(OS); 289 for (unsigned I = 1; I != N; ++I) { 290 OS << ", "; 291 getStructField(I).dump(OS); 292 } 293 } 294 return; 295 case Union: 296 OS << "Union: "; 297 getUnionValue().dump(OS); 298 return; 299 case MemberPointer: 300 OS << "MemberPointer: <todo>"; 301 return; 302 case AddrLabelDiff: 303 OS << "AddrLabelDiff: <todo>"; 304 return; 305 } 306 llvm_unreachable("Unknown APValue kind!"); 307} 308 309void APValue::printPretty(raw_ostream &Out, ASTContext &Ctx, QualType Ty) const{ 310 switch (getKind()) { 311 case APValue::Uninitialized: 312 Out << "<uninitialized>"; 313 return; 314 case APValue::Int: 315 if (Ty->isBooleanType()) 316 Out << (getInt().getBoolValue() ? "true" : "false"); 317 else 318 Out << getInt(); 319 return; 320 case APValue::Float: 321 Out << GetApproxValue(getFloat()); 322 return; 323 case APValue::Vector: { 324 Out << '{'; 325 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 326 getVectorElt(0).printPretty(Out, Ctx, ElemTy); 327 for (unsigned i = 1; i != getVectorLength(); ++i) { 328 Out << ", "; 329 getVectorElt(i).printPretty(Out, Ctx, ElemTy); 330 } 331 Out << '}'; 332 return; 333 } 334 case APValue::ComplexInt: 335 Out << getComplexIntReal() << "+" << getComplexIntImag() << "i"; 336 return; 337 case APValue::ComplexFloat: 338 Out << GetApproxValue(getComplexFloatReal()) << "+" 339 << GetApproxValue(getComplexFloatImag()) << "i"; 340 return; 341 case APValue::LValue: { 342 LValueBase Base = getLValueBase(); 343 if (!Base) { 344 Out << "0"; 345 return; 346 } 347 348 bool IsReference = Ty->isReferenceType(); 349 QualType InnerTy 350 = IsReference ? Ty.getNonReferenceType() : Ty->getPointeeType(); 351 if (InnerTy.isNull()) 352 InnerTy = Ty; 353 354 if (!hasLValuePath()) { 355 // No lvalue path: just print the offset. 356 CharUnits O = getLValueOffset(); 357 CharUnits S = Ctx.getTypeSizeInChars(InnerTy); 358 if (!O.isZero()) { 359 if (IsReference) 360 Out << "*("; 361 if (O % S) { 362 Out << "(char*)"; 363 S = CharUnits::One(); 364 } 365 Out << '&'; 366 } else if (!IsReference) 367 Out << '&'; 368 369 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) 370 Out << *VD; 371 else 372 Base.get<const Expr*>()->printPretty(Out, 0, Ctx.getPrintingPolicy()); 373 if (!O.isZero()) { 374 Out << " + " << (O / S); 375 if (IsReference) 376 Out << ')'; 377 } 378 return; 379 } 380 381 // We have an lvalue path. Print it out nicely. 382 if (!IsReference) 383 Out << '&'; 384 else if (isLValueOnePastTheEnd()) 385 Out << "*(&"; 386 387 QualType ElemTy; 388 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) { 389 Out << *VD; 390 ElemTy = VD->getType(); 391 } else { 392 const Expr *E = Base.get<const Expr*>(); 393 E->printPretty(Out, 0, Ctx.getPrintingPolicy()); 394 ElemTy = E->getType(); 395 } 396 397 ArrayRef<LValuePathEntry> Path = getLValuePath(); 398 const CXXRecordDecl *CastToBase = 0; 399 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 400 if (ElemTy->getAs<RecordType>()) { 401 // The lvalue refers to a class type, so the next path entry is a base 402 // or member. 403 const Decl *BaseOrMember = 404 BaseOrMemberType::getFromOpaqueValue(Path[I].BaseOrMember).getPointer(); 405 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) { 406 CastToBase = RD; 407 ElemTy = Ctx.getRecordType(RD); 408 } else { 409 const ValueDecl *VD = cast<ValueDecl>(BaseOrMember); 410 Out << "."; 411 if (CastToBase) 412 Out << *CastToBase << "::"; 413 Out << *VD; 414 ElemTy = VD->getType(); 415 } 416 } else { 417 // The lvalue must refer to an array. 418 Out << '[' << Path[I].ArrayIndex << ']'; 419 ElemTy = Ctx.getAsArrayType(ElemTy)->getElementType(); 420 } 421 } 422 423 // Handle formatting of one-past-the-end lvalues. 424 if (isLValueOnePastTheEnd()) { 425 // FIXME: If CastToBase is non-0, we should prefix the output with 426 // "(CastToBase*)". 427 Out << " + 1"; 428 if (IsReference) 429 Out << ')'; 430 } 431 return; 432 } 433 case APValue::Array: { 434 const ArrayType *AT = Ctx.getAsArrayType(Ty); 435 QualType ElemTy = AT->getElementType(); 436 Out << '{'; 437 if (unsigned N = getArrayInitializedElts()) { 438 getArrayInitializedElt(0).printPretty(Out, Ctx, ElemTy); 439 for (unsigned I = 1; I != N; ++I) { 440 Out << ", "; 441 if (I == 10) { 442 // Avoid printing out the entire contents of large arrays. 443 Out << "..."; 444 break; 445 } 446 getArrayInitializedElt(I).printPretty(Out, Ctx, ElemTy); 447 } 448 } 449 Out << '}'; 450 return; 451 } 452 case APValue::Struct: { 453 Out << '{'; 454 const RecordDecl *RD = Ty->getAs<RecordType>()->getDecl(); 455 bool First = true; 456 if (unsigned N = getStructNumBases()) { 457 const CXXRecordDecl *CD = cast<CXXRecordDecl>(RD); 458 CXXRecordDecl::base_class_const_iterator BI = CD->bases_begin(); 459 for (unsigned I = 0; I != N; ++I, ++BI) { 460 assert(BI != CD->bases_end()); 461 if (!First) 462 Out << ", "; 463 getStructBase(I).printPretty(Out, Ctx, BI->getType()); 464 First = false; 465 } 466 } 467 for (RecordDecl::field_iterator FI = RD->field_begin(); 468 FI != RD->field_end(); ++FI) { 469 if (!First) 470 Out << ", "; 471 if (FI->isUnnamedBitfield()) continue; 472 getStructField(FI->getFieldIndex()). 473 printPretty(Out, Ctx, FI->getType()); 474 First = false; 475 } 476 Out << '}'; 477 return; 478 } 479 case APValue::Union: 480 Out << '{'; 481 if (const FieldDecl *FD = getUnionField()) { 482 Out << "." << *FD << " = "; 483 getUnionValue().printPretty(Out, Ctx, FD->getType()); 484 } 485 Out << '}'; 486 return; 487 case APValue::MemberPointer: 488 // FIXME: This is not enough to unambiguously identify the member in a 489 // multiple-inheritance scenario. 490 if (const ValueDecl *VD = getMemberPointerDecl()) { 491 Out << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD; 492 return; 493 } 494 Out << "0"; 495 return; 496 case APValue::AddrLabelDiff: 497 Out << "&&" << getAddrLabelDiffLHS()->getLabel()->getName(); 498 Out << " - "; 499 Out << "&&" << getAddrLabelDiffRHS()->getLabel()->getName(); 500 return; 501 } 502 llvm_unreachable("Unknown APValue kind!"); 503} 504 505std::string APValue::getAsString(ASTContext &Ctx, QualType Ty) const { 506 std::string Result; 507 llvm::raw_string_ostream Out(Result); 508 printPretty(Out, Ctx, Ty); 509 Out.flush(); 510 return Result; 511} 512 513const APValue::LValueBase APValue::getLValueBase() const { 514 assert(isLValue() && "Invalid accessor"); 515 return ((const LV*)(const void*)Data)->BaseAndIsOnePastTheEnd.getPointer(); 516} 517 518bool APValue::isLValueOnePastTheEnd() const { 519 assert(isLValue() && "Invalid accessor"); 520 return ((const LV*)(const void*)Data)->BaseAndIsOnePastTheEnd.getInt(); 521} 522 523CharUnits &APValue::getLValueOffset() { 524 assert(isLValue() && "Invalid accessor"); 525 return ((LV*)(void*)Data)->Offset; 526} 527 528bool APValue::hasLValuePath() const { 529 assert(isLValue() && "Invalid accessor"); 530 return ((const LV*)(const char*)Data)->hasPath(); 531} 532 533ArrayRef<APValue::LValuePathEntry> APValue::getLValuePath() const { 534 assert(isLValue() && hasLValuePath() && "Invalid accessor"); 535 const LV &LVal = *((const LV*)(const char*)Data); 536 return ArrayRef<LValuePathEntry>(LVal.getPath(), LVal.PathLength); 537} 538 539unsigned APValue::getLValueCallIndex() const { 540 assert(isLValue() && "Invalid accessor"); 541 return ((const LV*)(const char*)Data)->CallIndex; 542} 543 544void APValue::setLValue(LValueBase B, const CharUnits &O, NoLValuePath, 545 unsigned CallIndex) { 546 assert(isLValue() && "Invalid accessor"); 547 LV &LVal = *((LV*)(char*)Data); 548 LVal.BaseAndIsOnePastTheEnd.setPointer(B); 549 LVal.BaseAndIsOnePastTheEnd.setInt(false); 550 LVal.Offset = O; 551 LVal.CallIndex = CallIndex; 552 LVal.resizePath((unsigned)-1); 553} 554 555void APValue::setLValue(LValueBase B, const CharUnits &O, 556 ArrayRef<LValuePathEntry> Path, bool IsOnePastTheEnd, 557 unsigned CallIndex) { 558 assert(isLValue() && "Invalid accessor"); 559 LV &LVal = *((LV*)(char*)Data); 560 LVal.BaseAndIsOnePastTheEnd.setPointer(B); 561 LVal.BaseAndIsOnePastTheEnd.setInt(IsOnePastTheEnd); 562 LVal.Offset = O; 563 LVal.CallIndex = CallIndex; 564 LVal.resizePath(Path.size()); 565 memcpy(LVal.getPath(), Path.data(), Path.size() * sizeof(LValuePathEntry)); 566} 567 568const ValueDecl *APValue::getMemberPointerDecl() const { 569 assert(isMemberPointer() && "Invalid accessor"); 570 const MemberPointerData &MPD = *((const MemberPointerData*)(const char*)Data); 571 return MPD.MemberAndIsDerivedMember.getPointer(); 572} 573 574bool APValue::isMemberPointerToDerivedMember() const { 575 assert(isMemberPointer() && "Invalid accessor"); 576 const MemberPointerData &MPD = *((const MemberPointerData*)(const char*)Data); 577 return MPD.MemberAndIsDerivedMember.getInt(); 578} 579 580ArrayRef<const CXXRecordDecl*> APValue::getMemberPointerPath() const { 581 assert(isMemberPointer() && "Invalid accessor"); 582 const MemberPointerData &MPD = *((const MemberPointerData*)(const char*)Data); 583 return ArrayRef<const CXXRecordDecl*>(MPD.getPath(), MPD.PathLength); 584} 585 586void APValue::MakeLValue() { 587 assert(isUninit() && "Bad state change"); 588 assert(sizeof(LV) <= MaxSize && "LV too big"); 589 new ((void*)(char*)Data) LV(); 590 Kind = LValue; 591} 592 593void APValue::MakeArray(unsigned InitElts, unsigned Size) { 594 assert(isUninit() && "Bad state change"); 595 new ((void*)(char*)Data) Arr(InitElts, Size); 596 Kind = Array; 597} 598 599void APValue::MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember, 600 ArrayRef<const CXXRecordDecl*> Path) { 601 assert(isUninit() && "Bad state change"); 602 MemberPointerData *MPD = new ((void*)(char*)Data) MemberPointerData; 603 Kind = MemberPointer; 604 MPD->MemberAndIsDerivedMember.setPointer(Member); 605 MPD->MemberAndIsDerivedMember.setInt(IsDerivedMember); 606 MPD->resizePath(Path.size()); 607 memcpy(MPD->getPath(), Path.data(), Path.size()*sizeof(const CXXRecordDecl*)); 608} 609