← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to include/llvm/IR/Function.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/llvm/IR/Function.h
 
1
//===-- llvm/Function.h - Class to represent a single function --*- 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
// This file contains the declaration of the Function class, which represents a
 
11
// single function/procedure in LLVM.
 
12
//
 
13
// A function basically consists of a list of basic blocks, a list of arguments,
 
14
// and a symbol table.
 
15
//
 
16
//===----------------------------------------------------------------------===//
 
17
 
 
18
#ifndef LLVM_IR_FUNCTION_H
 
19
#define LLVM_IR_FUNCTION_H
 
20
 
 
21
#include "llvm/ADT/iterator_range.h"
 
22
#include "llvm/ADT/Optional.h"
 
23
#include "llvm/IR/Argument.h"
 
24
#include "llvm/IR/Attributes.h"
 
25
#include "llvm/IR/BasicBlock.h"
 
26
#include "llvm/IR/CallingConv.h"
 
27
#include "llvm/IR/GlobalObject.h"
 
28
#include "llvm/IR/OperandTraits.h"
 
29
#include "llvm/Support/Compiler.h"
 
30
 
 
31
namespace llvm {
 
32
 
 
33
class FunctionType;
 
34
class LLVMContext;
 
35
 
 
36
template<> struct ilist_traits<Argument>
 
37
  : public SymbolTableListTraits<Argument, Function> {
 
38
 
 
39
  Argument *createSentinel() const {
 
40
    return static_cast<Argument*>(&Sentinel);
 
41
  }
 
42
  static void destroySentinel(Argument*) {}
 
43
 
 
44
  Argument *provideInitialHead() const { return createSentinel(); }
 
45
  Argument *ensureHead(Argument*) const { return createSentinel(); }
 
46
  static void noteHead(Argument*, Argument*) {}
 
47
 
 
48
  static ValueSymbolTable *getSymTab(Function *ItemParent);
 
49
private:
 
50
  mutable ilist_half_node<Argument> Sentinel;
 
51
};
 
52
 
 
53
class Function : public GlobalObject, public ilist_node<Function> {
 
54
public:
 
55
  typedef iplist<Argument> ArgumentListType;
 
56
  typedef iplist<BasicBlock> BasicBlockListType;
 
57
 
 
58
  // BasicBlock iterators...
 
59
  typedef BasicBlockListType::iterator iterator;
 
60
  typedef BasicBlockListType::const_iterator const_iterator;
 
61
 
 
62
  typedef ArgumentListType::iterator arg_iterator;
 
63
  typedef ArgumentListType::const_iterator const_arg_iterator;
 
64
 
 
65
private:
 
66
  // Important things that make up a function!
 
67
  BasicBlockListType  BasicBlocks;        ///< The basic blocks
 
68
  mutable ArgumentListType ArgumentList;  ///< The formal arguments
 
69
  ValueSymbolTable *SymTab;               ///< Symbol table of args/instructions
 
70
  AttributeSet AttributeSets;             ///< Parameter attributes
 
71
  FunctionType *Ty;
 
72
 
 
73
  /*
 
74
   * Value::SubclassData
 
75
   *
 
76
   * bit 0  : HasLazyArguments
 
77
   * bit 1  : HasPrefixData
 
78
   * bit 2  : HasPrologueData
 
79
   * bit 3-6: CallingConvention
 
80
   */
 
81
 
 
82
  /// Bits from GlobalObject::GlobalObjectSubclassData.
 
83
  enum {
 
84
    /// Whether this function is materializable.
 
85
    IsMaterializableBit = 1 << 0,
 
86
    HasMetadataHashEntryBit = 1 << 1
 
87
  };
 
88
  void setGlobalObjectBit(unsigned Mask, bool Value) {
 
89
    setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
 
90
                                (Value ? Mask : 0u));
 
91
  }
 
92
 
 
93
  friend class SymbolTableListTraits<Function, Module>;
 
94
 
 
95
  void setParent(Module *parent);
 
96
 
 
97
  /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
 
98
  /// built on demand, so that the list isn't allocated until the first client
 
99
  /// needs it.  The hasLazyArguments predicate returns true if the arg list
 
100
  /// hasn't been set up yet.
 
101
  bool hasLazyArguments() const {
 
102
    return getSubclassDataFromValue() & (1<<0);
 
103
  }
 
104
  void CheckLazyArguments() const {
 
105
    if (hasLazyArguments())
 
106
      BuildLazyArguments();
 
107
  }
 
108
  void BuildLazyArguments() const;
 
109
 
 
110
  Function(const Function&) = delete;
 
111
  void operator=(const Function&) = delete;
 
112
 
 
113
  /// Function ctor - If the (optional) Module argument is specified, the
 
114
  /// function is automatically inserted into the end of the function list for
 
115
  /// the module.
 
116
  ///
 
117
  Function(FunctionType *Ty, LinkageTypes Linkage,
 
118
           const Twine &N = "", Module *M = nullptr);
 
119
 
 
120
public:
 
121
  static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
 
122
                          const Twine &N = "", Module *M = nullptr) {
 
123
    return new(1) Function(Ty, Linkage, N, M);
 
124
  }
 
