6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-26 21:32:10 +00:00
Code Issues Projects Releases Wiki Activity

Prologue support

Browse Source 
Patch by Ben Gamari!

This redefines the `prefix` attribute introduced previously and
introduces a `prologue` attribute.  There are a two primary usecases
that these attributes aim to serve,

  1. Function prologue sigils

  2. Function hot-patching: Enable the user to insert `nop` operations
     at the beginning of the function which can later be safely replaced
     with a call to some instrumentation facility

  3. Runtime metadata: Allow a compiler to insert data for use by the
     runtime during execution. GHC is one example of a compiler that
     needs this functionality for its tables-next-to-code functionality.

Previously `prefix` served cases (1) and (2) quite well by allowing the user
to introduce arbitrary data at the entrypoint but before the function
body. Case (3), however, was poorly handled by this approach as it
required that prefix data was valid executable code.

Here we redefine the notion of prefix data to instead be data which
occurs immediately before the function entrypoint (i.e. the symbol
address). Since prefix data now occurs before the function entrypoint,
there is no need for the data to be valid code.

The previous notion of prefix data now goes under the name "prologue
data" to emphasize its duality with the function epilogue.

The intention here is to handle cases (1) and (2) with prologue data and
case (3) with prefix data.

References
----------

This idea arose out of discussions[1] with Reid Kleckner in response to a
proposal to introduce the notion of symbol offsets to enable handling of
case (3).

[1] http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-May/073235.html

Test Plan: testsuite

Differential Revision: http://reviews.llvm.org/D6454

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223189 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Peter Collingbourne 2014-12-03 02:08:38 +00:00
parent 8cc929ea00
commit bb660fc192
23 changed files with 306 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
docs/BitCodeFormat.rst
View File

@ -741,7 +741,7 @@ global variable. The operand fields are:
MODULE_CODE_FUNCTION Record
^^^^^^^^^^^^^^^^^^^^^^^^^^^
``[FUNCTION, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prefix, dllstorageclass]``
``[FUNCTION, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prologuedata, dllstorageclass, comdat, prefixdata]``
The ``FUNCTION`` record (code 8) marks the declaration or definition of a
function. The operand fields are:
@ -784,12 +784,18 @@ function. The operand fields are:
* *unnamed_addr*: If present and non-zero, indicates that the function has
``unnamed_addr``
* *prefix*: If non-zero, the value index of the prefix data for this function,
* *prologuedata*: If non-zero, the value index of the prologue data for this function,
plus 1.
* *dllstorageclass*: An encoding of the
:ref:`dllstorageclass<bcdllstorageclass>` of this function
* *comdat*: An encoding of the COMDAT of this function
* *prefixdata*: If non-zero, the value index of the prefix data for this function,
plus 1.
MODULE_CODE_ALIAS Record
^^^^^^^^^^^^^^^^^^^^^^^^

86
docs/LangRef.rst
View File

