Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/IR/Attributes.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/Attributes.h - Container for Attributes -------------*- 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
/// \file
11
/// \brief This file contains the simple types necessary to represent the
12
/// attributes associated with functions and their calls.
13
///
14
//===----------------------------------------------------------------------===//
15
16
#ifndef LLVM_IR_ATTRIBUTES_H
17
#define LLVM_IR_ATTRIBUTES_H
18
19
#include "llvm-c/Types.h"
20
#include "llvm/ADT/ArrayRef.h"
21
#include "llvm/ADT/FoldingSet.h"
22
#include "llvm/ADT/Optional.h"
23
#include "llvm/ADT/StringRef.h"
24
#include "llvm/ADT/iterator_range.h"
25
#include "llvm/Support/PointerLikeTypeTraits.h"
26
#include <bitset>
27
#include <cassert>
28
#include <cstdint>
29
#include <map>
30
#include <string>
31
#include <utility>
32
33
namespace llvm {
34
35
class AttrBuilder;
36
class AttributeImpl;
37
class AttributeListImpl;
38
class AttributeList;
39
class AttributeSetNode;
40
template<typename T> struct DenseMapInfo;
41
class Function;
42
class LLVMContext;
43
class Type;
44
45
//===----------------------------------------------------------------------===//
46
/// \class
47
/// \brief Functions, function parameters, and return types can have attributes
48
/// to indicate how they should be treated by optimizations and code
49
/// generation. This class represents one of those attributes. It's light-weight
50
/// and should be passed around by-value.
51
class Attribute {
52
public:
53
  /// This enumeration lists the attributes that can be associated with
54
  /// parameters, function results, or the function itself.
55
  ///
56
  /// Note: The `uwtable' attribute is about the ABI or the user mandating an
57
  /// entry in the unwind table. The `nounwind' attribute is about an exception
58
  /// passing by the function.
59
  ///
60
  /// In a theoretical system that uses tables for profiling and SjLj for
61
  /// exceptions, they would be fully independent. In a normal system that uses
62
  /// tables for both, the semantics are:
63
  ///
64
  /// nil                = Needs an entry because an exception might pass by.
65
  /// nounwind           = No need for an entry
66
  /// uwtable            = Needs an entry because the ABI says so and because
67
  ///                      an exception might pass by.
68
  /// uwtable + nounwind = Needs an entry because the ABI says so.
69
70
  enum AttrKind {
71
    // IR-Level Attributes
72
    None,                  ///< No attributes have been set
73
    #define GET_ATTR_ENUM
74
    #include "llvm/IR/Attributes.gen"
75
    EndAttrKinds           ///< Sentinal value useful for loops
76
  };
77
78
private:
79
  AttributeImpl *pImpl = nullptr;
80
81
20.9M
  Attribute(AttributeImpl *A) : pImpl(A) {}
82
83
public:
84
69.9M
  Attribute() = default;
85
86
  //===--------------------------------------------------------------------===//
87
  // Attribute Construction
88
  //===--------------------------------------------------------------------===//
89
90
  /// \brief Return a uniquified Attribute object.
91
  static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val = 0);
92
  static Attribute get(LLVMContext &Context, StringRef Kind,
93
                       StringRef Val = StringRef());
94
95
  /// \brief Return a uniquified Attribute object that has the specific
96
  /// alignment set.
97
  static Attribute getWithAlignment(LLVMContext &Context, uint64_t Align);
98
  static Attribute getWithStackAlignment(LLVMContext &Context, uint64_t Align);
99
  static Attribute getWithDereferenceableBytes(LLVMContext &Context,
100
                                              uint64_t Bytes);
101
  static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context,
102
                                                     uint64_t Bytes);
103
  static Attribute getWithAllocSizeArgs(LLVMContext &Context,
104
                                        unsigned ElemSizeArg,
105
                                        const Optional<unsigned> &NumElemsArg);
106
107
  //===--------------------------------------------------------------------===//
108
  // Attribute Accessors
109
  //===--------------------------------------------------------------------===//
110
111
  /// \brief Return true if the attribute is an Attribute::AttrKind type.
112
  bool isEnumAttribute() const;
113
114
  /// \brief Return true if the attribute is an integer attribute.
115
  bool isIntAttribute() const;
116
117
  /// \brief Return true if the attribute is a string (target-dependent)
118
  /// attribute.
119
  bool isStringAttribute() const;
120
121
  /// \brief Return true if the attribute is present.
122
  bool hasAttribute(AttrKind Val) const;
123
124
  /// \brief Return true if the target-dependent attribute is present.
125
  bool hasAttribute(StringRef Val) const;
