Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- llvm/Function.h - Class to represent a single function ---*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file contains the declaration of the Function class, which represents a

// single function/procedure in LLVM.

//

// A function basically consists of a list of basic blocks, a list of arguments,

// and a symbol table.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_IR_FUNCTION_H

#define LLVM_IR_FUNCTION_H

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/Twine.h"

#include "llvm/ADT/ilist_node.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/IR/Argument.h"

#include "llvm/IR/Attributes.h"

#include "llvm/IR/BasicBlock.h"

#include "llvm/IR/CallingConv.h"

#include "llvm/IR/DerivedTypes.h"

#include "llvm/IR/GlobalObject.h"

#include "llvm/IR/GlobalValue.h"

#include "llvm/IR/OperandTraits.h"

#include "llvm/IR/SymbolTableListTraits.h"

#include "llvm/IR/Value.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <memory>

#include <string>

namespace llvm {

namespace Intrinsic {

typedef unsigned ID;

}

class AssemblyAnnotationWriter;

class Constant;

struct DenormalMode;

class DISubprogram;

class LLVMContext;

class Module;

class raw_ostream;

class Type;

class User;

class BranchProbabilityInfo;

class BlockFrequencyInfo;

class LLVM_EXTERNAL_VISIBILITY Function : public GlobalObject,

                                          public ilist_node<Function> {

public:

  using BasicBlockListType = SymbolTableList<BasicBlock>;

  // BasicBlock iterators...

  using iterator = BasicBlockListType::iterator;

  using const_iterator = BasicBlockListType::const_iterator;

  using arg_iterator = Argument *;

  using const_arg_iterator = const Argument *;

private:

  // Important things that make up a function!

  BasicBlockListType BasicBlocks;         ///< The basic blocks

  mutable Argument *Arguments = nullptr;  ///< The formal arguments

  size_t NumArgs;

  std::unique_ptr<ValueSymbolTable>

      SymTab;                             ///< Symbol table of args/instructions

  AttributeList AttributeSets;            ///< Parameter attributes

  /*

   * Value::SubclassData

   *

   * bit 0      : HasLazyArguments

   * bit 1      : HasPrefixData

   * bit 2      : HasPrologueData

   * bit 3      : HasPersonalityFn

   * bits 4-13  : CallingConvention

   * bits 14    : HasGC

   * bits 15 : [reserved]

   */

  /// Bits from GlobalObject::GlobalObjectSubclassData.

  enum {

    /// Whether this function is materializable.

    IsMaterializableBit = 0,

  };

  friend class SymbolTableListTraits<Function>;

  /// hasLazyArguments/CheckLazyArguments - The argument list of a function is

  /// built on demand, so that the list isn't allocated until the first client

  /// needs it.  The hasLazyArguments predicate returns true if the arg list

  /// hasn't been set up yet.

public:

  bool hasLazyArguments() const {

    return getSubclassDataFromValue() & (1<<0);

  }

private:

  void CheckLazyArguments() const {

    if (hasLazyArguments())

      BuildLazyArguments();

  }

  void BuildLazyArguments() const;

  void clearArguments();

  /// Function ctor - If the (optional) Module argument is specified, the

  /// function is automatically inserted into the end of the function list for

  /// the module.

  ///

  Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,

           const Twine &N = "", Module *M = nullptr);

public:

  Function(const Function&) = delete;

  void operator=(const Function&) = delete;

  ~Function();

  // This is here to help easily convert from FunctionT * (Function * or

  // MachineFunction *) in BlockFrequencyInfoImpl to Function * by calling

  // FunctionT->getFunction().

  const Function &getFunction() const { return *this; }

  static Function *Create(FunctionType *Ty, LinkageTypes Linkage,

                          unsigned AddrSpace, const Twine &N = "",

                          Module *M = nullptr) {

    return new Function(Ty, Linkage, AddrSpace, N, M);

  }

  // TODO: remove this once all users have been updated to pass an AddrSpace

