Home | History | Annotate | Download | only in llvm
      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_FUNCTION_H
     19 #define LLVM_FUNCTION_H
     20 
     21 #include "llvm/GlobalValue.h"
     22 #include "llvm/CallingConv.h"
     23 #include "llvm/BasicBlock.h"
     24 #include "llvm/Argument.h"
     25 #include "llvm/Attributes.h"
     26 #include "llvm/Support/Compiler.h"
     27 
     28 namespace llvm {
     29 
     30 class FunctionType;
     31 class LLVMContext;
     32 
     33 // Traits for intrusive list of basic blocks...
     34 template<> struct ilist_traits<BasicBlock>
     35   : public SymbolTableListTraits<BasicBlock, Function> {
     36 
     37   // createSentinel is used to get hold of the node that marks the end of the
     38   // list... (same trick used here as in ilist_traits<Instruction>)
     39   BasicBlock *createSentinel() const {
     40     return static_cast<BasicBlock*>(&Sentinel);
     41   }
     42   static void destroySentinel(BasicBlock*) {}
     43 
     44   BasicBlock *provideInitialHead() const { return createSentinel(); }
     45   BasicBlock *ensureHead(BasicBlock*) const { return createSentinel(); }
     46   static void noteHead(BasicBlock*, BasicBlock*) {}
     47 
     48   static ValueSymbolTable *getSymTab(Function *ItemParent);
     49 private:
     50   mutable ilist_half_node<BasicBlock> Sentinel;
     51 };
     52 
     53 template<> struct ilist_traits<Argument>
     54   : public SymbolTableListTraits<Argument, Function> {
     55 
     56   Argument *createSentinel() const {
     57     return static_cast<Argument*>(&Sentinel);
     58   }
     59   static void destroySentinel(Argument*) {}
     60 
     61   Argument *provideInitialHead() const { return createSentinel(); }
     62   Argument *ensureHead(Argument*) const { return createSentinel(); }
     63   static void noteHead(Argument*, Argument*) {}
     64 
     65   static ValueSymbolTable *getSymTab(Function *ItemParent);
     66 private:
     67   mutable ilist_half_node<Argument> Sentinel;
     68 };
     69 
     70 class Function : public GlobalValue,
     71                  public ilist_node<Function> {
     72 public:
     73   typedef iplist<Argument> ArgumentListType;
     74   typedef iplist<BasicBlock> BasicBlockListType;
     75 
     76   // BasicBlock iterators...
     77   typedef BasicBlockListType::iterator iterator;
     78   typedef BasicBlockListType::const_iterator const_iterator;
     79 
     80   typedef ArgumentListType::iterator arg_iterator;
     81   typedef ArgumentListType::const_iterator const_arg_iterator;
     82 
     83 private:
     84   // Important things that make up a function!
     85   BasicBlockListType  BasicBlocks;        ///< The basic blocks
     86   mutable ArgumentListType ArgumentList;  ///< The formal arguments
     87   ValueSymbolTable *SymTab;               ///< Symbol table of args/instructions
     88   AttrListPtr AttributeList;              ///< Parameter attributes
     89 
     90   // HasLazyArguments is stored in Value::SubclassData.
     91   /*bool HasLazyArguments;*/
     92 
     93   // The Calling Convention is stored in Value::SubclassData.
     94   /*CallingConv::ID CallingConvention;*/
     95 
     96   friend class SymbolTableListTraits<Function, Module>;
     97 
     98   void setParent(Module *parent);
     99 
    100   /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
    101   /// built on demand, so that the list isn't allocated until the first client
    102   /// needs it.  The hasLazyArguments predicate returns true if the arg list
    103   /// hasn't been set up yet.
    104   bool hasLazyArguments() const {
    105     return getSubclassDataFromValue() & 1;
    106   }
    107   void CheckLazyArguments() const {
    108     if (hasLazyArguments())
    109       BuildLazyArguments();
    110   }
    111   void BuildLazyArguments() const;
    112 
    113   Function(const Function&); // DO NOT IMPLEMENT
    114   void operator=(const Function&); // DO NOT IMPLEMENT
    115 
    116   /// Function ctor - If the (optional) Module argument is specified, the
    117   /// function is automatically inserted into the end of the function list for
    118   /// the module.
    119   ///
    120   Function(FunctionType *Ty, LinkageTypes Linkage,
    121            const Twine &N = "", Module *M = 0);
    122 
    123 public:
    124   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
    125                           const Twine &N = "", Module *M = 0) {
    126     return new(0) Function(Ty, Linkage, N, M);
    127   }
    128 
    129   ~Function();
    130 
    131   Type *getReturnType() const;           // Return the type of the ret val
    132   FunctionType *getFunctionType() const; // Return the FunctionType for me
    133 
    134   /// getContext - Return a pointer to the LLVMContext associated with this
    135   /// function, or NULL if this function is not bound to a context yet.
    136   LLVMContext &getContext() const;
    137 
    138   /// isVarArg - Return true if this function takes a variable number of
    139   /// arguments.
    140   bool isVarArg() const;
    141 
    142   /// getIntrinsicID - This method returns the ID number of the specified
    143   /// function, or Intrinsic::not_intrinsic if the function is not an
    144   /// instrinsic, or if the pointer is null.  This value is always defined to be
    145   /// zero to allow easy checking for whether a function is intrinsic or not.
    146   /// The particular intrinsic functions which correspond to this value are
    147   /// defined in llvm/Intrinsics.h.
    148   ///
    149   unsigned getIntrinsicID() const LLVM_ATTRIBUTE_READONLY;
    150   bool isIntrinsic() const { return getIntrinsicID() != 0; }
    151 
    152   /// getCallingConv()/setCallingConv(CC) - These method get and set the
    153   /// calling convention of this function.  The enum values for the known
    154   /// calling conventions are defined in CallingConv.h.
    155   CallingConv::ID getCallingConv() const {
    156     return static_cast<CallingConv::ID>(getSubclassDataFromValue() >> 1);
    157   }
    158   void setCallingConv(CallingConv::ID CC) {
    159     setValueSubclassData((getSubclassDataFromValue() & 1) |
    160                          (static_cast<unsigned>(CC) << 1));
    161   }
    162 
    163   /// getAttributes - Return the attribute list for this Function.
    164   ///
    165   const AttrListPtr &getAttributes() const { return AttributeList; }
    166 
    167   /// setAttributes - Set the attribute list for this Function.
    168   ///
    169   void setAttributes(const AttrListPtr &attrs) { AttributeList = attrs; }
    170 
    171   /// hasFnAttr - Return true if this function has the given attribute.
    172   bool hasFnAttr(Attributes N) const {
    173     // Function Attributes are stored at ~0 index
    174     return AttributeList.paramHasAttr(~0U, N);
    175   }
    176 
    177   /// addFnAttr - Add function attributes to this function.
    178   ///
    179   void addFnAttr(Attributes N) {
    180     // Function Attributes are stored at ~0 index
    181     addAttribute(~0U, N);
    182   }
    183 
    184   /// removeFnAttr - Remove function attributes from this function.
    185   ///
    186   void removeFnAttr(Attributes N) {
    187     // Function Attributes are stored at ~0 index
    188     removeAttribute(~0U, N);
    189   }
    190 
    191   /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
    192   ///                             to use during code generation.
    193   bool hasGC() const;
    194   const char *getGC() const;
    195   void setGC(const char *Str);
    196   void clearGC();
    197 
    198   /// @brief Determine whether the function has the given attribute.
    199   bool paramHasAttr(unsigned i, Attributes attr) const {
    200     return AttributeList.paramHasAttr(i, attr);
    201   }
    202 
    203   /// addAttribute - adds the attribute to the list of attributes.
    204   void addAttribute(unsigned i, Attributes attr);
    205 
    206   /// removeAttribute - removes the attribute from the list of attributes.
    207   void removeAttribute(unsigned i, Attributes attr);
    208 
    209   /// @brief Extract the alignment for a call or parameter (0=unknown).
    210   unsigned getParamAlignment(unsigned i) const {
    211     return AttributeList.getParamAlignment(i);
    212   }
    213 
    214   /// @brief Determine if the function does not access memory.
    215   bool doesNotAccessMemory() const {
    216     return hasFnAttr(Attribute::ReadNone);
    217   }
    218   void setDoesNotAccessMemory(bool DoesNotAccessMemory = true) {
    219     if (DoesNotAccessMemory) addFnAttr(Attribute::ReadNone);
    220     else removeFnAttr(Attribute::ReadNone);
    221   }
    222 
    223   /// @brief Determine if the function does not access or only reads memory.
    224   bool onlyReadsMemory() const {
    225     return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
    226   }
    227   void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
    228     if (OnlyReadsMemory) addFnAttr(Attribute::ReadOnly);
    229     else removeFnAttr(Attribute::ReadOnly | Attribute::ReadNone);
    230   }
    231 
    232   /// @brief Determine if the function cannot return.
    233   bool doesNotReturn() const {
    234     return hasFnAttr(Attribute::NoReturn);
    235   }
    236   void setDoesNotReturn(bool DoesNotReturn = true) {
    237     if (DoesNotReturn) addFnAttr(Attribute::NoReturn);
    238     else removeFnAttr(Attribute::NoReturn);
    239   }
    240 
    241   /// @brief Determine if the function cannot unwind.
    242   bool doesNotThrow() const {
    243     return hasFnAttr(Attribute::NoUnwind);
    244   }
    245   void setDoesNotThrow(bool DoesNotThrow = true) {
    246     if (DoesNotThrow) addFnAttr(Attribute::NoUnwind);
    247     else removeFnAttr(Attribute::NoUnwind);
    248   }
    249 
    250   /// @brief True if the ABI mandates (or the user requested) that this
    251   /// function be in a unwind table.
    252   bool hasUWTable() const {
    253     return hasFnAttr(Attribute::UWTable);
    254   }
    255   void setHasUWTable(bool HasUWTable = true) {
    256     if (HasUWTable)
    257       addFnAttr(Attribute::UWTable);
    258     else
    259       removeFnAttr(Attribute::UWTable);
    260   }
    261 
    262   /// @brief True if this function needs an unwind table.
    263   bool needsUnwindTableEntry() const {
    264     return hasUWTable() || !doesNotThrow();
    265   }
    266 
    267   /// @brief Determine if the function returns a structure through first
    268   /// pointer argument.
    269   bool hasStructRetAttr() const {
    270     return paramHasAttr(1, Attribute::StructRet);
    271   }
    272 
    273   /// @brief Determine if the parameter does not alias other parameters.
    274   /// @param n The parameter to check. 1 is the first parameter, 0 is the return
    275   bool doesNotAlias(unsigned n) const {
    276     return paramHasAttr(n, Attribute::NoAlias);
    277   }
    278   void setDoesNotAlias(unsigned n, bool DoesNotAlias = true) {
    279     if (DoesNotAlias) addAttribute(n, Attribute::NoAlias);
    280     else removeAttribute(n, Attribute::NoAlias);
    281   }
    282 
    283   /// @brief Determine if the parameter can be captured.
    284   /// @param n The parameter to check. 1 is the first parameter, 0 is the return
    285   bool doesNotCapture(unsigned n) const {
    286     return paramHasAttr(n, Attribute::NoCapture);
    287   }
    288   void setDoesNotCapture(unsigned n, bool DoesNotCapture = true) {
    289     if (DoesNotCapture) addAttribute(n, Attribute::NoCapture);
    290     else removeAttribute(n, Attribute::NoCapture);
    291   }
    292 
    293   /// copyAttributesFrom - copy all additional attributes (those not needed to
    294   /// create a Function) from the Function Src to this one.
    295   void copyAttributesFrom(const GlobalValue *Src);
    296 
    297   /// deleteBody - This method deletes the body of the function, and converts
    298   /// the linkage to external.
    299   ///
    300   void deleteBody() {
    301     dropAllReferences();
    302     setLinkage(ExternalLinkage);
    303   }
    304 
    305   /// removeFromParent - This method unlinks 'this' from the containing module,
    306   /// but does not delete it.
    307   ///
    308   virtual void removeFromParent();
    309 
    310   /// eraseFromParent - This method unlinks 'this' from the containing module
    311   /// and deletes it.
    312   ///
    313   virtual void eraseFromParent();
    314 
    315 
    316   /// Get the underlying elements of the Function... the basic block list is
    317   /// empty for external functions.
    318   ///
    319   const ArgumentListType &getArgumentList() const {
    320     CheckLazyArguments();
    321     return ArgumentList;
    322   }
    323   ArgumentListType &getArgumentList() {
    324     CheckLazyArguments();
    325     return ArgumentList;
    326   }
    327   static iplist<Argument> Function::*getSublistAccess(Argument*) {
    328     return &Function::ArgumentList;
    329   }
    330 
    331   const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
    332         BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }
    333   static iplist<BasicBlock> Function::*getSublistAccess(BasicBlock*) {
    334     return &Function::BasicBlocks;
    335   }
    336 
    337   const BasicBlock       &getEntryBlock() const   { return front(); }
    338         BasicBlock       &getEntryBlock()         { return front(); }
    339 
    340   //===--------------------------------------------------------------------===//
    341   // Symbol Table Accessing functions...
    342 
    343   /// getSymbolTable() - Return the symbol table...
    344   ///
    345   inline       ValueSymbolTable &getValueSymbolTable()       { return *SymTab; }
    346   inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; }
    347 
    348 
    349   //===--------------------------------------------------------------------===//
    350   // BasicBlock iterator forwarding functions
    351   //
    352   iterator                begin()       { return BasicBlocks.begin(); }
    353   const_iterator          begin() const { return BasicBlocks.begin(); }
    354   iterator                end  ()       { return BasicBlocks.end();   }
    355   const_iterator          end  () const { return BasicBlocks.end();   }
    356 
    357   size_t                   size() const { return BasicBlocks.size();  }
    358   bool                    empty() const { return BasicBlocks.empty(); }
    359   const BasicBlock       &front() const { return BasicBlocks.front(); }
    360         BasicBlock       &front()       { return BasicBlocks.front(); }
    361   const BasicBlock        &back() const { return BasicBlocks.back();  }
    362         BasicBlock        &back()       { return BasicBlocks.back();  }
    363 
    364   //===--------------------------------------------------------------------===//
    365   // Argument iterator forwarding functions
    366   //
    367   arg_iterator arg_begin() {
    368     CheckLazyArguments();
    369     return ArgumentList.begin();
    370   }
    371   const_arg_iterator arg_begin() const {
    372     CheckLazyArguments();
    373     return ArgumentList.begin();
    374   }
    375   arg_iterator arg_end() {
    376     CheckLazyArguments();
    377     return ArgumentList.end();
    378   }
    379   const_arg_iterator arg_end() const {
    380     CheckLazyArguments();
    381     return ArgumentList.end();
    382   }
    383 
    384   size_t arg_size() const;
    385   bool arg_empty() const;
    386 
    387   /// viewCFG - This function is meant for use from the debugger.  You can just
    388   /// say 'call F->viewCFG()' and a ghostview window should pop up from the
    389   /// program, displaying the CFG of the current function with the code for each
    390   /// basic block inside.  This depends on there being a 'dot' and 'gv' program
    391   /// in your path.
    392   ///
    393   void viewCFG() const;
    394 
    395   /// viewCFGOnly - This function is meant for use from the debugger.  It works
    396   /// just like viewCFG, but it does not include the contents of basic blocks
    397   /// into the nodes, just the label.  If you are only interested in the CFG
    398   /// this can make the graph smaller.
    399   ///
    400   void viewCFGOnly() const;
    401 
    402   /// Methods for support type inquiry through isa, cast, and dyn_cast:
    403   static inline bool classof(const Function *) { return true; }
    404   static inline bool classof(const Value *V) {
    405     return V->getValueID() == Value::FunctionVal;
    406   }
    407 
    408   /// dropAllReferences() - This method causes all the subinstructions to "let
    409   /// go" of all references that they are maintaining.  This allows one to
    410   /// 'delete' a whole module at a time, even though there may be circular
    411   /// references... first all references are dropped, and all use counts go to
    412   /// zero.  Then everything is deleted for real.  Note that no operations are
    413   /// valid on an object that has "dropped all references", except operator
    414   /// delete.
    415   ///
    416   /// Since no other object in the module can have references into the body of a
    417   /// function, dropping all references deletes the entire body of the function,
    418   /// including any contained basic blocks.
    419   ///
    420   void dropAllReferences();
    421 
    422   /// hasAddressTaken - returns true if there are any uses of this function
    423   /// other than direct calls or invokes to it. Optionally passes back the
    424   /// offending user for diagnostic purposes.
    425   ///
    426   bool hasAddressTaken(const User** = 0) const;
    427 
    428   /// callsFunctionThatReturnsTwice - Return true if the function has a call to
    429   /// setjmp or other function that gcc recognizes as "returning twice".
    430   bool callsFunctionThatReturnsTwice() const;
    431 
    432 private:
    433   // Shadow Value::setValueSubclassData with a private forwarding method so that
    434   // subclasses cannot accidentally use it.
    435   void setValueSubclassData(unsigned short D) {
    436     Value::setValueSubclassData(D);
    437   }
    438 };
    439 
    440 inline ValueSymbolTable *
    441 ilist_traits<BasicBlock>::getSymTab(Function *F) {
    442   return F ? &F->getValueSymbolTable() : 0;
    443 }
    444 
    445 inline ValueSymbolTable *
    446 ilist_traits<Argument>::getSymTab(Function *F) {
    447   return F ? &F->getValueSymbolTable() : 0;
    448 }
    449 
    450 } // End llvm namespace
    451 
    452 #endif
    453