@ -633,7 +633,8 @@ name, a (possibly empty) argument list (each with optional :ref:`parameter
attributes <paramattrs>`), optional :ref:`function attributes <fnattrs>`,
an optional section, an optional alignment,
an optional :ref:`comdat <langref_comdats>`,
an optional :ref:`garbage collector name <gc>`, an optional :ref:`prefix <prefixdata>`, an opening
an optional :ref:`garbage collector name <gc>`, an optional :ref:`prefix <prefixdata>`,
an optional :ref:`prologue <prologuedata>`, an opening
curly brace, a list of basic blocks, and a closing curly brace.
LLVM function declarations consist of the "``declare``" keyword, an
@ -643,7 +644,8 @@ an optional :ref:`calling convention <callingconv>`,
an optional ``unnamed_addr`` attribute, a return type, an optional
:ref:`parameter attribute <paramattrs>` for the return type, a function
name, a possibly empty list of arguments, an optional alignment, an optional
:ref:`garbage collector name <gc>` and an optional :ref:`prefix <prefixdata>`.
:ref:`garbage collector name <gc>`, an optional :ref:`prefix <prefixdata>`,
and an optional :ref:`prologue <prologuedata>`.
A function definition contains a list of basic blocks, forming the CFG (Control
Flow Graph) for the function. Each basic block may optionally start with a label
@ -680,7 +682,7 @@ Syntax::
[cconv] [ret attrs]
<ResultType> @<FunctionName> ([argument list])
[unnamed_addr] [fn Attrs] [section "name"] [comdat $<ComdatName>]
[align N] [gc] [prefix Constant] { ... }
[align N] [gc] [prefix Constant] [prologue Constant] { ... }
The argument list is a comma seperated sequence of arguments where each
argument is of the following form
@ -1021,47 +1023,79 @@ support the named garbage collection algorithm.
Prefix Data
-----------
Prefix data is data associated with a function which the code generator
will emit immediately before the function body. The purpose of this feature
is to allow frontends to associate language-specific runtime metadata with
specific functions and make it available through the function pointer while
still allowing the function pointer to be called. To access the data for a
given function, a program may bitcast the function pointer to a pointer to
the constant's type. This implies that the IR symbol points to the start
of the prefix data.
Prefix data is data associated with a function which the code
generator will emit immediately before the function's entrypoint.
The purpose of this feature is to allow frontends to associate
language-specific runtime metadata with specific functions and make it
available through the function pointer while still allowing the
function pointer to be called.
To maintain the semantics of ordinary function calls, the prefix data must
To access the data for a given function, a program may bitcast the
function pointer to a pointer to the constant's type and dereference
index -1. This implies that the IR symbol points just past the end of
the prefix data. For instance, take the example of a function annotated
with a single ``i32``,
.. code-block:: llvm
define void @f() prefix i32 123 { ... }
The prefix data can be referenced as,
.. code-block:: llvm
%0 = bitcast *void () @f to *i32
%a = getelementptr inbounds *i32 %0, i32 -1
%b = load i32* %a
Prefix data is laid out as if it were an initializer for a global variable
of the prefix data's type. The function will be placed such that the
beginning of the prefix data is aligned. This means that if the size
of the prefix data is not a multiple of the alignment size, the
function's entrypoint will not be aligned. If alignment of the
function's entrypoint is desired, padding must be added to the prefix
data.
A function may have prefix data but no body. This has similar semantics
to the ``available_externally`` linkage in that the data may be used by the
optimizers but will not be emitted in the object file.
.. _prologuedata:
Prologue Data
-------------
The ``prologue`` attribute allows arbitrary code (encoded as bytes) to
be inserted prior to the function body. This can be used for enabling
function hot-patching and instrumentation.
To maintain the semantics of ordinary function calls, the prologue data must
have a particular format. Specifically, it must begin with a sequence of
bytes which decode to a sequence of machine instructions, valid for the
module's target, which transfer control to the point immediately succeeding
the prefix data, without performing any other visible action. This allows
the prologue data, without performing any other visible action. This allows
the inliner and other passes to reason about the semantics of the function
definition without needing to reason about the prefix data. Obviously this
makes the format of the prefix data highly target dependent.
definition without needing to reason about the prologue data. Obviously this
makes the format of the prologue data highly target dependent.
Prefix data is laid out as if it were an initializer for a global variable
of the prefix data's type. No padding is automatically placed between the
prefix data and the function body. If padding is required, it must be part
of the prefix data.
A trivial example of valid prefix data for the x86 architecture is ``i8 144``,
A trivial example of valid prologue data for the x86 architecture is ``i8 144``,
which encodes the ``nop`` instruction:
.. code-block:: llvm
define void @f() prefix i8 144 { ... }
define void @f() prologue i8 144 { ... }
Generally prefix data can be formed by encoding a relative branch instruction
which skips the metadata, as in this example of valid prefix data for the
Generally prologue data can be formed by encoding a relative branch instruction
which skips the metadata, as in this example of valid prologue data for the
x86_64 architecture, where the first two bytes encode ``jmp .+10``:
.. code-block:: llvm
%0 = type <{ i8, i8, i8* }>
define void @f() prefix %0 <{ i8 235, i8 8, i8* @md}> { ... }
define void @f() prologue %0 <{ i8 235, i8 8, i8* @md}> { ... }
A function may have prefix data but no body. This has similar semantics
A function may have prologue data but no body. This has similar semantics
to the ``available_externally`` linkage in that the data may be used by the
optimizers but will not be emitted in the object file.

44
docs/ReleaseNotes.rst
View File

