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 "llvm/IR/Function.h" 18#include "AttributeImpl.h" 19#include "LLVMContextImpl.h" 20#include "llvm/ADT/STLExtras.h" 21#include "llvm/ADT/StringExtras.h" 22#include "llvm/IR/Type.h" 23#include "llvm/Support/Atomic.h" 24#include "llvm/Support/Debug.h" 25#include "llvm/Support/ManagedStatic.h" 26#include "llvm/Support/Mutex.h" 27#include "llvm/Support/raw_ostream.h" 28#include <algorithm> 29using namespace llvm; 30 31//===----------------------------------------------------------------------===// 32// Attribute Construction Methods 33//===----------------------------------------------------------------------===// 34 35Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind, 36 uint64_t Val) { 37 LLVMContextImpl *pImpl = Context.pImpl; 38 FoldingSetNodeID ID; 39 ID.AddInteger(Kind); 40 if (Val) ID.AddInteger(Val); 41 42 void *InsertPoint; 43 AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint); 44 45 if (!PA) { 46 // If we didn't find any existing attributes of the same shape then create a 47 // new one and insert it. 48 if (!Val) 49 PA = new EnumAttributeImpl(Kind); 50 else 51 PA = new IntAttributeImpl(Kind, Val); 52 pImpl->AttrsSet.InsertNode(PA, InsertPoint); 53 } 54 55 // Return the Attribute that we found or created. 56 return Attribute(PA); 57} 58 59Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) { 60 LLVMContextImpl *pImpl = Context.pImpl; 61 FoldingSetNodeID ID; 62 ID.AddString(Kind); 63 if (!Val.empty()) ID.AddString(Val); 64 65 void *InsertPoint; 66 AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint); 67 68 if (!PA) { 69 // If we didn't find any existing attributes of the same shape then create a 70 // new one and insert it. 71 PA = new StringAttributeImpl(Kind, Val); 72 pImpl->AttrsSet.InsertNode(PA, InsertPoint); 73 } 74 75 // Return the Attribute that we found or created. 76 return Attribute(PA); 77} 78 79Attribute Attribute::getWithAlignment(LLVMContext &Context, uint64_t Align) { 80 assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); 81 assert(Align <= 0x40000000 && "Alignment too large."); 82 return get(Context, Alignment, Align); 83} 84 85Attribute Attribute::getWithStackAlignment(LLVMContext &Context, 86 uint64_t Align) { 87 assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); 88 assert(Align <= 0x100 && "Alignment too large."); 89 return get(Context, StackAlignment, Align); 90} 91 92Attribute Attribute::getWithDereferenceableBytes(LLVMContext &Context, 93 uint64_t Bytes) { 94 assert(Bytes && "Bytes must be non-zero."); 95 return get(Context, Dereferenceable, Bytes); 96} 97 98Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context, 99 uint64_t Bytes) { 100 assert(Bytes && "Bytes must be non-zero."); 101 return get(Context, DereferenceableOrNull, Bytes); 102} 103 104//===----------------------------------------------------------------------===// 105// Attribute Accessor Methods 106//===----------------------------------------------------------------------===// 107 108bool Attribute::isEnumAttribute() const { 109 return pImpl && pImpl->isEnumAttribute(); 110} 111 112bool Attribute::isIntAttribute() const { 113 return pImpl && pImpl->isIntAttribute(); 114} 115 116bool Attribute::isStringAttribute() const { 117 return pImpl && pImpl->isStringAttribute(); 118} 119 120Attribute::AttrKind Attribute::getKindAsEnum() const { 121 if (!pImpl) return None; 122 assert((isEnumAttribute() || isIntAttribute()) && 123 "Invalid attribute type to get the kind as an enum!"); 124 return pImpl->getKindAsEnum(); 125} 126 127uint64_t Attribute::getValueAsInt() const { 128 if (!pImpl) return 0; 129 assert(isIntAttribute() && 130 "Expected the attribute to be an integer attribute!"); 131 return pImpl->getValueAsInt(); 132} 133 134StringRef Attribute::getKindAsString() const { 135 if (!pImpl) return StringRef(); 136 assert(isStringAttribute() && 137 "Invalid attribute type to get the kind as a string!"); 138 return pImpl->getKindAsString(); 139} 140 141StringRef Attribute::getValueAsString() const { 142 if (!pImpl) return StringRef(); 143 assert(isStringAttribute() && 144 "Invalid attribute type to get the value as a string!"); 145 return pImpl->getValueAsString(); 146} 147 148bool Attribute::hasAttribute(AttrKind Kind) const { 149 return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None); 150} 151 152bool Attribute::hasAttribute(StringRef Kind) const { 153 if (!isStringAttribute()) return false; 154 return pImpl && pImpl->hasAttribute(Kind); 155} 156 157/// This returns the alignment field of an attribute as a byte alignment value. 158unsigned Attribute::getAlignment() const { 159 assert(hasAttribute(Attribute::Alignment) && 160 "Trying to get alignment from non-alignment attribute!"); 161 return pImpl->getValueAsInt(); 162} 163 164/// This returns the stack alignment field of an attribute as a byte alignment 165/// value. 166unsigned Attribute::getStackAlignment() const { 167 assert(hasAttribute(Attribute::StackAlignment) && 168 "Trying to get alignment from non-alignment attribute!"); 169 return pImpl->getValueAsInt(); 170} 171 172/// This returns the number of dereferenceable bytes. 173uint64_t Attribute::getDereferenceableBytes() const { 174 assert(hasAttribute(Attribute::Dereferenceable) && 175 "Trying to get dereferenceable bytes from " 176 "non-dereferenceable attribute!"); 177 return pImpl->getValueAsInt(); 178} 179 180uint64_t Attribute::getDereferenceableOrNullBytes() const { 181 assert(hasAttribute(Attribute::DereferenceableOrNull) && 182 "Trying to get dereferenceable bytes from " 183 "non-dereferenceable attribute!"); 184 return pImpl->getValueAsInt(); 185} 186 187std::string Attribute::getAsString(bool InAttrGrp) const { 188 if (!pImpl) return ""; 189 190 if (hasAttribute(Attribute::SanitizeAddress)) 191 return "sanitize_address"; 192 if (hasAttribute(Attribute::AlwaysInline)) 193 return "alwaysinline"; 194 if (hasAttribute(Attribute::ArgMemOnly)) 195 return "argmemonly"; 196 if (hasAttribute(Attribute::Builtin)) 197 return "builtin"; 198 if (hasAttribute(Attribute::ByVal)) 199 return "byval"; 200 if (hasAttribute(Attribute::Convergent)) 201 return "convergent"; 202 if (hasAttribute(Attribute::InaccessibleMemOnly)) 203 return "inaccessiblememonly"; 204 if (hasAttribute(Attribute::InaccessibleMemOrArgMemOnly)) 205 return "inaccessiblemem_or_argmemonly"; 206 if (hasAttribute(Attribute::InAlloca)) 207 return "inalloca"; 208 if (hasAttribute(Attribute::InlineHint)) 209 return "inlinehint"; 210 if (hasAttribute(Attribute::InReg)) 211 return "inreg"; 212 if (hasAttribute(Attribute::JumpTable)) 213 return "jumptable"; 214 if (hasAttribute(Attribute::MinSize)) 215 return "minsize"; 216 if (hasAttribute(Attribute::Naked)) 217 return "naked"; 218 if (hasAttribute(Attribute::Nest)) 219 return "nest"; 220 if (hasAttribute(Attribute::NoAlias)) 221 return "noalias"; 222 if (hasAttribute(Attribute::NoBuiltin)) 223 return "nobuiltin"; 224 if (hasAttribute(Attribute::NoCapture)) 225 return "nocapture"; 226 if (hasAttribute(Attribute::NoDuplicate)) 227 return "noduplicate"; 228 if (hasAttribute(Attribute::NoImplicitFloat)) 229 return "noimplicitfloat"; 230 if (hasAttribute(Attribute::NoInline)) 231 return "noinline"; 232 if (hasAttribute(Attribute::NonLazyBind)) 233 return "nonlazybind"; 234 if (hasAttribute(Attribute::NonNull)) 235 return "nonnull"; 236 if (hasAttribute(Attribute::NoRedZone)) 237 return "noredzone"; 238 if (hasAttribute(Attribute::NoReturn)) 239 return "noreturn"; 240 if (hasAttribute(Attribute::NoRecurse)) 241 return "norecurse"; 242 if (hasAttribute(Attribute::NoUnwind)) 243 return "nounwind"; 244 if (hasAttribute(Attribute::OptimizeNone)) 245 return "optnone"; 246 if (hasAttribute(Attribute::OptimizeForSize)) 247 return "optsize"; 248 if (hasAttribute(Attribute::ReadNone)) 249 return "readnone"; 250 if (hasAttribute(Attribute::ReadOnly)) 251 return "readonly"; 252 if (hasAttribute(Attribute::Returned)) 253 return "returned"; 254 if (hasAttribute(Attribute::ReturnsTwice)) 255 return "returns_twice"; 256 if (hasAttribute(Attribute::SExt)) 257 return "signext"; 258 if (hasAttribute(Attribute::StackProtect)) 259 return "ssp"; 260 if (hasAttribute(Attribute::StackProtectReq)) 261 return "sspreq"; 262 if (hasAttribute(Attribute::StackProtectStrong)) 263 return "sspstrong"; 264 if (hasAttribute(Attribute::SafeStack)) 265 return "safestack"; 266 if (hasAttribute(Attribute::StructRet)) 267 return "sret"; 268 if (hasAttribute(Attribute::SanitizeThread)) 269 return "sanitize_thread"; 270 if (hasAttribute(Attribute::SanitizeMemory)) 271 return "sanitize_memory"; 272 if (hasAttribute(Attribute::UWTable)) 273 return "uwtable"; 274 if (hasAttribute(Attribute::ZExt)) 275 return "zeroext"; 276 if (hasAttribute(Attribute::Cold)) 277 return "cold"; 278 279 // FIXME: These should be output like this: 280 // 281 // align=4 282 // alignstack=8 283 // 284 if (hasAttribute(Attribute::Alignment)) { 285 std::string Result; 286 Result += "align"; 287 Result += (InAttrGrp) ? "=" : " "; 288 Result += utostr(getValueAsInt()); 289 return Result; 290 } 291 292 auto AttrWithBytesToString = [&](const char *Name) { 293 std::string Result; 294 Result += Name; 295 if (InAttrGrp) { 296 Result += "="; 297 Result += utostr(getValueAsInt()); 298 } else { 299 Result += "("; 300 Result += utostr(getValueAsInt()); 301 Result += ")"; 302 } 303 return Result; 304 }; 305 306 if (hasAttribute(Attribute::StackAlignment)) 307 return AttrWithBytesToString("alignstack"); 308 309 if (hasAttribute(Attribute::Dereferenceable)) 310 return AttrWithBytesToString("dereferenceable"); 311 312 if (hasAttribute(Attribute::DereferenceableOrNull)) 313 return AttrWithBytesToString("dereferenceable_or_null"); 314 315 // Convert target-dependent attributes to strings of the form: 316 // 317 // "kind" 318 // "kind" = "value" 319 // 320 if (isStringAttribute()) { 321 std::string Result; 322 Result += (Twine('"') + getKindAsString() + Twine('"')).str(); 323 324 StringRef Val = pImpl->getValueAsString(); 325 if (Val.empty()) return Result; 326 327 Result += ("=\"" + Val + Twine('"')).str(); 328 return Result; 329 } 330 331 llvm_unreachable("Unknown attribute"); 332} 333 334bool Attribute::operator<(Attribute A) const { 335 if (!pImpl && !A.pImpl) return false; 336 if (!pImpl) return true; 337 if (!A.pImpl) return false; 338 return *pImpl < *A.pImpl; 339} 340 341//===----------------------------------------------------------------------===// 342// AttributeImpl Definition 343//===----------------------------------------------------------------------===// 344 345// Pin the vtables to this file. 346AttributeImpl::~AttributeImpl() {} 347void EnumAttributeImpl::anchor() {} 348void IntAttributeImpl::anchor() {} 349void StringAttributeImpl::anchor() {} 350 351bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const { 352 if (isStringAttribute()) return false; 353 return getKindAsEnum() == A; 354} 355 356bool AttributeImpl::hasAttribute(StringRef Kind) const { 357 if (!isStringAttribute()) return false; 358 return getKindAsString() == Kind; 359} 360 361Attribute::AttrKind AttributeImpl::getKindAsEnum() const { 362 assert(isEnumAttribute() || isIntAttribute()); 363 return static_cast<const EnumAttributeImpl *>(this)->getEnumKind(); 364} 365 366uint64_t AttributeImpl::getValueAsInt() const { 367 assert(isIntAttribute()); 368 return static_cast<const IntAttributeImpl *>(this)->getValue(); 369} 370 371StringRef AttributeImpl::getKindAsString() const { 372 assert(isStringAttribute()); 373 return static_cast<const StringAttributeImpl *>(this)->getStringKind(); 374} 375 376StringRef AttributeImpl::getValueAsString() const { 377 assert(isStringAttribute()); 378 return static_cast<const StringAttributeImpl *>(this)->getStringValue(); 379} 380 381bool AttributeImpl::operator<(const AttributeImpl &AI) const { 382 // This sorts the attributes with Attribute::AttrKinds coming first (sorted 383 // relative to their enum value) and then strings. 384 if (isEnumAttribute()) { 385 if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum(); 386 if (AI.isIntAttribute()) return true; 387 if (AI.isStringAttribute()) return true; 388 } 389 390 if (isIntAttribute()) { 391 if (AI.isEnumAttribute()) return false; 392 if (AI.isIntAttribute()) return getValueAsInt() < AI.getValueAsInt(); 393 if (AI.isStringAttribute()) return true; 394 } 395 396 if (AI.isEnumAttribute()) return false; 397 if (AI.isIntAttribute()) return false; 398 if (getKindAsString() == AI.getKindAsString()) 399 return getValueAsString() < AI.getValueAsString(); 400 return getKindAsString() < AI.getKindAsString(); 401} 402 403uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) { 404 // FIXME: Remove this. 405 switch (Val) { 406 case Attribute::EndAttrKinds: 407 llvm_unreachable("Synthetic enumerators which should never get here"); 408 409 case Attribute::None: return 0; 410 case Attribute::ZExt: return 1 << 0; 411 case Attribute::SExt: return 1 << 1; 412 case Attribute::NoReturn: return 1 << 2; 413 case Attribute::InReg: return 1 << 3; 414 case Attribute::StructRet: return 1 << 4; 415 case Attribute::NoUnwind: return 1 << 5; 416 case Attribute::NoAlias: return 1 << 6; 417 case Attribute::ByVal: return 1 << 7; 418 case Attribute::Nest: return 1 << 8; 419 case Attribute::ReadNone: return 1 << 9; 420 case Attribute::ReadOnly: return 1 << 10; 421 case Attribute::NoInline: return 1 << 11; 422 case Attribute::AlwaysInline: return 1 << 12; 423 case Attribute::OptimizeForSize: return 1 << 13; 424 case Attribute::StackProtect: return 1 << 14; 425 case Attribute::StackProtectReq: return 1 << 15; 426 case Attribute::Alignment: return 31 << 16; 427 case Attribute::NoCapture: return 1 << 21; 428 case Attribute::NoRedZone: return 1 << 22; 429 case Attribute::NoImplicitFloat: return 1 << 23; 430 case Attribute::Naked: return 1 << 24; 431 case Attribute::InlineHint: return 1 << 25; 432 case Attribute::StackAlignment: return 7 << 26; 433 case Attribute::ReturnsTwice: return 1 << 29; 434 case Attribute::UWTable: return 1 << 30; 435 case Attribute::NonLazyBind: return 1U << 31; 436 case Attribute::SanitizeAddress: return 1ULL << 32; 437 case Attribute::MinSize: return 1ULL << 33; 438 case Attribute::NoDuplicate: return 1ULL << 34; 439 case Attribute::StackProtectStrong: return 1ULL << 35; 440 case Attribute::SanitizeThread: return 1ULL << 36; 441 case Attribute::SanitizeMemory: return 1ULL << 37; 442 case Attribute::NoBuiltin: return 1ULL << 38; 443 case Attribute::Returned: return 1ULL << 39; 444 case Attribute::Cold: return 1ULL << 40; 445 case Attribute::Builtin: return 1ULL << 41; 446 case Attribute::OptimizeNone: return 1ULL << 42; 447 case Attribute::InAlloca: return 1ULL << 43; 448 case Attribute::NonNull: return 1ULL << 44; 449 case Attribute::JumpTable: return 1ULL << 45; 450 case Attribute::Convergent: return 1ULL << 46; 451 case Attribute::SafeStack: return 1ULL << 47; 452 case Attribute::NoRecurse: return 1ULL << 48; 453 case Attribute::InaccessibleMemOnly: return 1ULL << 49; 454 case Attribute::InaccessibleMemOrArgMemOnly: return 1ULL << 50; 455 case Attribute::Dereferenceable: 456 llvm_unreachable("dereferenceable attribute not supported in raw format"); 457 break; 458 case Attribute::DereferenceableOrNull: 459 llvm_unreachable("dereferenceable_or_null attribute not supported in raw " 460 "format"); 461 break; 462 case Attribute::ArgMemOnly: 463 llvm_unreachable("argmemonly attribute not supported in raw format"); 464 break; 465 } 466 llvm_unreachable("Unsupported attribute type"); 467} 468 469//===----------------------------------------------------------------------===// 470// AttributeSetNode Definition 471//===----------------------------------------------------------------------===// 472 473AttributeSetNode *AttributeSetNode::get(LLVMContext &C, 474 ArrayRef<Attribute> Attrs) { 475 if (Attrs.empty()) 476 return nullptr; 477 478 // Otherwise, build a key to look up the existing attributes. 479 LLVMContextImpl *pImpl = C.pImpl; 480 FoldingSetNodeID ID; 481 482 SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end()); 483 array_pod_sort(SortedAttrs.begin(), SortedAttrs.end()); 484 485 for (Attribute Attr : SortedAttrs) 486 Attr.Profile(ID); 487 488 void *InsertPoint; 489 AttributeSetNode *PA = 490 pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint); 491 492 // If we didn't find any existing attributes of the same shape then create a 493 // new one and insert it. 494 if (!PA) { 495 // Coallocate entries after the AttributeSetNode itself. 496 void *Mem = ::operator new(totalSizeToAlloc<Attribute>(SortedAttrs.size())); 497 PA = new (Mem) AttributeSetNode(SortedAttrs); 498 pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint); 499 } 500 501 // Return the AttributesListNode that we found or created. 502 return PA; 503} 504 505bool AttributeSetNode::hasAttribute(Attribute::AttrKind Kind) const { 506 for (iterator I = begin(), E = end(); I != E; ++I) 507 if (I->hasAttribute(Kind)) 508 return true; 509 return false; 510} 511 512bool AttributeSetNode::hasAttribute(StringRef Kind) const { 513 for (iterator I = begin(), E = end(); I != E; ++I) 514 if (I->hasAttribute(Kind)) 515 return true; 516 return false; 517} 518 519Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const { 520 for (iterator I = begin(), E = end(); I != E; ++I) 521 if (I->hasAttribute(Kind)) 522 return *I; 523 return Attribute(); 524} 525 526Attribute AttributeSetNode::getAttribute(StringRef Kind) const { 527 for (iterator I = begin(), E = end(); I != E; ++I) 528 if (I->hasAttribute(Kind)) 529 return *I; 530 return Attribute(); 531} 532 533unsigned AttributeSetNode::getAlignment() const { 534 for (iterator I = begin(), E = end(); I != E; ++I) 535 if (I->hasAttribute(Attribute::Alignment)) 536 return I->getAlignment(); 537 return 0; 538} 539 540unsigned AttributeSetNode::getStackAlignment() const { 541 for (iterator I = begin(), E = end(); I != E; ++I) 542 if (I->hasAttribute(Attribute::StackAlignment)) 543 return I->getStackAlignment(); 544 return 0; 545} 546 547uint64_t AttributeSetNode::getDereferenceableBytes() const { 548 for (iterator I = begin(), E = end(); I != E; ++I) 549 if (I->hasAttribute(Attribute::Dereferenceable)) 550 return I->getDereferenceableBytes(); 551 return 0; 552} 553 554uint64_t AttributeSetNode::getDereferenceableOrNullBytes() const { 555 for (iterator I = begin(), E = end(); I != E; ++I) 556 if (I->hasAttribute(Attribute::DereferenceableOrNull)) 557 return I->getDereferenceableOrNullBytes(); 558 return 0; 559} 560 561std::string AttributeSetNode::getAsString(bool InAttrGrp) const { 562 std::string Str; 563 for (iterator I = begin(), E = end(); I != E; ++I) { 564 if (I != begin()) 565 Str += ' '; 566 Str += I->getAsString(InAttrGrp); 567 } 568 return Str; 569} 570 571//===----------------------------------------------------------------------===// 572// AttributeSetImpl Definition 573//===----------------------------------------------------------------------===// 574 575uint64_t AttributeSetImpl::Raw(unsigned Index) const { 576 for (unsigned I = 0, E = getNumAttributes(); I != E; ++I) { 577 if (getSlotIndex(I) != Index) continue; 578 const AttributeSetNode *ASN = getSlotNode(I); 579 uint64_t Mask = 0; 580 581 for (AttributeSetNode::iterator II = ASN->begin(), 582 IE = ASN->end(); II != IE; ++II) { 583 Attribute Attr = *II; 584 585 // This cannot handle string attributes. 586 if (Attr.isStringAttribute()) continue; 587 588 Attribute::AttrKind Kind = Attr.getKindAsEnum(); 589 590 if (Kind == Attribute::Alignment) 591 Mask |= (Log2_32(ASN->getAlignment()) + 1) << 16; 592 else if (Kind == Attribute::StackAlignment) 593 Mask |= (Log2_32(ASN->getStackAlignment()) + 1) << 26; 594 else if (Kind == Attribute::Dereferenceable) 595 llvm_unreachable("dereferenceable not supported in bit mask"); 596 else 597 Mask |= AttributeImpl::getAttrMask(Kind); 598 } 599 600 return Mask; 601 } 602 603 return 0; 604} 605 606void AttributeSetImpl::dump() const { 607 AttributeSet(const_cast<AttributeSetImpl *>(this)).dump(); 608} 609 610//===----------------------------------------------------------------------===// 611// AttributeSet Construction and Mutation Methods 612//===----------------------------------------------------------------------===// 613 614AttributeSet 615AttributeSet::getImpl(LLVMContext &C, 616 ArrayRef<std::pair<unsigned, AttributeSetNode*> > Attrs) { 617 LLVMContextImpl *pImpl = C.pImpl; 618 FoldingSetNodeID ID; 619 AttributeSetImpl::Profile(ID, Attrs); 620 621 void *InsertPoint; 622 AttributeSetImpl *PA = pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint); 623 624 // If we didn't find any existing attributes of the same shape then 625 // create a new one and insert it. 626 if (!PA) { 627 // Coallocate entries after the AttributeSetImpl itself. 628 void *Mem = ::operator new( 629 AttributeSetImpl::totalSizeToAlloc<IndexAttrPair>(Attrs.size())); 630 PA = new (Mem) AttributeSetImpl(C, Attrs); 631 pImpl->AttrsLists.InsertNode(PA, InsertPoint); 632 } 633 634 // Return the AttributesList that we found or created. 635 return AttributeSet(PA); 636} 637 638AttributeSet AttributeSet::get(LLVMContext &C, 639 ArrayRef<std::pair<unsigned, Attribute> > Attrs){ 640 // If there are no attributes then return a null AttributesList pointer. 641 if (Attrs.empty()) 642 return AttributeSet(); 643 644 assert(std::is_sorted(Attrs.begin(), Attrs.end(), 645 [](const std::pair<unsigned, Attribute> &LHS, 646 const std::pair<unsigned, Attribute> &RHS) { 647 return LHS.first < RHS.first; 648 }) && "Misordered Attributes list!"); 649 assert(std::none_of(Attrs.begin(), Attrs.end(), 650 [](const std::pair<unsigned, Attribute> &Pair) { 651 return Pair.second.hasAttribute(Attribute::None); 652 }) && "Pointless attribute!"); 653 654 // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes 655 // list. 656 SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrPairVec; 657 for (ArrayRef<std::pair<unsigned, Attribute> >::iterator I = Attrs.begin(), 658 E = Attrs.end(); I != E; ) { 659 unsigned Index = I->first; 660 SmallVector<Attribute, 4> AttrVec; 661 while (I != E && I->first == Index) { 662 AttrVec.push_back(I->second); 663 ++I; 664 } 665 666 AttrPairVec.push_back(std::make_pair(Index, 667 AttributeSetNode::get(C, AttrVec))); 668 } 669 670 return getImpl(C, AttrPairVec); 671} 672 673AttributeSet AttributeSet::get(LLVMContext &C, 674 ArrayRef<std::pair<unsigned, 675 AttributeSetNode*> > Attrs) { 676 // If there are no attributes then return a null AttributesList pointer. 677 if (Attrs.empty()) 678 return AttributeSet(); 679 680 return getImpl(C, Attrs); 681} 682 683AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index, 684 const AttrBuilder &B) { 685 if (!B.hasAttributes()) 686 return AttributeSet(); 687 688 // Add target-independent attributes. 689 SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; 690 for (Attribute::AttrKind Kind = Attribute::None; 691 Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) { 692 if (!B.contains(Kind)) 693 continue; 694 695 Attribute Attr; 696 switch (Kind) { 697 case Attribute::Alignment: 698 Attr = Attribute::getWithAlignment(C, B.getAlignment()); 699 break; 700 case Attribute::StackAlignment: 701 Attr = Attribute::getWithStackAlignment(C, B.getStackAlignment()); 702 break; 703 case Attribute::Dereferenceable: 704 Attr = Attribute::getWithDereferenceableBytes( 705 C, B.getDereferenceableBytes()); 706 break; 707 case Attribute::DereferenceableOrNull: 708 Attr = Attribute::getWithDereferenceableOrNullBytes( 709 C, B.getDereferenceableOrNullBytes()); 710 break; 711 default: 712 Attr = Attribute::get(C, Kind); 713 } 714 Attrs.push_back(std::make_pair(Index, Attr)); 715 } 716 717 // Add target-dependent (string) attributes. 718 for (const AttrBuilder::td_type &TDA : B.td_attrs()) 719 Attrs.push_back( 720 std::make_pair(Index, Attribute::get(C, TDA.first, TDA.second))); 721 722 return get(C, Attrs); 723} 724 725AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index, 726 ArrayRef<Attribute::AttrKind> Kind) { 727 SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; 728 for (Attribute::AttrKind K : Kind) 729 Attrs.push_back(std::make_pair(Index, Attribute::get(C, K))); 730 return get(C, Attrs); 731} 732 733AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<AttributeSet> Attrs) { 734 if (Attrs.empty()) return AttributeSet(); 735 if (Attrs.size() == 1) return Attrs[0]; 736 737 SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrNodeVec; 738 AttributeSetImpl *A0 = Attrs[0].pImpl; 739 if (A0) 740 AttrNodeVec.append(A0->getNode(0), A0->getNode(A0->getNumAttributes())); 741 // Copy all attributes from Attrs into AttrNodeVec while keeping AttrNodeVec 742 // ordered by index. Because we know that each list in Attrs is ordered by 743 // index we only need to merge each successive list in rather than doing a 744 // full sort. 745 for (unsigned I = 1, E = Attrs.size(); I != E; ++I) { 746 AttributeSetImpl *AS = Attrs[I].pImpl; 747 if (!AS) continue; 748 SmallVector<std::pair<unsigned, AttributeSetNode *>, 8>::iterator 749 ANVI = AttrNodeVec.begin(), ANVE; 750 for (const IndexAttrPair *AI = AS->getNode(0), 751 *AE = AS->getNode(AS->getNumAttributes()); 752 AI != AE; ++AI) { 753 ANVE = AttrNodeVec.end(); 754 while (ANVI != ANVE && ANVI->first <= AI->first) 755 ++ANVI; 756 ANVI = AttrNodeVec.insert(ANVI, *AI) + 1; 757 } 758 } 759 760 return getImpl(C, AttrNodeVec); 761} 762 763AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index, 764 Attribute::AttrKind Attr) const { 765 if (hasAttribute(Index, Attr)) return *this; 766 return addAttributes(C, Index, AttributeSet::get(C, Index, Attr)); 767} 768 769AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index, 770 StringRef Kind) const { 771 llvm::AttrBuilder B; 772 B.addAttribute(Kind); 773 return addAttributes(C, Index, AttributeSet::get(C, Index, B)); 774} 775 776AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index, 777 StringRef Kind, StringRef Value) const { 778 llvm::AttrBuilder B; 779 B.addAttribute(Kind, Value); 780 return addAttributes(C, Index, AttributeSet::get(C, Index, B)); 781} 782 783AttributeSet AttributeSet::addAttribute(LLVMContext &C, 784 ArrayRef<unsigned> Indices, 785 Attribute A) const { 786 unsigned I = 0, E = pImpl ? pImpl->getNumAttributes() : 0; 787 auto IdxI = Indices.begin(), IdxE = Indices.end(); 788 SmallVector<AttributeSet, 4> AttrSet; 789 790 while (I != E && IdxI != IdxE) { 791 if (getSlotIndex(I) < *IdxI) 792 AttrSet.emplace_back(getSlotAttributes(I++)); 793 else if (getSlotIndex(I) > *IdxI) 794 AttrSet.emplace_back(AttributeSet::get(C, std::make_pair(*IdxI++, A))); 795 else { 796 AttrBuilder B(getSlotAttributes(I), *IdxI); 797 B.addAttribute(A); 798 AttrSet.emplace_back(AttributeSet::get(C, *IdxI, B)); 799 ++I; 800 ++IdxI; 801 } 802 } 803 804 while (I != E) 805 AttrSet.emplace_back(getSlotAttributes(I++)); 806 807 while (IdxI != IdxE) 808 AttrSet.emplace_back(AttributeSet::get(C, std::make_pair(*IdxI++, A))); 809 810 return get(C, AttrSet); 811} 812 813AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Index, 814 AttributeSet Attrs) const { 815 if (!pImpl) return Attrs; 816 if (!Attrs.pImpl) return *this; 817 818#ifndef NDEBUG 819 // FIXME it is not obvious how this should work for alignment. For now, say 820 // we can't change a known alignment. 821 unsigned OldAlign = getParamAlignment(Index); 822 unsigned NewAlign = Attrs.getParamAlignment(Index); 823 assert((!OldAlign || !NewAlign || OldAlign == NewAlign) && 824 "Attempt to change alignment!"); 825#endif 826 827 // Add the attribute slots before the one we're trying to add. 828 SmallVector<AttributeSet, 4> AttrSet; 829 uint64_t NumAttrs = pImpl->getNumAttributes(); 830 AttributeSet AS; 831 uint64_t LastIndex = 0; 832 for (unsigned I = 0, E = NumAttrs; I != E; ++I) { 833 if (getSlotIndex(I) >= Index) { 834 if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++); 835 break; 836 } 837 LastIndex = I + 1; 838 AttrSet.push_back(getSlotAttributes(I)); 839 } 840 841 // Now add the attribute into the correct slot. There may already be an 842 // AttributeSet there. 843 AttrBuilder B(AS, Index); 844 845 for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I) 846 if (Attrs.getSlotIndex(I) == Index) { 847 for (AttributeSetImpl::iterator II = Attrs.pImpl->begin(I), 848 IE = Attrs.pImpl->end(I); II != IE; ++II) 849 B.addAttribute(*II); 850 break; 851 } 852 853 AttrSet.push_back(AttributeSet::get(C, Index, B)); 854 855 // Add the remaining attribute slots. 856 for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I) 857 AttrSet.push_back(getSlotAttributes(I)); 858 859 return get(C, AttrSet); 860} 861 862AttributeSet AttributeSet::removeAttribute(LLVMContext &C, unsigned Index, 863 Attribute::AttrKind Attr) const { 864 if (!hasAttribute(Index, Attr)) return *this; 865 return removeAttributes(C, Index, AttributeSet::get(C, Index, Attr)); 866} 867 868AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Index, 869 AttributeSet Attrs) const { 870 if (!pImpl) return AttributeSet(); 871 if (!Attrs.pImpl) return *this; 872 873 // FIXME it is not obvious how this should work for alignment. 874 // For now, say we can't pass in alignment, which no current use does. 875 assert(!Attrs.hasAttribute(Index, Attribute::Alignment) && 876 "Attempt to change alignment!"); 877 878 // Add the attribute slots before the one we're trying to add. 879 SmallVector<AttributeSet, 4> AttrSet; 880 uint64_t NumAttrs = pImpl->getNumAttributes(); 881 AttributeSet AS; 882 uint64_t LastIndex = 0; 883 for (unsigned I = 0, E = NumAttrs; I != E; ++I) { 884 if (getSlotIndex(I) >= Index) { 885 if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++); 886 break; 887 } 888 LastIndex = I + 1; 889 AttrSet.push_back(getSlotAttributes(I)); 890 } 891 892 // Now remove the attribute from the correct slot. There may already be an 893 // AttributeSet there. 894 AttrBuilder B(AS, Index); 895 896 for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I) 897 if (Attrs.getSlotIndex(I) == Index) { 898 B.removeAttributes(Attrs.pImpl->getSlotAttributes(I), Index); 899 break; 900 } 901 902 AttrSet.push_back(AttributeSet::get(C, Index, B)); 903 904 // Add the remaining attribute slots. 905 for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I) 906 AttrSet.push_back(getSlotAttributes(I)); 907 908 return get(C, AttrSet); 909} 910 911AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Index, 912 const AttrBuilder &Attrs) const { 913 if (!pImpl) return AttributeSet(); 914 915 // FIXME it is not obvious how this should work for alignment. 916 // For now, say we can't pass in alignment, which no current use does. 917 assert(!Attrs.hasAlignmentAttr() && "Attempt to change alignment!"); 918 919 // Add the attribute slots before the one we're trying to add. 920 SmallVector<AttributeSet, 4> AttrSet; 921 uint64_t NumAttrs = pImpl->getNumAttributes(); 922 AttributeSet AS; 923 uint64_t LastIndex = 0; 924 for (unsigned I = 0, E = NumAttrs; I != E; ++I) { 925 if (getSlotIndex(I) >= Index) { 926 if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++); 927 break; 928 } 929 LastIndex = I + 1; 930 AttrSet.push_back(getSlotAttributes(I)); 931 } 932 933 // Now remove the attribute from the correct slot. There may already be an 934 // AttributeSet there. 935 AttrBuilder B(AS, Index); 936 B.remove(Attrs); 937 938 AttrSet.push_back(AttributeSet::get(C, Index, B)); 939 940 // Add the remaining attribute slots. 941 for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I) 942 AttrSet.push_back(getSlotAttributes(I)); 943 944 return get(C, AttrSet); 945} 946 947AttributeSet AttributeSet::addDereferenceableAttr(LLVMContext &C, unsigned Index, 948 uint64_t Bytes) const { 949 llvm::AttrBuilder B; 950 B.addDereferenceableAttr(Bytes); 951 return addAttributes(C, Index, AttributeSet::get(C, Index, B)); 952} 953 954AttributeSet AttributeSet::addDereferenceableOrNullAttr(LLVMContext &C, 955 unsigned Index, 956 uint64_t Bytes) const { 957 llvm::AttrBuilder B; 958 B.addDereferenceableOrNullAttr(Bytes); 959 return addAttributes(C, Index, AttributeSet::get(C, Index, B)); 960} 961 962//===----------------------------------------------------------------------===// 963// AttributeSet Accessor Methods 964//===----------------------------------------------------------------------===// 965 966LLVMContext &AttributeSet::getContext() const { 967 return pImpl->getContext(); 968} 969 970AttributeSet AttributeSet::getParamAttributes(unsigned Index) const { 971 return pImpl && hasAttributes(Index) ? 972 AttributeSet::get(pImpl->getContext(), 973 ArrayRef<std::pair<unsigned, AttributeSetNode*> >( 974 std::make_pair(Index, getAttributes(Index)))) : 975 AttributeSet(); 976} 977 978AttributeSet AttributeSet::getRetAttributes() const { 979 return pImpl && hasAttributes(ReturnIndex) ? 980 AttributeSet::get(pImpl->getContext(), 981 ArrayRef<std::pair<unsigned, AttributeSetNode*> >( 982 std::make_pair(ReturnIndex, 983 getAttributes(ReturnIndex)))) : 984 AttributeSet(); 985} 986 987AttributeSet AttributeSet::getFnAttributes() const { 988 return pImpl && hasAttributes(FunctionIndex) ? 989 AttributeSet::get(pImpl->getContext(), 990 ArrayRef<std::pair<unsigned, AttributeSetNode*> >( 991 std::make_pair(FunctionIndex, 992 getAttributes(FunctionIndex)))) : 993 AttributeSet(); 994} 995 996bool AttributeSet::hasAttribute(unsigned Index, Attribute::AttrKind Kind) const{ 997 AttributeSetNode *ASN = getAttributes(Index); 998 return ASN && ASN->hasAttribute(Kind); 999} 1000 1001bool AttributeSet::hasAttribute(unsigned Index, StringRef Kind) const { 1002 AttributeSetNode *ASN = getAttributes(Index); 1003 return ASN && ASN->hasAttribute(Kind); 1004} 1005 1006bool AttributeSet::hasAttributes(unsigned Index) const { 1007 AttributeSetNode *ASN = getAttributes(Index); 1008 return ASN && ASN->hasAttributes(); 1009} 1010 1011/// \brief Return true if the specified attribute is set for at least one 1012/// parameter or for the return value. 1013bool AttributeSet::hasAttrSomewhere(Attribute::AttrKind Attr) const { 1014 if (!pImpl) return false; 1015 1016 for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) 1017 for (AttributeSetImpl::iterator II = pImpl->begin(I), 1018 IE = pImpl->end(I); II != IE; ++II) 1019 if (II->hasAttribute(Attr)) 1020 return true; 1021 1022 return false; 1023} 1024 1025Attribute AttributeSet::getAttribute(unsigned Index, 1026 Attribute::AttrKind Kind) const { 1027 AttributeSetNode *ASN = getAttributes(Index); 1028 return ASN ? ASN->getAttribute(Kind) : Attribute(); 1029} 1030 1031Attribute AttributeSet::getAttribute(unsigned Index, 1032 StringRef Kind) const { 1033 AttributeSetNode *ASN = getAttributes(Index); 1034 return ASN ? ASN->getAttribute(Kind) : Attribute(); 1035} 1036 1037unsigned AttributeSet::getParamAlignment(unsigned Index) const { 1038 AttributeSetNode *ASN = getAttributes(Index); 1039 return ASN ? ASN->getAlignment() : 0; 1040} 1041 1042unsigned AttributeSet::getStackAlignment(unsigned Index) const { 1043 AttributeSetNode *ASN = getAttributes(Index); 1044 return ASN ? ASN->getStackAlignment() : 0; 1045} 1046 1047uint64_t AttributeSet::getDereferenceableBytes(unsigned Index) const { 1048 AttributeSetNode *ASN = getAttributes(Index); 1049 return ASN ? ASN->getDereferenceableBytes() : 0; 1050} 1051 1052uint64_t AttributeSet::getDereferenceableOrNullBytes(unsigned Index) const { 1053 AttributeSetNode *ASN = getAttributes(Index); 1054 return ASN ? ASN->getDereferenceableOrNullBytes() : 0; 1055} 1056 1057std::string AttributeSet::getAsString(unsigned Index, 1058 bool InAttrGrp) const { 1059 AttributeSetNode *ASN = getAttributes(Index); 1060 return ASN ? ASN->getAsString(InAttrGrp) : std::string(""); 1061} 1062 1063/// \brief The attributes for the specified index are returned. 1064AttributeSetNode *AttributeSet::getAttributes(unsigned Index) const { 1065 if (!pImpl) return nullptr; 1066 1067 // Loop through to find the attribute node we want. 1068 for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) 1069 if (pImpl->getSlotIndex(I) == Index) 1070 return pImpl->getSlotNode(I); 1071 1072 return nullptr; 1073} 1074 1075AttributeSet::iterator AttributeSet::begin(unsigned Slot) const { 1076 if (!pImpl) 1077 return ArrayRef<Attribute>().begin(); 1078 return pImpl->begin(Slot); 1079} 1080 1081AttributeSet::iterator AttributeSet::end(unsigned Slot) const { 1082 if (!pImpl) 1083 return ArrayRef<Attribute>().end(); 1084 return pImpl->end(Slot); 1085} 1086 1087//===----------------------------------------------------------------------===// 1088// AttributeSet Introspection Methods 1089//===----------------------------------------------------------------------===// 1090 1091/// \brief Return the number of slots used in this attribute list. This is the 1092/// number of arguments that have an attribute set on them (including the 1093/// function itself). 1094unsigned AttributeSet::getNumSlots() const { 1095 return pImpl ? pImpl->getNumAttributes() : 0; 1096} 1097 1098unsigned AttributeSet::getSlotIndex(unsigned Slot) const { 1099 assert(pImpl && Slot < pImpl->getNumAttributes() && 1100 "Slot # out of range!"); 1101 return pImpl->getSlotIndex(Slot); 1102} 1103 1104AttributeSet AttributeSet::getSlotAttributes(unsigned Slot) const { 1105 assert(pImpl && Slot < pImpl->getNumAttributes() && 1106 "Slot # out of range!"); 1107 return pImpl->getSlotAttributes(Slot); 1108} 1109 1110uint64_t AttributeSet::Raw(unsigned Index) const { 1111 // FIXME: Remove this. 1112 return pImpl ? pImpl->Raw(Index) : 0; 1113} 1114 1115void AttributeSet::dump() const { 1116 dbgs() << "PAL[\n"; 1117 1118 for (unsigned i = 0, e = getNumSlots(); i < e; ++i) { 1119 uint64_t Index = getSlotIndex(i); 1120 dbgs() << " { "; 1121 if (Index == ~0U) 1122 dbgs() << "~0U"; 1123 else 1124 dbgs() << Index; 1125 dbgs() << " => " << getAsString(Index) << " }\n"; 1126 } 1127 1128 dbgs() << "]\n"; 1129} 1130 1131//===----------------------------------------------------------------------===// 1132// AttrBuilder Method Implementations 1133//===----------------------------------------------------------------------===// 1134 1135AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index) 1136 : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0), 1137 DerefOrNullBytes(0) { 1138 AttributeSetImpl *pImpl = AS.pImpl; 1139 if (!pImpl) return; 1140 1141 for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) { 1142 if (pImpl->getSlotIndex(I) != Index) continue; 1143 1144 for (AttributeSetImpl::iterator II = pImpl->begin(I), 1145 IE = pImpl->end(I); II != IE; ++II) 1146 addAttribute(*II); 1147 1148 break; 1149 } 1150} 1151 1152void AttrBuilder::clear() { 1153 Attrs.reset(); 1154 TargetDepAttrs.clear(); 1155 Alignment = StackAlignment = DerefBytes = DerefOrNullBytes = 0; 1156} 1157 1158AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) { 1159 assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!"); 1160 assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment && 1161 Val != Attribute::Dereferenceable && 1162 "Adding integer attribute without adding a value!"); 1163 Attrs[Val] = true; 1164 return *this; 1165} 1166 1167AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) { 1168 if (Attr.isStringAttribute()) { 1169 addAttribute(Attr.getKindAsString(), Attr.getValueAsString()); 1170 return *this; 1171 } 1172 1173 Attribute::AttrKind Kind = Attr.getKindAsEnum(); 1174 Attrs[Kind] = true; 1175 1176 if (Kind == Attribute::Alignment) 1177 Alignment = Attr.getAlignment(); 1178 else if (Kind == Attribute::StackAlignment) 1179 StackAlignment = Attr.getStackAlignment(); 1180 else if (Kind == Attribute::Dereferenceable) 1181 DerefBytes = Attr.getDereferenceableBytes(); 1182 else if (Kind == Attribute::DereferenceableOrNull) 1183 DerefOrNullBytes = Attr.getDereferenceableOrNullBytes(); 1184 return *this; 1185} 1186 1187AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) { 1188 TargetDepAttrs[A] = V; 1189 return *this; 1190} 1191 1192AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) { 1193 assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!"); 1194 Attrs[Val] = false; 1195 1196 if (Val == Attribute::Alignment) 1197 Alignment = 0; 1198 else if (Val == Attribute::StackAlignment) 1199 StackAlignment = 0; 1200 else if (Val == Attribute::Dereferenceable) 1201 DerefBytes = 0; 1202 else if (Val == Attribute::DereferenceableOrNull) 1203 DerefOrNullBytes = 0; 1204 1205 return *this; 1206} 1207 1208AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) { 1209 unsigned Slot = ~0U; 1210 for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I) 1211 if (A.getSlotIndex(I) == Index) { 1212 Slot = I; 1213 break; 1214 } 1215 1216 assert(Slot != ~0U && "Couldn't find index in AttributeSet!"); 1217 1218 for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) { 1219 Attribute Attr = *I; 1220 if (Attr.isEnumAttribute() || Attr.isIntAttribute()) { 1221 removeAttribute(Attr.getKindAsEnum()); 1222 } else { 1223 assert(Attr.isStringAttribute() && "Invalid attribute type!"); 1224 removeAttribute(Attr.getKindAsString()); 1225 } 1226 } 1227 1228 return *this; 1229} 1230 1231AttrBuilder &AttrBuilder::removeAttribute(StringRef A) { 1232 std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(A); 1233 if (I != TargetDepAttrs.end()) 1234 TargetDepAttrs.erase(I); 1235 return *this; 1236} 1237 1238AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) { 1239 if (Align == 0) return *this; 1240 1241 assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); 1242 assert(Align <= 0x40000000 && "Alignment too large."); 1243 1244 Attrs[Attribute::Alignment] = true; 1245 Alignment = Align; 1246 return *this; 1247} 1248 1249AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) { 1250 // Default alignment, allow the target to define how to align it. 1251 if (Align == 0) return *this; 1252 1253 assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); 1254 assert(Align <= 0x100 && "Alignment too large."); 1255 1256 Attrs[Attribute::StackAlignment] = true; 1257 StackAlignment = Align; 1258 return *this; 1259} 1260 1261AttrBuilder &AttrBuilder::addDereferenceableAttr(uint64_t Bytes) { 1262 if (Bytes == 0) return *this; 1263 1264 Attrs[Attribute::Dereferenceable] = true; 1265 DerefBytes = Bytes; 1266 return *this; 1267} 1268 1269AttrBuilder &AttrBuilder::addDereferenceableOrNullAttr(uint64_t Bytes) { 1270 if (Bytes == 0) 1271 return *this; 1272 1273 Attrs[Attribute::DereferenceableOrNull] = true; 1274 DerefOrNullBytes = Bytes; 1275 return *this; 1276} 1277 1278AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) { 1279 // FIXME: What if both have alignments, but they don't match?! 1280 if (!Alignment) 1281 Alignment = B.Alignment; 1282 1283 if (!StackAlignment) 1284 StackAlignment = B.StackAlignment; 1285 1286 if (!DerefBytes) 1287 DerefBytes = B.DerefBytes; 1288 1289 if (!DerefOrNullBytes) 1290 DerefOrNullBytes = B.DerefOrNullBytes; 1291 1292 Attrs |= B.Attrs; 1293 1294 for (auto I : B.td_attrs()) 1295 TargetDepAttrs[I.first] = I.second; 1296 1297 return *this; 1298} 1299 1300AttrBuilder &AttrBuilder::remove(const AttrBuilder &B) { 1301 // FIXME: What if both have alignments, but they don't match?! 1302 if (B.Alignment) 1303 Alignment = 0; 1304 1305 if (B.StackAlignment) 1306 StackAlignment = 0; 1307 1308 if (B.DerefBytes) 1309 DerefBytes = 0; 1310 1311 if (B.DerefOrNullBytes) 1312 DerefOrNullBytes = 0; 1313 1314 Attrs &= ~B.Attrs; 1315 1316 for (auto I : B.td_attrs()) 1317 TargetDepAttrs.erase(I.first); 1318 1319 return *this; 1320} 1321 1322bool AttrBuilder::overlaps(const AttrBuilder &B) const { 1323 // First check if any of the target independent attributes overlap. 1324 if ((Attrs & B.Attrs).any()) 1325 return true; 1326 1327 // Then check if any target dependent ones do. 1328 for (auto I : td_attrs()) 1329 if (B.contains(I.first)) 1330 return true; 1331 1332 return false; 1333} 1334 1335bool AttrBuilder::contains(StringRef A) const { 1336 return TargetDepAttrs.find(A) != TargetDepAttrs.end(); 1337} 1338 1339bool AttrBuilder::hasAttributes() const { 1340 return !Attrs.none() || !TargetDepAttrs.empty(); 1341} 1342 1343bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const { 1344 unsigned Slot = ~0U; 1345 for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I) 1346 if (A.getSlotIndex(I) == Index) { 1347 Slot = I; 1348 break; 1349 } 1350 1351 assert(Slot != ~0U && "Couldn't find the index!"); 1352 1353 for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) { 1354 Attribute Attr = *I; 1355 if (Attr.isEnumAttribute() || Attr.isIntAttribute()) { 1356 if (Attrs[I->getKindAsEnum()]) 1357 return true; 1358 } else { 1359 assert(Attr.isStringAttribute() && "Invalid attribute kind!"); 1360 return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end(); 1361 } 1362 } 1363 1364 return false; 1365} 1366 1367bool AttrBuilder::hasAlignmentAttr() const { 1368 return Alignment != 0; 1369} 1370 1371bool AttrBuilder::operator==(const AttrBuilder &B) { 1372 if (Attrs != B.Attrs) 1373 return false; 1374 1375 for (td_const_iterator I = TargetDepAttrs.begin(), 1376 E = TargetDepAttrs.end(); I != E; ++I) 1377 if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end()) 1378 return false; 1379 1380 return Alignment == B.Alignment && StackAlignment == B.StackAlignment && 1381 DerefBytes == B.DerefBytes; 1382} 1383 1384AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) { 1385 // FIXME: Remove this in 4.0. 1386 if (!Val) return *this; 1387 1388 for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds; 1389 I = Attribute::AttrKind(I + 1)) { 1390 if (I == Attribute::Dereferenceable || 1391 I == Attribute::DereferenceableOrNull || 1392 I == Attribute::ArgMemOnly) 1393 continue; 1394 if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) { 1395 Attrs[I] = true; 1396 1397 if (I == Attribute::Alignment) 1398 Alignment = 1ULL << ((A >> 16) - 1); 1399 else if (I == Attribute::StackAlignment) 1400 StackAlignment = 1ULL << ((A >> 26)-1); 1401 } 1402 } 1403 1404 return *this; 1405} 1406 1407//===----------------------------------------------------------------------===// 1408// AttributeFuncs Function Defintions 1409//===----------------------------------------------------------------------===// 1410 1411/// \brief Which attributes cannot be applied to a type. 1412AttrBuilder AttributeFuncs::typeIncompatible(Type *Ty) { 1413 AttrBuilder Incompatible; 1414 1415 if (!Ty->isIntegerTy()) 1416 // Attribute that only apply to integers. 1417 Incompatible.addAttribute(Attribute::SExt) 1418 .addAttribute(Attribute::ZExt); 1419 1420 if (!Ty->isPointerTy()) 1421 // Attribute that only apply to pointers. 1422 Incompatible.addAttribute(Attribute::ByVal) 1423 .addAttribute(Attribute::Nest) 1424 .addAttribute(Attribute::NoAlias) 1425 .addAttribute(Attribute::NoCapture) 1426 .addAttribute(Attribute::NonNull) 1427 .addDereferenceableAttr(1) // the int here is ignored 1428 .addDereferenceableOrNullAttr(1) // the int here is ignored 1429 .addAttribute(Attribute::ReadNone) 1430 .addAttribute(Attribute::ReadOnly) 1431 .addAttribute(Attribute::StructRet) 1432 .addAttribute(Attribute::InAlloca); 1433 1434 return Incompatible; 1435} 1436 1437template<typename AttrClass> 1438static bool isEqual(const Function &Caller, const Function &Callee) { 1439 return Caller.getFnAttribute(AttrClass::getKind()) == 1440 Callee.getFnAttribute(AttrClass::getKind()); 1441} 1442 1443/// \brief Compute the logical AND of the attributes of the caller and the 1444/// callee. 1445/// 1446/// This function sets the caller's attribute to false if the callee's attribute 1447/// is false. 1448template<typename AttrClass> 1449static void setAND(Function &Caller, const Function &Callee) { 1450 if (AttrClass::isSet(Caller, AttrClass::getKind()) && 1451 !AttrClass::isSet(Callee, AttrClass::getKind())) 1452 AttrClass::set(Caller, AttrClass::getKind(), false); 1453} 1454 1455/// \brief Compute the logical OR of the attributes of the caller and the 1456/// callee. 1457/// 1458/// This function sets the caller's attribute to true if the callee's attribute 1459/// is true. 1460template<typename AttrClass> 1461static void setOR(Function &Caller, const Function &Callee) { 1462 if (!AttrClass::isSet(Caller, AttrClass::getKind()) && 1463 AttrClass::isSet(Callee, AttrClass::getKind())) 1464 AttrClass::set(Caller, AttrClass::getKind(), true); 1465} 1466 1467/// \brief If the inlined function had a higher stack protection level than the 1468/// calling function, then bump up the caller's stack protection level. 1469static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) { 1470 // If upgrading the SSP attribute, clear out the old SSP Attributes first. 1471 // Having multiple SSP attributes doesn't actually hurt, but it adds useless 1472 // clutter to the IR. 1473 AttrBuilder B; 1474 B.addAttribute(Attribute::StackProtect) 1475 .addAttribute(Attribute::StackProtectStrong) 1476 .addAttribute(Attribute::StackProtectReq); 1477 AttributeSet OldSSPAttr = AttributeSet::get(Caller.getContext(), 1478 AttributeSet::FunctionIndex, 1479 B); 1480 1481 if (Callee.hasFnAttribute(Attribute::SafeStack)) { 1482 Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr); 1483 Caller.addFnAttr(Attribute::SafeStack); 1484 } else if (Callee.hasFnAttribute(Attribute::StackProtectReq) && 1485 !Caller.hasFnAttribute(Attribute::SafeStack)) { 1486 Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr); 1487 Caller.addFnAttr(Attribute::StackProtectReq); 1488 } else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) && 1489 !Caller.hasFnAttribute(Attribute::SafeStack) && 1490 !Caller.hasFnAttribute(Attribute::StackProtectReq)) { 1491 Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr); 1492 Caller.addFnAttr(Attribute::StackProtectStrong); 1493 } else if (Callee.hasFnAttribute(Attribute::StackProtect) && 1494 !Caller.hasFnAttribute(Attribute::SafeStack) && 1495 !Caller.hasFnAttribute(Attribute::StackProtectReq) && 1496 !Caller.hasFnAttribute(Attribute::StackProtectStrong)) 1497 Caller.addFnAttr(Attribute::StackProtect); 1498} 1499 1500#define GET_ATTR_COMPAT_FUNC 1501#include "AttributesCompatFunc.inc" 1502 1503bool AttributeFuncs::areInlineCompatible(const Function &Caller, 1504 const Function &Callee) { 1505 return hasCompatibleFnAttrs(Caller, Callee); 1506} 1507 1508 1509void AttributeFuncs::mergeAttributesForInlining(Function &Caller, 1510 const Function &Callee) { 1511 mergeFnAttrs(Caller, Callee); 1512} 1513