/usr/include/llvm-4.0/llvm/IR/Argument.h is in llvm-4.0-dev 1:4.0.1-10.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | //===-- 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_IR_ARGUMENT_H
#define LLVM_IR_ARGUMENT_H
#include "llvm/ADT/Twine.h"
#include "llvm/ADT/ilist_node.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/Value.h"
namespace llvm {
template <typename NodeTy> class SymbolTableListTraits;
/// \brief LLVM Argument representation
///
/// This class represents an incoming formal argument to a Function. A formal
/// argument, since it is ``formal'', does not contain an actual value but
/// instead represents the type, argument number, and attributes of an argument
/// for a specific function. When used in the body of said function, the
/// argument of course represents the value of the actual argument that the
/// function was called with.
class Argument : public Value, public ilist_node<Argument> {
virtual void anchor();
Function *Parent;
friend class SymbolTableListTraits<Argument>;
void setParent(Function *parent);
public:
/// \brief Constructor.
///
/// If \p F is specified, the argument is inserted at the end of the argument
/// list for \p F.
explicit Argument(Type *Ty, const Twine &Name = "", Function *F = nullptr);
inline const Function *getParent() const { return Parent; }
inline Function *getParent() { return Parent; }
/// \brief 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;
/// \brief Return true if this argument has the nonnull attribute on it in
/// its containing function. Also returns true if at least one byte is known
/// to be dereferenceable and the pointer is in addrspace(0).
bool hasNonNullAttr() const;
/// \brief If this argument has the dereferenceable attribute on it in its
/// containing function, return the number of bytes known to be
/// dereferenceable. Otherwise, zero is returned.
uint64_t getDereferenceableBytes() const;
/// \brief If this argument has the dereferenceable_or_null attribute on
/// it in its containing function, return the number of bytes known to be
/// dereferenceable. Otherwise, zero is returned.
uint64_t getDereferenceableOrNullBytes() const;
/// \brief Return true if this argument has the byval attribute on it in its
/// containing function.
bool hasByValAttr() const;
/// \brief Return true if this argument has the swiftself attribute.
bool hasSwiftSelfAttr() const;
/// \brief Return true if this argument has the swifterror attribute.
bool hasSwiftErrorAttr() const;
/// \brief Return true if this argument has the byval attribute or inalloca
/// attribute on it in its containing function. These attributes both
/// represent arguments being passed by value.
bool hasByValOrInAllocaAttr() const;
/// \brief If this is a byval or inalloca argument, return its alignment.
unsigned getParamAlignment() const;
/// \brief Return true if this argument has the nest attribute on it in its
/// containing function.
bool hasNestAttr() const;
/// \brief Return true if this argument has the noalias attribute on it in its
/// containing function.
bool hasNoAliasAttr() const;
/// \brief Return true if this argument has the nocapture attribute on it in
/// its containing function.
bool hasNoCaptureAttr() const;
/// \brief Return true if this argument has the sret attribute on it in its
/// containing function.
bool hasStructRetAttr() const;
/// \brief Return true if this argument has the returned attribute on it in
/// its containing function.
bool hasReturnedAttr() const;
/// \brief Return true if this argument has the readonly or readnone attribute
/// on it in its containing function.
bool onlyReadsMemory() const;
/// \brief Return true if this argument has the inalloca attribute on it in
/// its containing function.
bool hasInAllocaAttr() const;
/// \brief Return true if this argument has the zext attribute on it in its
/// containing function.
bool hasZExtAttr() const;
/// \brief Return true if this argument has the sext attribute on it in its
/// containing function.
bool hasSExtAttr() const;
/// \brief Add a Attribute to an argument.
void addAttr(AttributeSet AS);
void addAttr(Attribute::AttrKind Kind) {
addAttr(AttributeSet::get(getContext(), getArgNo() + 1, Kind));
}
/// \brief Remove a Attribute from an argument.
void removeAttr(AttributeSet AS);
void removeAttr(Attribute::AttrKind Kind) {
removeAttr(AttributeSet::get(getContext(), getArgNo() + 1, Kind));
}
/// \brief Checks if an argument has a given attribute.
bool hasAttribute(Attribute::AttrKind Kind) const;
/// \brief Method for support type inquiry through isa, cast, and
/// dyn_cast.
static inline bool classof(const Value *V) {
return V->getValueID() == ArgumentVal;
}
};
} // End llvm namespace
#endif
|