@ -58,6 +58,50 @@ Non-comprehensive list of changes in this release
Makes programs 10x faster by doing Special New Thing.
Prefix data rework
------------------
The semantics of the ``prefix`` attribute have been changed. Users
that want the previous ``prefix`` semantics should instead use
``prologue``. To motivate this change, let's examine the primary
usecases that these attributes aim to serve,
1. Code sanitization metadata (e.g. Clang's undefined behavior
sanitizer)
2. Function hot-patching: Enable the user to insert ``nop`` operations
at the beginning of the function which can later be safely replaced
with a call to some instrumentation facility.
3. Language runtime metadata: Allow a compiler to insert data for
use by the runtime during execution. GHC is one example of a
compiler that needs this functionality for its
tables-next-to-code functionality.
Previously ``prefix`` served cases (1) and (2) quite well by allowing the user
to introduce arbitrary data at the entrypoint but before the function
body. Case (3), however, was poorly handled by this approach as it
required that prefix data was valid executable code.
In this release the concept of prefix data has been redefined to be
data which occurs immediately before the function entrypoint (i.e. the
symbol address). Since prefix data now occurs before the function
entrypoint, there is no need for the data to be valid code.
The previous notion of prefix data now goes under the name "prologue
data" to emphasize its duality with the function epilogue.
The intention here is to handle cases (1) and (2) with prologue data and
case (3) with prefix data. See the language reference for further details
on the semantics of these attributes.
This refactoring arose out of discussions_ with Reid Kleckner in
response to a proposal to introduce the notion of symbol offsets to
enable handling of case (3).
.. _discussions: http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-May/073235.html
Changes to the ARM Backend
--------------------------

30
include/llvm/IR/Function.h
View File

@ -87,11 +87,14 @@ private:
ValueSymbolTable *SymTab; ///< Symbol table of args/instructions
AttributeSet AttributeSets; ///< Parameter attributes
// HasLazyArguments is stored in Value::SubclassData.
/*bool HasLazyArguments;*/
// The Calling Convention is stored in Value::SubclassData.
/*CallingConv::ID CallingConvention;*/
/*
* Value::SubclassData
*
* bit 0 : HasLazyArguments
* bit 1 : HasPrefixData
* bit 2 : HasPrologueData
* bit 3-6: CallingConvention
*/
friend class SymbolTableListTraits<Function, Module>;
@ -102,7 +105,7 @@ private:
/// needs it. The hasLazyArguments predicate returns true if the arg list
/// hasn't been set up yet.
bool hasLazyArguments() const {
return getSubclassDataFromValue() & 1;
return getSubclassDataFromValue() & (1<<0);
}
void CheckLazyArguments() const {
if (hasLazyArguments())
@ -162,11 +165,11 @@ public:
/// calling convention of this function. The enum values for the known
/// calling conventions are defined in CallingConv.h.
CallingConv::ID getCallingConv() const {
return static_cast<CallingConv::ID>(getSubclassDataFromValue() >> 2);
return static_cast<CallingConv::ID>(getSubclassDataFromValue() >> 3);
}
void setCallingConv(CallingConv::ID CC) {
setValueSubclassData((getSubclassDataFromValue() & 3) |
(static_cast<unsigned>(CC) << 2));
setValueSubclassData((getSubclassDataFromValue() & 7) |
(static_cast<unsigned>(CC) << 3));
}
/// @brief Return the attribute list for this Function.
@ -448,12 +451,19 @@ public:
bool arg_empty() const;
bool hasPrefixData() const {
return getSubclassDataFromValue() & 2;
return getSubclassDataFromValue() & (1<<1);
}
Constant *getPrefixData() const;
void setPrefixData(Constant *PrefixData);
bool hasPrologueData() const {
return getSubclassDataFromValue() & (1<<2);
}
Constant *getPrologueData() const;
void setPrologueData(Constant *PrologueData);
/// viewCFG - This function is meant for use from the debugger. You can just
/// say 'call F->viewCFG()' and a ghostview window should pop up from the
/// program, displaying the CFG of the current function with the code for each

1
lib/AsmParser/LLLexer.cpp
View File

@ -573,6 +573,7 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(inteldialect);
KEYWORD(gc);
KEYWORD(prefix);
KEYWORD(prologue);
KEYWORD(ccc);
KEYWORD(fastcc);

8
lib/AsmParser/LLParser.cpp
View File

@ -3122,7 +3122,7 @@ bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
/// FunctionHeader
/// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs
/// OptUnnamedAddr Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
/// OptionalAlign OptGC OptionalPrefix
/// OptionalAlign OptGC OptionalPrefix OptionalPrologue
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
// Parse the linkage.
LocTy LinkageLoc = Lex.getLoc();
@ -3203,6 +3203,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
bool UnnamedAddr;
LocTy UnnamedAddrLoc;
Constant *Prefix = nullptr;
Constant *Prologue = nullptr;
Comdat *C;
if (ParseArgumentList(ArgList, isVarArg) ||
@ -3217,7 +3218,9 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
(EatIfPresent(lltok::kw_gc) &&
ParseStringConstant(GC)) ||
(EatIfPresent(lltok::kw_prefix) &&
ParseGlobalTypeAndValue(Prefix)))
ParseGlobalTypeAndValue(Prefix)) ||
(EatIfPresent(lltok::kw_prologue) &&
ParseGlobalTypeAndValue(Prologue)))
return true;
if (FuncAttrs.contains(Attribute::Builtin))
@ -3318,6 +3321,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
Fn->setComdat(C);
if (!GC.empty()) Fn->setGC(GC.c_str());
Fn->setPrefixData(Prefix);
Fn->setPrologueData(Prologue);
ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;
// Add all of the arguments we parsed to the function.

