maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Dale and Evan suggested putting the "check for setjmp" much earlier in the 

machine code generation. That's a good idea, so I made it so.

llvm-svn: 104655
This commit is contained in:
Bill Wendling 2010-05-26 00:32:40 +00:00
parent 0b0274524c
commit c5222d6c38
3 changed files with 53 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
llvm/include/llvm/CodeGen/MachineFunction.h
View File

@ -114,9 +114,13 @@ class MachineFunction {
///
unsigned FunctionNumber;
/// The alignment of the function.
/// Alignment - The alignment of the function.
unsigned Alignment;
/// HasReturnsTwiceCall - Returns true if there's a call with a
/// "returns_twice" attribute, like setjmp.
bool HasReturnsTwiceCall;
MachineFunction(const MachineFunction &); // DO NOT IMPLEMENT
void operator=(const MachineFunction&); // DO NOT IMPLEMENT
public:
@ -181,6 +185,15 @@ public:
void EnsureAlignment(unsigned A) {
if (Alignment < A) Alignment = A;
}
/// hasReturnsTwiceCall - Returns true if there's a call with a
/// "returns_twice" attribute, like setjmp.
bool hasReturnsTwiceCall() const {
return HasReturnsTwiceCall;
}
void setReturnsTwiceCall(bool B) {
HasReturnsTwiceCall = B;
}
/// getInfo - Keep track of various per-function pieces of information for
/// backends that would like to do so.

34
llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -25,6 +25,7 @@
#include "llvm/Intrinsics.h"
#include "llvm/IntrinsicInst.h"
#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/CodeGen/FastISel.h"
#include "llvm/CodeGen/GCStrategy.h"
#include "llvm/CodeGen/GCMetadata.h"
@ -253,6 +254,39 @@ bool SelectionDAGISel::runOnMachineFunction(MachineFunction &mf) {
done:;
}
// Set a flag indicating if the machine function makes a call to setjmp /
// sigsetjmp (i.e., a function marked "returns_twice"). We'll use this to
// disable certain optimizations which cannot handle such control flows.
//
// FIXME: This goes beyond the setjmp/sigsetjmp functions. We should check for
// the GCC "returns twice" attribute.
const Module *M = Fn.getParent();
const Function *SetJmp = M->getFunction("setjmp");
const Function *SigSetJmp = M->getFunction("sigsetjmp");
bool HasReturnsTwiceCall = false;
if (SetJmp || SigSetJmp) {
if (SetJmp && !SetJmp->use_empty())
for (Value::const_use_iterator
I = SetJmp->use_begin(), E = SetJmp->use_end(); I != E; ++I)
if (const CallInst *CI = dyn_cast<CallInst>(I))
if (CI->getParent()->getParent() == &Fn) {
HasReturnsTwiceCall = true;
break;
}
if (!HasReturnsTwiceCall && SigSetJmp && !SigSetJmp->use_empty())
for (Value::const_use_iterator
I = SigSetJmp->use_begin(), E = SigSetJmp->use_end(); I != E; ++I)
if (const CallInst *CI = dyn_cast<CallInst>(I))
if (CI->getParent()->getParent() == &Fn) {
HasReturnsTwiceCall = true;
break;
}
mf.setReturnsTwiceCall(HasReturnsTwiceCall);
}
// Release function-specific state. SDB and CurDAG are already cleared
// at this point.
FuncInfo->clear();

42
llvm/lib/CodeGen/StackSlotColoring.cpp
View File

@ -118,7 +118,6 @@ namespace {
private:
void InitializeSlots();
bool CheckForSetJmpCall(const MachineFunction &MF) const;
void ScanForSpillSlotRefs(MachineFunction &MF);
bool OverlapWithAssignments(LiveInterval *li, int Color) const;
int ColorSlot(LiveInterval *li);
@ -162,34 +161,6 @@ namespace {
};
}
/// CheckForSetJmpCall - Return true if there's a call to setjmp/sigsetjmp in
/// this function.
bool StackSlotColoring::CheckForSetJmpCall(const MachineFunction &MF) const {
const Function *F = MF.getFunction();
const Module *M = F->getParent();
const Function *SetJmp = M->getFunction("setjmp");
const Function *SigSetJmp = M->getFunction("sigsetjmp");
if (!SetJmp && !SigSetJmp)
return false;
if (SetJmp && !SetJmp->use_empty())
for (Value::const_use_iterator
I = SetJmp->use_begin(), E = SetJmp->use_end(); I != E; ++I)
if (const CallInst *CI = dyn_cast<CallInst>(I))
if (CI->getParent()->getParent() == F)
return true;
if (SigSetJmp && !SigSetJmp->use_empty())
for (Value::const_use_iterator
I = SigSetJmp->use_begin(), E = SigSetJmp->use_end(); I != E; ++I)
if (const CallInst *CI = dyn_cast<CallInst>(I))
if (CI->getParent()->getParent() == F)
return true;
return false;
}
/// ScanForSpillSlotRefs - Scan all the machine instructions for spill slot
/// references and update spill slot weights.
void StackSlotColoring::ScanForSpillSlotRefs(MachineFunction &MF) {
@ -753,14 +724,11 @@ bool StackSlotColoring::runOnMachineFunction(MachineFunction &MF) {
return false;
}
// If there are calls to setjmp or sigsetjmp, don't perform stack slot
// coloring. The stack could be modified before the longjmp is executed,
// resulting in the wrong value being used afterwards. (See
// <rdar://problem/8007500>.)
//
// FIXME: This goes beyond the setjmp/sigsetjmp functions. Ideally, we should
// check for the GCC "returns twice" attribute.
if (CheckForSetJmpCall(MF))
// If there is a call to a function with the attribute "returns_twice" (like
// setjmp or sigsetjmp), don't perform stack slot coloring. The stack could be
// modified before the the second return, resulting in the wrong value being
// used afterwards. (See <rdar://problem/8007500>.)
if (MF.hasReturnsTwiceCall())
return false;
// Gather spill slot references