126
127
  /// \brief Return the attribute's kind as an enum (Attribute::AttrKind). This
128
  /// requires the attribute to be an enum or integer attribute.
129
  Attribute::AttrKind getKindAsEnum() const;
130
131
  /// \brief Return the attribute's value as an integer. This requires that the
132
  /// attribute be an integer attribute.
133
  uint64_t getValueAsInt() const;
134
135
  /// \brief Return the attribute's kind as a string. This requires the
136
  /// attribute to be a string attribute.
137
  StringRef getKindAsString() const;
138
139
  /// \brief Return the attribute's value as a string. This requires the
140
  /// attribute to be a string attribute.
141
  StringRef getValueAsString() const;
142
143
  /// \brief Returns the alignment field of an attribute as a byte alignment
144
  /// value.
145
  unsigned getAlignment() const;
146
147
  /// \brief Returns the stack alignment field of an attribute as a byte
148
  /// alignment value.
149
  unsigned getStackAlignment() const;
150
151
  /// \brief Returns the number of dereferenceable bytes from the
152
  /// dereferenceable attribute.
153
  uint64_t getDereferenceableBytes() const;
154
155
  /// \brief Returns the number of dereferenceable_or_null bytes from the
156
  /// dereferenceable_or_null attribute.
157
  uint64_t getDereferenceableOrNullBytes() const;
158
159
  /// Returns the argument numbers for the allocsize attribute (or pair(0, 0)
160
  /// if not known).
161
  std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
162
163
  /// \brief The Attribute is converted to a string of equivalent mnemonic. This
164
  /// is, presumably, for writing out the mnemonics for the assembly writer.
165
  std::string getAsString(bool InAttrGrp = false) const;
166
167
  /// \brief Equality and non-equality operators.
168
8.83M
  bool operator==(Attribute A) const { return pImpl == A.pImpl; }
169
0
  bool operator!=(Attribute A) const { return pImpl != A.pImpl; }
170
171
  /// \brief Less-than operator. Useful for sorting the attributes list.
172
  bool operator<(Attribute A) const;
173
174
40.6M
  void Profile(FoldingSetNodeID &ID) const {
175
40.6M
    ID.AddPointer(pImpl);
176
40.6M
  }
177
178
  /// \brief Return a raw pointer that uniquely identifies this attribute.
179
3.80k
  void *getRawPointer() const {
180
3.80k
    return pImpl;
181
3.80k
  }
182
183
  /// \brief Get an attribute from a raw pointer created by getRawPointer.
184
20
  static Attribute fromRawPointer(void *RawPtr) {
185
20
    return Attribute(reinterpret_cast<AttributeImpl*>(RawPtr));
186
20
  }
