2003-10-13 03:32:08 +00:00
|
|
|
//===-- Function.cpp - Implement the Global object classes ----------------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2013-01-02 09:10:48 +00:00
|
|
|
// This file implements the Function class for the IR library.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Function.h"
|
2013-03-01 18:48:54 +00:00
|
|
|
#include "LLVMContextImpl.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "SymbolTableListTraitsImpl.h"
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
|
|
|
#include "llvm/CodeGen/ValueTypes.h"
|
2014-03-04 11:01:28 +00:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2014-03-04 10:30:26 +00:00
|
|
|
#include "llvm/IR/InstIterator.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2014-03-04 12:46:06 +00:00
|
|
|
#include "llvm/IR/LeakDetector.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Module.h"
|
2009-06-17 22:23:31 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/RWMutex.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/Support/StringPool.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/Threading.h"
|
2003-11-21 20:23:48 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2002-06-25 16:13:24 +00:00
|
|
|
// Explicit instantiations of SymbolTableListTraits since some of the methods
|
|
|
|
// are not in the public header file...
|
2009-12-19 00:55:12 +00:00
|
|
|
template class llvm::SymbolTableListTraits<Argument, Function>;
|
|
|
|
template class llvm::SymbolTableListTraits<BasicBlock, Function>;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-04-09 19:39:35 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Argument Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-12-20 02:50:00 +00:00
|
|
|
void Argument::anchor() { }
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Argument::Argument(Type *Ty, const Twine &Name, Function *Par)
|
2007-02-12 05:18:08 +00:00
|
|
|
: Value(Ty, Value::ArgumentVal) {
|
2014-04-09 06:08:46 +00:00
|
|
|
Parent = nullptr;
|
2002-09-08 18:59:35 +00:00
|
|
|
|
|
|
|
// Make sure that we get added to a function
|
|
|
|
LeakDetector::addGarbageObject(this);
|
|
|
|
|
2002-09-06 21:33:15 +00:00
|
|
|
if (Par)
|
|
|
|
Par->getArgumentList().push_back(this);
|
2007-02-12 05:18:08 +00:00
|
|
|
setName(Name);
|
2002-09-06 21:33:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Argument::setParent(Function *parent) {
|
2002-09-08 18:59:35 +00:00
|
|
|
if (getParent())
|
|
|
|
LeakDetector::addGarbageObject(this);
|
2002-09-06 21:33:15 +00:00
|
|
|
Parent = parent;
|
2002-09-08 18:59:35 +00:00
|
|
|
if (getParent())
|
|
|
|
LeakDetector::removeGarbageObject(this);
|
2002-09-06 21:33:15 +00:00
|
|
|
}
|
|
|
|
|
2008-01-24 17:47:11 +00:00
|
|
|
/// getArgNo - Return the index of this formal argument in its containing
|
2012-12-17 20:37:55 +00:00
|
|
|
/// function. For example in "void foo(int a, float b)" a is 0 and b is 1.
|
2008-01-24 17:47:11 +00:00
|
|
|
unsigned Argument::getArgNo() const {
|
|
|
|
const Function *F = getParent();
|
|
|
|
assert(F && "Argument is not in a function");
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2008-01-24 17:47:11 +00:00
|
|
|
Function::const_arg_iterator AI = F->arg_begin();
|
|
|
|
unsigned ArgIdx = 0;
|
|
|
|
for (; &*AI != this; ++AI)
|
|
|
|
++ArgIdx;
|
|
|
|
|
|
|
|
return ArgIdx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// hasByValAttr - Return true if this argument has the byval attribute on it
|
|
|
|
/// in its containing function.
|
|
|
|
bool Argument::hasByValAttr() const {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!getType()->isPointerTy()) return false;
|
2012-12-30 12:45:13 +00:00
|
|
|
return getParent()->getAttributes().
|
|
|
|
hasAttribute(getArgNo()+1, Attribute::ByVal);
|
2008-01-24 17:47:11 +00:00
|
|
|
}
|
|
|
|
|
2013-12-19 02:14:12 +00:00
|
|
|
/// \brief Return true if this argument has the inalloca attribute on it in
|
|
|
|
/// its containing function.
|
|
|
|
bool Argument::hasInAllocaAttr() const {
|
|
|
|
if (!getType()->isPointerTy()) return false;
|
|
|
|
return getParent()->getAttributes().
|
|
|
|
hasAttribute(getArgNo()+1, Attribute::InAlloca);
|
|
|
|
}
|
|
|
|
|
2014-01-17 23:58:17 +00:00
|
|
|
bool Argument::hasByValOrInAllocaAttr() const {
|
|
|
|
if (!getType()->isPointerTy()) return false;
|
|
|
|
AttributeSet Attrs = getParent()->getAttributes();
|
|
|
|
return Attrs.hasAttribute(getArgNo() + 1, Attribute::ByVal) ||
|
|
|
|
Attrs.hasAttribute(getArgNo() + 1, Attribute::InAlloca);
|
|
|
|
}
|
|
|
|
|
2011-05-22 23:57:23 +00:00
|
|
|
unsigned Argument::getParamAlignment() const {
|
|
|
|
assert(getType()->isPointerTy() && "Only pointers have alignments");
|
|
|
|
return getParent()->getParamAlignment(getArgNo()+1);
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2011-05-22 23:57:23 +00:00
|
|
|
}
|
|
|
|
|
2009-12-11 08:36:17 +00:00
|
|
|
/// hasNestAttr - Return true if this argument has the nest attribute on
|
|
|
|
/// it in its containing function.
|
|
|
|
bool Argument::hasNestAttr() const {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!getType()->isPointerTy()) return false;
|
2012-12-30 12:45:13 +00:00
|
|
|
return getParent()->getAttributes().
|
|
|
|
hasAttribute(getArgNo()+1, Attribute::Nest);
|
2009-12-11 08:36:17 +00:00
|
|
|
}
|
|
|
|
|
2008-01-24 17:47:11 +00:00
|
|
|
/// hasNoAliasAttr - Return true if this argument has the noalias attribute on
|
|
|
|
/// it in its containing function.
|
|
|
|
bool Argument::hasNoAliasAttr() const {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!getType()->isPointerTy()) return false;
|
2012-12-30 12:45:13 +00:00
|
|
|
return getParent()->getAttributes().
|
|
|
|
hasAttribute(getArgNo()+1, Attribute::NoAlias);
|
2008-01-24 17:47:11 +00:00
|
|
|
}
|
|
|
|
|
2008-12-31 18:08:59 +00:00
|
|
|
/// hasNoCaptureAttr - Return true if this argument has the nocapture attribute
|
|
|
|
/// on it in its containing function.
|
|
|
|
bool Argument::hasNoCaptureAttr() const {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!getType()->isPointerTy()) return false;
|
2012-12-30 12:45:13 +00:00
|
|
|
return getParent()->getAttributes().
|
|
|
|
hasAttribute(getArgNo()+1, Attribute::NoCapture);
|
2008-12-31 18:08:59 +00:00
|
|
|
}
|
|
|
|
|
2008-02-17 23:22:28 +00:00
|
|
|
/// hasSRetAttr - Return true if this argument has the sret attribute on
|
|
|
|
/// it in its containing function.
|
|
|
|
bool Argument::hasStructRetAttr() const {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!getType()->isPointerTy()) return false;
|
2008-05-15 10:04:30 +00:00
|
|
|
if (this != getParent()->arg_begin())
|
|
|
|
return false; // StructRet param must be first param
|
2012-12-30 12:45:13 +00:00
|
|
|
return getParent()->getAttributes().
|
|
|
|
hasAttribute(1, Attribute::StructRet);
|
2008-02-17 23:22:28 +00:00
|
|
|
}
|
|
|
|
|
2013-04-20 05:14:40 +00:00
|
|
|
/// hasReturnedAttr - Return true if this argument has the returned attribute on
|
|
|
|
/// it in its containing function.
|
|
|
|
bool Argument::hasReturnedAttr() const {
|
|
|
|
return getParent()->getAttributes().
|
|
|
|
hasAttribute(getArgNo()+1, Attribute::Returned);
|
|
|
|
}
|
|
|
|
|
2013-07-06 00:29:58 +00:00
|
|
|
/// Return true if this argument has the readonly or readnone attribute on it
|
|
|
|
/// in its containing function.
|
|
|
|
bool Argument::onlyReadsMemory() const {
|
|
|
|
return getParent()->getAttributes().
|
|
|
|
hasAttribute(getArgNo()+1, Attribute::ReadOnly) ||
|
|
|
|
getParent()->getAttributes().
|
|
|
|
hasAttribute(getArgNo()+1, Attribute::ReadNone);
|
|
|
|
}
|
|
|
|
|
2013-01-23 06:14:59 +00:00
|
|
|
/// addAttr - Add attributes to an argument.
|
|
|
|
void Argument::addAttr(AttributeSet AS) {
|
2013-02-21 19:46:51 +00:00
|
|
|
assert(AS.getNumSlots() <= 1 &&
|
2013-02-20 23:04:11 +00:00
|
|
|
"Trying to add more than one attribute set to an argument!");
|
|
|
|
AttrBuilder B(AS, AS.getSlotIndex(0));
|
|
|
|
getParent()->addAttributes(getArgNo() + 1,
|
|
|
|
AttributeSet::get(Parent->getContext(),
|
|
|
|
getArgNo() + 1, B));
|
2008-04-28 17:37:06 +00:00
|
|
|
}
|
2008-07-08 09:41:30 +00:00
|
|
|
|
2013-01-23 06:14:59 +00:00
|
|
|
/// removeAttr - Remove attributes from an argument.
|
|
|
|
void Argument::removeAttr(AttributeSet AS) {
|
2013-02-21 19:46:51 +00:00
|
|
|
assert(AS.getNumSlots() <= 1 &&
|
2013-02-20 23:04:11 +00:00
|
|
|
"Trying to remove more than one attribute set from an argument!");
|
|
|
|
AttrBuilder B(AS, AS.getSlotIndex(0));
|
|
|
|
getParent()->removeAttributes(getArgNo() + 1,
|
|
|
|
AttributeSet::get(Parent->getContext(),
|
|
|
|
getArgNo() + 1, B));
|
2008-04-28 17:37:06 +00:00
|
|
|
}
|
2008-01-24 17:47:11 +00:00
|
|
|
|
2007-04-09 15:01:12 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2008-01-02 23:42:30 +00:00
|
|
|
// Helper Methods in Function
|
2007-04-09 15:01:12 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-07-22 00:24:57 +00:00
|
|
|
LLVMContext &Function::getContext() const {
|
|
|
|
return getType()->getContext();
|
2009-07-02 18:03:58 +00:00
|
|
|
}
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
FunctionType *Function::getFunctionType() const {
|
2008-01-02 23:42:30 +00:00
|
|
|
return cast<FunctionType>(getType()->getElementType());
|
2007-04-09 15:01:12 +00:00
|
|
|
}
|
|
|
|
|
2008-01-02 23:42:30 +00:00
|
|
|
bool Function::isVarArg() const {
|
|
|
|
return getFunctionType()->isVarArg();
|
2007-04-09 15:01:12 +00:00
|
|
|
}
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Type *Function::getReturnType() const {
|
2008-01-02 23:42:30 +00:00
|
|
|
return getFunctionType()->getReturnType();
|
2007-11-25 14:10:56 +00:00
|
|
|
}
|
|
|
|
|
2008-01-02 23:42:30 +00:00
|
|
|
void Function::removeFromParent() {
|
|
|
|
getParent()->getFunctionList().remove(this);
|
2007-11-25 14:10:56 +00:00
|
|
|
}
|
|
|
|
|
2008-01-02 23:42:30 +00:00
|
|
|
void Function::eraseFromParent() {
|
|
|
|
getParent()->getFunctionList().erase(this);
|
2007-04-09 15:01:12 +00:00
|
|
|
}
|
|
|
|
|
2001-09-10 07:58:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2002-03-26 18:01:55 +00:00
|
|
|
// Function Implementation
|
2001-09-10 07:58:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Function::Function(FunctionType *Ty, LinkageTypes Linkage,
|
2009-07-25 04:41:11 +00:00
|
|
|
const Twine &name, Module *ParentModule)
|
2012-12-17 20:37:55 +00:00
|
|
|
: GlobalValue(PointerType::getUnqual(Ty),
|
2014-04-09 06:08:46 +00:00
|
|
|
Value::FunctionVal, nullptr, 0, Linkage, name) {
|
2009-01-05 07:58:59 +00:00
|
|
|
assert(FunctionType::isValidReturnType(getReturnType()) &&
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
"invalid return type");
|
2007-02-05 20:47:22 +00:00
|
|
|
SymTab = new ValueSymbolTable();
|
2002-09-06 20:46:32 +00:00
|
|
|
|
2007-08-18 06:14:52 +00:00
|
|
|
// If the function has arguments, mark them as lazily built.
|
|
|
|
if (Ty->getNumParams())
|
2009-12-29 02:14:09 +00:00
|
|
|
setValueSubclassData(1); // Set the "has lazy arguments" bit.
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2002-09-08 18:59:35 +00:00
|
|
|
// Make sure that we get added to a function
|
|
|
|
LeakDetector::addGarbageObject(this);
|
|
|
|
|
2002-09-06 20:46:32 +00:00
|
|
|
if (ParentModule)
|
|
|
|
ParentModule->getFunctionList().push_back(this);
|
2008-04-07 13:39:11 +00:00
|
|
|
|
|
|
|
// Ensure intrinsics have the right parameter attributes.
|
2009-02-05 01:49:45 +00:00
|
|
|
if (unsigned IID = getIntrinsicID())
|
2012-10-15 04:46:55 +00:00
|
|
|
setAttributes(Intrinsic::getAttributes(getContext(), Intrinsic::ID(IID)));
|
2008-09-02 20:51:15 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2007-12-10 02:14:30 +00:00
|
|
|
Function::~Function() {
|
|
|
|
dropAllReferences(); // After this it is safe to delete instructions.
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
// Delete all of the method arguments and unlink from symbol table...
|
2007-12-10 02:14:30 +00:00
|
|
|
ArgumentList.clear();
|
|
|
|
delete SymTab;
|
2007-04-22 17:28:03 +00:00
|
|
|
|
2008-08-17 18:44:35 +00:00
|
|
|
// Remove the function from the on-the-side GC table.
|
|
|
|
clearGC();
|
2013-03-01 18:48:54 +00:00
|
|
|
|
|
|
|
// Remove the intrinsicID from the Cache.
|
2013-03-20 21:04:53 +00:00
|
|
|
if (getValueName() && isIntrinsic())
|
2013-03-01 18:48:54 +00:00
|
|
|
getContext().pImpl->IntrinsicIDCache.erase(this);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2007-08-18 06:14:52 +00:00
|
|
|
void Function::BuildLazyArguments() const {
|
|
|
|
// Create the arguments vector, all arguments start out unnamed.
|
2011-07-18 04:54:35 +00:00
|
|
|
FunctionType *FT = getFunctionType();
|
2007-08-18 06:14:52 +00:00
|
|
|
for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
|
2010-01-05 13:12:22 +00:00
|
|
|
assert(!FT->getParamType(i)->isVoidTy() &&
|
2007-08-18 06:14:52 +00:00
|
|
|
"Cannot have void typed arguments!");
|
|
|
|
ArgumentList.push_back(new Argument(FT->getParamType(i)));
|
|
|
|
}
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2007-08-18 06:14:52 +00:00
|
|
|
// Clear the lazy arguments bit.
|
2009-12-29 02:14:09 +00:00
|
|
|
unsigned SDC = getSubclassDataFromValue();
|
|
|
|
const_cast<Function*>(this)->setValueSubclassData(SDC &= ~1);
|
2007-08-18 06:14:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t Function::arg_size() const {
|
|
|
|
return getFunctionType()->getNumParams();
|
|
|
|
}
|
|
|
|
bool Function::arg_empty() const {
|
|
|
|
return getFunctionType()->getNumParams() == 0;
|
|
|
|
}
|
|
|
|
|
2002-03-23 22:51:58 +00:00
|
|
|
void Function::setParent(Module *parent) {
|
2002-09-08 18:59:35 +00:00
|
|
|
if (getParent())
|
|
|
|
LeakDetector::addGarbageObject(this);
|
2001-06-06 20:29:01 +00:00
|
|
|
Parent = parent;
|
2002-09-08 18:59:35 +00:00
|
|
|
if (getParent())
|
|
|
|
LeakDetector::removeGarbageObject(this);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
|
|
|
// references... first all references are dropped, and all use counts go to
|
2003-10-10 17:54:14 +00:00
|
|
|
// zero. Then everything is deleted for real. Note that no operations are
|
2005-04-21 23:48:37 +00:00
|
|
|
// valid on an object that has "dropped all references", except operator
|
2001-06-06 20:29:01 +00:00
|
|
|
// delete.
|
|
|
|
//
|
2002-03-23 22:51:58 +00:00
|
|
|
void Function::dropAllReferences() {
|
2002-06-25 16:13:24 +00:00
|
|
|
for (iterator I = begin(), E = end(); I != E; ++I)
|
|
|
|
I->dropAllReferences();
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2010-12-07 19:56:51 +00:00
|
|
|
// Delete all basic blocks. They are now unused, except possibly by
|
|
|
|
// blockaddresses, but BasicBlock's destructor takes care of those.
|
|
|
|
while (!BasicBlocks.empty())
|
|
|
|
BasicBlocks.begin()->eraseFromParent();
|
2013-09-16 01:08:15 +00:00
|
|
|
|
|
|
|
// Prefix data is stored in a side table.
|
2014-04-09 06:08:46 +00:00
|
|
|
setPrefixData(nullptr);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2001-09-10 07:58:01 +00:00
|
|
|
|
2013-01-23 00:20:53 +00:00
|
|
|
void Function::addAttribute(unsigned i, Attribute::AttrKind attr) {
|
2012-12-07 23:16:57 +00:00
|
|
|
AttributeSet PAL = getAttributes();
|
2013-01-23 00:20:53 +00:00
|
|
|
PAL = PAL.addAttribute(getContext(), i, attr);
|
|
|
|
setAttributes(PAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Function::addAttributes(unsigned i, AttributeSet attrs) {
|
|
|
|
AttributeSet PAL = getAttributes();
|
|
|
|
PAL = PAL.addAttributes(getContext(), i, attrs);
|
2008-09-25 21:00:45 +00:00
|
|
|
setAttributes(PAL);
|
2008-04-08 07:23:58 +00:00
|
|
|
}
|
|
|
|
|
2013-01-23 00:45:55 +00:00
|
|
|
void Function::removeAttributes(unsigned i, AttributeSet attrs) {
|
2012-12-07 23:16:57 +00:00
|
|
|
AttributeSet PAL = getAttributes();
|
2013-01-23 00:45:55 +00:00
|
|
|
PAL = PAL.removeAttributes(getContext(), i, attrs);
|
2008-09-25 21:00:45 +00:00
|
|
|
setAttributes(PAL);
|
2008-05-16 20:39:43 +00:00
|
|
|
}
|
|
|
|
|
2008-08-17 18:44:35 +00:00
|
|
|
// Maintain the GC 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 do
|
|
|
|
// use GC.
|
2009-06-17 23:49:06 +00:00
|
|
|
static DenseMap<const Function*,PooledStringPtr> *GCNames;
|
|
|
|
static StringPool *GCNamePool;
|
2009-06-18 20:56:48 +00:00
|
|
|
static ManagedStatic<sys::SmartRWMutex<true> > GCLock;
|
2007-12-10 03:18:06 +00:00
|
|
|
|
2008-08-17 18:44:35 +00:00
|
|
|
bool Function::hasGC() const {
|
2009-07-07 18:33:04 +00:00
|
|
|
sys::SmartScopedReader<true> Reader(*GCLock);
|
2009-06-18 20:56:48 +00:00
|
|
|
return GCNames && GCNames->count(this);
|
2007-12-10 03:18:06 +00:00
|
|
|
}
|
|
|
|
|
2008-08-17 18:44:35 +00:00
|
|
|
const char *Function::getGC() const {
|
|
|
|
assert(hasGC() && "Function has no collector");
|
2009-07-07 18:33:04 +00:00
|
|
|
sys::SmartScopedReader<true> Reader(*GCLock);
|
2009-06-18 20:56:48 +00:00
|
|
|
return *(*GCNames)[this];
|
2007-12-10 03:18:06 +00:00
|
|
|
}
|
|
|
|
|
2008-08-17 18:44:35 +00:00
|
|
|
void Function::setGC(const char *Str) {
|
2009-07-07 18:33:04 +00:00
|
|
|
sys::SmartScopedWriter<true> Writer(*GCLock);
|
2009-06-17 23:49:06 +00:00
|
|
|
if (!GCNamePool)
|
|
|
|
GCNamePool = new StringPool();
|
|
|
|
if (!GCNames)
|
|
|
|
GCNames = new DenseMap<const Function*,PooledStringPtr>();
|
|
|
|
(*GCNames)[this] = GCNamePool->intern(Str);
|
2007-12-10 03:18:06 +00:00
|
|
|
}
|
|
|
|
|
2008-08-17 18:44:35 +00:00
|
|
|
void Function::clearGC() {
|
2009-07-07 18:33:04 +00:00
|
|
|
sys::SmartScopedWriter<true> Writer(*GCLock);
|
2009-06-17 23:49:06 +00:00
|
|
|
if (GCNames) {
|
2008-08-17 18:44:35 +00:00
|
|
|
GCNames->erase(this);
|
2009-06-17 23:49:06 +00:00
|
|
|
if (GCNames->empty()) {
|
|
|
|
delete GCNames;
|
2014-04-09 06:08:46 +00:00
|
|
|
GCNames = nullptr;
|
2009-06-17 23:49:06 +00:00
|
|
|
if (GCNamePool->empty()) {
|
|
|
|
delete GCNamePool;
|
2014-04-09 06:08:46 +00:00
|
|
|
GCNamePool = nullptr;
|
2009-06-17 23:49:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-12-10 03:18:06 +00:00
|
|
|
}
|
|
|
|
|
2008-05-26 19:58:59 +00:00
|
|
|
/// copyAttributesFrom - copy all additional attributes (those not needed to
|
|
|
|
/// create a Function) from the Function Src to this one.
|
|
|
|
void Function::copyAttributesFrom(const GlobalValue *Src) {
|
|
|
|
assert(isa<Function>(Src) && "Expected a Function!");
|
|
|
|
GlobalValue::copyAttributesFrom(Src);
|
|
|
|
const Function *SrcF = cast<Function>(Src);
|
|
|
|
setCallingConv(SrcF->getCallingConv());
|
2008-09-25 21:00:45 +00:00
|
|
|
setAttributes(SrcF->getAttributes());
|
2008-08-17 18:44:35 +00:00
|
|
|
if (SrcF->hasGC())
|
|
|
|
setGC(SrcF->getGC());
|
|
|
|
else
|
|
|
|
clearGC();
|
2013-09-16 01:08:15 +00:00
|
|
|
if (SrcF->hasPrefixData())
|
|
|
|
setPrefixData(SrcF->getPrefixData());
|
|
|
|
else
|
2014-04-09 06:08:46 +00:00
|
|
|
setPrefixData(nullptr);
|
2008-05-26 19:58:59 +00:00
|
|
|
}
|
|
|
|
|
2003-05-08 03:47:33 +00:00
|
|
|
/// getIntrinsicID - This method returns the ID number of the specified
|
2003-11-11 22:41:34 +00:00
|
|
|
/// function, or Intrinsic::not_intrinsic if the function is not an
|
2003-10-10 17:54:14 +00:00
|
|
|
/// intrinsic, or if the pointer is null. This value is always defined to be
|
2003-05-08 03:47:33 +00:00
|
|
|
/// zero to allow easy checking for whether a function is intrinsic or not. The
|
|
|
|
/// particular intrinsic functions which correspond to this value are defined in
|
2013-03-01 18:48:54 +00:00
|
|
|
/// llvm/Intrinsics.h. Results are cached in the LLVM context, subsequent
|
|
|
|
/// requests for the same ID return results much faster from the cache.
|
2003-05-08 03:47:33 +00:00
|
|
|
///
|
2009-02-05 01:49:45 +00:00
|
|
|
unsigned Function::getIntrinsicID() const {
|
2007-02-15 19:17:16 +00:00
|
|
|
const ValueName *ValName = this->getValueName();
|
2012-12-19 23:17:20 +00:00
|
|
|
if (!ValName || !isIntrinsic())
|
2007-04-16 07:08:44 +00:00
|
|
|
return 0;
|
2013-03-01 18:48:54 +00:00
|
|
|
|
|
|
|
LLVMContextImpl::IntrinsicIDCacheTy &IntrinsicIDCache =
|
|
|
|
getContext().pImpl->IntrinsicIDCache;
|
2013-03-20 21:04:53 +00:00
|
|
|
if (!IntrinsicIDCache.count(this)) {
|
2013-03-01 18:48:54 +00:00
|
|
|
unsigned Id = lookupIntrinsicID();
|
|
|
|
IntrinsicIDCache[this]=Id;
|
|
|
|
return Id;
|
|
|
|
}
|
|
|
|
return IntrinsicIDCache[this];
|
|
|
|
}
|
|
|
|
|
|
|
|
/// This private method does the actual lookup of an intrinsic ID when the query
|
|
|
|
/// could not be answered from the cache.
|
|
|
|
unsigned Function::lookupIntrinsicID() const {
|
|
|
|
const ValueName *ValName = this->getValueName();
|
2007-02-15 19:17:16 +00:00
|
|
|
unsigned Len = ValName->getKeyLength();
|
|
|
|
const char *Name = ValName->getKeyData();
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2006-03-09 20:35:01 +00:00
|
|
|
#define GET_FUNCTION_RECOGNIZER
|
2013-01-02 12:09:16 +00:00
|
|
|
#include "llvm/IR/Intrinsics.gen"
|
2006-03-09 20:35:01 +00:00
|
|
|
#undef GET_FUNCTION_RECOGNIZER
|
2013-03-01 18:48:54 +00:00
|
|
|
|
2003-05-08 03:47:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-14 17:45:39 +00:00
|
|
|
std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
|
2006-03-25 06:32:47 +00:00
|
|
|
assert(id < num_intrinsics && "Invalid intrinsic ID!");
|
2011-04-25 22:14:33 +00:00
|
|
|
static const char * const Table[] = {
|
2006-03-25 06:32:47 +00:00
|
|
|
"not_intrinsic",
|
|
|
|
#define GET_INTRINSIC_NAME_TABLE
|
2013-01-02 12:09:16 +00:00
|
|
|
#include "llvm/IR/Intrinsics.gen"
|
2006-03-25 06:32:47 +00:00
|
|
|
#undef GET_INTRINSIC_NAME_TABLE
|
|
|
|
};
|
2011-07-14 17:45:39 +00:00
|
|
|
if (Tys.empty())
|
2007-04-01 07:25:33 +00:00
|
|
|
return Table[id];
|
|
|
|
std::string Result(Table[id]);
|
2011-07-14 17:45:39 +00:00
|
|
|
for (unsigned i = 0; i < Tys.size(); ++i) {
|
2011-07-18 04:54:35 +00:00
|
|
|
if (PointerType* PTyp = dyn_cast<PointerType>(Tys[i])) {
|
2012-12-17 20:37:55 +00:00
|
|
|
Result += ".p" + llvm::utostr(PTyp->getAddressSpace()) +
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT::getEVT(PTyp->getElementType()).getEVTString();
|
2008-07-30 04:36:53 +00:00
|
|
|
}
|
|
|
|
else if (Tys[i])
|
2009-08-10 22:56:29 +00:00
|
|
|
Result += "." + EVT::getEVT(Tys[i]).getEVTString();
|
2008-07-30 04:36:53 +00:00
|
|
|
}
|
2007-04-01 07:25:33 +00:00
|
|
|
return Result;
|
2006-03-25 06:32:47 +00:00
|
|
|
}
|
|
|
|
|
2012-05-16 06:34:44 +00:00
|
|
|
|
2012-05-27 18:28:35 +00:00
|
|
|
/// IIT_Info - These are enumerators that describe the entries returned by the
|
|
|
|
/// getIntrinsicInfoTableEntries function.
|
|
|
|
///
|
|
|
|
/// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
|
|
|
|
enum IIT_Info {
|
|
|
|
// Common values should be encoded with 0-15.
|
|
|
|
IIT_Done = 0,
|
|
|
|
IIT_I1 = 1,
|
|
|
|
IIT_I8 = 2,
|
|
|
|
IIT_I16 = 3,
|
|
|
|
IIT_I32 = 4,
|
|
|
|
IIT_I64 = 5,
|
2013-01-11 01:45:05 +00:00
|
|
|
IIT_F16 = 6,
|
|
|
|
IIT_F32 = 7,
|
|
|
|
IIT_F64 = 8,
|
|
|
|
IIT_V2 = 9,
|
|
|
|
IIT_V4 = 10,
|
|
|
|
IIT_V8 = 11,
|
|
|
|
IIT_V16 = 12,
|
|
|
|
IIT_V32 = 13,
|
2012-05-27 18:28:35 +00:00
|
|
|
IIT_PTR = 14,
|
|
|
|
IIT_ARG = 15,
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-27 18:28:35 +00:00
|
|
|
// Values from 16+ are only encodable with the inefficient encoding.
|
2013-01-11 01:45:05 +00:00
|
|
|
IIT_MMX = 16,
|
|
|
|
IIT_METADATA = 17,
|
|
|
|
IIT_EMPTYSTRUCT = 18,
|
|
|
|
IIT_STRUCT2 = 19,
|
|
|
|
IIT_STRUCT3 = 20,
|
|
|
|
IIT_STRUCT4 = 21,
|
|
|
|
IIT_STRUCT5 = 22,
|
2014-03-28 12:31:39 +00:00
|
|
|
IIT_EXTEND_ARG = 23,
|
|
|
|
IIT_TRUNC_ARG = 24,
|
2013-09-24 02:47:27 +00:00
|
|
|
IIT_ANYPTR = 25,
|
2013-10-31 17:18:11 +00:00
|
|
|
IIT_V1 = 26,
|
2014-03-29 07:04:54 +00:00
|
|
|
IIT_VARARG = 27,
|
|
|
|
IIT_HALF_VEC_ARG = 28
|
2012-05-27 18:28:35 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
|
|
|
|
SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) {
|
2012-05-17 05:13:57 +00:00
|
|
|
IIT_Info Info = IIT_Info(Infos[NextElt++]);
|
2012-05-17 05:03:24 +00:00
|
|
|
unsigned StructElts = 2;
|
2012-05-27 18:28:35 +00:00
|
|
|
using namespace Intrinsic;
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-17 05:13:57 +00:00
|
|
|
switch (Info) {
|
2012-05-27 18:28:35 +00:00
|
|
|
case IIT_Done:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
|
|
|
|
return;
|
2013-10-31 17:18:11 +00:00
|
|
|
case IIT_VARARG:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
|
|
|
|
return;
|
2012-05-27 18:28:35 +00:00
|
|
|
case IIT_MMX:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
|
|
|
|
return;
|
|
|
|
case IIT_METADATA:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
|
|
|
|
return;
|
2013-01-11 01:45:05 +00:00
|
|
|
case IIT_F16:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
|
|
|
|
return;
|
2012-05-27 18:28:35 +00:00
|
|
|
case IIT_F32:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
|
|
|
|
return;
|
|
|
|
case IIT_F64:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
|
|
|
|
return;
|
|
|
|
case IIT_I1:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
|
|
|
|
return;
|
|
|
|
case IIT_I8:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
|
|
|
|
return;
|
|
|
|
case IIT_I16:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
|
|
|
|
return;
|
|
|
|
case IIT_I32:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
|
|
|
|
return;
|
|
|
|
case IIT_I64:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
|
|
|
|
return;
|
2013-09-24 02:47:27 +00:00
|
|
|
case IIT_V1:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1));
|
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
2012-05-17 04:30:58 +00:00
|
|
|
case IIT_V2:
|
2012-05-27 18:28:35 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2));
|
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
2012-05-17 04:30:58 +00:00
|
|
|
case IIT_V4:
|
2012-05-27 18:28:35 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4));
|
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
2012-05-17 04:30:58 +00:00
|
|
|
case IIT_V8:
|
2012-05-27 18:28:35 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8));
|
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
2012-05-17 04:30:58 +00:00
|
|
|
case IIT_V16:
|
2012-05-27 18:28:35 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16));
|
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
2012-05-17 05:03:24 +00:00
|
|
|
case IIT_V32:
|
2012-05-27 18:28:35 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32));
|
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
2012-05-23 05:19:18 +00:00
|
|
|
case IIT_PTR:
|
2012-05-27 18:28:35 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
|
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
2012-05-23 05:19:18 +00:00
|
|
|
case IIT_ANYPTR: { // [ANYPTR addrspace, subtype]
|
2012-12-17 20:37:55 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
|
2012-05-27 18:28:35 +00:00
|
|
|
Infos[NextElt++]));
|
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case IIT_ARG: {
|
|
|
|
unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
|
|
|
|
return;
|
|
|
|
}
|
2014-03-28 12:31:39 +00:00
|
|
|
case IIT_EXTEND_ARG: {
|
2012-05-27 18:28:35 +00:00
|
|
|
unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
|
2014-03-28 12:31:39 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
|
2012-05-27 18:28:35 +00:00
|
|
|
ArgInfo));
|
|
|
|
return;
|
2012-05-21 23:21:28 +00:00
|
|
|
}
|
2014-03-28 12:31:39 +00:00
|
|
|
case IIT_TRUNC_ARG: {
|
2012-05-27 18:28:35 +00:00
|
|
|
unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
|
2014-03-28 12:31:39 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
|
2012-05-27 18:28:35 +00:00
|
|
|
ArgInfo));
|
|
|
|
return;
|
2012-05-17 05:03:24 +00:00
|
|
|
}
|
2014-03-29 07:04:54 +00:00
|
|
|
case IIT_HALF_VEC_ARG: {
|
|
|
|
unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
|
|
|
|
ArgInfo));
|
|
|
|
return;
|
|
|
|
}
|
2012-05-27 18:28:35 +00:00
|
|
|
case IIT_EMPTYSTRUCT:
|
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
|
|
|
|
return;
|
2012-05-17 05:03:24 +00:00
|
|
|
case IIT_STRUCT5: ++StructElts; // FALL THROUGH.
|
|
|
|
case IIT_STRUCT4: ++StructElts; // FALL THROUGH.
|
|
|
|
case IIT_STRUCT3: ++StructElts; // FALL THROUGH.
|
|
|
|
case IIT_STRUCT2: {
|
2012-05-27 18:28:35 +00:00
|
|
|
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
|
|
|
|
|
2012-05-17 05:03:24 +00:00
|
|
|
for (unsigned i = 0; i != StructElts; ++i)
|
2012-05-27 18:28:35 +00:00
|
|
|
DecodeIITType(NextElt, Infos, OutputTable);
|
|
|
|
return;
|
2012-05-17 04:30:58 +00:00
|
|
|
}
|
2012-05-16 06:34:44 +00:00
|
|
|
}
|
|
|
|
llvm_unreachable("unhandled");
|
|
|
|
}
|
|
|
|
|
2012-05-27 18:28:35 +00:00
|
|
|
|
|
|
|
#define GET_INTRINSIC_GENERATOR_GLOBAL
|
2013-01-02 12:09:16 +00:00
|
|
|
#include "llvm/IR/Intrinsics.gen"
|
2012-05-27 18:28:35 +00:00
|
|
|
#undef GET_INTRINSIC_GENERATOR_GLOBAL
|
|
|
|
|
2012-12-17 20:37:55 +00:00
|
|
|
void Intrinsic::getIntrinsicInfoTableEntries(ID id,
|
2012-05-27 18:28:35 +00:00
|
|
|
SmallVectorImpl<IITDescriptor> &T){
|
2012-05-16 06:34:44 +00:00
|
|
|
// Check to see if the intrinsic's type was expressible by the table.
|
|
|
|
unsigned TableVal = IIT_Table[id-1];
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-17 15:55:41 +00:00
|
|
|
// Decode the TableVal into an array of IITValues.
|
|
|
|
SmallVector<unsigned char, 8> IITValues;
|
|
|
|
ArrayRef<unsigned char> IITEntries;
|
|
|
|
unsigned NextElt = 0;
|
|
|
|
if ((TableVal >> 31) != 0) {
|
|
|
|
// This is an offset into the IIT_LongEncodingTable.
|
|
|
|
IITEntries = IIT_LongEncodingTable;
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-17 15:55:41 +00:00
|
|
|
// Strip sentinel bit.
|
|
|
|
NextElt = (TableVal << 1) >> 1;
|
|
|
|
} else {
|
2012-05-27 18:28:35 +00:00
|
|
|
// Decode the TableVal into an array of IITValues. If the entry was encoded
|
|
|
|
// into a single word in the table itself, decode it now.
|
2012-05-17 05:13:57 +00:00
|
|
|
do {
|
|
|
|
IITValues.push_back(TableVal & 0xF);
|
|
|
|
TableVal >>= 4;
|
|
|
|
} while (TableVal);
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-17 15:55:41 +00:00
|
|
|
IITEntries = IITValues;
|
|
|
|
NextElt = 0;
|
2012-05-16 06:34:44 +00:00
|
|
|
}
|
2012-05-27 18:28:35 +00:00
|
|
|
|
|
|
|
// Okay, decode the table into the output vector of IITDescriptors.
|
|
|
|
DecodeIITType(NextElt, IITEntries, T);
|
|
|
|
while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
|
|
|
|
DecodeIITType(NextElt, IITEntries, T);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos,
|
|
|
|
ArrayRef<Type*> Tys, LLVMContext &Context) {
|
|
|
|
using namespace Intrinsic;
|
|
|
|
IITDescriptor D = Infos.front();
|
|
|
|
Infos = Infos.slice(1);
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-27 18:28:35 +00:00
|
|
|
switch (D.Kind) {
|
|
|
|
case IITDescriptor::Void: return Type::getVoidTy(Context);
|
2013-10-31 17:18:11 +00:00
|
|
|
case IITDescriptor::VarArg: return Type::getVoidTy(Context);
|
2012-05-27 18:28:35 +00:00
|
|
|
case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
|
|
|
|
case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
|
2013-01-11 01:45:05 +00:00
|
|
|
case IITDescriptor::Half: return Type::getHalfTy(Context);
|
2012-05-27 18:28:35 +00:00
|
|
|
case IITDescriptor::Float: return Type::getFloatTy(Context);
|
|
|
|
case IITDescriptor::Double: return Type::getDoubleTy(Context);
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-27 18:28:35 +00:00
|
|
|
case IITDescriptor::Integer:
|
|
|
|
return IntegerType::get(Context, D.Integer_Width);
|
|
|
|
case IITDescriptor::Vector:
|
|
|
|
return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width);
|
|
|
|
case IITDescriptor::Pointer:
|
|
|
|
return PointerType::get(DecodeFixedType(Infos, Tys, Context),
|
|
|
|
D.Pointer_AddressSpace);
|
|
|
|
case IITDescriptor::Struct: {
|
|
|
|
Type *Elts[5];
|
|
|
|
assert(D.Struct_NumElements <= 5 && "Can't handle this yet");
|
|
|
|
for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
|
|
|
|
Elts[i] = DecodeFixedType(Infos, Tys, Context);
|
|
|
|
return StructType::get(Context, ArrayRef<Type*>(Elts,D.Struct_NumElements));
|
|
|
|
}
|
|
|
|
|
|
|
|
case IITDescriptor::Argument:
|
|
|
|
return Tys[D.getArgumentNumber()];
|
2014-03-28 12:31:39 +00:00
|
|
|
case IITDescriptor::ExtendArgument: {
|
|
|
|
Type *Ty = Tys[D.getArgumentNumber()];
|
|
|
|
if (VectorType *VTy = dyn_cast<VectorType>(Ty))
|
|
|
|
return VectorType::getExtendedElementVectorType(VTy);
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2014-03-28 12:31:39 +00:00
|
|
|
return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
|
|
|
|
}
|
|
|
|
case IITDescriptor::TruncArgument: {
|
|
|
|
Type *Ty = Tys[D.getArgumentNumber()];
|
|
|
|
if (VectorType *VTy = dyn_cast<VectorType>(Ty))
|
|
|
|
return VectorType::getTruncatedElementVectorType(VTy);
|
|
|
|
|
|
|
|
IntegerType *ITy = cast<IntegerType>(Ty);
|
|
|
|
assert(ITy->getBitWidth() % 2 == 0);
|
|
|
|
return IntegerType::get(Context, ITy->getBitWidth() / 2);
|
|
|
|
}
|
2014-03-29 07:04:54 +00:00
|
|
|
case IITDescriptor::HalfVecArgument:
|
|
|
|
return VectorType::getHalfElementsVectorType(cast<VectorType>(
|
|
|
|
Tys[D.getArgumentNumber()]));
|
2012-05-27 18:28:35 +00:00
|
|
|
}
|
|
|
|
llvm_unreachable("unhandled");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FunctionType *Intrinsic::getType(LLVMContext &Context,
|
|
|
|
ID id, ArrayRef<Type*> Tys) {
|
|
|
|
SmallVector<IITDescriptor, 8> Table;
|
|
|
|
getIntrinsicInfoTableEntries(id, Table);
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-27 18:28:35 +00:00
|
|
|
ArrayRef<IITDescriptor> TableRef = Table;
|
|
|
|
Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
|
2012-12-17 20:37:55 +00:00
|
|
|
|
2012-05-17 15:55:41 +00:00
|
|
|
SmallVector<Type*, 8> ArgTys;
|
2012-05-27 18:28:35 +00:00
|
|
|
while (!TableRef.empty())
|
|
|
|
ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
|
2007-02-07 20:38:26 +00:00
|
|
|
|
2012-12-17 20:37:55 +00:00
|
|
|
return FunctionType::get(ResultTy, ArgTys, false);
|
2007-02-07 20:38:26 +00:00
|
|
|
}
|
|
|
|
|
2009-02-24 23:17:49 +00:00
|
|
|
bool Intrinsic::isOverloaded(ID id) {
|
|
|
|
#define GET_INTRINSIC_OVERLOAD_TABLE
|
2013-01-02 12:09:16 +00:00
|
|
|
#include "llvm/IR/Intrinsics.gen"
|
2009-02-24 23:17:49 +00:00
|
|
|
#undef GET_INTRINSIC_OVERLOAD_TABLE
|
|
|
|
}
|
|
|
|
|
2009-01-12 01:18:58 +00:00
|
|
|
/// This defines the "Intrinsic::getAttributes(ID id)" method.
|
2007-12-03 20:06:50 +00:00
|
|
|
#define GET_INTRINSIC_ATTRIBUTES
|
2013-01-02 12:09:16 +00:00
|
|
|
#include "llvm/IR/Intrinsics.gen"
|
2007-12-03 20:06:50 +00:00
|
|
|
#undef GET_INTRINSIC_ATTRIBUTES
|
|
|
|
|
2011-07-14 17:45:39 +00:00
|
|
|
Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) {
|
2007-12-03 20:06:50 +00:00
|
|
|
// There can never be multiple globals with the same name of different types,
|
|
|
|
// because intrinsics must be a specific type.
|
2008-04-07 13:39:11 +00:00
|
|
|
return
|
2011-07-14 17:45:39 +00:00
|
|
|
cast<Function>(M->getOrInsertFunction(getName(id, Tys),
|
|
|
|
getType(M->getContext(), id, Tys)));
|
2007-02-07 20:38:26 +00:00
|
|
|
}
|
|
|
|
|
2009-02-05 01:49:45 +00:00
|
|
|
// This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
|
|
|
|
#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
|
2013-01-02 12:09:16 +00:00
|
|
|
#include "llvm/IR/Intrinsics.gen"
|
2009-02-05 01:49:45 +00:00
|
|
|
#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
|
|
|
|
|
2010-03-23 14:40:20 +00:00
|
|
|
/// hasAddressTaken - returns true if there are any uses of this function
|
|
|
|
/// other than direct calls or invokes to it.
|
2010-03-24 13:21:49 +00:00
|
|
|
bool Function::hasAddressTaken(const User* *PutOffender) const {
|
2014-03-09 03:16:01 +00:00
|
|
|
for (const Use &U : uses()) {
|
|
|
|
const User *FU = U.getUser();
|
|
|
|
if (isa<BlockAddress>(FU))
|
2012-05-12 08:30:16 +00:00
|
|
|
continue;
|
2014-03-09 03:16:01 +00:00
|
|
|
if (!isa<CallInst>(FU) && !isa<InvokeInst>(FU))
|
|
|
|
return PutOffender ? (*PutOffender = FU, true) : true;
|
|
|
|
ImmutableCallSite CS(cast<Instruction>(FU));
|
|
|
|
if (!CS.isCallee(&U))
|
|
|
|
return PutOffender ? (*PutOffender = FU, true) : true;
|
2009-06-10 08:41:11 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-10-20 05:23:42 +00:00
|
|
|
bool Function::isDefTriviallyDead() const {
|
|
|
|
// Check the linkage
|
|
|
|
if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
|
|
|
|
!hasAvailableExternallyLinkage())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check if the function is used by anything other than a blockaddress.
|
2014-03-09 03:16:01 +00:00
|
|
|
for (const User *U : users())
|
|
|
|
if (!isa<BlockAddress>(U))
|
2011-10-20 05:23:42 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-10-17 18:43:40 +00:00
|
|
|
/// callsFunctionThatReturnsTwice - Return true if the function has a call to
|
|
|
|
/// setjmp or other function that gcc recognizes as "returning twice".
|
|
|
|
bool Function::callsFunctionThatReturnsTwice() const {
|
|
|
|
for (const_inst_iterator
|
|
|
|
I = inst_begin(this), E = inst_end(this); I != E; ++I) {
|
2014-01-14 04:20:01 +00:00
|
|
|
ImmutableCallSite CS(&*I);
|
|
|
|
if (CS && CS.hasFnAttr(Attribute::ReturnsTwice))
|
2011-10-17 18:43:40 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2013-09-16 01:08:15 +00:00
|
|
|
|
|
|
|
Constant *Function::getPrefixData() const {
|
|
|
|
assert(hasPrefixData());
|
|
|
|
const LLVMContextImpl::PrefixDataMapTy &PDMap =
|
|
|
|
getContext().pImpl->PrefixDataMap;
|
|
|
|
assert(PDMap.find(this) != PDMap.end());
|
|
|
|
return cast<Constant>(PDMap.find(this)->second->getReturnValue());
|
|
|
|
}
|
|
|
|
|
|
|
|
void Function::setPrefixData(Constant *PrefixData) {
|
|
|
|
if (!PrefixData && !hasPrefixData())
|
|
|
|
return;
|
|
|
|
|
|
|
|
unsigned SCData = getSubclassDataFromValue();
|
|
|
|
LLVMContextImpl::PrefixDataMapTy &PDMap = getContext().pImpl->PrefixDataMap;
|
|
|
|
ReturnInst *&PDHolder = PDMap[this];
|
|
|
|
if (PrefixData) {
|
|
|
|
if (PDHolder)
|
|
|
|
PDHolder->setOperand(0, PrefixData);
|
|
|
|
else
|
|
|
|
PDHolder = ReturnInst::Create(getContext(), PrefixData);
|
|
|
|
SCData |= 2;
|
|
|
|
} else {
|
|
|
|
delete PDHolder;
|
|
|
|
PDMap.erase(this);
|
|
|
|
SCData &= ~2;
|
|
|
|
}
|
|
|
|
setValueSubclassData(SCData);
|
|
|
|
}
|