  static Function *Create(FunctionType *Ty, LinkageTypes Linkage,

                          const Twine &N = "", Module *M = nullptr) {

    return new Function(Ty, Linkage, static_cast<unsigned>(-1), N, M);

  }

  /// Creates a new function and attaches it to a module.

  ///

  /// Places the function in the program address space as specified

  /// by the module's data layout.

  static Function *Create(FunctionType *Ty, LinkageTypes Linkage,

                          const Twine &N, Module &M);

  /// Creates a function with some attributes recorded in llvm.module.flags

  /// applied.

  ///

  /// Use this when synthesizing new functions that need attributes that would

  /// have been set by command line options.

  static Function *createWithDefaultAttr(FunctionType *Ty, LinkageTypes Linkage,

                                         unsigned AddrSpace,

                                         const Twine &N = "",

                                         Module *M = nullptr);

  // Provide fast operand accessors.

  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);

  /// Returns the number of non-debug IR instructions in this function.

  /// This is equivalent to the sum of the sizes of each basic block contained

  /// within this function.

  unsigned getInstructionCount() const;

  /// Returns the FunctionType for me.

  FunctionType *getFunctionType() const {

    return cast<FunctionType>(getValueType());

  }

  /// Returns the type of the ret val.

  Type *getReturnType() const { return getFunctionType()->getReturnType(); }

  /// getContext - Return a reference to the LLVMContext associated with this

  /// function.

  LLVMContext &getContext() const;

  /// isVarArg - Return true if this function takes a variable number of

  /// arguments.

  bool isVarArg() const { return getFunctionType()->isVarArg(); }

  bool isMaterializable() const {

    return getGlobalObjectSubClassData() & (1 << IsMaterializableBit);

  }

  void setIsMaterializable(bool V) {

    unsigned Mask = 1 << IsMaterializableBit;

    setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |

                                (V ? Mask : 0u));

  }

  /// getIntrinsicID - This method returns the ID number of the specified

  /// function, or Intrinsic::not_intrinsic if the function is not an

  /// intrinsic, or if the pointer is null.  This value is always defined to be

  /// zero to allow easy checking for whether a function is intrinsic or not.

  /// The particular intrinsic functions which correspond to this value are

  /// defined in llvm/Intrinsics.h.

  Intrinsic::ID getIntrinsicID() const LLVM_READONLY { return IntID; }

  /// isIntrinsic - Returns true if the function's name starts with "llvm.".

  /// It's possible for this function to return true while getIntrinsicID()

  /// returns Intrinsic::not_intrinsic!

  bool isIntrinsic() const { return HasLLVMReservedName; }

  /// isTargetIntrinsic - Returns true if IID is an intrinsic specific to a

  /// certain target. If it is a generic intrinsic false is returned.

  static bool isTargetIntrinsic(Intrinsic::ID IID);

  /// isTargetIntrinsic - Returns true if this function is an intrinsic and the

  /// intrinsic is specific to a certain target. If this is not an intrinsic

  /// or a generic intrinsic, false is returned.

  bool isTargetIntrinsic() const;

  /// Returns true if the function is one of the "Constrained Floating-Point

  /// Intrinsics". Returns false if not, and returns false when

  /// getIntrinsicID() returns Intrinsic::not_intrinsic.

  bool isConstrainedFPIntrinsic() const;

  static Intrinsic::ID lookupIntrinsicID(StringRef Name);

  /// Recalculate the ID for this function if it is an Intrinsic defined

  /// in llvm/Intrinsics.h.  Sets the intrinsic ID to Intrinsic::not_intrinsic

  /// if the name of this function does not match an intrinsic in that header.

  /// Note, this method does not need to be called directly, as it is called

  /// from Value::setName() whenever the name of this function changes.

  void recalculateIntrinsicID();

  /// getCallingConv()/setCallingConv(CC) - These method get and set the

  /// calling convention of this function.  The enum values for the known

  /// calling conventions are defined in CallingConv.h.

  CallingConv::ID getCallingConv() const {

    return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) &

                                        CallingConv::MaxID);

  }

  void setCallingConv(CallingConv::ID CC) {

    auto ID = static_cast<unsigned>(CC);

    assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");

    setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4));

  }

  enum ProfileCountType { PCT_Real, PCT_Synthetic };

  /// Class to represent profile counts.

  ///

  /// This class represents both real and synthetic profile counts.

  class ProfileCount {

  private:

    uint64_t Count = 0;

    ProfileCountType PCT = PCT_Real;

  public:

    ProfileCount(uint64_t Count, ProfileCountType PCT)

        : Count(Count), PCT(PCT) {}

    uint64_t getCount() const { return Count; }

    ProfileCountType getType() const { return PCT; }

    bool isSynthetic() const { return PCT == PCT_Synthetic; }

  };

  /// Set the entry count for this function.

  ///

  /// Entry count is the number of times this function was executed based on

  /// pgo data. \p Imports points to a set of GUIDs that needs to

  /// be imported by the function for sample PGO, to enable the same inlines as

  /// the profiled optimized binary.

  void setEntryCount(ProfileCount Count,

                     const DenseSet<GlobalValue::GUID> *Imports = nullptr);

  /// A convenience wrapper for setting entry count

  void setEntryCount(uint64_t Count, ProfileCountType Type = PCT_Real,

                     const DenseSet<GlobalValue::GUID> *Imports = nullptr);

  /// Get the entry count for this function.

  ///

  /// Entry count is the number of times the function was executed.

  /// When AllowSynthetic is false, only pgo_data will be returned.

  std::optional<ProfileCount> getEntryCount(bool AllowSynthetic = false) const;

  /// Return true if the function is annotated with profile data.

  ///

  /// Presence of entry counts from a profile run implies the function has

  /// profile annotations. If IncludeSynthetic is false, only return true

  /// when the profile data is real.

  bool hasProfileData(bool IncludeSynthetic = false) const {

    return getEntryCount(IncludeSynthetic).has_value();

  }

  /// Returns the set of GUIDs that needs to be imported to the function for

  /// sample PGO, to enable the same inlines as the profiled optimized binary.

  DenseSet<GlobalValue::GUID> getImportGUIDs() const;

  /// Set the section prefix for this function.

  void setSectionPrefix(StringRef Prefix);

  /// Get the section prefix for this function.

  std::optional<StringRef> getSectionPrefix() const;

  /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm

  ///                             to use during code generation.

  bool hasGC() const {

    return getSubclassDataFromValue() & (1<<14);

  }

  const std::string &getGC() const;

  void setGC(std::string Str);

  void clearGC();

  /// Return the attribute list for this Function.

  AttributeList getAttributes() const { return AttributeSets; }

  /// Set the attribute list for this Function.

  void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }

  // TODO: remove non-AtIndex versions of these methods.

  /// adds the attribute to the list of attributes.

  void addAttributeAtIndex(unsigned i, Attribute Attr);

  /// Add function attributes to this function.

  void addFnAttr(Attribute::AttrKind Kind);

  /// Add function attributes to this function.

  void addFnAttr(StringRef Kind, StringRef Val = StringRef());

  /// Add function attributes to this function.

  void addFnAttr(Attribute Attr);

  /// Add function attributes to this function.

  void addFnAttrs(const AttrBuilder &Attrs);

  /// Add return value attributes to this function.

  void addRetAttr(Attribute::AttrKind Kind);

  /// Add return value attributes to this function.

  void addRetAttr(Attribute Attr);

  /// Add return value attributes to this function.

  void addRetAttrs(const AttrBuilder &Attrs);

  /// adds the attribute to the list of attributes for the given arg.

  void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);

  /// adds the attribute to the list of attributes for the given arg.

  void addParamAttr(unsigned ArgNo, Attribute Attr);

  /// adds the attributes to the list of attributes for the given arg.

  void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);

  /// removes the attribute from the list of attributes.

  void removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind);

  /// removes the attribute from the list of attributes.

  void removeAttributeAtIndex(unsigned i, StringRef Kind);

  /// Remove function attributes from this function.

  void removeFnAttr(Attribute::AttrKind Kind);

  /// Remove function attribute from this function.

  void removeFnAttr(StringRef Kind);

  void removeFnAttrs(const AttributeMask &Attrs);

  /// removes the attribute from the return value list of attributes.

  void removeRetAttr(Attribute::AttrKind Kind);

  /// removes the attribute from the return value list of attributes.

  void removeRetAttr(StringRef Kind);

  /// removes the attributes from the return value list of attributes.

  void removeRetAttrs(const AttributeMask &Attrs);

  /// removes the attribute from the list of attributes.

  void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);

  /// removes the attribute from the list of attributes.

  void removeParamAttr(unsigned ArgNo, StringRef Kind);

  /// removes the attribute from the list of attributes.

  void removeParamAttrs(unsigned ArgNo, const AttributeMask &Attrs);

  /// Return true if the function has the attribute.

  bool hasFnAttribute(Attribute::AttrKind Kind) const;

  /// Return true if the function has the attribute.

  bool hasFnAttribute(StringRef Kind) const;

  /// check if an attribute is in the list of attributes for the return value.

  bool hasRetAttribute(Attribute::AttrKind Kind) const;

  /// check if an attributes is in the list of attributes.

  bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;

  /// gets the attribute from the list of attributes.

  Attribute getAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) const;

  /// gets the attribute from the list of attributes.

  Attribute getAttributeAtIndex(unsigned i, StringRef Kind) const;

  /// Return the attribute for the given attribute kind.

  Attribute getFnAttribute(Attribute::AttrKind Kind) const;

  /// Return the attribute for the given attribute kind.

  Attribute getFnAttribute(StringRef Kind) const;

  /// For a string attribute \p Kind, parse attribute as an integer.

  ///

  /// \returns \p Default if attribute is not present.

  ///

  /// \returns \p Default if there is an error parsing the attribute integer,

  /// and error is emitted to the LLVMContext

  uint64_t getFnAttributeAsParsedInteger(StringRef Kind,

                                         uint64_t Default = 0) const;

  /// gets the specified attribute from the list of attributes.

  Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;

  /// removes noundef and other attributes that imply undefined behavior if a

  /// `undef` or `poison` value is passed from the list of attributes.

  void removeParamUndefImplyingAttrs(unsigned ArgNo);

  /// Return the stack alignment for the function.

  MaybeAlign getFnStackAlign() const {

    return AttributeSets.getFnStackAlignment();

  }

  /// Returns true if the function has ssp, sspstrong, or sspreq fn attrs.

  bool hasStackProtectorFnAttr() const;

  /// adds the dereferenceable attribute to the list of attributes for

  /// the given arg.

  void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes);

  /// adds the dereferenceable_or_null attribute to the list of

  /// attributes for the given arg.

  void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes);

  MaybeAlign getParamAlign(unsigned ArgNo) const {

    return AttributeSets.getParamAlignment(ArgNo);

  }

  MaybeAlign getParamStackAlign(unsigned ArgNo) const {

    return AttributeSets.getParamStackAlignment(ArgNo);

  }

  /// Extract the byval type for a parameter.

  Type *getParamByValType(unsigned ArgNo) const {

    return AttributeSets.getParamByValType(ArgNo);

  }

  /// Extract the sret type for a parameter.

  Type *getParamStructRetType(unsigned ArgNo) const {

    return AttributeSets.getParamStructRetType(ArgNo);

  }

  /// Extract the inalloca type for a parameter.

  Type *getParamInAllocaType(unsigned ArgNo) const {

    return AttributeSets.getParamInAllocaType(ArgNo);

  }

  /// Extract the byref type for a parameter.

  Type *getParamByRefType(unsigned ArgNo) const {

    return AttributeSets.getParamByRefType(ArgNo);

  }

  /// Extract the preallocated type for a parameter.

  Type *getParamPreallocatedType(unsigned ArgNo) const {

    return AttributeSets.getParamPreallocatedType(ArgNo);

  }

  /// Extract the number of dereferenceable bytes for a parameter.

  /// @param ArgNo Index of an argument, with 0 being the first function arg.

  uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {

    return AttributeSets.getParamDereferenceableBytes(ArgNo);

  }

  /// Extract the number of dereferenceable_or_null bytes for a

  /// parameter.

  /// @param ArgNo AttributeList ArgNo, referring to an argument.

  uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {

    return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);

  }

  /// Determine if the function is presplit coroutine.

  bool isPresplitCoroutine() const {

    return hasFnAttribute(Attribute::PresplitCoroutine);

  }

  void setPresplitCoroutine() { addFnAttr(Attribute::PresplitCoroutine); }

  void setSplittedCoroutine() { removeFnAttr(Attribute::PresplitCoroutine); }

  MemoryEffects getMemoryEffects() const;

  void setMemoryEffects(MemoryEffects ME);

  /// Determine if the function does not access memory.

  bool doesNotAccessMemory() const;

  void setDoesNotAccessMemory();

  /// Determine if the function does not access or only reads memory.

  bool onlyReadsMemory() const;

  void setOnlyReadsMemory();

  /// Determine if the function does not access or only writes memory.

  bool onlyWritesMemory() const;

  void setOnlyWritesMemory();

  /// Determine if the call can access memmory only using pointers based

  /// on its arguments.

  bool onlyAccessesArgMemory() const;

  void setOnlyAccessesArgMemory();

  /// Determine if the function may only access memory that is

  ///  inaccessible from the IR.

  bool onlyAccessesInaccessibleMemory() const;

  void setOnlyAccessesInaccessibleMemory();

  /// Determine if the function may only access memory that is

  ///  either inaccessible from the IR or pointed to by its arguments.

  bool onlyAccessesInaccessibleMemOrArgMem() const;

  void setOnlyAccessesInaccessibleMemOrArgMem();

  /// Determine if the function cannot return.

  bool doesNotReturn() const {

    return hasFnAttribute(Attribute::NoReturn);

  }

  void setDoesNotReturn() {

    addFnAttr(Attribute::NoReturn);

  }

  /// Determine if the function should not perform indirect branch tracking.

  bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); }

  /// Determine if the function cannot unwind.

  bool doesNotThrow() const {

    return hasFnAttribute(Attribute::NoUnwind);

  }

  void setDoesNotThrow() {

    addFnAttr(Attribute::NoUnwind);

  }

  /// Determine if the call cannot be duplicated.

  bool cannotDuplicate() const {

    return hasFnAttribute(Attribute::NoDuplicate);

  }

  void setCannotDuplicate() {

    addFnAttr(Attribute::NoDuplicate);

  }

  /// Determine if the call is convergent.

  bool isConvergent() const {

    return hasFnAttribute(Attribute::Convergent);

  }

  void setConvergent() {

    addFnAttr(Attribute::Convergent);

  }

  void setNotConvergent() {

    removeFnAttr(Attribute::Convergent);

  }

  /// Determine if the call has sideeffects.

  bool isSpeculatable() const {

    return hasFnAttribute(Attribute::Speculatable);

  }

  void setSpeculatable() {

    addFnAttr(Attribute::Speculatable);

  }

  /// Determine if the call might deallocate memory.

  bool doesNotFreeMemory() const {

    return onlyReadsMemory() || hasFnAttribute(Attribute::NoFree);

  }

  void setDoesNotFreeMemory() {

    addFnAttr(Attribute::NoFree);

  }

  /// Determine if the call can synchroize with other threads

  bool hasNoSync() const {

    return hasFnAttribute(Attribute::NoSync);

  }

  void setNoSync() {

    addFnAttr(Attribute::NoSync);

  }

  /// Determine if the function is known not to recurse, directly or

  /// indirectly.

  bool doesNotRecurse() const {

    return hasFnAttribute(Attribute::NoRecurse);

  }

  void setDoesNotRecurse() {

    addFnAttr(Attribute::NoRecurse);

  }

  /// Determine if the function is required to make forward progress.

  bool mustProgress() const {

    return hasFnAttribute(Attribute::MustProgress) ||

           hasFnAttribute(Attribute::WillReturn);

  }

  void setMustProgress() { addFnAttr(Attribute::MustProgress); }

  /// Determine if the function will return.

  bool willReturn() const { return hasFnAttribute(Attribute::WillReturn); }

  void setWillReturn() { addFnAttr(Attribute::WillReturn); }

  /// Get what kind of unwind table entry to generate for this function.

  UWTableKind getUWTableKind() const {

    return AttributeSets.getUWTableKind();

  }

  /// True if the ABI mandates (or the user requested) that this

  /// function be in a unwind table.

  bool hasUWTable() const {

    return getUWTableKind() != UWTableKind::None;

  }

  void setUWTableKind(UWTableKind K) {

    addFnAttr(Attribute::getWithUWTableKind(getContext(), K));

  }

  /// True if this function needs an unwind table.

  bool needsUnwindTableEntry() const {

    return hasUWTable() || !doesNotThrow() || hasPersonalityFn();

  }

  /// Determine if the function returns a structure through first

  /// or second pointer argument.

  bool hasStructRetAttr() const {

    return AttributeSets.hasParamAttr(0, Attribute::StructRet) ||

           AttributeSets.hasParamAttr(1, Attribute::StructRet);

  }

  /// Determine if the parameter or return value is marked with NoAlias

  /// attribute.

  bool returnDoesNotAlias() const {

    return AttributeSets.hasRetAttr(Attribute::NoAlias);

  }

  void setReturnDoesNotAlias() { addRetAttr(Attribute::NoAlias); }

  /// Do not optimize this function (-O0).

  bool hasOptNone() const { return hasFnAttribute(Attribute::OptimizeNone); }

  /// Optimize this function for minimum size (-Oz).

  bool hasMinSize() const { return hasFnAttribute(Attribute::MinSize); }

  /// Optimize this function for size (-Os) or minimum size (-Oz).

  bool hasOptSize() const {

    return hasFnAttribute(Attribute::OptimizeForSize) || hasMinSize();

  }

  /// Returns the denormal handling type for the default rounding mode of the

  /// function.

  DenormalMode getDenormalMode(const fltSemantics &FPType) const;

  /// copyAttributesFrom - copy all additional attributes (those not needed to

  /// create a Function) from the Function Src to this one.

  void copyAttributesFrom(const Function *Src);

  /// deleteBody - This method deletes the body of the function, and converts

  /// the linkage to external.

  ///

  void deleteBody() {

    dropAllReferences();

    setLinkage(ExternalLinkage);

  }

  /// removeFromParent - This method unlinks 'this' from the containing module,

  /// but does not delete it.

  ///

  void removeFromParent();

  /// eraseFromParent - This method unlinks 'this' from the containing module

  /// and deletes it.

  ///

  void eraseFromParent();

  /// Steal arguments from another function.

  ///

  /// Drop this function's arguments and splice in the ones from \c Src.

  /// Requires that this has no function body.

  void stealArgumentListFrom(Function &Src);

  /// Insert \p BB in the basic block list at \p Position. \Returns an iterator

  /// to the newly inserted BB.

  Function::iterator insert(Function::iterator Position, BasicBlock *BB) {

    return BasicBlocks.insert(Position, BB);

  }

  /// Transfer all blocks from \p FromF to this function at \p ToIt.

  void splice(Function::iterator ToIt, Function *FromF) {

    splice(ToIt, FromF, FromF->begin(), FromF->end());

  }

  /// Transfer one BasicBlock from \p FromF at \p FromIt to this function

  /// at \p ToIt.

  void splice(Function::iterator ToIt, Function *FromF,

              Function::iterator FromIt) {

    auto FromItNext = std::next(FromIt);

    // Single-element splice is a noop if destination == source.

    if (ToIt == FromIt || ToIt == FromItNext)

      return;

    splice(ToIt, FromF, FromIt, FromItNext);

  }

  /// Transfer a range of basic blocks that belong to \p FromF from \p

  /// FromBeginIt to \p FromEndIt, to this function at \p ToIt.

  void splice(Function::iterator ToIt, Function *FromF,

              Function::iterator FromBeginIt,

              Function::iterator FromEndIt);

  /// Erases a range of BasicBlocks from \p FromIt to (not including) \p ToIt.

  /// \Returns \p ToIt.

  Function::iterator erase(Function::iterator FromIt, Function::iterator ToIt);