187
};
188
189
// Specialized opaque value conversions.
190
3.80k
inline LLVMAttributeRef wrap(Attribute Attr) {
191
3.80k
  return reinterpret_cast<LLVMAttributeRef>(Attr.getRawPointer());
192
3.80k
}
193
194
// Specialized opaque value conversions.
195
20
inline Attribute unwrap(LLVMAttributeRef Attr) {
196
20
  return Attribute::fromRawPointer(Attr);
197
20
}
198
199
//===----------------------------------------------------------------------===//
200
/// \class
201
/// This class holds the attributes for a particular argument, parameter,
202
/// function, or return value. It is an immutable value type that is cheap to
203
/// copy. Adding and removing enum attributes is intended to be fast, but adding
204
/// and removing string or integer attributes involves a FoldingSet lookup.
205
class AttributeSet {
206
  // TODO: Extract AvailableAttrs from AttributeSetNode and store them here.
207
  // This will allow an efficient implementation of addAttribute and
208
  // removeAttribute for enum attrs.
209
210
  /// Private implementation pointer.
211
  AttributeSetNode *SetNode = nullptr;
212
213
  friend AttributeListImpl;
214
  template <typename Ty> friend struct DenseMapInfo;
215
216
private:
217
9.27M
  explicit AttributeSet(AttributeSetNode *ASN) : SetNode(ASN) {}
218
219
public:
220
  /// AttributeSet is a trivially copyable value type.
221
613M
  AttributeSet() = default;
222
  AttributeSet(const AttributeSet &) = default;
223
  ~AttributeSet() = default;
224
225
  static AttributeSet get(LLVMContext &C, const AttrBuilder &B);
226
  static AttributeSet get(LLVMContext &C, ArrayRef<Attribute> Attrs);
227
228
1.99M
  bool operator==(const AttributeSet &O) { return SetNode == O.SetNode; }
229
0
  bool operator!=(const AttributeSet &O) { return !(*this == O); }
230
231
  /// Add an argument attribute. Returns a new set because attribute sets are
232
  /// immutable.
233
  AttributeSet addAttribute(LLVMContext &C, Attribute::AttrKind Kind) const;
234
235
  /// Add a target-dependent attribute. Returns a new set because attribute sets
236
  /// are immutable.
237
  AttributeSet addAttribute(LLVMContext &C, StringRef Kind,
238
                            StringRef Value = StringRef()) const;
239
240
  /// Add attributes to the attribute set. Returns a new set because attribute
241
  /// sets are immutable.
242
  AttributeSet addAttributes(LLVMContext &C, AttributeSet AS) const;
243
244
  /// Remove the specified attribute from this set. Returns a new set because
245
  /// attribute sets are immutable.
246
  AttributeSet removeAttribute(LLVMContext &C, Attribute::AttrKind Kind) const;
247
248
  /// Remove the specified attribute from this set. Returns a new set because
249
  /// attribute sets are immutable.
250
  AttributeSet removeAttribute(LLVMContext &C, StringRef Kind) const;
251
252
  /// Remove the specified attributes from this set. Returns a new set because
253
  /// attribute sets are immutable.
254
  AttributeSet removeAttributes(LLVMContext &C,
255
                                const AttrBuilder &AttrsToRemove) const;
256
257
  /// Return the number of attributes in this set.
258
  unsigned getNumAttributes() const;
259
260
  /// Return true if attributes exists in this set.
261
8.67M
  bool hasAttributes() const { return SetNode != nullptr; }
262
263
  /// Return true if the attribute exists in this set.
264
  bool hasAttribute(Attribute::AttrKind Kind) const;
265
266
  /// Return true if the attribute exists in this set.
267
  bool hasAttribute(StringRef Kind) const;
268
269
  /// Return the attribute object.
270
  Attribute getAttribute(Attribute::AttrKind Kind) const;
271
272
  /// Return the target-dependent attribute object.
273
  Attribute getAttribute(StringRef Kind) const;
274
275
  unsigned getAlignment() const;
276
  unsigned getStackAlignment() const;
277
  uint64_t getDereferenceableBytes() const;
278
  uint64_t getDereferenceableOrNullBytes() const;
279
  std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
280
  std::string getAsString(bool InAttrGrp = false) const;
281
282
  using iterator = const Attribute *;
283
284
  iterator begin() const;
285
  iterator end() const;
286
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
287
  void dump() const;
288
#endif
289
};
290
291
//===----------------------------------------------------------------------===//
292
/// \class
293
/// \brief Provide DenseMapInfo for AttributeSet.
294
template <> struct DenseMapInfo<AttributeSet> {
295
460k
  static inline AttributeSet getEmptyKey() {
296
460k
    uintptr_t Val = static_cast<uintptr_t>(-1);
297
460k
    Val <<= PointerLikeTypeTraits<void *>::NumLowBitsAvailable;
298
460k
    return AttributeSet(reinterpret_cast<AttributeSetNode *>(Val));
299
460k
  }
300
301
415k
  static inline AttributeSet getTombstoneKey() {
302
415k
    uintptr_t Val = static_cast<uintptr_t>(-2);
303
415k
    Val <<= PointerLikeTypeTraits<void *>::NumLowBitsAvailable;
304
415k
    return AttributeSet(reinterpret_cast<AttributeSetNode *>(Val));
305
415k
  }
306
307
373k
  static unsigned getHashValue(AttributeSet AS) {
308
373k
    return (unsigned((uintptr_t)AS.SetNode) >> 4) ^
309
373k
           (unsigned((uintptr_t)AS.SetNode) >> 9);
310
373k
  }
311
312
1.99M
  static bool isEqual(AttributeSet LHS, AttributeSet RHS) { return LHS == RHS; }
313
};
314
315
//===----------------------------------------------------------------------===//
316
/// \class
317
/// \brief This class holds the attributes for a function, its return value, and
318
/// its parameters. You access the attributes for each of them via an index into
319
/// the AttributeList object. The function attributes are at index
320
/// `AttributeList::FunctionIndex', the return value is at index
321
/// `AttributeList::ReturnIndex', and the attributes for the parameters start at
322
/// index `AttributeList::FirstArgIndex'.
323
class AttributeList {
324
public:
325
  enum AttrIndex : unsigned {
326
    ReturnIndex = 0U,
327
    FunctionIndex = ~0U,
328
    FirstArgIndex = 1,
329
  };
330
331
private:
332
  friend class AttrBuilder;
333
  friend class AttributeListImpl;
334
  friend class AttributeSet;
335
  friend class AttributeSetNode;
336
337
  template <typename Ty> friend struct DenseMapInfo;
338
339
  /// \brief The attributes that we are managing. This can be null to represent
340
  /// the empty attributes list.
341
  AttributeListImpl *pImpl = nullptr;
342
343
public:
344
  /// \brief Create an AttributeList with the specified parameters in it.
345
  static AttributeList get(LLVMContext &C,
346
                           ArrayRef<std::pair<unsigned, Attribute>> Attrs);
347
  static AttributeList get(LLVMContext &C,
348
                           ArrayRef<std::pair<unsigned, AttributeSet>> Attrs);
349
350
  /// \brief Create an AttributeList from attribute sets for a function, its
351
  /// return value, and all of its arguments.
352
  static AttributeList get(LLVMContext &C, AttributeSet FnAttrs,
353
                           AttributeSet RetAttrs,
354
                           ArrayRef<AttributeSet> ArgAttrs);
355
356
private:
357
5.04M
  explicit AttributeList(AttributeListImpl *LI) : pImpl(LI) {}
358
359
  static AttributeList getImpl(LLVMContext &C, ArrayRef<AttributeSet> AttrSets);
360
361
public:
362
20.9M
  AttributeList() = default;
363
364
  //===--------------------------------------------------------------------===//
365
  // AttributeList Construction and Mutation
366
  //===--------------------------------------------------------------------===//
367
368
  /// \brief Return an AttributeList with the specified parameters in it.
369
  static AttributeList get(LLVMContext &C, ArrayRef<AttributeList> Attrs);
370
  static AttributeList get(LLVMContext &C, unsigned Index,
371
                           ArrayRef<Attribute::AttrKind> Kinds);
372
  static AttributeList get(LLVMContext &C, unsigned Index,
373
                           ArrayRef<StringRef> Kind);
374
  static AttributeList get(LLVMContext &C, unsigned Index,
375
                           const AttrBuilder &B);
376
377
  /// \brief Add an attribute to the attribute set at the given index.
378
  /// Returns a new list because attribute lists are immutable.
379
  AttributeList addAttribute(LLVMContext &C, unsigned Index,
380
                             Attribute::AttrKind Kind) const;
381
382
  /// \brief Add an attribute to the attribute set at the given index.
383
  /// Returns a new list because attribute lists are immutable.
384
  AttributeList addAttribute(LLVMContext &C, unsigned Index, StringRef Kind,
385
                             StringRef Value = StringRef()) const;
386
387
  /// Add an attribute to the attribute set at the given index.
388
  /// Returns a new list because attribute lists are immutable.
389
  AttributeList addAttribute(LLVMContext &C, unsigned Index, Attribute A) const;
390
391
  /// \brief Add attributes to the attribute set at the given index.
392
  /// Returns a new list because attribute lists are immutable.
393
  AttributeList addAttributes(LLVMContext &C, unsigned Index,
394
                              const AttrBuilder &B) const;
395
396
  /// Add an argument attribute to the list. Returns a new list because
397
  /// attribute lists are immutable.
398
  AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo,
399
259k
                                  Attribute::AttrKind Kind) const {
400
259k
    return addAttribute(C, ArgNo + FirstArgIndex, Kind);
401
259k
  }
