1 //===-- Attributes.cpp - Implement AttributesList -------------------------===// 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 // \file 11 // \brief This file implements the Attribute, AttributeImpl, AttrBuilder, 12 // AttributeSetImpl, and AttributeSet classes. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/IR/Attributes.h" 17 #include "AttributeImpl.h" 18 #include "LLVMContextImpl.h" 19 #include "llvm/ADT/StringExtras.h" 20 #include "llvm/IR/Type.h" 21 #include "llvm/Support/Atomic.h" 22 #include "llvm/Support/Debug.h" 23 #include "llvm/Support/ManagedStatic.h" 24 #include "llvm/Support/Mutex.h" 25 #include "llvm/Support/raw_ostream.h" 26 #include <algorithm> 27 using namespace llvm; 28 29 //===----------------------------------------------------------------------===// 30 // Attribute Construction Methods 31 //===----------------------------------------------------------------------===// 32 33 Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind, 34 uint64_t Val) { 35 LLVMContextImpl *pImpl = Context.pImpl; 36 FoldingSetNodeID ID; 37 ID.AddInteger(Kind); 38 if (Val) ID.AddInteger(Val); 39 40 void *InsertPoint; 41 AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint); 42 43 if (!PA) { 44 // If we didn't find any existing attributes of the same shape then create a 45 // new one and insert it. 46 PA = !Val ? 47 new AttributeImpl(Context, Kind) : 48 new AttributeImpl(Context, Kind, Val); 49 pImpl->AttrsSet.InsertNode(PA, InsertPoint); 50 } 51 52 // Return the Attribute that we found or created. 53 return Attribute(PA); 54 } 55 56 Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) { 57 LLVMContextImpl *pImpl = Context.pImpl; 58 FoldingSetNodeID ID; 59 ID.AddString(Kind); 60 if (!Val.empty()) ID.AddString(Val); 61 62 void *InsertPoint; 63 AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint); 64 65 if (!PA) { 66 // If we didn't find any existing attributes of the same shape then create a 67 // new one and insert it. 68 PA = new AttributeImpl(Context, Kind, Val); 69 pImpl->AttrsSet.InsertNode(PA, InsertPoint); 70 } 71 72 // Return the Attribute that we found or created. 73 return Attribute(PA); 74 } 75 76 Attribute Attribute::getWithAlignment(LLVMContext &Context, uint64_t Align) { 77 assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); 78 assert(Align <= 0x40000000 && "Alignment too large."); 79 return get(Context, Alignment, Align); 80 } 81 82 Attribute Attribute::getWithStackAlignment(LLVMContext &Context, 83 uint64_t Align) { 84 assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); 85 assert(Align <= 0x100 && "Alignment too large."); 86 return get(Context, StackAlignment, Align); 87 } 88 89 //===----------------------------------------------------------------------===// 90 // Attribute Accessor Methods 91 //===----------------------------------------------------------------------===// 92 93 bool Attribute::isEnumAttribute() const { 94 return pImpl && pImpl->isEnumAttribute(); 95 } 96 97 bool Attribute::isAlignAttribute() const { 98 return pImpl && pImpl->isAlignAttribute(); 99 } 100 101 bool Attribute::isStringAttribute() const { 102 return pImpl && pImpl->isStringAttribute(); 103 } 104 105 Attribute::AttrKind Attribute::getKindAsEnum() const { 106 assert((isEnumAttribute() || isAlignAttribute()) && 107 "Invalid attribute type to get the kind as an enum!"); 108 return pImpl ? pImpl->getKindAsEnum() : None; 109 } 110 111 uint64_t Attribute::getValueAsInt() const { 112 assert(isAlignAttribute() && 113 "Expected the attribute to be an alignment attribute!"); 114 return pImpl ? pImpl->getValueAsInt() : 0; 115 } 116 117 StringRef Attribute::getKindAsString() const { 118 assert(isStringAttribute() && 119 "Invalid attribute type to get the kind as a string!"); 120 return pImpl ? pImpl->getKindAsString() : StringRef(); 121 } 122 123 StringRef Attribute::getValueAsString() const { 124 assert(isStringAttribute() && 125 "Invalid attribute type to get the value as a string!"); 126 return pImpl ? pImpl->getValueAsString() : StringRef(); 127 } 128 129 bool Attribute::hasAttribute(AttrKind Kind) const { 130 return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None); 131 } 132 133 bool Attribute::hasAttribute(StringRef Kind) const { 134 if (!isStringAttribute()) return false; 135 return pImpl && pImpl->hasAttribute(Kind); 136 } 137 138 /// This returns the alignment field of an attribute as a byte alignment value. 139 unsigned Attribute::getAlignment() const { 140 assert(hasAttribute(Attribute::Alignment) && 141 "Trying to get alignment from non-alignment attribute!"); 142 return pImpl->getValueAsInt(); 143 } 144 145 /// This returns the stack alignment field of an attribute as a byte alignment 146 /// value. 147 unsigned Attribute::getStackAlignment() const { 148 assert(hasAttribute(Attribute::StackAlignment) && 149 "Trying to get alignment from non-alignment attribute!"); 150 return pImpl->getValueAsInt(); 151 } 152 153 std::string Attribute::getAsString(bool InAttrGrp) const { 154 if (!pImpl) return ""; 155 156 if (hasAttribute(Attribute::SanitizeAddress)) 157 return "sanitize_address"; 158 if (hasAttribute(Attribute::AlwaysInline)) 159 return "alwaysinline"; 160 if (hasAttribute(Attribute::ByVal)) 161 return "byval"; 162 if (hasAttribute(Attribute::InlineHint)) 163 return "inlinehint"; 164 if (hasAttribute(Attribute::InReg)) 165 return "inreg"; 166 if (hasAttribute(Attribute::MinSize)) 167 return "minsize"; 168 if (hasAttribute(Attribute::Naked)) 169 return "naked"; 170 if (hasAttribute(Attribute::Nest)) 171 return "nest"; 172 if (hasAttribute(Attribute::NoAlias)) 173 return "noalias"; 174 if (hasAttribute(Attribute::NoBuiltin)) 175 return "nobuiltin"; 176 if (hasAttribute(Attribute::NoCapture)) 177 return "nocapture"; 178 if (hasAttribute(Attribute::NoDuplicate)) 179 return "noduplicate"; 180 if (hasAttribute(Attribute::NoImplicitFloat)) 181 return "noimplicitfloat"; 182 if (hasAttribute(Attribute::NoInline)) 183 return "noinline"; 184 if (hasAttribute(Attribute::NonLazyBind)) 185 return "nonlazybind"; 186 if (hasAttribute(Attribute::NoRedZone)) 187 return "noredzone"; 188 if (hasAttribute(Attribute::NoReturn)) 189 return "noreturn"; 190 if (hasAttribute(Attribute::NoUnwind)) 191 return "nounwind"; 192 if (hasAttribute(Attribute::OptimizeForSize)) 193 return "optsize"; 194 if (hasAttribute(Attribute::ReadNone)) 195 return "readnone"; 196 if (hasAttribute(Attribute::ReadOnly)) 197 return "readonly"; 198 if (hasAttribute(Attribute::ReturnsTwice)) 199 return "returns_twice"; 200 if (hasAttribute(Attribute::SExt)) 201 return "signext"; 202 if (hasAttribute(Attribute::StackProtect)) 203 return "ssp"; 204 if (hasAttribute(Attribute::StackProtectReq)) 205 return "sspreq"; 206 if (hasAttribute(Attribute::StackProtectStrong)) 207 return "sspstrong"; 208 if (hasAttribute(Attribute::StructRet)) 209 return "sret"; 210 if (hasAttribute(Attribute::SanitizeThread)) 211 return "sanitize_thread"; 212 if (hasAttribute(Attribute::SanitizeMemory)) 213 return "sanitize_memory"; 214 if (hasAttribute(Attribute::UWTable)) 215 return "uwtable"; 216 if (hasAttribute(Attribute::ZExt)) 217 return "zeroext"; 218 219 // FIXME: These should be output like this: 220 // 221 // align=4 222 // alignstack=8 223 // 224 if (hasAttribute(Attribute::Alignment)) { 225 std::string Result; 226 Result += "align"; 227 Result += (InAttrGrp) ? "=" : " "; 228 Result += utostr(getValueAsInt()); 229 return Result; 230 } 231 232 if (hasAttribute(Attribute::StackAlignment)) { 233 std::string Result; 234 Result += "alignstack"; 235 if (InAttrGrp) { 236 Result += "="; 237 Result += utostr(getValueAsInt()); 238 } else { 239 Result += "("; 240 Result += utostr(getValueAsInt()); 241 Result += ")"; 242 } 243 return Result; 244 } 245 246 // Convert target-dependent attributes to strings of the form: 247 // 248 // "kind" 249 // "kind" = "value" 250 // 251 if (isStringAttribute()) { 252 std::string Result; 253 Result += '\"' + getKindAsString().str() + '"'; 254 255 StringRef Val = pImpl->getValueAsString(); 256 if (Val.empty()) return Result; 257 258 Result += "=\"" + Val.str() + '"'; 259 return Result; 260 } 261 262 llvm_unreachable("Unknown attribute"); 263 } 264 265 bool Attribute::operator<(Attribute A) const { 266 if (!pImpl && !A.pImpl) return false; 267 if (!pImpl) return true; 268 if (!A.pImpl) return false; 269 return *pImpl < *A.pImpl; 270 } 271 272 //===----------------------------------------------------------------------===// 273 // AttributeImpl Definition 274 //===----------------------------------------------------------------------===// 275 276 AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind) 277 : Context(C), Entry(new EnumAttributeEntry(Kind)) {} 278 279 AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind, 280 unsigned Align) 281 : Context(C) { 282 assert((Kind == Attribute::Alignment || Kind == Attribute::StackAlignment) && 283 "Wrong kind for alignment attribute!"); 284 Entry = new AlignAttributeEntry(Kind, Align); 285 } 286 287 AttributeImpl::AttributeImpl(LLVMContext &C, StringRef Kind, StringRef Val) 288 : Context(C), Entry(new StringAttributeEntry(Kind, Val)) {} 289 290 AttributeImpl::~AttributeImpl() { 291 delete Entry; 292 } 293 294 bool AttributeImpl::isEnumAttribute() const { 295 return isa<EnumAttributeEntry>(Entry); 296 } 297 298 bool AttributeImpl::isAlignAttribute() const { 299 return isa<AlignAttributeEntry>(Entry); 300 } 301 302 bool AttributeImpl::isStringAttribute() const { 303 return isa<StringAttributeEntry>(Entry); 304 } 305 306 bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const { 307 if (isStringAttribute()) return false; 308 return getKindAsEnum() == A; 309 } 310 311 bool AttributeImpl::hasAttribute(StringRef Kind) const { 312 if (!isStringAttribute()) return false; 313 return getKindAsString() == Kind; 314 } 315 316 Attribute::AttrKind AttributeImpl::getKindAsEnum() const { 317 if (EnumAttributeEntry *E = dyn_cast<EnumAttributeEntry>(Entry)) 318 return E->getEnumKind(); 319 return cast<AlignAttributeEntry>(Entry)->getEnumKind(); 320 } 321 322 uint64_t AttributeImpl::getValueAsInt() const { 323 return cast<AlignAttributeEntry>(Entry)->getAlignment(); 324 } 325 326 StringRef AttributeImpl::getKindAsString() const { 327 return cast<StringAttributeEntry>(Entry)->getStringKind(); 328 } 329 330 StringRef AttributeImpl::getValueAsString() const { 331 return cast<StringAttributeEntry>(Entry)->getStringValue(); 332 } 333 334 bool AttributeImpl::operator<(const AttributeImpl &AI) const { 335 // This sorts the attributes with Attribute::AttrKinds coming first (sorted 336 // relative to their enum value) and then strings. 337 if (isEnumAttribute()) { 338 if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum(); 339 if (AI.isAlignAttribute()) return true; 340 if (AI.isStringAttribute()) return true; 341 } 342 343 if (isAlignAttribute()) { 344 if (AI.isEnumAttribute()) return false; 345 if (AI.isAlignAttribute()) return getValueAsInt() < AI.getValueAsInt(); 346 if (AI.isStringAttribute()) return true; 347 } 348 349 if (AI.isEnumAttribute()) return false; 350 if (AI.isAlignAttribute()) return false; 351 if (getKindAsString() == AI.getKindAsString()) 352 return getValueAsString() < AI.getValueAsString(); 353 return getKindAsString() < AI.getKindAsString(); 354 } 355 356 uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) { 357 // FIXME: Remove this. 358 switch (Val) { 359 case Attribute::EndAttrKinds: 360 llvm_unreachable("Synthetic enumerators which should never get here"); 361 362 case Attribute::None: return 0; 363 case Attribute::ZExt: return 1 << 0; 364 case Attribute::SExt: return 1 << 1; 365 case Attribute::NoReturn: return 1 << 2; 366 case Attribute::InReg: return 1 << 3; 367 case Attribute::StructRet: return 1 << 4; 368 case Attribute::NoUnwind: return 1 << 5; 369 case Attribute::NoAlias: return 1 << 6; 370 case Attribute::ByVal: return 1 << 7; 371 case Attribute::Nest: return 1 << 8; 372 case Attribute::ReadNone: return 1 << 9; 373 case Attribute::ReadOnly: return 1 << 10; 374 case Attribute::NoInline: return 1 << 11; 375 case Attribute::AlwaysInline: return 1 << 12; 376 case Attribute::OptimizeForSize: return 1 << 13; 377 case Attribute::StackProtect: return 1 << 14; 378 case Attribute::StackProtectReq: return 1 << 15; 379 case Attribute::Alignment: return 31 << 16; 380 case Attribute::NoCapture: return 1 << 21; 381 case Attribute::NoRedZone: return 1 << 22; 382 case Attribute::NoImplicitFloat: return 1 << 23; 383 case Attribute::Naked: return 1 << 24; 384 case Attribute::InlineHint: return 1 << 25; 385 case Attribute::StackAlignment: return 7 << 26; 386 case Attribute::ReturnsTwice: return 1 << 29; 387 case Attribute::UWTable: return 1 << 30; 388 case Attribute::NonLazyBind: return 1U << 31; 389 case Attribute::SanitizeAddress: return 1ULL << 32; 390 case Attribute::MinSize: return 1ULL << 33; 391 case Attribute::NoDuplicate: return 1ULL << 34; 392 case Attribute::StackProtectStrong: return 1ULL << 35; 393 case Attribute::SanitizeThread: return 1ULL << 36; 394 case Attribute::SanitizeMemory: return 1ULL << 37; 395 case Attribute::NoBuiltin: return 1ULL << 38; 396 } 397 llvm_unreachable("Unsupported attribute type"); 398 } 399 400 //===----------------------------------------------------------------------===// 401 // AttributeSetNode Definition 402 //===----------------------------------------------------------------------===// 403 404 AttributeSetNode *AttributeSetNode::get(LLVMContext &C, 405 ArrayRef<Attribute> Attrs) { 406 if (Attrs.empty()) 407 return 0; 408 409 // Otherwise, build a key to look up the existing attributes. 410 LLVMContextImpl *pImpl = C.pImpl; 411 FoldingSetNodeID ID; 412 413 SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end()); 414 array_pod_sort(SortedAttrs.begin(), SortedAttrs.end()); 415 416 for (SmallVectorImpl<Attribute>::iterator I = SortedAttrs.begin(), 417 E = SortedAttrs.end(); I != E; ++I) 418 I->Profile(ID); 419 420 void *InsertPoint; 421 AttributeSetNode *PA = 422 pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint); 423 424 // If we didn't find any existing attributes of the same shape then create a 425 // new one and insert it. 426 if (!PA) { 427 PA = new AttributeSetNode(SortedAttrs); 428 pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint); 429 } 430 431 // Return the AttributesListNode that we found or created. 432 return PA; 433 } 434 435 bool AttributeSetNode::hasAttribute(Attribute::AttrKind Kind) const { 436 for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(), 437 E = AttrList.end(); I != E; ++I) 438 if (I->hasAttribute(Kind)) 439 return true; 440 return false; 441 } 442 443 bool AttributeSetNode::hasAttribute(StringRef Kind) const { 444 for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(), 445 E = AttrList.end(); I != E; ++I) 446 if (I->hasAttribute(Kind)) 447 return true; 448 return false; 449 } 450 451 Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const { 452 for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(), 453 E = AttrList.end(); I != E; ++I) 454 if (I->hasAttribute(Kind)) 455 return *I; 456 return Attribute(); 457 } 458 459 Attribute AttributeSetNode::getAttribute(StringRef Kind) const { 460 for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(), 461 E = AttrList.end(); I != E; ++I) 462 if (I->hasAttribute(Kind)) 463 return *I; 464 return Attribute(); 465 } 466 467 unsigned AttributeSetNode::getAlignment() const { 468 for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(), 469 E = AttrList.end(); I != E; ++I) 470 if (I->hasAttribute(Attribute::Alignment)) 471 return I->getAlignment(); 472 return 0; 473 } 474 475 unsigned AttributeSetNode::getStackAlignment() const { 476 for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(), 477 E = AttrList.end(); I != E; ++I) 478 if (I->hasAttribute(Attribute::StackAlignment)) 479 return I->getStackAlignment(); 480 return 0; 481 } 482 483 std::string AttributeSetNode::getAsString(bool InAttrGrp) const { 484 std::string Str = ""; 485 for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(), 486 E = AttrList.end(); I != E; ) { 487 Str += I->getAsString(InAttrGrp); 488 if (++I != E) Str += " "; 489 } 490 return Str; 491 } 492 493 //===----------------------------------------------------------------------===// 494 // AttributeSetImpl Definition 495 //===----------------------------------------------------------------------===// 496 497 uint64_t AttributeSetImpl::Raw(uint64_t Index) const { 498 for (unsigned I = 0, E = getNumAttributes(); I != E; ++I) { 499 if (getSlotIndex(I) != Index) continue; 500 const AttributeSetNode *ASN = AttrNodes[I].second; 501 uint64_t Mask = 0; 502 503 for (AttributeSetNode::const_iterator II = ASN->begin(), 504 IE = ASN->end(); II != IE; ++II) { 505 Attribute Attr = *II; 506 507 // This cannot handle string attributes. 508 if (Attr.isStringAttribute()) continue; 509 510 Attribute::AttrKind Kind = Attr.getKindAsEnum(); 511 512 if (Kind == Attribute::Alignment) 513 Mask |= (Log2_32(ASN->getAlignment()) + 1) << 16; 514 else if (Kind == Attribute::StackAlignment) 515 Mask |= (Log2_32(ASN->getStackAlignment()) + 1) << 26; 516 else 517 Mask |= AttributeImpl::getAttrMask(Kind); 518 } 519 520 return Mask; 521 } 522 523 return 0; 524 } 525 526 //===----------------------------------------------------------------------===// 527 // AttributeSet Construction and Mutation Methods 528 //===----------------------------------------------------------------------===// 529 530 AttributeSet 531 AttributeSet::getImpl(LLVMContext &C, 532 ArrayRef<std::pair<unsigned, AttributeSetNode*> > Attrs) { 533 LLVMContextImpl *pImpl = C.pImpl; 534 FoldingSetNodeID ID; 535 AttributeSetImpl::Profile(ID, Attrs); 536 537 void *InsertPoint; 538 AttributeSetImpl *PA = pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint); 539 540 // If we didn't find any existing attributes of the same shape then 541 // create a new one and insert it. 542 if (!PA) { 543 PA = new AttributeSetImpl(C, Attrs); 544 pImpl->AttrsLists.InsertNode(PA, InsertPoint); 545 } 546 547 // Return the AttributesList that we found or created. 548 return AttributeSet(PA); 549 } 550 551 AttributeSet AttributeSet::get(LLVMContext &C, 552 ArrayRef<std::pair<unsigned, Attribute> > Attrs){ 553 // If there are no attributes then return a null AttributesList pointer. 554 if (Attrs.empty()) 555 return AttributeSet(); 556 557 #ifndef NDEBUG 558 for (unsigned i = 0, e = Attrs.size(); i != e; ++i) { 559 assert((!i || Attrs[i-1].first <= Attrs[i].first) && 560 "Misordered Attributes list!"); 561 assert(!Attrs[i].second.hasAttribute(Attribute::None) && 562 "Pointless attribute!"); 563 } 564 #endif 565 566 // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes 567 // list. 568 SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrPairVec; 569 for (ArrayRef<std::pair<unsigned, Attribute> >::iterator I = Attrs.begin(), 570 E = Attrs.end(); I != E; ) { 571 unsigned Index = I->first; 572 SmallVector<Attribute, 4> AttrVec; 573 while (I != E && I->first == Index) { 574 AttrVec.push_back(I->second); 575 ++I; 576 } 577 578 AttrPairVec.push_back(std::make_pair(Index, 579 AttributeSetNode::get(C, AttrVec))); 580 } 581 582 return getImpl(C, AttrPairVec); 583 } 584 585 AttributeSet AttributeSet::get(LLVMContext &C, 586 ArrayRef<std::pair<unsigned, 587 AttributeSetNode*> > Attrs) { 588 // If there are no attributes then return a null AttributesList pointer. 589 if (Attrs.empty()) 590 return AttributeSet(); 591 592 return getImpl(C, Attrs); 593 } 594 595 AttributeSet AttributeSet::get(LLVMContext &C, unsigned Idx, AttrBuilder &B) { 596 if (!B.hasAttributes()) 597 return AttributeSet(); 598 599 // Add target-independent attributes. 600 SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; 601 for (Attribute::AttrKind Kind = Attribute::None; 602 Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) { 603 if (!B.contains(Kind)) 604 continue; 605 606 if (Kind == Attribute::Alignment) 607 Attrs.push_back(std::make_pair(Idx, Attribute:: 608 getWithAlignment(C, B.getAlignment()))); 609 else if (Kind == Attribute::StackAlignment) 610 Attrs.push_back(std::make_pair(Idx, Attribute:: 611 getWithStackAlignment(C, B.getStackAlignment()))); 612 else 613 Attrs.push_back(std::make_pair(Idx, Attribute::get(C, Kind))); 614 } 615 616 // Add target-dependent (string) attributes. 617 for (AttrBuilder::td_iterator I = B.td_begin(), E = B.td_end(); 618 I != E; ++I) 619 Attrs.push_back(std::make_pair(Idx, Attribute::get(C, I->first,I->second))); 620 621 return get(C, Attrs); 622 } 623 624 AttributeSet AttributeSet::get(LLVMContext &C, unsigned Idx, 625 ArrayRef<Attribute::AttrKind> Kind) { 626 SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; 627 for (ArrayRef<Attribute::AttrKind>::iterator I = Kind.begin(), 628 E = Kind.end(); I != E; ++I) 629 Attrs.push_back(std::make_pair(Idx, Attribute::get(C, *I))); 630 return get(C, Attrs); 631 } 632 633 AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<AttributeSet> Attrs) { 634 if (Attrs.empty()) return AttributeSet(); 635 636 SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrNodeVec; 637 for (unsigned I = 0, E = Attrs.size(); I != E; ++I) { 638 AttributeSet AS = Attrs[I]; 639 if (!AS.pImpl) continue; 640 AttrNodeVec.append(AS.pImpl->AttrNodes.begin(), AS.pImpl->AttrNodes.end()); 641 } 642 643 return getImpl(C, AttrNodeVec); 644 } 645 646 AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Idx, 647 Attribute::AttrKind Attr) const { 648 if (hasAttribute(Idx, Attr)) return *this; 649 return addAttributes(C, Idx, AttributeSet::get(C, Idx, Attr)); 650 } 651 652 AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Idx, 653 StringRef Kind) const { 654 llvm::AttrBuilder B; 655 B.addAttribute(Kind); 656 return addAttributes(C, Idx, AttributeSet::get(C, Idx, B)); 657 } 658 659 AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Idx, 660 AttributeSet Attrs) const { 661 if (!pImpl) return Attrs; 662 if (!Attrs.pImpl) return *this; 663 664 #ifndef NDEBUG 665 // FIXME it is not obvious how this should work for alignment. For now, say 666 // we can't change a known alignment. 667 unsigned OldAlign = getParamAlignment(Idx); 668 unsigned NewAlign = Attrs.getParamAlignment(Idx); 669 assert((!OldAlign || !NewAlign || OldAlign == NewAlign) && 670 "Attempt to change alignment!"); 671 #endif 672 673 // Add the attribute slots before the one we're trying to add. 674 SmallVector<AttributeSet, 4> AttrSet; 675 uint64_t NumAttrs = pImpl->getNumAttributes(); 676 AttributeSet AS; 677 uint64_t LastIndex = 0; 678 for (unsigned I = 0, E = NumAttrs; I != E; ++I) { 679 if (getSlotIndex(I) >= Idx) { 680 if (getSlotIndex(I) == Idx) AS = getSlotAttributes(LastIndex++); 681 break; 682 } 683 LastIndex = I + 1; 684 AttrSet.push_back(getSlotAttributes(I)); 685 } 686 687 // Now add the attribute into the correct slot. There may already be an 688 // AttributeSet there. 689 AttrBuilder B(AS, Idx); 690 691 for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I) 692 if (Attrs.getSlotIndex(I) == Idx) { 693 for (AttributeSetImpl::const_iterator II = Attrs.pImpl->begin(I), 694 IE = Attrs.pImpl->end(I); II != IE; ++II) 695 B.addAttribute(*II); 696 break; 697 } 698 699 AttrSet.push_back(AttributeSet::get(C, Idx, B)); 700 701 // Add the remaining attribute slots. 702 for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I) 703 AttrSet.push_back(getSlotAttributes(I)); 704 705 return get(C, AttrSet); 706 } 707 708 AttributeSet AttributeSet::removeAttribute(LLVMContext &C, unsigned Idx, 709 Attribute::AttrKind Attr) const { 710 if (!hasAttribute(Idx, Attr)) return *this; 711 return removeAttributes(C, Idx, AttributeSet::get(C, Idx, Attr)); 712 } 713 714 AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Idx, 715 AttributeSet Attrs) const { 716 if (!pImpl) return AttributeSet(); 717 if (!Attrs.pImpl) return *this; 718 719 #ifndef NDEBUG 720 // FIXME it is not obvious how this should work for alignment. 721 // For now, say we can't pass in alignment, which no current use does. 722 assert(!Attrs.hasAttribute(Idx, Attribute::Alignment) && 723 "Attempt to change alignment!"); 724 #endif 725 726 // Add the attribute slots before the one we're trying to add. 727 SmallVector<AttributeSet, 4> AttrSet; 728 uint64_t NumAttrs = pImpl->getNumAttributes(); 729 AttributeSet AS; 730 uint64_t LastIndex = 0; 731 for (unsigned I = 0, E = NumAttrs; I != E; ++I) { 732 if (getSlotIndex(I) >= Idx) { 733 if (getSlotIndex(I) == Idx) AS = getSlotAttributes(LastIndex++); 734 break; 735 } 736 LastIndex = I + 1; 737 AttrSet.push_back(getSlotAttributes(I)); 738 } 739 740 // Now remove the attribute from the correct slot. There may already be an 741 // AttributeSet there. 742 AttrBuilder B(AS, Idx); 743 744 for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I) 745 if (Attrs.getSlotIndex(I) == Idx) { 746 B.removeAttributes(Attrs.pImpl->getSlotAttributes(I), Idx); 747 break; 748 } 749 750 AttrSet.push_back(AttributeSet::get(C, Idx, B)); 751 752 // Add the remaining attribute slots. 753 for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I) 754 AttrSet.push_back(getSlotAttributes(I)); 755 756 return get(C, AttrSet); 757 } 758 759 //===----------------------------------------------------------------------===// 760 // AttributeSet Accessor Methods 761 //===----------------------------------------------------------------------===// 762 763 LLVMContext &AttributeSet::getContext() const { 764 return pImpl->getContext(); 765 } 766 767 AttributeSet AttributeSet::getParamAttributes(unsigned Idx) const { 768 return pImpl && hasAttributes(Idx) ? 769 AttributeSet::get(pImpl->getContext(), 770 ArrayRef<std::pair<unsigned, AttributeSetNode*> >( 771 std::make_pair(Idx, getAttributes(Idx)))) : 772 AttributeSet(); 773 } 774 775 AttributeSet AttributeSet::getRetAttributes() const { 776 return pImpl && hasAttributes(ReturnIndex) ? 777 AttributeSet::get(pImpl->getContext(), 778 ArrayRef<std::pair<unsigned, AttributeSetNode*> >( 779 std::make_pair(ReturnIndex, 780 getAttributes(ReturnIndex)))) : 781 AttributeSet(); 782 } 783 784 AttributeSet AttributeSet::getFnAttributes() const { 785 return pImpl && hasAttributes(FunctionIndex) ? 786 AttributeSet::get(pImpl->getContext(), 787 ArrayRef<std::pair<unsigned, AttributeSetNode*> >( 788 std::make_pair(FunctionIndex, 789 getAttributes(FunctionIndex)))) : 790 AttributeSet(); 791 } 792 793 bool AttributeSet::hasAttribute(unsigned Index, Attribute::AttrKind Kind) const{ 794 AttributeSetNode *ASN = getAttributes(Index); 795 return ASN ? ASN->hasAttribute(Kind) : false; 796 } 797 798 bool AttributeSet::hasAttribute(unsigned Index, StringRef Kind) const { 799 AttributeSetNode *ASN = getAttributes(Index); 800 return ASN ? ASN->hasAttribute(Kind) : false; 801 } 802 803 bool AttributeSet::hasAttributes(unsigned Index) const { 804 AttributeSetNode *ASN = getAttributes(Index); 805 return ASN ? ASN->hasAttributes() : false; 806 } 807 808 /// \brief Return true if the specified attribute is set for at least one 809 /// parameter or for the return value. 810 bool AttributeSet::hasAttrSomewhere(Attribute::AttrKind Attr) const { 811 if (pImpl == 0) return false; 812 813 for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) 814 for (AttributeSetImpl::const_iterator II = pImpl->begin(I), 815 IE = pImpl->end(I); II != IE; ++II) 816 if (II->hasAttribute(Attr)) 817 return true; 818 819 return false; 820 } 821 822 Attribute AttributeSet::getAttribute(unsigned Index, 823 Attribute::AttrKind Kind) const { 824 AttributeSetNode *ASN = getAttributes(Index); 825 return ASN ? ASN->getAttribute(Kind) : Attribute(); 826 } 827 828 Attribute AttributeSet::getAttribute(unsigned Index, 829 StringRef Kind) const { 830 AttributeSetNode *ASN = getAttributes(Index); 831 return ASN ? ASN->getAttribute(Kind) : Attribute(); 832 } 833 834 unsigned AttributeSet::getParamAlignment(unsigned Index) const { 835 AttributeSetNode *ASN = getAttributes(Index); 836 return ASN ? ASN->getAlignment() : 0; 837 } 838 839 unsigned AttributeSet::getStackAlignment(unsigned Index) const { 840 AttributeSetNode *ASN = getAttributes(Index); 841 return ASN ? ASN->getStackAlignment() : 0; 842 } 843 844 std::string AttributeSet::getAsString(unsigned Index, 845 bool InAttrGrp) const { 846 AttributeSetNode *ASN = getAttributes(Index); 847 return ASN ? ASN->getAsString(InAttrGrp) : std::string(""); 848 } 849 850 /// \brief The attributes for the specified index are returned. 851 AttributeSetNode *AttributeSet::getAttributes(unsigned Idx) const { 852 if (!pImpl) return 0; 853 854 // Loop through to find the attribute node we want. 855 for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) 856 if (pImpl->getSlotIndex(I) == Idx) 857 return pImpl->getSlotNode(I); 858 859 return 0; 860 } 861 862 AttributeSet::iterator AttributeSet::begin(unsigned Idx) const { 863 if (!pImpl) 864 return ArrayRef<Attribute>().begin(); 865 return pImpl->begin(Idx); 866 } 867 868 AttributeSet::iterator AttributeSet::end(unsigned Idx) const { 869 if (!pImpl) 870 return ArrayRef<Attribute>().end(); 871 return pImpl->end(Idx); 872 } 873 874 //===----------------------------------------------------------------------===// 875 // AttributeSet Introspection Methods 876 //===----------------------------------------------------------------------===// 877 878 /// \brief Return the number of slots used in this attribute list. This is the 879 /// number of arguments that have an attribute set on them (including the 880 /// function itself). 881 unsigned AttributeSet::getNumSlots() const { 882 return pImpl ? pImpl->getNumAttributes() : 0; 883 } 884 885 uint64_t AttributeSet::getSlotIndex(unsigned Slot) const { 886 assert(pImpl && Slot < pImpl->getNumAttributes() && 887 "Slot # out of range!"); 888 return pImpl->getSlotIndex(Slot); 889 } 890 891 AttributeSet AttributeSet::getSlotAttributes(unsigned Slot) const { 892 assert(pImpl && Slot < pImpl->getNumAttributes() && 893 "Slot # out of range!"); 894 return pImpl->getSlotAttributes(Slot); 895 } 896 897 uint64_t AttributeSet::Raw(unsigned Index) const { 898 // FIXME: Remove this. 899 return pImpl ? pImpl->Raw(Index) : 0; 900 } 901 902 void AttributeSet::dump() const { 903 dbgs() << "PAL[\n"; 904 905 for (unsigned i = 0, e = getNumSlots(); i < e; ++i) { 906 uint64_t Index = getSlotIndex(i); 907 dbgs() << " { "; 908 if (Index == ~0U) 909 dbgs() << "~0U"; 910 else 911 dbgs() << Index; 912 dbgs() << " => " << getAsString(Index) << " }\n"; 913 } 914 915 dbgs() << "]\n"; 916 } 917 918 //===----------------------------------------------------------------------===// 919 // AttrBuilder Method Implementations 920 //===----------------------------------------------------------------------===// 921 922 AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Idx) 923 : Attrs(0), Alignment(0), StackAlignment(0) { 924 AttributeSetImpl *pImpl = AS.pImpl; 925 if (!pImpl) return; 926 927 for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) { 928 if (pImpl->getSlotIndex(I) != Idx) continue; 929 930 for (AttributeSetImpl::const_iterator II = pImpl->begin(I), 931 IE = pImpl->end(I); II != IE; ++II) 932 addAttribute(*II); 933 934 break; 935 } 936 } 937 938 void AttrBuilder::clear() { 939 Attrs.reset(); 940 Alignment = StackAlignment = 0; 941 } 942 943 AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) { 944 assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!"); 945 assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment && 946 "Adding alignment attribute without adding alignment value!"); 947 Attrs[Val] = true; 948 return *this; 949 } 950 951 AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) { 952 if (Attr.isStringAttribute()) { 953 addAttribute(Attr.getKindAsString(), Attr.getValueAsString()); 954 return *this; 955 } 956 957 Attribute::AttrKind Kind = Attr.getKindAsEnum(); 958 Attrs[Kind] = true; 959 960 if (Kind == Attribute::Alignment) 961 Alignment = Attr.getAlignment(); 962 else if (Kind == Attribute::StackAlignment) 963 StackAlignment = Attr.getStackAlignment(); 964 return *this; 965 } 966 967 AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) { 968 TargetDepAttrs[A] = V; 969 return *this; 970 } 971 972 AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) { 973 assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!"); 974 Attrs[Val] = false; 975 976 if (Val == Attribute::Alignment) 977 Alignment = 0; 978 else if (Val == Attribute::StackAlignment) 979 StackAlignment = 0; 980 981 return *this; 982 } 983 984 AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) { 985 unsigned Idx = ~0U; 986 for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I) 987 if (A.getSlotIndex(I) == Index) { 988 Idx = I; 989 break; 990 } 991 992 assert(Idx != ~0U && "Couldn't find index in AttributeSet!"); 993 994 for (AttributeSet::iterator I = A.begin(Idx), E = A.end(Idx); I != E; ++I) { 995 Attribute Attr = *I; 996 if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) { 997 Attribute::AttrKind Kind = I->getKindAsEnum(); 998 Attrs[Kind] = false; 999 1000 if (Kind == Attribute::Alignment) 1001 Alignment = 0; 1002 else if (Kind == Attribute::StackAlignment) 1003 StackAlignment = 0; 1004 } else { 1005 assert(Attr.isStringAttribute() && "Invalid attribute type!"); 1006 std::map<std::string, std::string>::iterator 1007 Iter = TargetDepAttrs.find(Attr.getKindAsString()); 1008 if (Iter != TargetDepAttrs.end()) 1009 TargetDepAttrs.erase(Iter); 1010 } 1011 } 1012 1013 return *this; 1014 } 1015 1016 AttrBuilder &AttrBuilder::removeAttribute(StringRef A) { 1017 std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(A); 1018 if (I != TargetDepAttrs.end()) 1019 TargetDepAttrs.erase(I); 1020 return *this; 1021 } 1022 1023 AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) { 1024 if (Align == 0) return *this; 1025 1026 assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); 1027 assert(Align <= 0x40000000 && "Alignment too large."); 1028 1029 Attrs[Attribute::Alignment] = true; 1030 Alignment = Align; 1031 return *this; 1032 } 1033 1034 AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) { 1035 // Default alignment, allow the target to define how to align it. 1036 if (Align == 0) return *this; 1037 1038 assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); 1039 assert(Align <= 0x100 && "Alignment too large."); 1040 1041 Attrs[Attribute::StackAlignment] = true; 1042 StackAlignment = Align; 1043 return *this; 1044 } 1045 1046 AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) { 1047 // FIXME: What if both have alignments, but they don't match?! 1048 if (!Alignment) 1049 Alignment = B.Alignment; 1050 1051 if (!StackAlignment) 1052 StackAlignment = B.StackAlignment; 1053 1054 Attrs |= B.Attrs; 1055 1056 for (td_const_iterator I = B.TargetDepAttrs.begin(), 1057 E = B.TargetDepAttrs.end(); I != E; ++I) 1058 TargetDepAttrs[I->first] = I->second; 1059 1060 return *this; 1061 } 1062 1063 bool AttrBuilder::contains(StringRef A) const { 1064 return TargetDepAttrs.find(A) != TargetDepAttrs.end(); 1065 } 1066 1067 bool AttrBuilder::hasAttributes() const { 1068 return !Attrs.none() || !TargetDepAttrs.empty(); 1069 } 1070 1071 bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const { 1072 unsigned Idx = ~0U; 1073 for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I) 1074 if (A.getSlotIndex(I) == Index) { 1075 Idx = I; 1076 break; 1077 } 1078 1079 assert(Idx != ~0U && "Couldn't find the index!"); 1080 1081 for (AttributeSet::iterator I = A.begin(Idx), E = A.end(Idx); 1082 I != E; ++I) { 1083 Attribute Attr = *I; 1084 if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) { 1085 if (Attrs[I->getKindAsEnum()]) 1086 return true; 1087 } else { 1088 assert(Attr.isStringAttribute() && "Invalid attribute kind!"); 1089 return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end(); 1090 } 1091 } 1092 1093 return false; 1094 } 1095 1096 bool AttrBuilder::hasAlignmentAttr() const { 1097 return Alignment != 0; 1098 } 1099 1100 bool AttrBuilder::operator==(const AttrBuilder &B) { 1101 if (Attrs != B.Attrs) 1102 return false; 1103 1104 for (td_const_iterator I = TargetDepAttrs.begin(), 1105 E = TargetDepAttrs.end(); I != E; ++I) 1106 if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end()) 1107 return false; 1108 1109 return Alignment == B.Alignment && StackAlignment == B.StackAlignment; 1110 } 1111 1112 void AttrBuilder::removeFunctionOnlyAttrs() { 1113 removeAttribute(Attribute::NoReturn) 1114 .removeAttribute(Attribute::NoUnwind) 1115 .removeAttribute(Attribute::ReadNone) 1116 .removeAttribute(Attribute::ReadOnly) 1117 .removeAttribute(Attribute::NoInline) 1118 .removeAttribute(Attribute::AlwaysInline) 1119 .removeAttribute(Attribute::OptimizeForSize) 1120 .removeAttribute(Attribute::StackProtect) 1121 .removeAttribute(Attribute::StackProtectReq) 1122 .removeAttribute(Attribute::StackProtectStrong) 1123 .removeAttribute(Attribute::NoRedZone) 1124 .removeAttribute(Attribute::NoImplicitFloat) 1125 .removeAttribute(Attribute::Naked) 1126 .removeAttribute(Attribute::InlineHint) 1127 .removeAttribute(Attribute::StackAlignment) 1128 .removeAttribute(Attribute::UWTable) 1129 .removeAttribute(Attribute::NonLazyBind) 1130 .removeAttribute(Attribute::ReturnsTwice) 1131 .removeAttribute(Attribute::SanitizeAddress) 1132 .removeAttribute(Attribute::SanitizeThread) 1133 .removeAttribute(Attribute::SanitizeMemory) 1134 .removeAttribute(Attribute::MinSize) 1135 .removeAttribute(Attribute::NoDuplicate) 1136 .removeAttribute(Attribute::NoBuiltin); 1137 } 1138 1139 AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) { 1140 // FIXME: Remove this in 4.0. 1141 if (!Val) return *this; 1142 1143 for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds; 1144 I = Attribute::AttrKind(I + 1)) { 1145 if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) { 1146 Attrs[I] = true; 1147 1148 if (I == Attribute::Alignment) 1149 Alignment = 1ULL << ((A >> 16) - 1); 1150 else if (I == Attribute::StackAlignment) 1151 StackAlignment = 1ULL << ((A >> 26)-1); 1152 } 1153 } 1154 1155 return *this; 1156 } 1157 1158 //===----------------------------------------------------------------------===// 1159 // AttributeFuncs Function Defintions 1160 //===----------------------------------------------------------------------===// 1161 1162 /// \brief Which attributes cannot be applied to a type. 1163 AttributeSet AttributeFuncs::typeIncompatible(Type *Ty, uint64_t Index) { 1164 AttrBuilder Incompatible; 1165 1166 if (!Ty->isIntegerTy()) 1167 // Attribute that only apply to integers. 1168 Incompatible.addAttribute(Attribute::SExt) 1169 .addAttribute(Attribute::ZExt); 1170 1171 if (!Ty->isPointerTy()) 1172 // Attribute that only apply to pointers. 1173 Incompatible.addAttribute(Attribute::ByVal) 1174 .addAttribute(Attribute::Nest) 1175 .addAttribute(Attribute::NoAlias) 1176 .addAttribute(Attribute::NoCapture) 1177 .addAttribute(Attribute::StructRet); 1178 1179 return AttributeSet::get(Ty->getContext(), Index, Incompatible); 1180 } 1181