1
lib/AsmParser/LLToken.h
View File

@ -83,6 +83,7 @@ namespace lltok {
kw_inteldialect,
kw_gc,
kw_prefix,
kw_prologue,
kw_c,
kw_cc, kw_ccc, kw_fastcc, kw_coldcc,

22
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -1152,10 +1152,12 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() {
std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
std::vector<std::pair<Function*, unsigned> > FunctionPrefixWorklist;
std::vector<std::pair<Function*, unsigned> > FunctionPrologueWorklist;
GlobalInitWorklist.swap(GlobalInits);
AliasInitWorklist.swap(AliasInits);
FunctionPrefixWorklist.swap(FunctionPrefixes);
FunctionPrologueWorklist.swap(FunctionPrologues);
while (!GlobalInitWorklist.empty()) {
unsigned ValID = GlobalInitWorklist.back().second;
@ -1197,6 +1199,19 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() {
FunctionPrefixWorklist.pop_back();
}
while (!FunctionPrologueWorklist.empty()) {
unsigned ValID = FunctionPrologueWorklist.back().second;
if (ValID >= ValueList.size()) {
FunctionPrologues.push_back(FunctionPrologueWorklist.back());
} else {
if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
FunctionPrologueWorklist.back().first->setPrologueData(C);
else
return Error(BitcodeError::ExpectedConstant);
}
FunctionPrologueWorklist.pop_back();
}
return std::error_code();
}
@ -2011,7 +2026,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) {
}
// FUNCTION: [type, callingconv, isproto, linkage, paramattr,
// alignment, section, visibility, gc, unnamed_addr,
// dllstorageclass]
// prologuedata, dllstorageclass, comdat, prefixdata]
case bitc::MODULE_CODE_FUNCTION: {
if (Record.size() < 8)
return Error(BitcodeError::InvalidRecord);
@ -2053,7 +2068,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) {
UnnamedAddr = Record[9];
Func->setUnnamedAddr(UnnamedAddr);
if (Record.size() > 10 && Record[10] != 0)
FunctionPrefixes.push_back(std::make_pair(Func, Record[10]-1));
FunctionPrologues.push_back(std::make_pair(Func, Record[10]-1));
if (Record.size() > 11)
Func->setDLLStorageClass(GetDecodedDLLStorageClass(Record[11]));
@ -2066,6 +2081,9 @@ std::error_code BitcodeReader::ParseModule(bool Resume) {
Func->setComdat(ComdatList[ComdatID - 1]);
}
if (Record.size() > 13 && Record[13] != 0)
FunctionPrefixes.push_back(std::make_pair(Func, Record[13]-1));
ValueList.push_back(Func);
// If this is a function with a body, remember the prototype we are

1
lib/Bitcode/Reader/BitcodeReader.h
View File

@ -143,6 +143,7 @@ class BitcodeReader : public GVMaterializer {
std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
std::vector<std::pair<Function*, unsigned> > FunctionPrefixes;
std::vector<std::pair<Function*, unsigned> > FunctionPrologues;
SmallVector<Instruction*, 64> InstsWithTBAATag;

9
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -670,7 +670,8 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
// Emit the function proto information.
for (const Function &F : *M) {
// FUNCTION: [type, callingconv, isproto, linkage, paramattrs, alignment,
// section, visibility, gc, unnamed_addr, prefix]
// section, visibility, gc, unnamed_addr, prologuedata,
// dllstorageclass, comdat, prefixdata]
Vals.push_back(VE.getTypeID(F.getType()));
Vals.push_back(F.getCallingConv());
Vals.push_back(F.isDeclaration());
@ -681,10 +682,12 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
Vals.push_back(getEncodedVisibility(F));
Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
Vals.push_back(F.hasUnnamedAddr());
Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
: 0);
Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
: 0);
Vals.push_back(getEncodedDLLStorageClass(F));
Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
: 0);
unsigned AbbrevToUse = 0;
Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);