125
 
 
126
  ~Function() override;
 
127
 
 
128
  /// \brief Provide fast operand accessors
 
129
  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
130
 
 
131
  /// \brief Get the personality function associated with this function.
 
132
  bool hasPersonalityFn() const { return getNumOperands() != 0; }
 
133
  Constant *getPersonalityFn() const {
 
134
    assert(hasPersonalityFn());
 
135
    return cast<Constant>(Op<0>());
 
136
  }
 
137
  void setPersonalityFn(Constant *C);
 
138
 
 
139
  Type *getReturnType() const;           // Return the type of the ret val
 
140
  FunctionType *getFunctionType() const; // Return the FunctionType for me
 
141
 
 
142
  /// getContext - Return a reference to the LLVMContext associated with this
 
143
  /// function.
 
144
  LLVMContext &getContext() const;
 
145
 
 
146
  /// isVarArg - Return true if this function takes a variable number of
 
147
  /// arguments.
 
148
  bool isVarArg() const;
 
149
 
 
150
  bool isMaterializable() const;
 
151
  void setIsMaterializable(bool V);
 
152
 
 
153
  /// getIntrinsicID - This method returns the ID number of the specified
 
154
  /// function, or Intrinsic::not_intrinsic if the function is not an
 
155
  /// intrinsic, or if the pointer is null.  This value is always defined to be
 
156
  /// zero to allow easy checking for whether a function is intrinsic or not.
 
157
  /// The particular intrinsic functions which correspond to this value are
 
158
  /// defined in llvm/Intrinsics.h.
 
159
  Intrinsic::ID getIntrinsicID() const LLVM_READONLY { return IntID; }
 
160
  bool isIntrinsic() const { return getName().startswith("llvm."); }
 
161
 
 
162
  /// \brief Recalculate the ID for this function if it is an Intrinsic defined
 
163
  /// in llvm/Intrinsics.h.  Sets the intrinsic ID to Intrinsic::not_intrinsic
 
164
  /// if the name of this function does not match an intrinsic in that header.
 
165
  /// Note, this method does not need to be called directly, as it is called
 
166
  /// from Value::setName() whenever the name of this function changes.
 
167
  void recalculateIntrinsicID();
 
168
 
 
169
  /// getCallingConv()/setCallingConv(CC) - These method get and set the
 
170
  /// calling convention of this function.  The enum values for the known
 
171
  /// calling conventions are defined in CallingConv.h.
 
172
  CallingConv::ID getCallingConv() const {
 
173
    return static_cast<CallingConv::ID>(getSubclassDataFromValue() >> 3);
 
174
  }
 
175
  void setCallingConv(CallingConv::ID CC) {
 
176
    setValueSubclassData((getSubclassDataFromValue() & 7) |
 
177
                         (static_cast<unsigned>(CC) << 3));
 
178
  }
 
