#include "llvm/Module.h"
#include "llvm/DerivedTypes.h"
#include "llvm/IntrinsicInst.h"
-#include "llvm/ParameterAttributes.h"
#include "llvm/CodeGen/ValueTypes.h"
#include "llvm/Support/LeakDetector.h"
#include "llvm/Support/StringPool.h"
using namespace llvm;
BasicBlock *ilist_traits<BasicBlock>::createSentinel() {
- BasicBlock *Ret = new BasicBlock();
+ BasicBlock *Ret = BasicBlock::Create();
// This should not be garbage monitored.
LeakDetector::removeGarbageObject(Ret);
return Ret;
/// it in its containing function.
bool Argument::hasStructRetAttr() const {
if (!isa<PointerType>(getType())) return false;
- if (this != getParent()->arg_begin()) return false; // StructRet param must be first param
+ if (this != getParent()->arg_begin())
+ return false; // StructRet param must be first param
return getParent()->paramHasAttr(1, ParamAttr::StructRet);
}
+/// addAttr - Add a ParamAttr to an argument
+void Argument::addAttr(ParameterAttributes attr) {
+ getParent()->setParamAttrs(
+ getParent()->getParamAttrs().addAttr(getArgNo() + 1, attr));
+}
+
+/// removeAttr - Remove a ParamAttr from an argument
+void Argument::removeAttr(ParameterAttributes attr) {
+ getParent()->setParamAttrs(
+ getParent()->getParamAttrs().removeAttr(getArgNo() + 1, attr));
+}
getParent()->getFunctionList().erase(this);
}
-/// @brief Determine whether the function has the given attribute.
-bool Function::paramHasAttr(uint16_t i, ParameterAttributes attr) const {
- return ParamAttrs && ParamAttrs->paramHasAttr(i, attr);
-}
-
-/// @brief Determine if the function cannot return.
-bool Function::doesNotReturn() const {
- return paramHasAttr(0, ParamAttr::NoReturn);
-}
-
-/// @brief Determine if the function cannot unwind.
-bool Function::doesNotThrow() const {
- return paramHasAttr(0, ParamAttr::NoUnwind);
-}
-
-/// @brief Determine if the function does not access memory.
-bool Function::doesNotAccessMemory() const {
- return paramHasAttr(0, ParamAttr::ReadNone);
-}
-
-/// @brief Determine if the function does not access or only reads memory.
-bool Function::onlyReadsMemory() const {
- return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
-}
-
-/// @brief Determine if the function returns a structure.
-bool Function::isStructReturn() const {
- return paramHasAttr(1, ParamAttr::StructRet);
-}
-
//===----------------------------------------------------------------------===//
// Function Implementation
//===----------------------------------------------------------------------===//
Function::Function(const FunctionType *Ty, LinkageTypes Linkage,
const std::string &name, Module *ParentModule)
: GlobalValue(PointerType::getUnqual(Ty),
- Value::FunctionVal, 0, 0, Linkage, name),
- ParamAttrs(0) {
+ Value::FunctionVal, 0, 0, Linkage, name) {
SymTab = new ValueSymbolTable();
- assert((getReturnType()->isFirstClassType() ||getReturnType() == Type::VoidTy)
+ assert((getReturnType()->isFirstClassType() ||getReturnType() == Type::VoidTy
+ || isa<StructType>(getReturnType()))
&& "LLVM functions cannot return aggregate values!");
// If the function has arguments, mark them as lazily built.
if (ParentModule)
ParentModule->getFunctionList().push_back(this);
+
+ // Ensure intrinsics have the right parameter attributes.
+ if (unsigned IID = getIntrinsicID(true))
+ setParamAttrs(Intrinsic::getParamAttrs(Intrinsic::ID(IID)));
}
Function::~Function() {
ArgumentList.clear();
delete SymTab;
- // Drop our reference to the parameter attributes, if any.
- if (ParamAttrs)
- ParamAttrs->dropRef();
-
// Remove the function from the on-the-side collector table.
clearCollector();
}
LeakDetector::removeGarbageObject(this);
}
-void Function::setParamAttrs(const ParamAttrsList *attrs) {
- // Avoid deleting the ParamAttrsList if they are setting the
- // attributes to the same list.
- if (ParamAttrs == attrs)
- return;
-
- // Drop reference on the old ParamAttrsList
- if (ParamAttrs)
- ParamAttrs->dropRef();
-
- // Add reference to the new ParamAttrsList
- if (attrs)
- attrs->addRef();
-
- // Set the new ParamAttrsList.
- ParamAttrs = attrs;
-}
-
// dropAllReferences() - This function causes all the subinstructions to "let
// go" of all references that they are maintaining. This allows one to
// 'delete' a whole class at a time, even though there may be circular
BasicBlocks.clear(); // Delete all basic blocks...
}
+void Function::setDoesNotThrow(bool doesNotThrow) {
+ PAListPtr PAL = getParamAttrs();
+ if (doesNotThrow)
+ PAL = PAL.addAttr(0, ParamAttr::NoUnwind);
+ else
+ PAL = PAL.removeAttr(0, ParamAttr::NoUnwind);
+ setParamAttrs(PAL);
+}
+
// Maintain the collector name for each function in an on-the-side table. This
// saves allocating an additional word in Function for programs which do not use
// GC (i.e., most programs) at the cost of increased overhead for clients which
return FunctionType::get(ResultTy, ArgTys, IsVarArg);
}
-const ParamAttrsList *Intrinsic::getParamAttrs(ID id) {
- ParamAttrsVector Attrs;
+PAListPtr Intrinsic::getParamAttrs(ID id) {
ParameterAttributes Attr = ParamAttr::None;
#define GET_INTRINSIC_ATTRIBUTES
// Intrinsics cannot throw exceptions.
Attr |= ParamAttr::NoUnwind;
- Attrs.push_back(ParamAttrsWithIndex::get(0, Attr));
- return ParamAttrsList::get(Attrs);
+ ParamAttrsWithIndex PAWI = ParamAttrsWithIndex::get(0, Attr);
+ return PAListPtr::get(&PAWI, 1);
}
Function *Intrinsic::getDeclaration(Module *M, ID id, const Type **Tys,
unsigned numTys) {
// There can never be multiple globals with the same name of different types,
// because intrinsics must be a specific type.
- Function *F =
+ return
cast<Function>(M->getOrInsertFunction(getName(id, Tys, numTys),
getType(id, Tys, numTys)));
- F->setParamAttrs(getParamAttrs(id));
- return F;
-}
-
-Value *IntrinsicInst::StripPointerCasts(Value *Ptr) {
- if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) {
- if (CE->getOpcode() == Instruction::BitCast) {
- if (isa<PointerType>(CE->getOperand(0)->getType()))
- return StripPointerCasts(CE->getOperand(0));
- } else if (CE->getOpcode() == Instruction::GetElementPtr) {
- for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i)
- if (!CE->getOperand(i)->isNullValue())
- return Ptr;
- return StripPointerCasts(CE->getOperand(0));
- }
- return Ptr;
- }
-
- if (BitCastInst *CI = dyn_cast<BitCastInst>(Ptr)) {
- if (isa<PointerType>(CI->getOperand(0)->getType()))
- return StripPointerCasts(CI->getOperand(0));
- } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr)) {
- if (GEP->hasAllZeroIndices())
- return StripPointerCasts(GEP->getOperand(0));
- }
- return Ptr;
}
// vim: sw=2 ai
projects / oota-llvm.git / blobdiff