16
lib/Bitcode/Writer/ValueEnumerator.cpp
View File

@ -85,10 +85,14 @@ static OrderMap orderModule(const Module &M) {
for (const GlobalAlias &A : M.aliases())
if (!isa<GlobalValue>(A.getAliasee()))
orderValue(A.getAliasee(), OM);
for (const Function &F : M)
for (const Function &F : M) {
if (F.hasPrefixData())
if (!isa<GlobalValue>(F.getPrefixData()))
orderValue(F.getPrefixData(), OM);
if (F.hasPrologueData())
if (!isa<GlobalValue>(F.getPrologueData()))
orderValue(F.getPrologueData(), OM);
}
OM.LastGlobalConstantID = OM.size();
// Initializers of GlobalValues are processed in
@ -264,9 +268,12 @@ static UseListOrderStack predictUseListOrder(const Module &M) {
predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
for (const GlobalAlias &A : M.aliases())
predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
for (const Function &F : M)
for (const Function &F : M) {
if (F.hasPrefixData())
predictValueUseListOrder(F.getPrefixData(), nullptr, OM, Stack);
if (F.hasPrologueData())
predictValueUseListOrder(F.getPrologueData(), nullptr, OM, Stack);
}
return Stack;
}
@ -314,6 +321,11 @@ ValueEnumerator::ValueEnumerator(const Module &M) {
if (I->hasPrefixData())
EnumerateValue(I->getPrefixData());
// Enumerate the prologue data constants.
for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)
if (I->hasPrologueData())
EnumerateValue(I->getPrologueData());
// Insert constants and metadata that are named at module level into the slot
// pool so that the module symbol table can refer to them...
EnumerateValueSymbolTable(M.getValueSymbolTable());

10
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -508,6 +508,10 @@ void AsmPrinter::EmitFunctionHeader() {
OutStreamer.GetCommentOS() << '\n';
}
// Emit the prefix data.
if (F->hasPrefixData())
EmitGlobalConstant(F->getPrefixData());
// Emit the CurrentFnSym. This is a virtual function to allow targets to
// do their wild and crazy things as required.
EmitFunctionEntryLabel();
@ -528,9 +532,9 @@ void AsmPrinter::EmitFunctionHeader() {
HI.Handler->beginFunction(MF);
}
// Emit the prefix data.
if (F->hasPrefixData())
EmitGlobalConstant(F->getPrefixData());
// Emit the prologue data.
if (F->hasPrologueData())
EmitGlobalConstant(F->getPrologueData());
}
/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the

10
lib/IR/AsmWriter.cpp
View File