179
 
 
180
  /// @brief Return the attribute list for this Function.
 
181
  AttributeSet getAttributes() const { return AttributeSets; }
 
182
 
 
183
  /// @brief Set the attribute list for this Function.
 
184
  void setAttributes(AttributeSet attrs) { AttributeSets = attrs; }
 
185
 
 
186
  /// @brief Add function attributes to this function.
 
187
  void addFnAttr(Attribute::AttrKind N) {
 
188
    setAttributes(AttributeSets.addAttribute(getContext(),
 
189
                                             AttributeSet::FunctionIndex, N));
 
190
  }
 
191
 
 
192
  /// @brief Remove function attributes from this function.
 
193
  void removeFnAttr(Attribute::AttrKind N) {
 
194
    setAttributes(AttributeSets.removeAttribute(
 
195
        getContext(), AttributeSet::FunctionIndex, N));
 
196
  }
 
197
 
 
198
  /// @brief Add function attributes to this function.
 
199
  void addFnAttr(StringRef Kind) {
 
200
    setAttributes(
 
201
      AttributeSets.addAttribute(getContext(),
 
202
                                 AttributeSet::FunctionIndex, Kind));
 
203
  }
 
204
  void addFnAttr(StringRef Kind, StringRef Value) {
 
205
    setAttributes(
 
206
      AttributeSets.addAttribute(getContext(),
 
207
                                 AttributeSet::FunctionIndex, Kind, Value));
 
208
  }
 
209
 
 
210
  /// Set the entry count for this function.
 
211
  void setEntryCount(uint64_t Count);
 
212
 
 
213
  /// Get the entry count for this function.
 
214
  Optional<uint64_t> getEntryCount() const;
 
215
 
 
216
  /// @brief Return true if the function has the attribute.
 
217
  bool hasFnAttribute(Attribute::AttrKind Kind) const {
 
218
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex, Kind);
 
219
  }
 
220
  bool hasFnAttribute(StringRef Kind) const {
 
221
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex, Kind);
 
222
  }
 
223
 
 
224
  /// @brief Return the attribute for the given attribute kind.
 
225
  Attribute getFnAttribute(Attribute::AttrKind Kind) const {
 
226
    return AttributeSets.getAttribute(AttributeSet::FunctionIndex, Kind);
 
227
  }
 
228
  Attribute getFnAttribute(StringRef Kind) const {
 
229
    return AttributeSets.getAttribute(AttributeSet::FunctionIndex, Kind);
 
230
  }
 
231
 
 
232
  /// \brief Return the stack alignment for the function.
 
233
  unsigned getFnStackAlignment() const {
 
234
    return AttributeSets.getStackAlignment(AttributeSet::FunctionIndex);
 
235
  }
 
236
 
 
237
  /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
 
238
  ///                             to use during code generation.
 
239
  bool hasGC() const;
 
240
  const char *getGC() const;
 
241
  void setGC(const char *Str);
 
242
  void clearGC();
 
243
 
 
244
  /// @brief adds the attribute to the list of attributes.
 
245
  void addAttribute(unsigned i, Attribute::AttrKind attr);
 
246
 
 
247
  /// @brief adds the attributes to the list of attributes.
 
248
  void addAttributes(unsigned i, AttributeSet attrs);
 
249
 
 
250
  /// @brief removes the attributes from the list of attributes.
 
251
  void removeAttributes(unsigned i, AttributeSet attr);
 
252
 
 
253
  /// @brief adds the dereferenceable attribute to the list of attributes.
 
254
  void addDereferenceableAttr(unsigned i, uint64_t Bytes);
 
255
 
 
256
  /// @brief adds the dereferenceable_or_null attribute to the list of
 
257
  /// attributes.
 
258
  void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
 
259
 
 
260
  /// @brief Extract the alignment for a call or parameter (0=unknown).
 
261
  unsigned getParamAlignment(unsigned i) const {
 
262
    return AttributeSets.getParamAlignment(i);
 
263
  }
 