402
403
  /// Add an argument attribute to the list. Returns a new list because
404
  /// attribute lists are immutable.
405
  AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo,
406
                                  StringRef Kind,
407
0
                                  StringRef Value = StringRef()) const {
408
0
    return addAttribute(C, ArgNo + FirstArgIndex, Kind, Value);
409
0
  }
410
411
  /// Add an attribute to the attribute list at the given arg indices. Returns a
412
  /// new list because attribute lists are immutable.
413
  AttributeList addParamAttribute(LLVMContext &C, ArrayRef<unsigned> ArgNos,
414
                                  Attribute A) const;
415
416
  /// Add an argument attribute to the list. Returns a new list because
417
  /// attribute lists are immutable.
418
  AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo,
419
7
                                   const AttrBuilder &B) const {
420
7
    return addAttributes(C, ArgNo + FirstArgIndex, B);
421
7
  }
422
423
  /// \brief Remove the specified attribute at the specified index from this
424
  /// attribute list. Returns a new list because attribute lists are immutable.
425
  AttributeList removeAttribute(LLVMContext &C, unsigned Index,
426
                                Attribute::AttrKind Kind) const;
427
428
  /// \brief Remove the specified attribute at the specified index from this
429
  /// attribute list. Returns a new list because attribute lists are immutable.
430
  AttributeList removeAttribute(LLVMContext &C, unsigned Index,
431
                                StringRef Kind) const;
