2007-01-27 05:38:26 +08:00
|
|
|
//===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- C++ -*-===//
|
2006-01-04 21:36:38 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2006-01-04 21:36:38 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2007-01-27 05:38:26 +08:00
|
|
|
#include "llvm/CodeGen/MachineModuleInfo.h"
|
2006-01-04 21:36:38 +08:00
|
|
|
|
2006-01-27 04:21:46 +08:00
|
|
|
#include "llvm/Constants.h"
|
2008-06-30 15:31:25 +08:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2006-11-08 03:33:46 +08:00
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
2008-09-23 06:21:38 +08:00
|
|
|
#include "llvm/CodeGen/Passes.h"
|
2006-11-08 03:33:46 +08:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2007-01-30 07:40:33 +08:00
|
|
|
#include "llvm/Target/TargetOptions.h"
|
2006-01-27 04:21:46 +08:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2006-02-06 23:33:21 +08:00
|
|
|
#include "llvm/GlobalVariable.h"
|
2006-01-27 04:21:46 +08:00
|
|
|
#include "llvm/Intrinsics.h"
|
|
|
|
#include "llvm/Instructions.h"
|
|
|
|
#include "llvm/Module.h"
|
|
|
|
#include "llvm/Support/Dwarf.h"
|
2006-12-08 04:04:42 +08:00
|
|
|
#include "llvm/Support/Streams.h"
|
2006-01-04 21:36:38 +08:00
|
|
|
using namespace llvm;
|
2006-03-02 04:39:36 +08:00
|
|
|
using namespace llvm::dwarf;
|
2006-01-04 21:36:38 +08:00
|
|
|
|
|
|
|
// Handle the Pass registration stuff necessary to use TargetData's.
|
2008-05-13 08:00:25 +08:00
|
|
|
static RegisterPass<MachineModuleInfo>
|
|
|
|
X("machinemoduleinfo", "Module Information");
|
2007-05-03 09:11:54 +08:00
|
|
|
char MachineModuleInfo::ID = 0;
|
2006-01-18 01:31:53 +08:00
|
|
|
|
2006-01-27 04:21:46 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2008-07-04 06:53:42 +08:00
|
|
|
|
2007-01-27 05:38:26 +08:00
|
|
|
MachineModuleInfo::MachineModuleInfo()
|
2008-09-05 01:05:41 +08:00
|
|
|
: ImmutablePass(&ID)
|
2006-11-08 03:33:46 +08:00
|
|
|
, LabelIDList()
|
2006-04-08 00:34:46 +08:00
|
|
|
, FrameMoves()
|
2007-02-22 06:38:31 +08:00
|
|
|
, LandingPads()
|
2007-05-13 23:42:26 +08:00
|
|
|
, Personalities()
|
2007-07-14 22:06:15 +08:00
|
|
|
, CallsEHReturn(0)
|
|
|
|
, CallsUnwindInit(0)
|
2009-01-14 07:02:17 +08:00
|
|
|
, DbgInfoAvailable(false)
|
2007-05-13 23:42:26 +08:00
|
|
|
{
|
|
|
|
// Always emit "no personality" info
|
|
|
|
Personalities.push_back(NULL);
|
|
|
|
}
|
2007-01-27 05:38:26 +08:00
|
|
|
MachineModuleInfo::~MachineModuleInfo() {
|
2006-01-27 04:21:46 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2007-01-27 05:38:26 +08:00
|
|
|
/// doInitialization - Initialize the state for a new module.
|
2006-01-05 06:28:25 +08:00
|
|
|
///
|
2007-01-27 05:38:26 +08:00
|
|
|
bool MachineModuleInfo::doInitialization() {
|
2006-01-05 06:28:25 +08:00
|
|
|
return false;
|
|
|
|
}
|
2006-01-04 21:36:38 +08:00
|
|
|
|
2007-01-27 05:38:26 +08:00
|
|
|
/// doFinalization - Tear down the state after completion of a module.
|
2006-01-05 06:28:25 +08:00
|
|
|
///
|
2007-01-27 05:38:26 +08:00
|
|
|
bool MachineModuleInfo::doFinalization() {
|
2006-01-05 06:28:25 +08:00
|
|
|
return false;
|
|
|
|
}
|
2006-01-27 04:21:46 +08:00
|
|
|
|
2007-01-27 05:38:26 +08:00
|
|
|
/// BeginFunction - Begin gathering function meta information.
|
2006-04-08 00:34:46 +08:00
|
|
|
///
|
2007-01-27 05:38:26 +08:00
|
|
|
void MachineModuleInfo::BeginFunction(MachineFunction *MF) {
|
2006-04-08 00:34:46 +08:00
|
|
|
// Coming soon.
|
|
|
|
}
|
|
|
|
|
2007-01-27 05:38:26 +08:00
|
|
|
/// EndFunction - Discard function meta information.
|
2006-04-08 00:34:46 +08:00
|
|
|
///
|
2007-01-27 05:38:26 +08:00
|
|
|
void MachineModuleInfo::EndFunction() {
|
2006-04-08 00:34:46 +08:00
|
|
|
// Clean up frame info.
|
|
|
|
FrameMoves.clear();
|
2007-02-22 06:38:31 +08:00
|
|
|
|
|
|
|
// Clean up exception info.
|
|
|
|
LandingPads.clear();
|
|
|
|
TypeInfos.clear();
|
2007-06-03 00:53:42 +08:00
|
|
|
FilterIds.clear();
|
2007-07-05 23:15:01 +08:00
|
|
|
FilterEnds.clear();
|
2007-07-14 22:06:15 +08:00
|
|
|
CallsEHReturn = 0;
|
|
|
|
CallsUnwindInit = 0;
|
2006-04-08 00:34:46 +08:00
|
|
|
}
|
|
|
|
|
2006-01-27 04:21:46 +08:00
|
|
|
/// AnalyzeModule - Scan the module for global debug information.
|
|
|
|
///
|
2007-01-27 05:38:26 +08:00
|
|
|
void MachineModuleInfo::AnalyzeModule(Module &M) {
|
2008-01-17 03:59:28 +08:00
|
|
|
// Insert functions in the llvm.used array into UsedFunctions.
|
|
|
|
GlobalVariable *GV = M.getGlobalVariable("llvm.used");
|
|
|
|
if (!GV || !GV->hasInitializer()) return;
|
|
|
|
|
|
|
|
// Should be an array of 'i8*'.
|
|
|
|
ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
|
|
|
|
if (InitList == 0) return;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(InitList->getOperand(i)))
|
|
|
|
if (CE->getOpcode() == Instruction::BitCast)
|
|
|
|
if (Function *F = dyn_cast<Function>(CE->getOperand(0)))
|
|
|
|
UsedFunctions.insert(F);
|
|
|
|
}
|
2006-01-27 04:21:46 +08:00
|
|
|
}
|
|
|
|
|
2007-02-22 06:38:31 +08:00
|
|
|
//===-EH-------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the
|
|
|
|
/// specified MachineBasicBlock.
|
2008-07-04 06:53:42 +08:00
|
|
|
LandingPadInfo &MachineModuleInfo::getOrCreateLandingPadInfo
|
|
|
|
(MachineBasicBlock *LandingPad) {
|
2007-02-22 06:38:31 +08:00
|
|
|
unsigned N = LandingPads.size();
|
|
|
|
for (unsigned i = 0; i < N; ++i) {
|
2007-03-02 04:25:32 +08:00
|
|
|
LandingPadInfo &LP = LandingPads[i];
|
|
|
|
if (LP.LandingPadBlock == LandingPad)
|
|
|
|
return LP;
|
2007-02-22 06:38:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
LandingPads.push_back(LandingPadInfo(LandingPad));
|
|
|
|
return LandingPads[N];
|
|
|
|
}
|
|
|
|
|
|
|
|
/// addInvoke - Provide the begin and end labels of an invoke style call and
|
|
|
|
/// associate it with a try landing pad block.
|
|
|
|
void MachineModuleInfo::addInvoke(MachineBasicBlock *LandingPad,
|
|
|
|
unsigned BeginLabel, unsigned EndLabel) {
|
2007-03-02 04:25:32 +08:00
|
|
|
LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
|
2007-05-11 06:34:59 +08:00
|
|
|
LP.BeginLabels.push_back(BeginLabel);
|
|
|
|
LP.EndLabels.push_back(EndLabel);
|
2007-02-22 06:38:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// addLandingPad - Provide the label of a try LandingPad block.
|
|
|
|
///
|
|
|
|
unsigned MachineModuleInfo::addLandingPad(MachineBasicBlock *LandingPad) {
|
|
|
|
unsigned LandingPadLabel = NextLabelID();
|
2007-03-02 04:25:32 +08:00
|
|
|
LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
|
|
|
|
LP.LandingPadLabel = LandingPadLabel;
|
2007-02-22 06:38:31 +08:00
|
|
|
return LandingPadLabel;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// addPersonality - Provide the personality function for the exception
|
|
|
|
/// information.
|
|
|
|
void MachineModuleInfo::addPersonality(MachineBasicBlock *LandingPad,
|
2007-05-13 23:42:26 +08:00
|
|
|
Function *Personality) {
|
2007-03-02 04:25:32 +08:00
|
|
|
LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
|
2007-05-13 23:42:26 +08:00
|
|
|
LP.Personality = Personality;
|
2007-05-13 06:36:25 +08:00
|
|
|
|
2008-07-04 06:53:42 +08:00
|
|
|
for (unsigned i = 0; i < Personalities.size(); ++i)
|
2007-05-13 23:42:26 +08:00
|
|
|
if (Personalities[i] == Personality)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Personalities.push_back(Personality);
|
2007-02-22 06:38:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// addCatchTypeInfo - Provide the catch typeinfo for a landing pad.
|
|
|
|
///
|
|
|
|
void MachineModuleInfo::addCatchTypeInfo(MachineBasicBlock *LandingPad,
|
|
|
|
std::vector<GlobalVariable *> &TyInfo) {
|
2007-03-02 04:25:32 +08:00
|
|
|
LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
|
2007-02-22 06:38:31 +08:00
|
|
|
for (unsigned N = TyInfo.size(); N; --N)
|
2007-03-02 04:25:32 +08:00
|
|
|
LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
|
2007-02-22 06:38:31 +08:00
|
|
|
}
|
2007-06-03 00:53:42 +08:00
|
|
|
|
|
|
|
/// addFilterTypeInfo - Provide the filter typeinfo for a landing pad.
|
2007-03-02 04:25:32 +08:00
|
|
|
///
|
2007-06-03 00:53:42 +08:00
|
|
|
void MachineModuleInfo::addFilterTypeInfo(MachineBasicBlock *LandingPad,
|
|
|
|
std::vector<GlobalVariable *> &TyInfo) {
|
2007-03-02 04:25:32 +08:00
|
|
|
LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
|
2008-07-08 05:41:57 +08:00
|
|
|
std::vector<unsigned> IdsInFilter(TyInfo.size());
|
2008-07-04 06:53:42 +08:00
|
|
|
for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
|
2007-06-03 00:53:42 +08:00
|
|
|
IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
|
|
|
|
LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
|
2007-03-02 04:25:32 +08:00
|
|
|
}
|
|
|
|
|
There is an impedance matching problem between LLVM and
gcc exception handling: if an exception unwinds through
an invoke, then execution must branch to the invoke's
unwind target. We previously tried to enforce this by
appending a cleanup action to every selector, however
this does not always work correctly due to an optimization
in the C++ unwinding runtime: if only cleanups would be
run while unwinding an exception, then the program just
terminates without actually executing the cleanups, as
invoke semantics would require. I was hoping this
wouldn't be a problem, but in fact it turns out to be the
cause of all the remaining failures in the LLVM testsuite
(these also fail with -enable-correct-eh-support, so turning
on -enable-eh didn't make things worse!). Instead we need
to append a full-blown catch-all to the end of each
selector. The correct way of doing this depends on the
personality function, i.e. it is language dependent, so
can only be done by gcc. Thus this patch which generalizes
the eh.selector intrinsic so that it can handle all possible
kinds of action table entries (before it didn't accomodate
cleanups): now 0 indicates a cleanup, and filters have to be
specified using the number of type infos plus one rather than
the number of type infos. Related gcc patches will cause
Ada to pass a cleanup (0) to force the selector to always
fire, while C++ will use a C++ catch-all (null).
llvm-svn: 41484
2007-08-27 23:47:50 +08:00
|
|
|
/// addCleanup - Add a cleanup action for a landing pad.
|
|
|
|
///
|
|
|
|
void MachineModuleInfo::addCleanup(MachineBasicBlock *LandingPad) {
|
|
|
|
LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
|
|
|
|
LP.TypeIds.push_back(0);
|
|
|
|
}
|
|
|
|
|
2007-02-22 06:38:31 +08:00
|
|
|
/// TidyLandingPads - Remap landing pad labels and remove any deleted landing
|
|
|
|
/// pads.
|
|
|
|
void MachineModuleInfo::TidyLandingPads() {
|
|
|
|
for (unsigned i = 0; i != LandingPads.size(); ) {
|
|
|
|
LandingPadInfo &LandingPad = LandingPads[i];
|
|
|
|
LandingPad.LandingPadLabel = MappedLabel(LandingPad.LandingPadLabel);
|
2007-05-11 06:34:59 +08:00
|
|
|
|
2007-05-23 19:08:31 +08:00
|
|
|
// Special case: we *should* emit LPs with null LP MBB. This indicates
|
2007-12-19 15:36:31 +08:00
|
|
|
// "nounwind" case.
|
2007-05-23 19:08:31 +08:00
|
|
|
if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
|
2007-02-22 06:38:31 +08:00
|
|
|
LandingPads.erase(LandingPads.begin() + i);
|
|
|
|
continue;
|
|
|
|
}
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
llvm-svn: 41718
2007-09-05 19:27:52 +08:00
|
|
|
|
2008-07-04 06:53:42 +08:00
|
|
|
for (unsigned j=0; j != LandingPads[i].BeginLabels.size(); ) {
|
2007-05-11 06:34:59 +08:00
|
|
|
unsigned BeginLabel = MappedLabel(LandingPad.BeginLabels[j]);
|
|
|
|
unsigned EndLabel = MappedLabel(LandingPad.EndLabels[j]);
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
llvm-svn: 41718
2007-09-05 19:27:52 +08:00
|
|
|
|
2007-05-11 06:34:59 +08:00
|
|
|
if (!BeginLabel || !EndLabel) {
|
|
|
|
LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
|
|
|
|
LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
LandingPad.BeginLabels[j] = BeginLabel;
|
|
|
|
LandingPad.EndLabels[j] = EndLabel;
|
|
|
|
++j;
|
|
|
|
}
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
llvm-svn: 41718
2007-09-05 19:27:52 +08:00
|
|
|
|
|
|
|
// Remove landing pads with no try-ranges.
|
2008-01-29 21:02:09 +08:00
|
|
|
if (LandingPads[i].BeginLabels.empty()) {
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
llvm-svn: 41718
2007-09-05 19:27:52 +08:00
|
|
|
LandingPads.erase(LandingPads.begin() + i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there is no landing pad, ensure that the list of typeids is empty.
|
|
|
|
// If the only typeid is a cleanup, this is the same as having no typeids.
|
|
|
|
if (!LandingPad.LandingPadBlock ||
|
|
|
|
(LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
|
|
|
|
LandingPad.TypeIds.clear();
|
|
|
|
|
2007-02-22 06:38:31 +08:00
|
|
|
++i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getTypeIDFor - Return the type id for the specified typeinfo. This is
|
|
|
|
/// function wide.
|
|
|
|
unsigned MachineModuleInfo::getTypeIDFor(GlobalVariable *TI) {
|
2008-07-04 06:53:42 +08:00
|
|
|
for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
|
|
|
|
if (TypeInfos[i] == TI) return i + 1;
|
2007-02-22 06:38:31 +08:00
|
|
|
|
|
|
|
TypeInfos.push_back(TI);
|
|
|
|
return TypeInfos.size();
|
|
|
|
}
|
|
|
|
|
2007-06-03 00:53:42 +08:00
|
|
|
/// getFilterIDFor - Return the filter id for the specified typeinfos. This is
|
|
|
|
/// function wide.
|
2008-06-27 09:27:56 +08:00
|
|
|
int MachineModuleInfo::getFilterIDFor(std::vector<unsigned> &TyIds) {
|
2007-07-05 23:15:01 +08:00
|
|
|
// If the new filter coincides with the tail of an existing filter, then
|
|
|
|
// re-use the existing filter. Folding filters more than this requires
|
|
|
|
// re-ordering filters and/or their elements - probably not worth it.
|
|
|
|
for (std::vector<unsigned>::iterator I = FilterEnds.begin(),
|
|
|
|
E = FilterEnds.end(); I != E; ++I) {
|
2008-06-27 09:27:56 +08:00
|
|
|
unsigned i = *I, j = TyIds.size();
|
2007-07-05 23:15:01 +08:00
|
|
|
|
|
|
|
while (i && j)
|
|
|
|
if (FilterIds[--i] != TyIds[--j])
|
|
|
|
goto try_next;
|
|
|
|
|
|
|
|
if (!j)
|
|
|
|
// The new filter coincides with range [i, end) of the existing filter.
|
|
|
|
return -(1 + i);
|
2008-06-27 09:27:56 +08:00
|
|
|
|
2007-07-05 23:15:01 +08:00
|
|
|
try_next:;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add the new filter.
|
2008-06-27 09:27:56 +08:00
|
|
|
int FilterID = -(1 + FilterIds.size());
|
|
|
|
FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
|
|
|
|
for (unsigned I = 0, N = TyIds.size(); I != N; ++I)
|
2007-06-03 00:53:42 +08:00
|
|
|
FilterIds.push_back(TyIds[I]);
|
2008-06-27 09:27:56 +08:00
|
|
|
FilterEnds.push_back(FilterIds.size());
|
2007-06-03 00:53:42 +08:00
|
|
|
FilterIds.push_back(0); // terminator
|
|
|
|
return FilterID;
|
|
|
|
}
|
|
|
|
|
2007-05-13 23:42:26 +08:00
|
|
|
/// getPersonality - Return the personality function for the current function.
|
2007-02-22 06:38:31 +08:00
|
|
|
Function *MachineModuleInfo::getPersonality() const {
|
2007-05-13 06:36:25 +08:00
|
|
|
// FIXME: Until PR1414 will be fixed, we're using 1 personality function per
|
2007-05-13 23:42:26 +08:00
|
|
|
// function
|
|
|
|
return !LandingPads.empty() ? LandingPads[0].Personality : NULL;
|
2007-02-22 06:38:31 +08:00
|
|
|
}
|
|
|
|
|
2007-05-13 23:42:26 +08:00
|
|
|
/// getPersonalityIndex - Return unique index for current personality
|
|
|
|
/// function. NULL personality function should always get zero index.
|
|
|
|
unsigned MachineModuleInfo::getPersonalityIndex() const {
|
2007-05-23 19:08:31 +08:00
|
|
|
const Function* Personality = NULL;
|
|
|
|
|
|
|
|
// Scan landing pads. If there is at least one non-NULL personality - use it.
|
2008-07-04 06:53:42 +08:00
|
|
|
for (unsigned i = 0; i != LandingPads.size(); ++i)
|
2007-05-23 19:08:31 +08:00
|
|
|
if (LandingPads[i].Personality) {
|
|
|
|
Personality = LandingPads[i].Personality;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-07-04 06:53:42 +08:00
|
|
|
for (unsigned i = 0; i < Personalities.size(); ++i) {
|
2007-05-13 23:42:26 +08:00
|
|
|
if (Personalities[i] == Personality)
|
|
|
|
return i;
|
2008-07-04 06:53:42 +08:00
|
|
|
}
|
2007-05-13 23:42:26 +08:00
|
|
|
|
|
|
|
// This should never happen
|
|
|
|
assert(0 && "Personality function should be set!");
|
|
|
|
return 0;
|
|
|
|
}
|
2007-02-22 06:38:31 +08:00
|
|
|
|
2006-11-08 03:33:46 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-01-27 05:38:26 +08:00
|
|
|
/// DebugLabelFolding pass - This pass prunes out redundant labels. This allows
|
|
|
|
/// a info consumer to determine if the range of two labels is empty, by seeing
|
|
|
|
/// if the labels map to the same reduced label.
|
2006-11-08 03:33:46 +08:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
|
|
|
struct DebugLabelFolder : public MachineFunctionPass {
|
2007-05-03 09:11:54 +08:00
|
|
|
static char ID;
|
2008-09-05 01:05:41 +08:00
|
|
|
DebugLabelFolder() : MachineFunctionPass(&ID) {}
|
2007-05-02 05:15:47 +08:00
|
|
|
|
2008-09-23 04:58:04 +08:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
2008-09-23 06:21:38 +08:00
|
|
|
AU.addPreservedID(MachineLoopInfoID);
|
|
|
|
AU.addPreservedID(MachineDominatorsID);
|
2008-09-23 04:58:04 +08:00
|
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
|
|
}
|
|
|
|
|
2006-11-08 03:33:46 +08:00
|
|
|
virtual bool runOnMachineFunction(MachineFunction &MF);
|
2007-01-27 05:38:26 +08:00
|
|
|
virtual const char *getPassName() const { return "Label Folder"; }
|
2006-11-08 03:33:46 +08:00
|
|
|
};
|
|
|
|
|
2007-05-03 09:11:54 +08:00
|
|
|
char DebugLabelFolder::ID = 0;
|
2007-05-02 05:15:47 +08:00
|
|
|
|
2006-11-08 03:33:46 +08:00
|
|
|
bool DebugLabelFolder::runOnMachineFunction(MachineFunction &MF) {
|
2007-01-27 05:38:26 +08:00
|
|
|
// Get machine module info.
|
2009-01-28 21:14:17 +08:00
|
|
|
MachineModuleInfo *MMI = getAnalysisIfAvailable<MachineModuleInfo>();
|
2007-01-27 05:38:26 +08:00
|
|
|
if (!MMI) return false;
|
2006-11-08 03:33:46 +08:00
|
|
|
|
|
|
|
// Track if change is made.
|
|
|
|
bool MadeChange = false;
|
|
|
|
// No prior label to begin.
|
|
|
|
unsigned PriorLabel = 0;
|
|
|
|
|
|
|
|
// Iterate through basic blocks.
|
|
|
|
for (MachineFunction::iterator BB = MF.begin(), E = MF.end();
|
|
|
|
BB != E; ++BB) {
|
|
|
|
// Iterate through instructions.
|
|
|
|
for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
|
2007-01-27 05:38:26 +08:00
|
|
|
// Is it a label.
|
2009-04-11 02:58:59 +08:00
|
|
|
if (I->isDebugLabel() && !MMI->isDbgLabelUsed(I->getOperand(0).getImm())){
|
2006-11-08 03:33:46 +08:00
|
|
|
// The label ID # is always operand #0, an immediate.
|
|
|
|
unsigned NextLabel = I->getOperand(0).getImm();
|
|
|
|
|
|
|
|
// If there was an immediate prior label.
|
|
|
|
if (PriorLabel) {
|
|
|
|
// Remap the current label to prior label.
|
2007-01-27 05:38:26 +08:00
|
|
|
MMI->RemapLabel(NextLabel, PriorLabel);
|
2006-11-08 03:33:46 +08:00
|
|
|
// Delete the current label.
|
|
|
|
I = BB->erase(I);
|
|
|
|
// Indicate a change has been made.
|
|
|
|
MadeChange = true;
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
// Start a new round.
|
|
|
|
PriorLabel = NextLabel;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// No consecutive labels.
|
|
|
|
PriorLabel = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
++I;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return MadeChange;
|
|
|
|
}
|
|
|
|
|
|
|
|
FunctionPass *createDebugLabelFoldingPass() { return new DebugLabelFolder(); }
|
|
|
|
|
|
|
|
}
|
2008-07-04 06:53:42 +08:00
|
|
|
|