264
 
 
265
  /// @brief Extract the number of dereferenceable bytes for a call or
 
266
  /// parameter (0=unknown).
 
267
  uint64_t getDereferenceableBytes(unsigned i) const {
 
268
    return AttributeSets.getDereferenceableBytes(i);
 
269
  }
 
270
  
 
271
  /// @brief Extract the number of dereferenceable_or_null bytes for a call or
 
272
  /// parameter (0=unknown).
 
273
  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
 
274
    return AttributeSets.getDereferenceableOrNullBytes(i);
 
275
  }
 
276
  
 
277
  /// @brief Determine if the function does not access memory.
 
278
  bool doesNotAccessMemory() const {
 
279
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
 
280
                                      Attribute::ReadNone);
 
281
  }
 
282
  void setDoesNotAccessMemory() {
 
283
    addFnAttr(Attribute::ReadNone);
 
284
  }
 
285
 
 
286
  /// @brief Determine if the function does not access or only reads memory.
 
287
  bool onlyReadsMemory() const {
 
288
    return doesNotAccessMemory() ||
 
289
      AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
 
290
                                 Attribute::ReadOnly);
 
291
  }
 
292
  void setOnlyReadsMemory() {
 
293
    addFnAttr(Attribute::ReadOnly);
 
294
  }
 
295
 
 
296
  /// @brief Determine if the call can access memmory only using pointers based
 
297
  /// on its arguments.
 
298
  bool onlyAccessesArgMemory() const {
 
299
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
 
300
                                      Attribute::ArgMemOnly);
 
301
  }
 
302
  void setOnlyAccessesArgMemory() {
 
303
    addFnAttr(Attribute::ArgMemOnly);
 
304
  }
 
305
  
 
306
  /// @brief Determine if the function cannot return.
 
307
  bool doesNotReturn() const {
 
308
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
 
309
                                      Attribute::NoReturn);
 
310
  }
 
311
  void setDoesNotReturn() {
 
312
    addFnAttr(Attribute::NoReturn);
 
313
  }
 
314
 
 
315
  /// @brief Determine if the function cannot unwind.
 
316
  bool doesNotThrow() const {
 
317
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
 
318
                                      Attribute::NoUnwind);
 
319
  }
 
320
  void setDoesNotThrow() {
 
321
    addFnAttr(Attribute::NoUnwind);
 
322
  }
 
323
 
 
324
  /// @brief Determine if the call cannot be duplicated.
 
325
  bool cannotDuplicate() const {
 
326
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
 
327
                                      Attribute::NoDuplicate);
 
328
  }
 
329
  void setCannotDuplicate() {
 
330
    addFnAttr(Attribute::NoDuplicate);
 
331
  }
 
332
 
 
333
  /// @brief Determine if the call is convergent.
 
334
  bool isConvergent() const {
 
335
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
 
336
                                      Attribute::Convergent);
 
337
  }
 
338
  void setConvergent() {
 
339
    addFnAttr(Attribute::Convergent);
 
340
  }
 
341
 
 
342
 
 
343
  /// @brief True if the ABI mandates (or the user requested) that this
 
344
  /// function be in a unwind table.
 
345
  bool hasUWTable() const {
 
346
    return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
 
347
                                      Attribute::UWTable);
 
348
  }
 
349
  void setHasUWTable() {
 
350
    addFnAttr(Attribute::UWTable);
 
351
  }
 
352
 
 
353
  /// @brief True if this function needs an unwind table.
 
354
  bool needsUnwindTableEntry() const {
 
355
    return hasUWTable() || !doesNotThrow();
 
356
  }
 
357
 
 
358
  /// @brief Determine if the function returns a structure through first
 
359
  /// pointer argument.
 
360
  bool hasStructRetAttr() const {
 
361
    return AttributeSets.hasAttribute(1, Attribute::StructRet) ||
 
362
           AttributeSets.hasAttribute(2, Attribute::StructRet);
 
363
  }
 
