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