private:

  // These need access to the underlying BB list.

  friend void BasicBlock::removeFromParent();

  friend iplist<BasicBlock>::iterator BasicBlock::eraseFromParent();

  template <class BB_t, class BB_i_t, class BI_t, class II_t>

  friend class InstIterator;

  friend class llvm::SymbolTableListTraits<llvm::BasicBlock>;

  friend class llvm::ilist_node_with_parent<llvm::BasicBlock, llvm::Function>;

  /// Get the underlying elements of the Function... the basic block list is

  /// empty for external functions.

  ///

  /// This is deliberately private because we have implemented an adequate set

  /// of functions to modify the list, including Function::splice(),

  /// Function::erase(), Function::insert() etc.

  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }

        BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }

  static BasicBlockListType Function::*getSublistAccess(BasicBlock*) {

    return &Function::BasicBlocks;

  }

public:

  const BasicBlock       &getEntryBlock() const   { return front(); }

        BasicBlock       &getEntryBlock()         { return front(); }

  //===--------------------------------------------------------------------===//

  // Symbol Table Accessing functions...

  /// getSymbolTable() - Return the symbol table if any, otherwise nullptr.

  ///

  inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); }

  inline const ValueSymbolTable *getValueSymbolTable() const {

    return SymTab.get();

  }

  //===--------------------------------------------------------------------===//

  // BasicBlock iterator forwarding functions

  //

  iterator                begin()       { return BasicBlocks.begin(); }

  const_iterator          begin() const { return BasicBlocks.begin(); }

  iterator                end  ()       { return BasicBlocks.end();   }

  const_iterator          end  () const { return BasicBlocks.end();   }

  size_t                   size() const { return BasicBlocks.size();  }

  bool                    empty() const { return BasicBlocks.empty(); }

  const BasicBlock       &front() const { return BasicBlocks.front(); }

        BasicBlock       &front()       { return BasicBlocks.front(); }

  const BasicBlock        &back() const { return BasicBlocks.back();  }

        BasicBlock        &back()       { return BasicBlocks.back();  }