364
 
 
365
  /// @brief Determine if the parameter does not alias other parameters.
 
366
  /// @param n The parameter to check. 1 is the first parameter, 0 is the return
 
367
  bool doesNotAlias(unsigned n) const {
 
368
    return AttributeSets.hasAttribute(n, Attribute::NoAlias);
 
369
  }
 
370
  void setDoesNotAlias(unsigned n) {
 
371
    addAttribute(n, Attribute::NoAlias);
 
372
  }
 
373
 
 
374
  /// @brief Determine if the parameter can be captured.
 
375
  /// @param n The parameter to check. 1 is the first parameter, 0 is the return
 
376
  bool doesNotCapture(unsigned n) const {
 
377
    return AttributeSets.hasAttribute(n, Attribute::NoCapture);
 
378
  }
 
379
  void setDoesNotCapture(unsigned n) {
 
380
    addAttribute(n, Attribute::NoCapture);
 
381
  }
 
382
 
 
383
  bool doesNotAccessMemory(unsigned n) const {
 
384
    return AttributeSets.hasAttribute(n, Attribute::ReadNone);
 
385
  }
 
386
  void setDoesNotAccessMemory(unsigned n) {
 
387
    addAttribute(n, Attribute::ReadNone);
 
388
  }
 
389
 
 
390
  bool onlyReadsMemory(unsigned n) const {
 
391
    return doesNotAccessMemory(n) ||
 
392
      AttributeSets.hasAttribute(n, Attribute::ReadOnly);
 
393
  }
 
394
  void setOnlyReadsMemory(unsigned n) {
 
395
    addAttribute(n, Attribute::ReadOnly);
 
396
  }
 
397
 
 
398
  /// copyAttributesFrom - copy all additional attributes (those not needed to
 
399
  /// create a Function) from the Function Src to this one.
 
400
  void copyAttributesFrom(const GlobalValue *Src) override;
 
401
 
 
402
  /// deleteBody - This method deletes the body of the function, and converts
 
403
  /// the linkage to external.
 
404
  ///
 
405
  void deleteBody() {
 
406
    dropAllReferences();
 
407
    setLinkage(ExternalLinkage);
 
408
  }
 
409
 
 
410
  /// removeFromParent - This method unlinks 'this' from the containing module,
 
411
  /// but does not delete it.
 
412
  ///
 
413
  void removeFromParent() override;
 
414
 
 
415
  /// eraseFromParent - This method unlinks 'this' from the containing module
 
416
  /// and deletes it.
 
417
  ///
 
418
  void eraseFromParent() override;
 
419
 
 
420
 
 
421
  /// Get the underlying elements of the Function... the basic block list is
 
422
  /// empty for external functions.
 
423
  ///
 
424
  const ArgumentListType &getArgumentList() const {
 
425
    CheckLazyArguments();
 
426
    return ArgumentList;
 
427
  }
 
428
  ArgumentListType &getArgumentList() {
 
429
    CheckLazyArguments();
 
430
    return ArgumentList;
 
431
  }
 
432
  static iplist<Argument> Function::*getSublistAccess(Argument*) {
 
433
    return &Function::ArgumentList;
 
434
  }
 
435
 
 
436
  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
 
437
        BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }
 
438
  static iplist<BasicBlock> Function::*getSublistAccess(BasicBlock*) {
 
439
    return &Function::BasicBlocks;
 
440
  }
 
441
 
 
442
  const BasicBlock       &getEntryBlock() const   { return front(); }
 
443
        BasicBlock       &getEntryBlock()         { return front(); }
 
444
 
 
445
  //===--------------------------------------------------------------------===//
 
446
  // Symbol Table Accessing functions...
 
447
 
 
448
  /// getSymbolTable() - Return the symbol table...
 
449
  ///
 
450
  inline       ValueSymbolTable &getValueSymbolTable()       { return *SymTab; }
 
451
  inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; }
 
452
 
 
453
 
 
454
  //===--------------------------------------------------------------------===//
 
455
  // BasicBlock iterator forwarding functions
 