432
433
  /// \brief Remove the specified attributes at the specified index from this
434
  /// attribute list. Returns a new list because attribute lists are immutable.
435
  AttributeList removeAttributes(LLVMContext &C, unsigned Index,
436
                                 const AttrBuilder &AttrsToRemove) const;
437
438
  /// \brief Remove all attributes at the specified index from this
439
  /// attribute list. Returns a new list because attribute lists are immutable.
440
  AttributeList removeAttributes(LLVMContext &C, unsigned Index) const;
441
442
  /// \brief Remove the specified attribute at the specified arg index from this
443
  /// attribute list. Returns a new list because attribute lists are immutable.
444
  AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo,
445
312
                                     Attribute::AttrKind Kind) const {
446
312
    return removeAttribute(C, ArgNo + FirstArgIndex, Kind);
447
312
  }
448
449
  /// \brief Remove the specified attribute at the specified arg index from this
450
  /// attribute list. Returns a new list because attribute lists are immutable.
451
  AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo,
452
0
                                     StringRef Kind) const {
453
0
    return removeAttribute(C, ArgNo + FirstArgIndex, Kind);
454
0
  }
455
456
  /// \brief Remove the specified attribute at the specified arg index from this
457
  /// attribute list. Returns a new list because attribute lists are immutable.
458
  AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo,
459
0
                                      const AttrBuilder &AttrsToRemove) const {
460
0
    return removeAttributes(C, ArgNo + FirstArgIndex, AttrsToRemove);
461
0
  }
462
463
  /// \brief Remove all attributes at the specified arg index from this
464
  /// attribute list. Returns a new list because attribute lists are immutable.
465
0
  AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo) const {
466
0
    return removeAttributes(C, ArgNo + FirstArgIndex);
467
0
  }
468
469
  /// \Brief Add the dereferenceable attribute to the attribute set at the given
470
  /// index. Returns a new list because attribute lists are immutable.
471
  AttributeList addDereferenceableAttr(LLVMContext &C, unsigned Index,
472
                                       uint64_t Bytes) const;
473
474
  /// \Brief Add the dereferenceable attribute to the attribute set at the given
475
  /// arg index. Returns a new list because attribute lists are immutable.
476
  AttributeList addDereferenceableParamAttr(LLVMContext &C, unsigned ArgNo,
477
0
                                            uint64_t Bytes) const {
478
0
    return addDereferenceableAttr(C, ArgNo + FirstArgIndex, Bytes);
479
0
  }
480
481
  /// \brief Add the dereferenceable_or_null attribute to the attribute set at
482
  /// the given index. Returns a new list because attribute lists are immutable.
483
  AttributeList addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
484
                                             uint64_t Bytes) const;
485
486
  /// \brief Add the dereferenceable_or_null attribute to the attribute set at
487
  /// the given arg index. Returns a new list because attribute lists are
488
  /// immutable.
489
  AttributeList addDereferenceableOrNullParamAttr(LLVMContext &C,
490
                                                  unsigned ArgNo,
491
0
                                                  uint64_t Bytes) const {
492
0
    return addDereferenceableOrNullAttr(C, ArgNo + FirstArgIndex, Bytes);
493
0
  }
494
495
  /// Add the allocsize attribute to the attribute set at the given index.
496
  /// Returns a new list because attribute lists are immutable.
497
  AttributeList addAllocSizeAttr(LLVMContext &C, unsigned Index,
498
                                 unsigned ElemSizeArg,
499
                                 const Optional<unsigned> &NumElemsArg);
500
501
  /// Add the allocsize attribute to the attribute set at the given arg index.
502
  /// Returns a new list because attribute lists are immutable.
503
  AttributeList addAllocSizeParamAttr(LLVMContext &C, unsigned ArgNo,
504
                                      unsigned ElemSizeArg,
505
0
                                      const Optional<unsigned> &NumElemsArg) {
506
0
    return addAllocSizeAttr(C, ArgNo + FirstArgIndex, ElemSizeArg, NumElemsArg);
507
0
  }
508
509
  //===--------------------------------------------------------------------===//
510
  // AttributeList Accessors
511
  //===--------------------------------------------------------------------===//
512
513
  /// \brief Retrieve the LLVM context.
514
  LLVMContext &getContext() const;
515
516
  /// \brief The attributes for the specified index are returned.
517
  AttributeSet getAttributes(unsigned Index) const;
518
519
  /// \brief The attributes for the argument or parameter at the given index are
520
  /// returned.
521
  AttributeSet getParamAttributes(unsigned ArgNo) const;
522
523
  /// \brief The attributes for the ret value are returned.
