#include "llvm/InstrTypes.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/ParameterAttributes.h"
namespace llvm {
/// setVolatile - Specify whether this is a volatile load or not.
///
void setVolatile(bool V) {
- SubclassData = (SubclassData & ~1) | V;
+ SubclassData = (SubclassData & ~1) | (V ? 1 : 0);
}
virtual LoadInst *clone() const;
/// setVolatile - Specify whether this is a volatile load or not.
///
void setVolatile(bool V) {
- SubclassData = (SubclassData & ~1) | V;
+ SubclassData = (SubclassData & ~1) | (V ? 1 : 0);
}
/// Transparently provide more efficient getOperand methods.
/// @brief Return the signed version of the predicate.
static Predicate getSignedPredicate(Predicate pred);
- /// This also tests for commutativity. If isEquality() returns true then
- /// the predicate is also commutative.
- /// @returns true if the predicate of this instruction is EQ or NE.
- /// @brief Determine if this is an equality predicate.
+ /// isEquality - Return true if this predicate is either EQ or NE. This also
+ /// tests for commutativity.
+ static bool isEquality(Predicate P) {
+ return P == ICMP_EQ || P == ICMP_NE;
+ }
+
+ /// isEquality - Return true if this predicate is either EQ or NE. This also
+ /// tests for commutativity.
bool isEquality() const {
- return SubclassData == ICMP_EQ || SubclassData == ICMP_NE;
+ return isEquality(getPredicate());
}
/// @returns true if the predicate of this ICmpInst is commutative
/// @brief Determine if this relation is commutative.
bool isCommutative() const { return isEquality(); }
- /// @returns true if the predicate is relational (not EQ or NE).
- /// @brief Determine if this a relational predicate.
+ /// isRelational - Return true if the predicate is relational (not EQ or NE).
+ ///
bool isRelational() const {
return !isEquality();
}
+ /// isRelational - Return true if the predicate is relational (not EQ or NE).
+ ///
+ static bool isRelational(Predicate P) {
+ return !isEquality(P);
+ }
+
/// @returns true if the predicate of this ICmpInst is signed, false otherwise
/// @brief Determine if this instruction's predicate is signed.
bool isSignedPredicate() const { return isSignedPredicate(getPredicate()); }
///
class CallInst : public Instruction {
- ParamAttrsList *ParamAttrs; ///< parameter attributes for call
+ const ParamAttrsList *ParamAttrs; ///< parameter attributes for call
CallInst(const CallInst &CI);
void init(Value *Func, Value* const *Params, unsigned NumParams);
void init(Value *Func, Value *Actual1, Value *Actual2);
/// parameter attributes information, if any.
/// @returns 0 if no attributes have been set.
/// @brief Get the parameter attributes.
- ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
+ const ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
/// Sets the parameter attributes for this CallInst. To construct a
/// ParamAttrsList, see ParameterAttributes.h
/// @brief Set the parameter attributes.
- void setParamAttrs(ParamAttrsList *attrs);
+ void setParamAttrs(const ParamAttrsList *attrs);
+
+ /// @brief Determine whether the call or the callee has the given attribute.
+ bool paramHasAttr(uint16_t i, ParameterAttributes attr) const;
+
+ /// @brief Determine if the call does not access memory.
+ bool doesNotAccessMemory() const {
+ return paramHasAttr(0, ParamAttr::ReadNone);
+ }
+
+ /// @brief Determine if the call does not access or only reads memory.
+ bool onlyReadsMemory() const {
+ return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
+ }
+
+ /// @brief Determine if the call cannot unwind.
+ bool isNoUnwind() const {
+ return paramHasAttr(0, ParamAttr::NoUnwind);
+ }
+
+ /// @brief Determine if the call returns a structure.
+ bool isStructReturn() const {
+ // Be friendly and also check the callee.
+ return paramHasAttr(1, ParamAttr::StructRet);
+ }
/// getCalledFunction - Return the function being called by this instruction
/// if it is a direct call. If it is a call through a function pointer,
/// calling convention of the call.
///
class InvokeInst : public TerminatorInst {
- ParamAttrsList *ParamAttrs;
+ const ParamAttrsList *ParamAttrs;
InvokeInst(const InvokeInst &BI);
void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
Value* const *Args, unsigned NumArgs);
/// parameter attributes information, if any.
/// @returns 0 if no attributes have been set.
/// @brief Get the parameter attributes.
- ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
+ const ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
/// Sets the parameter attributes for this InvokeInst. To construct a
/// ParamAttrsList, see ParameterAttributes.h
/// @brief Set the parameter attributes.
- void setParamAttrs(ParamAttrsList *attrs);
+ void setParamAttrs(const ParamAttrsList *attrs);
+
+ /// @brief Determine whether the call or the callee has the given attribute.
+ bool paramHasAttr(uint16_t i, ParameterAttributes attr) const;
+
+ /// @brief Determine if the call does not access memory.
+ bool doesNotAccessMemory() const {
+ return paramHasAttr(0, ParamAttr::ReadNone);
+ }
+
+ /// @brief Determine if the call does not access or only reads memory.
+ bool onlyReadsMemory() const {
+ return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
+ }
+
+ /// @brief Determine if the call cannot unwind.
+ bool isNoUnwind() const {
+ return paramHasAttr(0, ParamAttr::NoUnwind);
+ }
+
+ /// @brief Determine if the call returns a structure.
+ bool isStructReturn() const {
+ // Be friendly and also check the callee.
+ return paramHasAttr(1, ParamAttr::StructRet);
+ }
/// getCalledFunction - Return the function called, or null if this is an
/// indirect function invocation.