456
  //
 
457
  iterator                begin()       { return BasicBlocks.begin(); }
 
458
  const_iterator          begin() const { return BasicBlocks.begin(); }
 
459
  iterator                end  ()       { return BasicBlocks.end();   }
 
460
  const_iterator          end  () const { return BasicBlocks.end();   }
 
461
 
 
462
  size_t                   size() const { return BasicBlocks.size();  }
 
463
  bool                    empty() const { return BasicBlocks.empty(); }
 
464
  const BasicBlock       &front() const { return BasicBlocks.front(); }
 
465
        BasicBlock       &front()       { return BasicBlocks.front(); }
 
466
  const BasicBlock        &back() const { return BasicBlocks.back();  }
 
467
        BasicBlock        &back()       { return BasicBlocks.back();  }
 
468
 
 
469
/// @name Function Argument Iteration
 
470
/// @{
 
471
 
 
472
  arg_iterator arg_begin() {
 
473
    CheckLazyArguments();
 
474
    return ArgumentList.begin();
 
475
  }
 
476
  const_arg_iterator arg_begin() const {
 
477
    CheckLazyArguments();
 
478
    return ArgumentList.begin();
 
479
  }
 
480
  arg_iterator arg_end() {
 
481
    CheckLazyArguments();
 
482
    return ArgumentList.end();
 
483
  }
 
484
  const_arg_iterator arg_end() const {
 
485
    CheckLazyArguments();
 
486
    return ArgumentList.end();
 
487
  }
 
488
 
 
489
  iterator_range<arg_iterator> args() {
 
490
    return iterator_range<arg_iterator>(arg_begin(), arg_end());
 
491
  }
 
492
 
 
493
  iterator_range<const_arg_iterator> args() const {
 
494
    return iterator_range<const_arg_iterator>(arg_begin(), arg_end());
 
495
  }
 
496
 
 
497
/// @}
 
498
 
 
499
  size_t arg_size() const;
 
500
  bool arg_empty() const;
 
501
 
 
502
  bool hasPrefixData() const {
 
503
    return getSubclassDataFromValue() & (1<<1);
 
504
  }
 
505
 
 
506
  Constant *getPrefixData() const;
 
507
  void setPrefixData(Constant *PrefixData);
 
508
 
 
509
  bool hasPrologueData() const {
 
510
    return getSubclassDataFromValue() & (1<<2);
 
511
  }
 
512
 
 
513
  Constant *getPrologueData() const;
 
514
  void setPrologueData(Constant *PrologueData);
 
515
 
 
516
  /// Print the function to an output stream with an optional
 
517
  /// AssemblyAnnotationWriter.
 
518
  void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr) const;
 
519
 
 
520
  /// viewCFG - This function is meant for use from the debugger.  You can just
 
521
  /// say 'call F->viewCFG()' and a ghostview window should pop up from the
 
522
  /// program, displaying the CFG of the current function with the code for each
 
523
  /// basic block inside.  This depends on there being a 'dot' and 'gv' program
 
524
  /// in your path.
 
525
  ///
 
526
  void viewCFG() const;
 
527
 
 
528
  /// viewCFGOnly - This function is meant for use from the debugger.  It works
 
529
  /// just like viewCFG, but it does not include the contents of basic blocks
 
530
  /// into the nodes, just the label.  If you are only interested in the CFG
 
531
  /// this can make the graph smaller.
 
532
  ///
 
533
  void viewCFGOnly() const;
 
534
 
 
535
  /// Methods for support type inquiry through isa, cast, and dyn_cast:
 
536
  static inline bool classof(const Value *V) {
 
537
    return V->getValueID() == Value::FunctionVal;
 
538
  }
 
539
 
 
540
  /// dropAllReferences() - This method causes all the subinstructions to "let
 
541
  /// go" of all references that they are maintaining.  This allows one to
 
542
  /// 'delete' a whole module at a time, even though there may be circular
 
543
  /// references... first all references are dropped, and all use counts go to
 
