llvm.org GIT mirror llvm / release_23 include / llvm / Argument.h
release_23

Tree @release_23 (Download .tar.gz)

Argument.h @release_23

f091a53
9769ab2
6fbcc26
 
7ed47a1
 
9769ab2
6fbcc26
6c7fd1f
bddcb94
6c7fd1f
 
 
 
 
 
 
e2435da
6c7fd1f
d0fde30
 
17fcdd5
 
a7a805e
bddcb94
 
 
 
 
fab8c79
6c7fd1f
 
1896150
 
 
17fcdd5
fab8c79
6c7fd1f
 
fab8c79
 
 
de6fa5f
423c226
6c7fd1f
 
 
9769ab2
de6fa5f
 
 
 
 
 
 
 
 
 
 
 
7d54254
 
 
e2435da
 
 
7d54254
e2435da
 
 
6c7fd1f
5c7e326
 
 
6c7fd1f
2619905
 
 
6c7fd1f
 
a1a702c
6c7fd1f
570204c
 
 
 
 
 
 
6c7fd1f
 
d0fde30
 
6c7fd1f
//===-- llvm/Argument.h - Definition of the Argument class ------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the Argument class. 
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_ARGUMENT_H
#define LLVM_ARGUMENT_H

#include "llvm/Value.h"
#include "llvm/ParameterAttributes.h"

namespace llvm {

template<typename ValueSubClass, typename ItemParentClass>
  class SymbolTableListTraits;

/// A class to represent an incoming formal argument to a Function. An argument
/// is a very simple Value. It is essentially a named (optional) type. When used
/// in the body of a function, it represents the value of the actual argument
/// the function was called with.
/// @brief LLVM Argument representation  
class Argument : public Value {  // Defined in the Function.cpp file
  Function *Parent;

  Argument *Prev, *Next; // Next and Prev links for our intrusive linked list
  void setNext(Argument *N) { Next = N; }
  void setPrev(Argument *N) { Prev = N; }
  friend class SymbolTableListTraits<Argument, Function>;
  void setParent(Function *parent);

public:
  /// Argument ctor - If Function argument is specified, this argument is
  /// inserted at the end of the argument list for the function.
  ///
  explicit Argument(const Type *Ty, const std::string &Name = "",
                    Function *F = 0);

  inline const Function *getParent() const { return Parent; }
  inline       Function *getParent()       { return Parent; }

  /// getArgNo - Return the index of this formal argument in its containing
  /// function.  For example in "void foo(int a, float b)" a is 0 and b is 1. 
  unsigned getArgNo() const;
  
  /// hasByValAttr - Return true if this argument has the byval attribute on it
  /// in its containing function.
  bool hasByValAttr() const;

  /// hasNoAliasAttr - Return true if this argument has the noalias attribute on
  /// it in its containing function.
  bool hasNoAliasAttr() const;
  
  /// hasSRetAttr - Return true if this argument has the sret attribute on it in
  /// its containing function.
  bool hasStructRetAttr() const;

  /// addAttr - Add a ParamAttr to an argument
  void addAttr(ParameterAttributes);
  
  /// removeAttr - Remove a ParamAttr from an argument
  void removeAttr(ParameterAttributes);

  virtual void print(std::ostream &OS) const;
  void print(std::ostream *OS) const {
    if (OS) print(*OS);
  }

  /// classof - Methods for support type inquiry through isa, cast, and
  /// dyn_cast:
  ///
  static inline bool classof(const Argument *) { return true; }
  static inline bool classof(const Value *V) {
    return V->getValueID() == ArgumentVal;
  }
  
private:
  // getNext/Prev - Return the next or previous argument in the list.
  Argument *getNext()       { return Next; }
  const Argument *getNext() const { return Next; }
  Argument *getPrev()       { return Prev; }
  const Argument *getPrev() const { return Prev; }
};

} // End llvm namespace

#endif