524
  AttributeSet getRetAttributes() const;
525
526
  /// \brief The function attributes are returned.
527
  AttributeSet getFnAttributes() const;
528
529
  /// \brief Return true if the attribute exists at the given index.
530
  bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
531
532
  /// \brief Return true if the attribute exists at the given index.
533
  bool hasAttribute(unsigned Index, StringRef Kind) const;
534
535
  /// \brief Return true if attribute exists at the given index.
536
  bool hasAttributes(unsigned Index) const;
537
538
  /// \brief Return true if the attribute exists for the given argument
539
0
  bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
540
0
    return hasAttribute(ArgNo + FirstArgIndex, Kind);
541
0
  }
542
543
  /// \brief Return true if the attribute exists for the given argument
544
0
  bool hasParamAttr(unsigned ArgNo, StringRef Kind) const {
545
0
    return hasAttribute(ArgNo + FirstArgIndex, Kind);
546
0
  }
547
548
  /// \brief Return true if attributes exists for the given argument
549
0
  bool hasParamAttrs(unsigned ArgNo) const {
550
0
    return hasAttributes(ArgNo + FirstArgIndex);
551
0
  }
552
553
  /// \brief Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
554
  /// may be faster.
555
  bool hasFnAttribute(Attribute::AttrKind Kind) const;
556
557
  /// \brief Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
558
  /// may be faster.
559
  bool hasFnAttribute(StringRef Kind) const;
560
561
  /// \brief Equivalent to hasAttribute(ArgNo + FirstArgIndex, Kind).
562
  bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;
563
564
  /// \brief Return true if the specified attribute is set for at least one
565
  /// parameter or for the return value. If Index is not nullptr, the index
566
  /// of a parameter with the specified attribute is provided.
567
  bool hasAttrSomewhere(Attribute::AttrKind Kind,
568
                        unsigned *Index = nullptr) const;
569
570
  /// \brief Return the attribute object that exists at the given index.
571
  Attribute getAttribute(unsigned Index, Attribute::AttrKind Kind) const;
572
573
  /// \brief Return the attribute object that exists at the given index.
574
  Attribute getAttribute(unsigned Index, StringRef Kind) const;
575
576
  /// \brief Return the attribute object that exists at the arg index.
577
0
  Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
578
0
    return getAttribute(ArgNo + FirstArgIndex, Kind);
579
0
  }
580
581
  /// \brief Return the attribute object that exists at the given index.
582
0
  Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
583
0
    return getAttribute(ArgNo + FirstArgIndex, Kind);
584
0
  }
585
586
  /// \brief Return the alignment of the return value.
587
  unsigned getRetAlignment() const;
588
589
  /// \brief Return the alignment for the specified function parameter.
590
  unsigned getParamAlignment(unsigned ArgNo) const;
591
592
  /// \brief Get the stack alignment.
593
  unsigned getStackAlignment(unsigned Index) const;
594
595
  /// \brief Get the number of dereferenceable bytes (or zero if unknown).
596
  uint64_t getDereferenceableBytes(unsigned Index) const;
597
598
  /// \brief Get the number of dereferenceable bytes (or zero if unknown) of an
599
  /// arg.
600
92.4M
  uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
601
92.4M
    return getDereferenceableBytes(ArgNo + FirstArgIndex);
602
92.4M
  }
603
604
  /// \brief Get the number of dereferenceable_or_null bytes (or zero if
605
  /// unknown).
606
  uint64_t getDereferenceableOrNullBytes(unsigned Index) const;
607
608
  /// \brief Get the number of dereferenceable_or_null bytes (or zero if
609
  /// unknown) of an arg.
610
1.36M
  uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
611
1.36M
    return getDereferenceableOrNullBytes(ArgNo + FirstArgIndex);
612
1.36M
  }
613
614
  /// Get the allocsize argument numbers (or pair(0, 0) if unknown).
615
  std::pair<unsigned, Optional<unsigned>>
616
  getAllocSizeArgs(unsigned Index) const;
617
618
  /// \brief Return the attributes at the index as a string.
619
  std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
620
621
  //===--------------------------------------------------------------------===//
622
  // AttributeList Introspection
623
  //===--------------------------------------------------------------------===//
624
625
  using iterator = const AttributeSet *;
626
627
  iterator begin() const;
628
  iterator end() const;
629
630
  unsigned getNumAttrSets() const;
631
632
  /// Use these to iterate over the valid attribute indices.
633
195M
  unsigned index_begin() const { return AttributeList::FunctionIndex; }
634
195M
  unsigned index_end() const { return getNumAttrSets() - 1; }
635
636
  /// operator==/!= - Provide equality predicates.
