From 2e033f31dc229db8d5c84f19530b7d2ddc175f44 Mon Sep 17 00:00:00 2001 From: Duncan Sands Date: Tue, 8 Jul 2008 08:38:44 +0000 Subject: [PATCH] Add some convenience methods for manipulating call attributes. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53223 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Instructions.h | 44 ++++++++++++++++++++++++++++--- include/llvm/Support/CallSite.h | 6 +++++ lib/VMCore/Instructions.cpp | 46 +++++++++++++++++++++++---------- 3 files changed, 78 insertions(+), 18 deletions(-) diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index f9e0a2e5ce1..162601724c6 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -1065,6 +1065,9 @@ public: /// addParamAttr - adds the attribute to the list of attributes. void addParamAttr(unsigned i, ParameterAttributes attr); + /// removeParamAttr - removes the attribute from the list of attributes. + void removeParamAttr(unsigned i, ParameterAttributes attr); + /// @brief Determine whether the call or the callee has the given attribute. bool paramHasAttr(unsigned i, unsigned attr) const; @@ -1077,22 +1080,37 @@ public: bool doesNotAccessMemory() const { return paramHasAttr(0, ParamAttr::ReadNone); } - + void setDoesNotAccessMemory(bool doesNotAccessMemory = true) { + if (doesNotAccessMemory) addParamAttr(0, ParamAttr::ReadNone); + else removeParamAttr(0, ParamAttr::ReadNone); + } + /// @brief Determine if the call does not access or only reads memory. bool onlyReadsMemory() const { return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly); } - + void setOnlyReadsMemory(bool onlyReadsMemory = true) { + if (onlyReadsMemory) addParamAttr(0, ParamAttr::ReadOnly); + else removeParamAttr(0, ParamAttr::ReadOnly | ParamAttr::ReadNone); + } + /// @brief Determine if the call cannot return. bool doesNotReturn() const { return paramHasAttr(0, ParamAttr::NoReturn); } + void setDoesNotReturn(bool doesNotReturn = true) { + if (doesNotReturn) addParamAttr(0, ParamAttr::NoReturn); + else removeParamAttr(0, ParamAttr::NoReturn); + } /// @brief Determine if the call cannot unwind. bool doesNotThrow() const { return paramHasAttr(0, ParamAttr::NoUnwind); } - void setDoesNotThrow(bool doesNotThrow = true); + void setDoesNotThrow(bool doesNotThrow = true) { + if (doesNotThrow) addParamAttr(0, ParamAttr::NoUnwind); + else removeParamAttr(0, ParamAttr::NoUnwind); + } /// @brief Determine if the call returns a structure through first /// pointer argument. @@ -2427,6 +2445,9 @@ public: /// addParamAttr - adds the attribute to the list of attributes. void addParamAttr(unsigned i, ParameterAttributes attr); + /// removeParamAttr - removes the attribute from the list of attributes. + void removeParamAttr(unsigned i, ParameterAttributes attr); + /// @brief Extract the alignment for a call or parameter (0=unknown). unsigned getParamAlignment(unsigned i) const { return ParamAttrs.getParamAlignment(i); @@ -2436,22 +2457,37 @@ public: bool doesNotAccessMemory() const { return paramHasAttr(0, ParamAttr::ReadNone); } + void setDoesNotAccessMemory(bool doesNotAccessMemory = true) { + if (doesNotAccessMemory) addParamAttr(0, ParamAttr::ReadNone); + else removeParamAttr(0, ParamAttr::ReadNone); + } /// @brief Determine if the call does not access or only reads memory. bool onlyReadsMemory() const { return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly); } + void setOnlyReadsMemory(bool onlyReadsMemory = true) { + if (onlyReadsMemory) addParamAttr(0, ParamAttr::ReadOnly); + else removeParamAttr(0, ParamAttr::ReadOnly | ParamAttr::ReadNone); + } /// @brief Determine if the call cannot return. bool doesNotReturn() const { return paramHasAttr(0, ParamAttr::NoReturn); } + void setDoesNotReturn(bool doesNotReturn = true) { + if (doesNotReturn) addParamAttr(0, ParamAttr::NoReturn); + else removeParamAttr(0, ParamAttr::NoReturn); + } /// @brief Determine if the call cannot unwind. bool doesNotThrow() const { return paramHasAttr(0, ParamAttr::NoUnwind); } - void setDoesNotThrow(bool doesNotThrow = true); + void setDoesNotThrow(bool doesNotThrow = true) { + if (doesNotThrow) addParamAttr(0, ParamAttr::NoUnwind); + else removeParamAttr(0, ParamAttr::NoUnwind); + } /// @brief Determine if the call returns a structure through first /// pointer argument. diff --git a/include/llvm/Support/CallSite.h b/include/llvm/Support/CallSite.h index 9a6c00872ba..41019313c64 100644 --- a/include/llvm/Support/CallSite.h +++ b/include/llvm/Support/CallSite.h @@ -75,9 +75,15 @@ public: /// @brief Determine if the call does not access memory. bool doesNotAccessMemory() const; + void setDoesNotAccessMemory(bool doesNotAccessMemory = true); /// @brief Determine if the call does not access or only reads memory. bool onlyReadsMemory() const; + void setOnlyReadsMemory(bool onlyReadsMemory = true); + + /// @brief Determine if the call cannot return. + bool doesNotReturn() const; + void setDoesNotReturn(bool doesNotReturn = true); /// @brief Determine if the call cannot unwind. bool doesNotThrow() const; diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 4bcd560ee83..36c3de72ceb 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -72,12 +72,36 @@ bool CallSite::doesNotAccessMemory() const { else return cast(I)->doesNotAccessMemory(); } +void CallSite::setDoesNotAccessMemory(bool doesNotAccessMemory) { + if (CallInst *CI = dyn_cast(I)) + CI->setDoesNotAccessMemory(doesNotAccessMemory); + else + cast(I)->setDoesNotAccessMemory(doesNotAccessMemory); +} bool CallSite::onlyReadsMemory() const { if (CallInst *CI = dyn_cast(I)) return CI->onlyReadsMemory(); else return cast(I)->onlyReadsMemory(); } +void CallSite::setOnlyReadsMemory(bool onlyReadsMemory) { + if (CallInst *CI = dyn_cast(I)) + CI->setOnlyReadsMemory(onlyReadsMemory); + else + cast(I)->setOnlyReadsMemory(onlyReadsMemory); +} +bool CallSite::doesNotReturn() const { + if (CallInst *CI = dyn_cast(I)) + return CI->doesNotReturn(); + else + return cast(I)->doesNotReturn(); +} +void CallSite::setDoesNotReturn(bool doesNotReturn) { + if (CallInst *CI = dyn_cast(I)) + CI->setDoesNotReturn(doesNotReturn); + else + cast(I)->setDoesNotReturn(doesNotReturn); +} bool CallSite::doesNotThrow() const { if (CallInst *CI = dyn_cast(I)) return CI->doesNotThrow(); @@ -384,6 +408,12 @@ void CallInst::addParamAttr(unsigned i, ParameterAttributes attr) { setParamAttrs(PAL); } +void CallInst::removeParamAttr(unsigned i, ParameterAttributes attr) { + PAListPtr PAL = getParamAttrs(); + PAL = PAL.removeAttr(i, attr); + setParamAttrs(PAL); +} + bool CallInst::paramHasAttr(unsigned i, ParameterAttributes attr) const { if (ParamAttrs.paramHasAttr(i, attr)) return true; @@ -392,15 +422,6 @@ bool CallInst::paramHasAttr(unsigned i, ParameterAttributes attr) const { return false; } -void CallInst::setDoesNotThrow(bool doesNotThrow) { - PAListPtr PAL = getParamAttrs(); - if (doesNotThrow) - PAL = PAL.addAttr(0, ParamAttr::NoUnwind); - else - PAL = PAL.removeAttr(0, ParamAttr::NoUnwind); - setParamAttrs(PAL); -} - //===----------------------------------------------------------------------===// // InvokeInst Implementation @@ -466,12 +487,9 @@ void InvokeInst::addParamAttr(unsigned i, ParameterAttributes attr) { setParamAttrs(PAL); } -void InvokeInst::setDoesNotThrow(bool doesNotThrow) { +void InvokeInst::removeParamAttr(unsigned i, ParameterAttributes attr) { PAListPtr PAL = getParamAttrs(); - if (doesNotThrow) - PAL = PAL.addAttr(0, ParamAttr::NoUnwind); - else - PAL = PAL.removeAttr(0, ParamAttr::NoUnwind); + PAL = PAL.removeAttr(i, attr); setParamAttrs(PAL); }