/// @name Function Argument Iteration

/// @{

  arg_iterator arg_begin() {

    CheckLazyArguments();

    return Arguments;

  }

  const_arg_iterator arg_begin() const {

    CheckLazyArguments();

    return Arguments;

  }

  arg_iterator arg_end() {

    CheckLazyArguments();

    return Arguments + NumArgs;

  }

  const_arg_iterator arg_end() const {

    CheckLazyArguments();

    return Arguments + NumArgs;

  }

  Argument* getArg(unsigned i) const {

    assert (i < NumArgs && "getArg() out of range!");

    CheckLazyArguments();

    return Arguments + i;

  }

  iterator_range<arg_iterator> args() {

    return make_range(arg_begin(), arg_end());

  }

  iterator_range<const_arg_iterator> args() const {

    return make_range(arg_begin(), arg_end());

  }

/// @}

  size_t arg_size() const { return NumArgs; }

  bool arg_empty() const { return arg_size() == 0; }

  /// Check whether this function has a personality function.

  bool hasPersonalityFn() const {

    return getSubclassDataFromValue() & (1<<3);

  }

  /// Get the personality function associated with this function.

  Constant *getPersonalityFn() const;

  void setPersonalityFn(Constant *Fn);

  /// Check whether this function has prefix data.

  bool hasPrefixData() const {

    return getSubclassDataFromValue() & (1<<1);

  }