544
  /// zero.  Then everything is deleted for real.  Note that no operations are
 
545
  /// valid on an object that has "dropped all references", except operator
 
546
  /// delete.
 
547
  ///
 
548
  /// Since no other object in the module can have references into the body of a
 
549
  /// function, dropping all references deletes the entire body of the function,
 
550
  /// including any contained basic blocks.
 
551
  ///
 
552
  void dropAllReferences();
 
553
 
 
554
  /// hasAddressTaken - returns true if there are any uses of this function
 
555
  /// other than direct calls or invokes to it, or blockaddress expressions.
 
556
  /// Optionally passes back an offending user for diagnostic purposes.
 
557
  ///
 
558
  bool hasAddressTaken(const User** = nullptr) const;
 
559
 
 
560
  /// isDefTriviallyDead - Return true if it is trivially safe to remove
 
561
  /// this function definition from the module (because it isn't externally
 
562
  /// visible, does not have its address taken, and has no callers).  To make
 
563
  /// this more accurate, call removeDeadConstantUsers first.
 
564
  bool isDefTriviallyDead() const;
 
565
 
 
566
  /// callsFunctionThatReturnsTwice - Return true if the function has a call to
 
567
  /// setjmp or other function that gcc recognizes as "returning twice".
 
568
  bool callsFunctionThatReturnsTwice() const;
 
569
 
 
570
  /// \brief Check if this has any metadata.
 
571
  bool hasMetadata() const { return hasMetadataHashEntry(); }
 
572
 
 
573
  /// \brief Get the current metadata attachment, if any.
 
574
  ///
 
575
  /// Returns \c nullptr if such an attachment is missing.
 
576
  /// @{
 
577
  MDNode *getMetadata(unsigned KindID) const;
 
578
  MDNode *getMetadata(StringRef Kind) const;
 
579
  /// @}
 
580
 
 
581
  /// \brief Set a particular kind of metadata attachment.
 
582
  ///
 
583
  /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
 
584
  /// replacing it if it already exists.
 
585
  /// @{
 
586
  void setMetadata(unsigned KindID, MDNode *MD);
 
587
  void setMetadata(StringRef Kind, MDNode *MD);
 
588
  /// @}
 
589
 
 
590
  /// \brief Get all current metadata attachments.
 
591
  void
 
592
  getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
 
593
 
 
594
  /// \brief Drop metadata not in the given list.
 
595
  ///
 
596
  /// Drop all metadata from \c this not included in \c KnownIDs.
 
597
  void dropUnknownMetadata(ArrayRef<unsigned> KnownIDs);
 
598
 
 
599
private:
 
600
  // Shadow Value::setValueSubclassData with a private forwarding method so that
 
601
  // subclasses cannot accidentally use it.
 
602
  void setValueSubclassData(unsigned short D) {
 
603
    Value::setValueSubclassData(D);
 
604
  }
 
605
 
 
606
  bool hasMetadataHashEntry() const {
 
607
    return getGlobalObjectSubClassData() & HasMetadataHashEntryBit;
 
608
  }
 
609
  void setHasMetadataHashEntry(bool HasEntry) {
 
610
    setGlobalObjectBit(HasMetadataHashEntryBit, HasEntry);
 
611
  }
 
612
 
 
613
  void clearMetadata();
 
614
};
 
615
 
 
616
inline ValueSymbolTable *
 
617
ilist_traits<BasicBlock>::getSymTab(Function *F) {
 
618
  return F ? &F->getValueSymbolTable() : nullptr;
 
619
}
 
620
 
 
621
inline ValueSymbolTable *
 
622
ilist_traits<Argument>::getSymTab(Function *F) {
 
623
  return F ? &F->getValueSymbolTable() : nullptr;
 
624
}
 
625
 
 
626
template <>
 
627
struct OperandTraits<Function> : public OptionalOperandTraits<Function> {};
 
628
 
 
629
DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value)
 
630
 
 
631
} // End llvm namespace
 
632
 
 
633
#endif