@ -101,6 +101,11 @@ static OrderMap orderModule(const Module *M) {
if (F.hasPrefixData())
if (!isa<GlobalValue>(F.getPrefixData()))
orderValue(F.getPrefixData(), OM);
if (F.hasPrologueData())
if (!isa<GlobalValue>(F.getPrologueData()))
orderValue(F.getPrologueData(), OM);
orderValue(&F, OM);
if (F.isDeclaration())
@ -1902,6 +1907,11 @@ void AssemblyWriter::printFunction(const Function *F) {
Out << " prefix ";
writeOperand(F->getPrefixData(), true);
}
if (F->hasPrologueData()) {
Out << " prologue ";
writeOperand(F->getPrologueData(), true);
}
if (F->isDeclaration()) {
Out << '\n';
} else {

42
lib/IR/Function.cpp
View File

@ -298,7 +298,7 @@ void Function::BuildLazyArguments() const {
// Clear the lazy arguments bit.
unsigned SDC = getSubclassDataFromValue();
const_cast<Function*>(this)->setValueSubclassData(SDC &= ~1);
const_cast<Function*>(this)->setValueSubclassData(SDC &= ~(1<<0));
}
size_t Function::arg_size() const {
@ -335,8 +335,9 @@ void Function::dropAllReferences() {
while (!BasicBlocks.empty())
BasicBlocks.begin()->eraseFromParent();
// Prefix data is stored in a side table.
// Prefix and prologue data are stored in a side table.
setPrefixData(nullptr);
setPrologueData(nullptr);
}
void Function::addAttribute(unsigned i, Attribute::AttrKind attr) {
@ -416,6 +417,10 @@ void Function::copyAttributesFrom(const GlobalValue *Src) {
setPrefixData(SrcF->getPrefixData());
else
setPrefixData(nullptr);
if (SrcF->hasPrologueData())
setPrologueData(SrcF->getPrologueData());
else
setPrologueData(nullptr);
}
/// getIntrinsicID - This method returns the ID number of the specified
@ -880,11 +885,40 @@ void Function::setPrefixData(Constant *PrefixData) {
PDHolder->setOperand(0, PrefixData);
else
PDHolder = ReturnInst::Create(getContext(), PrefixData);
SCData |= 2;
SCData |= (1<<1);
} else {
delete PDHolder;
PDMap.erase(this);
SCData &= ~2;
SCData &= ~(1<<1);
}
setValueSubclassData(SCData);
}
Constant *Function::getPrologueData() const {
assert(hasPrologueData());
const LLVMContextImpl::PrologueDataMapTy &SOMap =
getContext().pImpl->PrologueDataMap;
assert(SOMap.find(this) != SOMap.end());
return cast<Constant>(SOMap.find(this)->second->getReturnValue());
}
void Function::setPrologueData(Constant *PrologueData) {
if (!PrologueData && !hasPrologueData())
return;
unsigned PDData = getSubclassDataFromValue();
LLVMContextImpl::PrologueDataMapTy &PDMap = getContext().pImpl->PrologueDataMap;
ReturnInst *&PDHolder = PDMap[this];
if (PrologueData) {
if (PDHolder)
PDHolder->setOperand(0, PrologueData);
else
PDHolder = ReturnInst::Create(getContext(), PrologueData);
PDData |= (1<<2);
} else {
delete PDHolder;
PDMap.erase(this);
PDData &= ~(1<<2);
}
setValueSubclassData(PDData);
}

6
lib/IR/LLVMContextImpl.h
View File

@ -401,6 +401,12 @@ public:
typedef DenseMap<const Function *, ReturnInst *> PrefixDataMapTy;
PrefixDataMapTy PrefixDataMap;
/// \brief Mapping from a function to its prologue data, which is stored as
/// the operand of an unparented ReturnInst so that the prologue data has a
/// Use.
typedef DenseMap<const Function *, ReturnInst *> PrologueDataMapTy;
PrologueDataMapTy PrologueDataMap;
int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);

3
lib/IR/TypeFinder.cpp
View File

@ -47,6 +47,9 @@ void TypeFinder::run(const Module &M, bool onlyNamed) {
if (FI->hasPrefixData())
incorporateValue(FI->getPrefixData());
if (FI->hasPrologueData())
incorporateValue(FI->getPrologueData());
// First incorporate the arguments.
for (Function::const_arg_iterator AI = FI->arg_begin(),
AE = FI->arg_end(); AI != AE; ++AI)

11
lib/Linker/LinkModules.cpp
View File

@ -1505,11 +1505,16 @@ bool ModuleLinker::run() {
if (DoNotLinkFromSource.count(SF)) continue;
Function *DF = cast<Function>(ValueMap[SF]);
if (SF->hasPrefixData()) {
// Link in the prefix data.
// Link in the prefix data.
if (SF->hasPrefixData())
DF->setPrefixData(MapValue(
SF->getPrefixData(), ValueMap, RF_None, &TypeMap, &ValMaterializer));
}
// Link in the prologue data.
if (SF->hasPrologueData())
DF->setPrologueData(MapValue(
SF->getPrologueData(), ValueMap, RF_None, &TypeMap, &ValMaterializer));
// Materialize if needed.
if (std::error_code EC = SF->materialize())

3
lib/Transforms/IPO/GlobalDCE.cpp
View File

@ -219,6 +219,9 @@ void GlobalDCE::GlobalIsNeeded(GlobalValue *G) {
if (F->hasPrefixData())
MarkUsedGlobalsAsNeeded(F->getPrefixData());
if (F->hasPrologueData())
MarkUsedGlobalsAsNeeded(F->getPrologueData());
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
for (User::op_iterator U = I->op_begin(), E = I->op_end(); U != E; ++U)

9
test/CodeGen/X86/prefixdata.ll
View File

@ -2,16 +2,17 @@
@i = linkonce_odr global i32 1
; CHECK: f:
; CHECK-NEXT: .cfi_startproc
; CHECK: .type f,@function
; CHECK-NEXT: .long 1
; CHECK-NEXT: # 0x1
; CHECK-NEXT: f:
define void @f() prefix i32 1 {
ret void
}
; CHECK: g:
; CHECK-NEXT: .cfi_startproc
; CHECK: .type g,@function
; CHECK-NEXT: .quad i
; CHECK-NEXT: g:
define void @g() prefix i32* @i {
ret void
}

17
test/CodeGen/X86/prologuedata.ll Normal file
View File

@ -0,0 +1,17 @@
; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s
@i = linkonce_odr global i32 1
; CHECK: f:
; CHECK-NEXT: .cfi_startproc
; CHECK-NEXT: .long 1
define void @f() prologue i32 1 {
ret void
}
; CHECK: g:
; CHECK-NEXT: .cfi_startproc
; CHECK-NEXT: .quad i
define void @g() prologue i32* @i {
ret void
}

18
test/Feature/prologuedata.ll Normal file
View File

@ -0,0 +1,18 @@
; RUN: llvm-as < %s | llvm-dis > %t1.ll
; RUN: FileCheck %s < %t1.ll
; RUN: llvm-as < %t1.ll | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
; RUN: opt -O3 -S < %t1.ll | FileCheck %s
; CHECK: @i
@i = linkonce_odr global i32 1
; CHECK: f(){{.*}}prologue i32 1
define void @f() prologue i32 1 {
ret void
}
; CHECK: g(){{.*}}prologue i32* @i
define void @g() prologue i32* @i {
ret void
}

4
test/Linker/prefixdata.ll → test/Linker/prologuedata.ll
View File

@ -3,7 +3,7 @@
@i = linkonce_odr global i32 1
; CHECK: define void @f() prefix i32* @i
define void @f() prefix i32* @i {
; CHECK: define void @f() prologue i32* @i
define void @f() prologue i32* @i {
ret void
}

10
tools/verify-uselistorder/verify-uselistorder.cpp
View File

@ -197,9 +197,12 @@ ValueMapping::ValueMapping(const Module &M) {
map(G.getInitializer());
for (const GlobalAlias &A : M.aliases())
map(A.getAliasee());
for (const Function &F : M)
for (const Function &F : M) {
if (F.hasPrefixData())
map(F.getPrefixData());
if (F.hasPrologueData())
map(F.getPrologueData());
}
// Function bodies.
for (const Function &F : M) {
@ -463,9 +466,12 @@ static void changeUseLists(Module &M, Changer changeValueUseList) {
changeValueUseList(G.getInitializer());
for (GlobalAlias &A : M.aliases())
changeValueUseList(A.getAliasee());
for (Function &F : M)
for (Function &F : M) {
if (F.hasPrefixData())
changeValueUseList(F.getPrefixData());
if (F.hasPrologueData())
changeValueUseList(F.getPrologueData());
}
// Function bodies.
for (Function &F : M) {