637
1.75M
  bool operator==(const AttributeList &RHS) const { return pImpl == RHS.pImpl; }
638
0
  bool operator!=(const AttributeList &RHS) const { return pImpl != RHS.pImpl; }
639
640
  /// \brief Return a raw pointer that uniquely identifies this attribute list.
641
0
  void *getRawPointer() const {
642
0
    return pImpl;
643
0
  }
644
645
  /// \brief Return true if there are no attributes.
646
1.25M
  bool isEmpty() const { return pImpl == nullptr; }
647
648
  void dump() const;
649
};
650
651
//===----------------------------------------------------------------------===//
652
/// \class
653
/// \brief Provide DenseMapInfo for AttributeList.
654
template <> struct DenseMapInfo<AttributeList> {
655
0
  static inline AttributeList getEmptyKey() {
656
0
    uintptr_t Val = static_cast<uintptr_t>(-1);
657
0
    Val <<= PointerLikeTypeTraits<void*>::NumLowBitsAvailable;
658
0
    return AttributeList(reinterpret_cast<AttributeListImpl *>(Val));
659
0
  }
660
661
0
  static inline AttributeList getTombstoneKey() {
662
0
    uintptr_t Val = static_cast<uintptr_t>(-2);
663
0
    Val <<= PointerLikeTypeTraits<void*>::NumLowBitsAvailable;
664
0
    return AttributeList(reinterpret_cast<AttributeListImpl *>(Val));
665
0
  }
666
667
0
  static unsigned getHashValue(AttributeList AS) {
668
0
    return (unsigned((uintptr_t)AS.pImpl) >> 4) ^
669
0
           (unsigned((uintptr_t)AS.pImpl) >> 9);
670
0
  }
671
672
0
  static bool isEqual(AttributeList LHS, AttributeList RHS) {
673
0
    return LHS == RHS;
674
0
  }
675
};
676
677
//===----------------------------------------------------------------------===//
678
/// \class
679
/// \brief This class is used in conjunction with the Attribute::get method to
680
/// create an Attribute object. The object itself is uniquified. The Builder's
681
/// value, however, is not. So this can be used as a quick way to test for
682
/// equality, presence of attributes, etc.
683
class AttrBuilder {
684
  std::bitset<Attribute::EndAttrKinds> Attrs;
685
  std::map<std::string, std::string> TargetDepAttrs;
686
  uint64_t Alignment = 0;
687
  uint64_t StackAlignment = 0;
688
  uint64_t DerefBytes = 0;
689
  uint64_t DerefOrNullBytes = 0;
690
  uint64_t AllocSizeArgs = 0;
691
692
public:
693
7.72M
  AttrBuilder() = default;
694
2
  AttrBuilder(const Attribute &A) {
695
2
    addAttribute(A);
696
2
  }
697
  AttrBuilder(AttributeList AS, unsigned Idx);
698
  AttrBuilder(AttributeSet AS);
699
700
  void clear();
701
702
  /// \brief Add an attribute to the builder.
703
  AttrBuilder &addAttribute(Attribute::AttrKind Val);
704
705
  /// \brief Add the Attribute object to the builder.
706
  AttrBuilder &addAttribute(Attribute A);
707
708
  /// \brief Add the target-dependent attribute to the builder.
709
  AttrBuilder &addAttribute(StringRef A, StringRef V = StringRef());
710
711
  /// \brief Remove an attribute from the builder.
712
  AttrBuilder &removeAttribute(Attribute::AttrKind Val);
713
714
  /// \brief Remove the attributes from the builder.
715
  AttrBuilder &removeAttributes(AttributeList A, uint64_t WithoutIndex);
716
717
  /// \brief Remove the target-dependent attribute to the builder.
718
  AttrBuilder &removeAttribute(StringRef A);
719
720
  /// \brief Add the attributes from the builder.
721
  AttrBuilder &merge(const AttrBuilder &B);
722
723
  /// \brief Remove the attributes from the builder.
724
  AttrBuilder &remove(const AttrBuilder &B);
725
726
  /// \brief Return true if the builder has any attribute that's in the
727
  /// specified builder.
728
  bool overlaps(const AttrBuilder &B) const;
729
730
  /// \brief Return true if the builder has the specified attribute.
731
398M
  bool contains(Attribute::AttrKind A) const {
732
398M
    assert((unsigned)A < Attribute::EndAttrKinds && "Attribute out of range!");
733
398M
    return Attrs[A];
734
398M
  }
735
736
  /// \brief Return true if the builder has the specified target-dependent
737
  /// attribute.
738
  bool contains(StringRef A) const;
739
740
  /// \brief Return true if the builder has IR-level attributes.
741
  bool hasAttributes() const;
742
743
  /// \brief Return true if the builder has any attribute that's in the
744
  /// specified attribute.
745
  bool hasAttributes(AttributeList A, uint64_t Index) const;
746
747
  /// \brief Return true if the builder has an alignment attribute.
748
  bool hasAlignmentAttr() const;
749
750
  /// \brief Retrieve the alignment attribute, if it exists.
751
3.16k
  uint64_t getAlignment() const { return Alignment; }
752
753
  /// \brief Retrieve the stack alignment attribute, if it exists.
754
199
  uint64_t getStackAlignment() const { return StackAlignment; }
755
756
  /// \brief Retrieve the number of dereferenceable bytes, if the
757
  /// dereferenceable attribute exists (zero is returned otherwise).
758
122k
  uint64_t getDereferenceableBytes() const { return DerefBytes; }
759
760
  /// \brief Retrieve the number of dereferenceable_or_null bytes, if the
761
  /// dereferenceable_or_null attribute exists (zero is returned otherwise).
762
81
  uint64_t getDereferenceableOrNullBytes() const { return DerefOrNullBytes; }
763
764
  /// Retrieve the allocsize args, if the allocsize attribute exists.  If it
765
  /// doesn't exist, pair(0, 0) is returned.
766
  std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
767
768
  /// \brief This turns an int alignment (which must be a power of 2) into the
769
  /// form used internally in Attribute.
770
  AttrBuilder &addAlignmentAttr(unsigned Align);
771
772
  /// \brief This turns an int stack alignment (which must be a power of 2) into
773
  /// the form used internally in Attribute.
774
  AttrBuilder &addStackAlignmentAttr(unsigned Align);
775
776
  /// \brief This turns the number of dereferenceable bytes into the form used
777
  /// internally in Attribute.
778
  AttrBuilder &addDereferenceableAttr(uint64_t Bytes);
779
780
  /// \brief This turns the number of dereferenceable_or_null bytes into the
781
  /// form used internally in Attribute.
782
  AttrBuilder &addDereferenceableOrNullAttr(uint64_t Bytes);
783
784
  /// This turns one (or two) ints into the form used internally in Attribute.
785
  AttrBuilder &addAllocSizeAttr(unsigned ElemSizeArg,
786
                                const Optional<unsigned> &NumElemsArg);
787
788
  /// Add an allocsize attribute, using the representation returned by
789
  /// Attribute.getIntValue().
790
  AttrBuilder &addAllocSizeAttrFromRawRepr(uint64_t RawAllocSizeRepr);
791
792
  /// \brief Return true if the builder contains no target-independent
793
  /// attributes.
794
896
  bool empty() const { return Attrs.none(); }
795
796
  // Iterators for target-dependent attributes.
797
  using td_type = std::pair<std::string, std::string>;
798
  using td_iterator = std::map<std::string, std::string>::iterator;
799
  using td_const_iterator = std::map<std::string, std::string>::const_iterator;
800
  using td_range = iterator_range<td_iterator>;
801
  using td_const_range = iterator_range<td_const_iterator>;
802
803
84
  td_iterator td_begin()             { return TargetDepAttrs.begin(); }
804
84
  td_iterator td_end()               { return TargetDepAttrs.end(); }
805
806
11.1M
  td_const_iterator td_begin() const { return TargetDepAttrs.begin(); }
807
11.1M
  td_const_iterator td_end() const   { return TargetDepAttrs.end(); }
808
809
84
  td_range td_attrs() { return td_range(td_begin(), td_end()); }
810
11.1M
  td_const_range td_attrs() const {
811
11.1M
    return td_const_range(td_begin(), td_end());
812
11.1M
  }
813
814
0
  bool td_empty() const              { return TargetDepAttrs.empty(); }
815
816
  bool operator==(const AttrBuilder &B);
817
219k
  bool operator!=(const AttrBuilder &B) {
818
219k
    return !(*this == B);
819
219k
  }
820
};
821
822
namespace AttributeFuncs {
823
824
/// \brief Which attributes cannot be applied to a type.
825
AttrBuilder typeIncompatible(Type *Ty);
826
827
/// \returns Return true if the two functions have compatible target-independent
828
/// attributes for inlining purposes.
829
bool areInlineCompatible(const Function &Caller, const Function &Callee);
830
831
/// \brief Merge caller's and callee's attributes.
832
void mergeAttributesForInlining(Function &Caller, const Function &Callee);
833
834
} // end namespace AttributeFuncs
835
836
} // end namespace llvm
837
838
#endif // LLVM_IR_ATTRIBUTES_H