MachineModuleInfo.cpp revision 0ff39b3feb10477c224138156941234f5fa46f58
1//===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- C++ -*-===// 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#include "llvm/CodeGen/MachineModuleInfo.h" 11 12#include "llvm/Constants.h" 13#include "llvm/Analysis/ValueTracking.h" 14#include "llvm/CodeGen/MachineFunctionPass.h" 15#include "llvm/CodeGen/MachineFunction.h" 16#include "llvm/CodeGen/MachineLocation.h" 17#include "llvm/CodeGen/MachineDebugInfoDesc.h" 18#include "llvm/Target/TargetInstrInfo.h" 19#include "llvm/Target/TargetMachine.h" 20#include "llvm/Target/TargetOptions.h" 21#include "llvm/DerivedTypes.h" 22#include "llvm/GlobalVariable.h" 23#include "llvm/Intrinsics.h" 24#include "llvm/Instructions.h" 25#include "llvm/Module.h" 26#include "llvm/Support/Dwarf.h" 27#include "llvm/Support/Streams.h" 28using namespace llvm; 29using namespace llvm::dwarf; 30 31// Handle the Pass registration stuff necessary to use TargetData's. 32static RegisterPass<MachineModuleInfo> 33X("machinemoduleinfo", "Module Information"); 34char MachineModuleInfo::ID = 0; 35 36//===----------------------------------------------------------------------===// 37 38/// getGlobalVariablesUsing - Return all of the GlobalVariables which have the 39/// specified value in their initializer somewhere. 40static void 41getGlobalVariablesUsing(Value *V, std::vector<GlobalVariable*> &Result) { 42 // Scan though value users. 43 for (Value::use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) { 44 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(*I)) { 45 // If the user is a GlobalVariable then add to result. 46 Result.push_back(GV); 47 } else if (Constant *C = dyn_cast<Constant>(*I)) { 48 // If the user is a constant variable then scan its users 49 getGlobalVariablesUsing(C, Result); 50 } 51 } 52} 53 54/// getGlobalVariablesUsing - Return all of the GlobalVariables that use the 55/// named GlobalVariable. 56static void 57getGlobalVariablesUsing(Module &M, const std::string &RootName, 58 std::vector<GlobalVariable*> &Result) { 59 std::vector<const Type*> FieldTypes; 60 FieldTypes.push_back(Type::Int32Ty); 61 FieldTypes.push_back(Type::Int32Ty); 62 63 // Get the GlobalVariable root. 64 GlobalVariable *UseRoot = M.getGlobalVariable(RootName, 65 StructType::get(FieldTypes)); 66 67 // If present and linkonce then scan for users. 68 if (UseRoot && UseRoot->hasLinkOnceLinkage()) 69 getGlobalVariablesUsing(UseRoot, Result); 70} 71 72/// isStringValue - Return true if the given value can be coerced to a string. 73/// 74static bool isStringValue(Value *V) { 75 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) { 76 if (GV->hasInitializer() && isa<ConstantArray>(GV->getInitializer())) { 77 ConstantArray *Init = cast<ConstantArray>(GV->getInitializer()); 78 return Init->isString(); 79 } 80 } else if (Constant *C = dyn_cast<Constant>(V)) { 81 if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) 82 return isStringValue(GV); 83 else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 84 if (CE->getOpcode() == Instruction::GetElementPtr) { 85 if (CE->getNumOperands() == 3 && 86 cast<Constant>(CE->getOperand(1))->isNullValue() && 87 isa<ConstantInt>(CE->getOperand(2))) { 88 return isStringValue(CE->getOperand(0)); 89 } 90 } 91 } 92 } 93 return false; 94} 95 96/// getGlobalVariable - Return either a direct or cast Global value. 97/// 98static GlobalVariable *getGlobalVariable(Value *V) { 99 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) { 100 return GV; 101 } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 102 if (CE->getOpcode() == Instruction::BitCast) { 103 return dyn_cast<GlobalVariable>(CE->getOperand(0)); 104 } else if (CE->getOpcode() == Instruction::GetElementPtr) { 105 for (unsigned int i=1; i<CE->getNumOperands(); i++) { 106 if (!CE->getOperand(i)->isNullValue()) 107 return NULL; 108 } 109 return dyn_cast<GlobalVariable>(CE->getOperand(0)); 110 } 111 } 112 return NULL; 113} 114 115/// isGlobalVariable - Return true if the given value can be coerced to a 116/// GlobalVariable. 117static bool isGlobalVariable(Value *V) { 118 if (isa<GlobalVariable>(V) || isa<ConstantPointerNull>(V)) { 119 return true; 120 } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 121 if (CE->getOpcode() == Instruction::BitCast) { 122 return isa<GlobalVariable>(CE->getOperand(0)); 123 } else if (CE->getOpcode() == Instruction::GetElementPtr) { 124 for (unsigned int i=1; i<CE->getNumOperands(); i++) { 125 if (!CE->getOperand(i)->isNullValue()) 126 return false; 127 } 128 return isa<GlobalVariable>(CE->getOperand(0)); 129 } 130 } 131 return false; 132} 133 134//===----------------------------------------------------------------------===// 135 136/// ApplyToFields - Target the visitor to each field of the debug information 137/// descriptor. 138void DIVisitor::ApplyToFields(DebugInfoDesc *DD) { 139 DD->ApplyToFields(this); 140} 141 142namespace { 143 144//===----------------------------------------------------------------------===// 145/// DICountVisitor - This DIVisitor counts all the fields in the supplied debug 146/// the supplied DebugInfoDesc. 147class DICountVisitor : public DIVisitor { 148private: 149 unsigned Count; // Running count of fields. 150 151public: 152 DICountVisitor() : DIVisitor(), Count(0) {} 153 154 // Accessors. 155 unsigned getCount() const { return Count; } 156 157 /// Apply - Count each of the fields. 158 /// 159 virtual void Apply(int &Field) { ++Count; } 160 virtual void Apply(unsigned &Field) { ++Count; } 161 virtual void Apply(int64_t &Field) { ++Count; } 162 virtual void Apply(uint64_t &Field) { ++Count; } 163 virtual void Apply(bool &Field) { ++Count; } 164 virtual void Apply(std::string &Field) { ++Count; } 165 virtual void Apply(DebugInfoDesc *&Field) { ++Count; } 166 virtual void Apply(GlobalVariable *&Field) { ++Count; } 167 virtual void Apply(std::vector<DebugInfoDesc *> &Field) { 168 ++Count; 169 } 170}; 171 172//===----------------------------------------------------------------------===// 173/// DIDeserializeVisitor - This DIVisitor deserializes all the fields in the 174/// supplied DebugInfoDesc. 175class DIDeserializeVisitor : public DIVisitor { 176private: 177 DIDeserializer &DR; // Active deserializer. 178 unsigned I; // Current operand index. 179 ConstantStruct *CI; // GlobalVariable constant initializer. 180 181public: 182 DIDeserializeVisitor(DIDeserializer &D, GlobalVariable *GV) 183 : DIVisitor(), DR(D), I(0), CI(cast<ConstantStruct>(GV->getInitializer())) 184 {} 185 186 /// Apply - Set the value of each of the fields. 187 /// 188 virtual void Apply(int &Field) { 189 Constant *C = CI->getOperand(I++); 190 Field = cast<ConstantInt>(C)->getSExtValue(); 191 } 192 virtual void Apply(unsigned &Field) { 193 Constant *C = CI->getOperand(I++); 194 Field = cast<ConstantInt>(C)->getZExtValue(); 195 } 196 virtual void Apply(int64_t &Field) { 197 Constant *C = CI->getOperand(I++); 198 Field = cast<ConstantInt>(C)->getSExtValue(); 199 } 200 virtual void Apply(uint64_t &Field) { 201 Constant *C = CI->getOperand(I++); 202 Field = cast<ConstantInt>(C)->getZExtValue(); 203 } 204 virtual void Apply(bool &Field) { 205 Constant *C = CI->getOperand(I++); 206 Field = cast<ConstantInt>(C)->getZExtValue(); 207 } 208 virtual void Apply(std::string &Field) { 209 Constant *C = CI->getOperand(I++); 210 // Fills in the string if it succeeds 211 if (!GetConstantStringInfo(C, Field)) 212 Field.clear(); 213 } 214 virtual void Apply(DebugInfoDesc *&Field) { 215 Constant *C = CI->getOperand(I++); 216 Field = DR.Deserialize(C); 217 } 218 virtual void Apply(GlobalVariable *&Field) { 219 Constant *C = CI->getOperand(I++); 220 Field = getGlobalVariable(C); 221 } 222 virtual void Apply(std::vector<DebugInfoDesc *> &Field) { 223 Field.resize(0); 224 Constant *C = CI->getOperand(I++); 225 GlobalVariable *GV = getGlobalVariable(C); 226 if (GV->hasInitializer()) { 227 if (ConstantArray *CA = dyn_cast<ConstantArray>(GV->getInitializer())) { 228 for (unsigned i = 0, N = CA->getNumOperands(); i < N; ++i) { 229 GlobalVariable *GVE = getGlobalVariable(CA->getOperand(i)); 230 DebugInfoDesc *DE = DR.Deserialize(GVE); 231 Field.push_back(DE); 232 } 233 } else if (GV->getInitializer()->isNullValue()) { 234 if (const ArrayType *T = 235 dyn_cast<ArrayType>(GV->getType()->getElementType())) { 236 Field.resize(T->getNumElements()); 237 } 238 } 239 } 240 } 241}; 242 243//===----------------------------------------------------------------------===// 244/// DISerializeVisitor - This DIVisitor serializes all the fields in 245/// the supplied DebugInfoDesc. 246class DISerializeVisitor : public DIVisitor { 247private: 248 DISerializer &SR; // Active serializer. 249 std::vector<Constant*> &Elements; // Element accumulator. 250 251public: 252 DISerializeVisitor(DISerializer &S, std::vector<Constant*> &E) 253 : DIVisitor() 254 , SR(S) 255 , Elements(E) 256 {} 257 258 /// Apply - Set the value of each of the fields. 259 /// 260 virtual void Apply(int &Field) { 261 Elements.push_back(ConstantInt::get(Type::Int32Ty, int32_t(Field))); 262 } 263 virtual void Apply(unsigned &Field) { 264 Elements.push_back(ConstantInt::get(Type::Int32Ty, uint32_t(Field))); 265 } 266 virtual void Apply(int64_t &Field) { 267 Elements.push_back(ConstantInt::get(Type::Int64Ty, int64_t(Field))); 268 } 269 virtual void Apply(uint64_t &Field) { 270 Elements.push_back(ConstantInt::get(Type::Int64Ty, uint64_t(Field))); 271 } 272 virtual void Apply(bool &Field) { 273 Elements.push_back(ConstantInt::get(Type::Int1Ty, Field)); 274 } 275 virtual void Apply(std::string &Field) { 276 Elements.push_back(SR.getString(Field)); 277 } 278 virtual void Apply(DebugInfoDesc *&Field) { 279 GlobalVariable *GV = NULL; 280 281 // If non-NULL then convert to global. 282 if (Field) GV = SR.Serialize(Field); 283 284 // FIXME - At some point should use specific type. 285 const PointerType *EmptyTy = SR.getEmptyStructPtrType(); 286 287 if (GV) { 288 // Set to pointer to global. 289 Elements.push_back(ConstantExpr::getBitCast(GV, EmptyTy)); 290 } else { 291 // Use NULL. 292 Elements.push_back(ConstantPointerNull::get(EmptyTy)); 293 } 294 } 295 virtual void Apply(GlobalVariable *&Field) { 296 const PointerType *EmptyTy = SR.getEmptyStructPtrType(); 297 if (Field) { 298 Elements.push_back(ConstantExpr::getBitCast(Field, EmptyTy)); 299 } else { 300 Elements.push_back(ConstantPointerNull::get(EmptyTy)); 301 } 302 } 303 virtual void Apply(std::vector<DebugInfoDesc *> &Field) { 304 const PointerType *EmptyTy = SR.getEmptyStructPtrType(); 305 unsigned N = Field.size(); 306 ArrayType *AT = ArrayType::get(EmptyTy, N); 307 std::vector<Constant *> ArrayElements; 308 309 for (unsigned i = 0; i < N; ++i) { 310 if (DebugInfoDesc *Element = Field[i]) { 311 GlobalVariable *GVE = SR.Serialize(Element); 312 Constant *CE = ConstantExpr::getBitCast(GVE, EmptyTy); 313 ArrayElements.push_back(cast<Constant>(CE)); 314 } else { 315 ArrayElements.push_back(ConstantPointerNull::get(EmptyTy)); 316 } 317 } 318 319 Constant *CA = ConstantArray::get(AT, ArrayElements); 320 GlobalVariable *CAGV = new GlobalVariable(AT, true, 321 GlobalValue::InternalLinkage, 322 CA, "llvm.dbg.array", 323 SR.getModule()); 324 CAGV->setSection("llvm.metadata"); 325 Constant *CAE = ConstantExpr::getBitCast(CAGV, EmptyTy); 326 Elements.push_back(CAE); 327 } 328}; 329 330//===----------------------------------------------------------------------===// 331/// DIGetTypesVisitor - This DIVisitor gathers all the field types in 332/// the supplied DebugInfoDesc. 333class DIGetTypesVisitor : public DIVisitor { 334private: 335 DISerializer &SR; // Active serializer. 336 std::vector<const Type*> &Fields; // Type accumulator. 337 338public: 339 DIGetTypesVisitor(DISerializer &S, std::vector<const Type*> &F) 340 : DIVisitor() 341 , SR(S) 342 , Fields(F) 343 {} 344 345 /// Apply - Set the value of each of the fields. 346 /// 347 virtual void Apply(int &Field) { 348 Fields.push_back(Type::Int32Ty); 349 } 350 virtual void Apply(unsigned &Field) { 351 Fields.push_back(Type::Int32Ty); 352 } 353 virtual void Apply(int64_t &Field) { 354 Fields.push_back(Type::Int64Ty); 355 } 356 virtual void Apply(uint64_t &Field) { 357 Fields.push_back(Type::Int64Ty); 358 } 359 virtual void Apply(bool &Field) { 360 Fields.push_back(Type::Int1Ty); 361 } 362 virtual void Apply(std::string &Field) { 363 Fields.push_back(SR.getStrPtrType()); 364 } 365 virtual void Apply(DebugInfoDesc *&Field) { 366 // FIXME - At some point should use specific type. 367 const PointerType *EmptyTy = SR.getEmptyStructPtrType(); 368 Fields.push_back(EmptyTy); 369 } 370 virtual void Apply(GlobalVariable *&Field) { 371 const PointerType *EmptyTy = SR.getEmptyStructPtrType(); 372 Fields.push_back(EmptyTy); 373 } 374 virtual void Apply(std::vector<DebugInfoDesc *> &Field) { 375 const PointerType *EmptyTy = SR.getEmptyStructPtrType(); 376 Fields.push_back(EmptyTy); 377 } 378}; 379 380//===----------------------------------------------------------------------===// 381/// DIVerifyVisitor - This DIVisitor verifies all the field types against 382/// a constant initializer. 383class DIVerifyVisitor : public DIVisitor { 384private: 385 DIVerifier &VR; // Active verifier. 386 bool IsValid; // Validity status. 387 unsigned I; // Current operand index. 388 ConstantStruct *CI; // GlobalVariable constant initializer. 389 390public: 391 DIVerifyVisitor(DIVerifier &V, GlobalVariable *GV) 392 : DIVisitor() 393 , VR(V) 394 , IsValid(true) 395 , I(0) 396 , CI(cast<ConstantStruct>(GV->getInitializer())) 397 { 398 } 399 400 // Accessors. 401 bool isValid() const { return IsValid; } 402 403 /// Apply - Set the value of each of the fields. 404 /// 405 virtual void Apply(int &Field) { 406 Constant *C = CI->getOperand(I++); 407 IsValid = IsValid && isa<ConstantInt>(C); 408 } 409 virtual void Apply(unsigned &Field) { 410 Constant *C = CI->getOperand(I++); 411 IsValid = IsValid && isa<ConstantInt>(C); 412 } 413 virtual void Apply(int64_t &Field) { 414 Constant *C = CI->getOperand(I++); 415 IsValid = IsValid && isa<ConstantInt>(C); 416 } 417 virtual void Apply(uint64_t &Field) { 418 Constant *C = CI->getOperand(I++); 419 IsValid = IsValid && isa<ConstantInt>(C); 420 } 421 virtual void Apply(bool &Field) { 422 Constant *C = CI->getOperand(I++); 423 IsValid = IsValid && isa<ConstantInt>(C) && C->getType() == Type::Int1Ty; 424 } 425 virtual void Apply(std::string &Field) { 426 Constant *C = CI->getOperand(I++); 427 IsValid = IsValid && 428 (!C || isStringValue(C) || C->isNullValue()); 429 } 430 virtual void Apply(DebugInfoDesc *&Field) { 431 // FIXME - Prepare the correct descriptor. 432 Constant *C = CI->getOperand(I++); 433 IsValid = IsValid && isGlobalVariable(C); 434 } 435 virtual void Apply(GlobalVariable *&Field) { 436 Constant *C = CI->getOperand(I++); 437 IsValid = IsValid && isGlobalVariable(C); 438 } 439 virtual void Apply(std::vector<DebugInfoDesc *> &Field) { 440 Constant *C = CI->getOperand(I++); 441 IsValid = IsValid && isGlobalVariable(C); 442 if (!IsValid) return; 443 444 GlobalVariable *GV = getGlobalVariable(C); 445 IsValid = IsValid && GV && GV->hasInitializer(); 446 if (!IsValid) return; 447 448 ConstantArray *CA = dyn_cast<ConstantArray>(GV->getInitializer()); 449 IsValid = IsValid && CA; 450 if (!IsValid) return; 451 452 for (unsigned i = 0, N = CA->getNumOperands(); IsValid && i < N; ++i) { 453 IsValid = IsValid && isGlobalVariable(CA->getOperand(i)); 454 if (!IsValid) return; 455 456 GlobalVariable *GVE = getGlobalVariable(CA->getOperand(i)); 457 VR.Verify(GVE); 458 } 459 } 460}; 461 462} 463 464//===----------------------------------------------------------------------===// 465 466DebugInfoDesc *DIDeserializer::Deserialize(Value *V) { 467 return Deserialize(getGlobalVariable(V)); 468} 469DebugInfoDesc *DIDeserializer::Deserialize(GlobalVariable *GV) { 470 // Handle NULL. 471 if (!GV) return NULL; 472 473 // Check to see if it has been already deserialized. 474 DebugInfoDesc *&Slot = GlobalDescs[GV]; 475 if (Slot) return Slot; 476 477 // Get the Tag from the global. 478 unsigned Tag = DebugInfoDesc::TagFromGlobal(GV); 479 480 // Create an empty instance of the correct sort. 481 Slot = DebugInfoDesc::DescFactory(Tag); 482 483 // If not a user defined descriptor. 484 if (Slot) { 485 // Deserialize the fields. 486 DIDeserializeVisitor DRAM(*this, GV); 487 DRAM.ApplyToFields(Slot); 488 } 489 490 return Slot; 491} 492 493//===----------------------------------------------------------------------===// 494 495/// getStrPtrType - Return a "sbyte *" type. 496/// 497const PointerType *DISerializer::getStrPtrType() { 498 // If not already defined. 499 if (!StrPtrTy) { 500 // Construct the pointer to signed bytes. 501 StrPtrTy = PointerType::getUnqual(Type::Int8Ty); 502 } 503 504 return StrPtrTy; 505} 506 507/// getEmptyStructPtrType - Return a "{ }*" type. 508/// 509const PointerType *DISerializer::getEmptyStructPtrType() { 510 // If not already defined. 511 if (EmptyStructPtrTy) return EmptyStructPtrTy; 512 513 // Construct the pointer to empty structure type. 514 const StructType *EmptyStructTy = 515 StructType::get(std::vector<const Type*>()); 516 517 // Construct the pointer to empty structure type. 518 EmptyStructPtrTy = PointerType::getUnqual(EmptyStructTy); 519 return EmptyStructPtrTy; 520} 521 522/// getTagType - Return the type describing the specified descriptor (via tag.) 523/// 524const StructType *DISerializer::getTagType(DebugInfoDesc *DD) { 525 // Attempt to get the previously defined type. 526 StructType *&Ty = TagTypes[DD->getTag()]; 527 528 // If not already defined. 529 if (!Ty) { 530 // Set up fields vector. 531 std::vector<const Type*> Fields; 532 // Get types of fields. 533 DIGetTypesVisitor GTAM(*this, Fields); 534 GTAM.ApplyToFields(DD); 535 536 // Construct structured type. 537 Ty = StructType::get(Fields); 538 539 // Register type name with module. 540 M->addTypeName(DD->getTypeString(), Ty); 541 } 542 543 return Ty; 544} 545 546/// getString - Construct the string as constant string global. 547/// 548Constant *DISerializer::getString(const std::string &String) { 549 // Check string cache for previous edition. 550 Constant *&Slot = StringCache[String.c_str()]; 551 552 // Return Constant if previously defined. 553 if (Slot) return Slot; 554 555 // If empty string then use a sbyte* null instead. 556 if (String.empty()) { 557 Slot = ConstantPointerNull::get(getStrPtrType()); 558 } else { 559 // Construct string as an llvm constant. 560 Constant *ConstStr = ConstantArray::get(String); 561 562 // Otherwise create and return a new string global. 563 GlobalVariable *StrGV = new GlobalVariable(ConstStr->getType(), true, 564 GlobalVariable::InternalLinkage, 565 ConstStr, ".str", M); 566 StrGV->setSection("llvm.metadata"); 567 568 // Convert to generic string pointer. 569 Slot = ConstantExpr::getBitCast(StrGV, getStrPtrType()); 570 } 571 572 return Slot; 573 574} 575 576/// Serialize - Recursively cast the specified descriptor into a GlobalVariable 577/// so that it can be serialized to a .bc or .ll file. 578GlobalVariable *DISerializer::Serialize(DebugInfoDesc *DD) { 579 // Check if the DebugInfoDesc is already in the map. 580 GlobalVariable *&Slot = DescGlobals[DD]; 581 582 // See if DebugInfoDesc exists, if so return prior GlobalVariable. 583 if (Slot) return Slot; 584 585 // Get the type associated with the Tag. 586 const StructType *Ty = getTagType(DD); 587 588 // Create the GlobalVariable early to prevent infinite recursion. 589 GlobalVariable *GV = new GlobalVariable(Ty, true, DD->getLinkage(), 590 NULL, DD->getDescString(), M); 591 GV->setSection("llvm.metadata"); 592 593 // Insert new GlobalVariable in DescGlobals map. 594 Slot = GV; 595 596 // Set up elements vector 597 std::vector<Constant*> Elements; 598 // Add fields. 599 DISerializeVisitor SRAM(*this, Elements); 600 SRAM.ApplyToFields(DD); 601 602 // Set the globals initializer. 603 GV->setInitializer(ConstantStruct::get(Ty, Elements)); 604 605 return GV; 606} 607 608/// addDescriptor - Directly connect DD with existing GV. 609void DISerializer::addDescriptor(DebugInfoDesc *DD, 610 GlobalVariable *GV) { 611 DescGlobals[DD] = GV; 612} 613 614//===----------------------------------------------------------------------===// 615 616/// Verify - Return true if the GlobalVariable appears to be a valid 617/// serialization of a DebugInfoDesc. 618bool DIVerifier::Verify(Value *V) { 619 return !V || Verify(getGlobalVariable(V)); 620} 621bool DIVerifier::Verify(GlobalVariable *GV) { 622 // NULLs are valid. 623 if (!GV) return true; 624 625 // Check prior validity. 626 unsigned &ValiditySlot = Validity[GV]; 627 628 // If visited before then use old state. 629 if (ValiditySlot) return ValiditySlot == Valid; 630 631 // Assume validity for the time being (recursion.) 632 ValiditySlot = Valid; 633 634 // Make sure the global is internal or link once (anchor.) 635 if (GV->getLinkage() != GlobalValue::InternalLinkage && 636 GV->getLinkage() != GlobalValue::LinkOnceLinkage) { 637 ValiditySlot = Invalid; 638 return false; 639 } 640 641 // Get the Tag. 642 unsigned Tag = DebugInfoDesc::TagFromGlobal(GV); 643 644 // Check for user defined descriptors. 645 if (Tag == DW_TAG_invalid) { 646 ValiditySlot = Valid; 647 return true; 648 } 649 650 // Get the Version. 651 unsigned Version = DebugInfoDesc::VersionFromGlobal(GV); 652 653 // Check for version mismatch. 654 if (Version != LLVMDebugVersion) { 655 ValiditySlot = Invalid; 656 return false; 657 } 658 659 // Construct an empty DebugInfoDesc. 660 DebugInfoDesc *DD = DebugInfoDesc::DescFactory(Tag); 661 662 // Allow for user defined descriptors. 663 if (!DD) return true; 664 665 // Get the initializer constant. 666 ConstantStruct *CI = cast<ConstantStruct>(GV->getInitializer()); 667 668 // Get the operand count. 669 unsigned N = CI->getNumOperands(); 670 671 // Get the field count. 672 unsigned &CountSlot = Counts[Tag]; 673 if (!CountSlot) { 674 // Check the operand count to the field count 675 DICountVisitor CTAM; 676 CTAM.ApplyToFields(DD); 677 CountSlot = CTAM.getCount(); 678 } 679 680 // Field count must be at most equal operand count. 681 if (CountSlot > N) { 682 delete DD; 683 ValiditySlot = Invalid; 684 return false; 685 } 686 687 // Check each field for valid type. 688 DIVerifyVisitor VRAM(*this, GV); 689 VRAM.ApplyToFields(DD); 690 691 // Release empty DebugInfoDesc. 692 delete DD; 693 694 // If fields are not valid. 695 if (!VRAM.isValid()) { 696 ValiditySlot = Invalid; 697 return false; 698 } 699 700 return true; 701} 702 703/// isVerified - Return true if the specified GV has already been 704/// verified as a debug information descriptor. 705bool DIVerifier::isVerified(GlobalVariable *GV) { 706 unsigned &ValiditySlot = Validity[GV]; 707 if (ValiditySlot) return ValiditySlot == Valid; 708 return false; 709} 710 711//===----------------------------------------------------------------------===// 712 713DebugScope::~DebugScope() { 714 for (unsigned i = 0, e = Scopes.size(); i < e; ++i) delete Scopes[i]; 715 for (unsigned i = 0, e = Variables.size(); i < e; ++i) delete Variables[i]; 716} 717 718//===----------------------------------------------------------------------===// 719 720MachineModuleInfo::MachineModuleInfo() 721: ImmutablePass((intptr_t)&ID) 722, DR() 723, VR() 724, CompileUnits() 725, Directories() 726, SourceFiles() 727, Lines() 728, LabelIDList() 729, ScopeMap() 730, RootScope(NULL) 731, FrameMoves() 732, LandingPads() 733, Personalities() 734, CallsEHReturn(0) 735, CallsUnwindInit(0) 736{ 737 // Always emit "no personality" info 738 Personalities.push_back(NULL); 739} 740MachineModuleInfo::~MachineModuleInfo() { 741 742} 743 744/// doInitialization - Initialize the state for a new module. 745/// 746bool MachineModuleInfo::doInitialization() { 747 return false; 748} 749 750/// doFinalization - Tear down the state after completion of a module. 751/// 752bool MachineModuleInfo::doFinalization() { 753 return false; 754} 755 756/// BeginFunction - Begin gathering function meta information. 757/// 758void MachineModuleInfo::BeginFunction(MachineFunction *MF) { 759 // Coming soon. 760} 761 762/// EndFunction - Discard function meta information. 763/// 764void MachineModuleInfo::EndFunction() { 765 // Clean up scope information. 766 if (RootScope) { 767 delete RootScope; 768 ScopeMap.clear(); 769 RootScope = NULL; 770 } 771 772 // Clean up line info. 773 Lines.clear(); 774 775 // Clean up frame info. 776 FrameMoves.clear(); 777 778 // Clean up exception info. 779 LandingPads.clear(); 780 TypeInfos.clear(); 781 FilterIds.clear(); 782 FilterEnds.clear(); 783 CallsEHReturn = 0; 784 CallsUnwindInit = 0; 785} 786 787/// getDescFor - Convert a Value to a debug information descriptor. 788/// 789// FIXME - use new Value type when available. 790DebugInfoDesc *MachineModuleInfo::getDescFor(Value *V) { 791 return DR.Deserialize(V); 792} 793 794/// AnalyzeModule - Scan the module for global debug information. 795/// 796void MachineModuleInfo::AnalyzeModule(Module &M) { 797 SetupCompileUnits(M); 798 799 // Insert functions in the llvm.used array into UsedFunctions. 800 GlobalVariable *GV = M.getGlobalVariable("llvm.used"); 801 if (!GV || !GV->hasInitializer()) return; 802 803 // Should be an array of 'i8*'. 804 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); 805 if (InitList == 0) return; 806 807 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { 808 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(InitList->getOperand(i))) 809 if (CE->getOpcode() == Instruction::BitCast) 810 if (Function *F = dyn_cast<Function>(CE->getOperand(0))) 811 UsedFunctions.insert(F); 812 } 813} 814 815/// SetupCompileUnits - Set up the unique vector of compile units. 816/// 817void MachineModuleInfo::SetupCompileUnits(Module &M) { 818 std::vector<void*> CUList; 819 CompileUnitDesc CUD; 820 getAnchoredDescriptors(M, &CUD, CUList); 821 822 for (unsigned i = 0, e = CUList.size(); i < e; i++) 823 CompileUnits.insert((CompileUnitDesc*)CUList[i]); 824} 825 826/// getCompileUnits - Return a vector of debug compile units. 827/// 828const UniqueVector<CompileUnitDesc *> MachineModuleInfo::getCompileUnits()const{ 829 return CompileUnits; 830} 831 832/// getAnchoredDescriptors - Return a vector of anchored debug descriptors. 833/// 834void 835MachineModuleInfo::getAnchoredDescriptors(Module &M, const AnchoredDesc *Desc, 836 std::vector<void*> &AnchoredDescs) { 837 std::vector<GlobalVariable*> Globals; 838 getGlobalVariablesUsing(M, Desc->getAnchorString(), Globals); 839 840 for (unsigned i = 0, e = Globals.size(); i < e; ++i) { 841 GlobalVariable *GV = Globals[i]; 842 843 // FIXME - In the short term, changes are too drastic to continue. 844 if (DebugInfoDesc::TagFromGlobal(GV) == Desc->getTag() && 845 DebugInfoDesc::VersionFromGlobal(GV) == LLVMDebugVersion) 846 AnchoredDescs.push_back(DR.Deserialize(GV)); 847 } 848} 849 850/// getGlobalVariablesUsing - Return all of the GlobalVariables that use the 851/// named GlobalVariable. 852void 853MachineModuleInfo::getGlobalVariablesUsing(Module &M, 854 const std::string &RootName, 855 std::vector<GlobalVariable*> &Globals) { 856 return ::getGlobalVariablesUsing(M, RootName, Globals); 857} 858 859/// RecordSourceLine - Records location information and associates it with a 860/// debug label. Returns a unique label ID used to generate a label and 861/// provide correspondence to the source line list. 862unsigned MachineModuleInfo::RecordSourceLine(unsigned Line, unsigned Column, 863 unsigned Source) { 864 unsigned ID = NextLabelID(); 865 Lines.push_back(SourceLineInfo(Line, Column, Source, ID)); 866 return ID; 867} 868 869/// RecordSource - Register a source file with debug info. Returns an source 870/// ID. 871unsigned MachineModuleInfo::RecordSource(const std::string &Directory, 872 const std::string &Source) { 873 unsigned DirectoryID = Directories.insert(Directory); 874 return SourceFiles.insert(SourceFileInfo(DirectoryID, Source)); 875} 876unsigned MachineModuleInfo::RecordSource(const CompileUnitDesc *CompileUnit) { 877 return RecordSource(CompileUnit->getDirectory(), 878 CompileUnit->getFileName()); 879} 880 881/// RecordRegionStart - Indicate the start of a region. 882/// 883unsigned MachineModuleInfo::RecordRegionStart(Value *V) { 884 // FIXME - need to be able to handle split scopes because of bb cloning. 885 DebugInfoDesc *ScopeDesc = DR.Deserialize(V); 886 DebugScope *Scope = getOrCreateScope(ScopeDesc); 887 unsigned ID = NextLabelID(); 888 if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID); 889 return ID; 890} 891 892/// RecordRegionEnd - Indicate the end of a region. 893/// 894unsigned MachineModuleInfo::RecordRegionEnd(Value *V) { 895 // FIXME - need to be able to handle split scopes because of bb cloning. 896 DebugInfoDesc *ScopeDesc = DR.Deserialize(V); 897 DebugScope *Scope = getOrCreateScope(ScopeDesc); 898 unsigned ID = NextLabelID(); 899 Scope->setEndLabelID(ID); 900 return ID; 901} 902 903/// RecordVariable - Indicate the declaration of a local variable. 904/// 905void MachineModuleInfo::RecordVariable(GlobalValue *GV, unsigned FrameIndex) { 906 VariableDesc *VD = cast<VariableDesc>(DR.Deserialize(GV)); 907 DebugScope *Scope = getOrCreateScope(VD->getContext()); 908 DebugVariable *DV = new DebugVariable(VD, FrameIndex); 909 Scope->AddVariable(DV); 910} 911 912/// getOrCreateScope - Returns the scope associated with the given descriptor. 913/// 914DebugScope *MachineModuleInfo::getOrCreateScope(DebugInfoDesc *ScopeDesc) { 915 DebugScope *&Slot = ScopeMap[ScopeDesc]; 916 if (!Slot) { 917 // FIXME - breaks down when the context is an inlined function. 918 DebugInfoDesc *ParentDesc = NULL; 919 if (BlockDesc *Block = dyn_cast<BlockDesc>(ScopeDesc)) { 920 ParentDesc = Block->getContext(); 921 } 922 DebugScope *Parent = ParentDesc ? getOrCreateScope(ParentDesc) : NULL; 923 Slot = new DebugScope(Parent, ScopeDesc); 924 if (Parent) { 925 Parent->AddScope(Slot); 926 } else if (RootScope) { 927 // FIXME - Add inlined function scopes to the root so we can delete 928 // them later. Long term, handle inlined functions properly. 929 RootScope->AddScope(Slot); 930 } else { 931 // First function is top level function. 932 RootScope = Slot; 933 } 934 } 935 return Slot; 936} 937 938//===-EH-------------------------------------------------------------------===// 939 940/// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the 941/// specified MachineBasicBlock. 942LandingPadInfo & 943MachineModuleInfo::getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad) { 944 unsigned N = LandingPads.size(); 945 946 for (unsigned i = 0; i < N; ++i) { 947 LandingPadInfo &LP = LandingPads[i]; 948 if (LP.LandingPadBlock == LandingPad) 949 return LP; 950 } 951 952 LandingPads.push_back(LandingPadInfo(LandingPad)); 953 return LandingPads[N]; 954} 955 956/// addInvoke - Provide the begin and end labels of an invoke style call and 957/// associate it with a try landing pad block. 958void MachineModuleInfo::addInvoke(MachineBasicBlock *LandingPad, 959 unsigned BeginLabel, unsigned EndLabel) { 960 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 961 LP.BeginLabels.push_back(BeginLabel); 962 LP.EndLabels.push_back(EndLabel); 963} 964 965/// addLandingPad - Provide the label of a try LandingPad block. 966/// 967unsigned MachineModuleInfo::addLandingPad(MachineBasicBlock *LandingPad) { 968 unsigned LandingPadLabel = NextLabelID(); 969 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 970 LP.LandingPadLabel = LandingPadLabel; 971 return LandingPadLabel; 972} 973 974/// addPersonality - Provide the personality function for the exception 975/// information. 976void MachineModuleInfo::addPersonality(MachineBasicBlock *LandingPad, 977 Function *Personality) { 978 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 979 LP.Personality = Personality; 980 981 for (unsigned i = 0, e = Personalities.size(); i < e; ++i) 982 if (Personalities[i] == Personality) 983 return; 984 985 Personalities.push_back(Personality); 986} 987 988/// addCatchTypeInfo - Provide the catch typeinfo for a landing pad. 989/// 990void MachineModuleInfo::addCatchTypeInfo(MachineBasicBlock *LandingPad, 991 std::vector<GlobalVariable *> &TyInfo) { 992 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 993 for (unsigned N = TyInfo.size(); N; --N) 994 LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1])); 995} 996 997/// addFilterTypeInfo - Provide the filter typeinfo for a landing pad. 998/// 999void MachineModuleInfo::addFilterTypeInfo(MachineBasicBlock *LandingPad, 1000 std::vector<GlobalVariable *> &TyInfo) { 1001 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 1002 unsigned TyInfoSize = TyInfo.size(); 1003 std::vector<unsigned> IdsInFilter(TyInfoSize); 1004 1005 for (unsigned I = 0; I != TyInfoSize; ++I) 1006 IdsInFilter[I] = getTypeIDFor(TyInfo[I]); 1007 1008 LP.TypeIds.push_back(getFilterIDFor(IdsInFilter)); 1009} 1010 1011/// addCleanup - Add a cleanup action for a landing pad. 1012/// 1013void MachineModuleInfo::addCleanup(MachineBasicBlock *LandingPad) { 1014 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 1015 LP.TypeIds.push_back(0); 1016} 1017 1018/// TidyLandingPads - Remap landing pad labels and remove any deleted landing 1019/// pads. 1020void MachineModuleInfo::TidyLandingPads() { 1021 for (unsigned i = 0; i != LandingPads.size(); ) { 1022 LandingPadInfo &LandingPad = LandingPads[i]; 1023 LandingPad.LandingPadLabel = MappedLabel(LandingPad.LandingPadLabel); 1024 1025 // Special case: we *should* emit LPs with null LP MBB. This indicates 1026 // "nounwind" case. 1027 if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) { 1028 LandingPads.erase(LandingPads.begin() + i); 1029 continue; 1030 } 1031 1032 for (unsigned j = 0; j != LandingPads[i].BeginLabels.size(); ) { 1033 unsigned BeginLabel = MappedLabel(LandingPad.BeginLabels[j]); 1034 unsigned EndLabel = MappedLabel(LandingPad.EndLabels[j]); 1035 1036 if (!BeginLabel || !EndLabel) { 1037 LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j); 1038 LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j); 1039 continue; 1040 } 1041 1042 LandingPad.BeginLabels[j] = BeginLabel; 1043 LandingPad.EndLabels[j] = EndLabel; 1044 ++j; 1045 } 1046 1047 // Remove landing pads with no try-ranges. 1048 if (LandingPads[i].BeginLabels.empty()) { 1049 LandingPads.erase(LandingPads.begin() + i); 1050 continue; 1051 } 1052 1053 // If there is no landing pad, ensure that the list of typeids is empty. 1054 // If the only typeid is a cleanup, this is the same as having no typeids. 1055 if (!LandingPad.LandingPadBlock || 1056 (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0])) 1057 LandingPad.TypeIds.clear(); 1058 1059 ++i; 1060 } 1061} 1062 1063/// getTypeIDFor - Return the type id for the specified typeinfo. This is 1064/// function wide. 1065unsigned MachineModuleInfo::getTypeIDFor(GlobalVariable *TI) { 1066 for (unsigned i = 0, e = TypeInfos.size(); i != e; ++i) 1067 if (TypeInfos[i] == TI) 1068 return i + 1; 1069 1070 TypeInfos.push_back(TI); 1071 return TypeInfos.size(); 1072} 1073 1074/// getFilterIDFor - Return the filter id for the specified typeinfos. This is 1075/// function wide. 1076int MachineModuleInfo::getFilterIDFor(std::vector<unsigned> &TyIds) { 1077 // If the new filter coincides with the tail of an existing filter, then 1078 // re-use the existing filter. Folding filters more than this requires 1079 // re-ordering filters and/or their elements - probably not worth it. 1080 for (std::vector<unsigned>::iterator I = FilterEnds.begin(), 1081 E = FilterEnds.end(); I != E; ++I) { 1082 unsigned i = *I, j = TyIds.size(); 1083 1084 while (i && j) 1085 if (FilterIds[--i] != TyIds[--j]) 1086 goto try_next; 1087 1088 if (!j) 1089 // The new filter coincides with range [i, end) of the existing filter. 1090 return -(1 + i); 1091 1092try_next:; 1093 } 1094 1095 // Add the new filter. 1096 int FilterID = -(1 + FilterIds.size()); 1097 FilterIds.reserve(FilterIds.size() + TyIds.size() + 1); 1098 1099 for (unsigned I = 0, N = TyIds.size(); I != N; ++I) 1100 FilterIds.push_back(TyIds[I]); 1101 1102 FilterEnds.push_back(FilterIds.size()); 1103 FilterIds.push_back(0); // terminator 1104 return FilterID; 1105} 1106 1107/// getPersonality - Return the personality function for the current function. 1108Function *MachineModuleInfo::getPersonality() const { 1109 // FIXME: Until PR1414 will be fixed, we're using 1 personality function per 1110 // function 1111 return !LandingPads.empty() ? LandingPads[0].Personality : NULL; 1112} 1113 1114/// getPersonalityIndex - Return unique index for current personality 1115/// function. NULL personality function should always get zero index. 1116unsigned MachineModuleInfo::getPersonalityIndex() const { 1117 const Function* Personality = NULL; 1118 1119 // Scan landing pads. If there is at least one non-NULL personality - use it. 1120 for (unsigned i = 0, e = LandingPads.size(); i != e; ++i) 1121 if (LandingPads[i].Personality) { 1122 Personality = LandingPads[i].Personality; 1123 break; 1124 } 1125 1126 for (unsigned i = 0, e = Personalities.size(); i < e; ++i) 1127 if (Personalities[i] == Personality) 1128 return i; 1129 1130 // This should never happen 1131 assert(0 && "Personality function should be set!"); 1132 return 0; 1133} 1134 1135//===----------------------------------------------------------------------===// 1136/// DebugLabelFolding pass - This pass prunes out redundant labels. This allows 1137/// a info consumer to determine if the range of two labels is empty, by seeing 1138/// if the labels map to the same reduced label. 1139 1140namespace llvm { 1141 1142struct DebugLabelFolder : public MachineFunctionPass { 1143 static char ID; 1144 DebugLabelFolder() : MachineFunctionPass((intptr_t)&ID) {} 1145 1146 virtual bool runOnMachineFunction(MachineFunction &MF); 1147 virtual const char *getPassName() const { return "Label Folder"; } 1148}; 1149 1150char DebugLabelFolder::ID = 0; 1151 1152bool DebugLabelFolder::runOnMachineFunction(MachineFunction &MF) { 1153 // Get machine module info. 1154 MachineModuleInfo *MMI = getAnalysisToUpdate<MachineModuleInfo>(); 1155 if (!MMI) return false; 1156 1157 // Track if change is made. 1158 bool MadeChange = false; 1159 // No prior label to begin. 1160 unsigned PriorLabel = 0; 1161 1162 // Iterate through basic blocks. 1163 for (MachineFunction::iterator BB = MF.begin(), E = MF.end(); 1164 BB != E; ++BB) { 1165 // Iterate through instructions. 1166 for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) { 1167 // Is it a label. 1168 if (I->isDebugLabel()) { 1169 // The label ID # is always operand #0, an immediate. 1170 unsigned NextLabel = I->getOperand(0).getImm(); 1171 1172 // If there was an immediate prior label. 1173 if (PriorLabel) { 1174 // Remap the current label to prior label. 1175 MMI->RemapLabel(NextLabel, PriorLabel); 1176 // Delete the current label. 1177 I = BB->erase(I); 1178 // Indicate a change has been made. 1179 MadeChange = true; 1180 continue; 1181 } else { 1182 // Start a new round. 1183 PriorLabel = NextLabel; 1184 } 1185 } else { 1186 // No consecutive labels. 1187 PriorLabel = 0; 1188 } 1189 1190 ++I; 1191 } 1192 } 1193 1194 return MadeChange; 1195} 1196 1197FunctionPass *createDebugLabelFoldingPass() { return new DebugLabelFolder(); } 1198 1199} 1200