Mercurial > projects > ldc
annotate gen/passes/GarbageCollect2Stack.cpp @ 1559:06d5cc873350
getTrue/getFalse were moved back to ConstantInt
Requires LLVM >= r77685
| author | Benjamin Kramer <benny.kra@gmail.com> |
|---|---|
| date | Fri, 31 Jul 2009 19:11:07 +0200 |
| parents | 3adcb70700cb |
| children | 8d086d552909 |
| rev | line source |
|---|---|
|
1558
3adcb70700cb
Added back option to disable metadata generation and users. Set USE_METADATA to OFF in ccmake.
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1555
diff
changeset
|
1 #if USE_METADATA |
|
3adcb70700cb
Added back option to disable metadata generation and users. Set USE_METADATA to OFF in ccmake.
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1555
diff
changeset
|
2 |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
3 //===- GarbageCollect2Stack - Optimize calls to the D garbage collector ---===// |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
4 // |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
5 // The LLVM D Compiler |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
6 // |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
7 // This file is distributed under the University of Illinois Open Source |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
8 // License. See LICENSE.TXT for details. |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
9 // |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
10 //===----------------------------------------------------------------------===// |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
11 // |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
12 // This file attempts to turn allocations on the garbage-collected heap into |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
13 // stack allocations. |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
14 // |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
15 //===----------------------------------------------------------------------===// |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
16 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
17 #include "gen/metadata.h" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
18 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
19 #define DEBUG_TYPE "dgc2stack" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
20 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
21 #include "Passes.h" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
22 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
23 #include "llvm/Pass.h" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
24 #include "llvm/Module.h" |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
25 #include "llvm/Constants.h" |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
26 #include "llvm/Intrinsics.h" |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
27 #include "llvm/Support/CallSite.h" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
28 #include "llvm/Support/CommandLine.h" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
29 #include "llvm/Support/IRBuilder.h" |
|
1424
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
30 #include "llvm/Analysis/CallGraph.h" |
|
1486
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
31 #include "llvm/Analysis/Dominators.h" |
|
1297
8e8552601ecd
Stack promotion for _d_newarrayvT. Array literals, concatenations (a ~ b) and
Frits van Bommel <fvbommel wxs.nl>
parents:
1295
diff
changeset
|
32 #include "llvm/Analysis/ValueTracking.h" |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
33 #include "llvm/Target/TargetData.h" |
|
1486
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
34 #include "llvm/ADT/SmallSet.h" |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
35 #include "llvm/ADT/SmallVector.h" |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
36 #include "llvm/ADT/StringMap.h" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
37 #include "llvm/ADT/Statistic.h" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
38 #include "llvm/Support/Compiler.h" |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
39 #include "llvm/Support/Debug.h" |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
40 #include "llvm/Support/raw_ostream.h" |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
41 using namespace llvm; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
42 |
|
1297
8e8552601ecd
Stack promotion for _d_newarrayvT. Array literals, concatenations (a ~ b) and
Frits van Bommel <fvbommel wxs.nl>
parents:
1295
diff
changeset
|
43 STATISTIC(NumGcToStack, "Number of calls promoted to constant-size allocas"); |
|
8e8552601ecd
Stack promotion for _d_newarrayvT. Array literals, concatenations (a ~ b) and
Frits van Bommel <fvbommel wxs.nl>
parents:
1295
diff
changeset
|
44 STATISTIC(NumToDynSize, "Number of calls promoted to dynamically-sized allocas"); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
45 STATISTIC(NumDeleted, "Number of GC calls deleted because the return value was unused"); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
46 |
|
1424
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
47 |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
48 namespace { |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
49 struct Analysis { |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
50 TargetData& TD; |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
51 const Module& M; |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
52 CallGraph* CG; |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
53 CallGraphNode* CGNode; |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
54 |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
55 const Type* getTypeFor(Value* typeinfo) const; |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
56 }; |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
57 } |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
58 |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
59 //===----------------------------------------------------------------------===// |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
60 // Helper functions |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
61 //===----------------------------------------------------------------------===// |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
62 |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
63 void EmitMemSet(IRBuilder<>& B, Value* Dst, Value* Val, Value* Len, |
|
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
64 const Analysis& A) { |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
65 Dst = B.CreateBitCast(Dst, PointerType::getUnqual(Type::Int8Ty)); |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
66 |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
67 Module *M = B.GetInsertBlock()->getParent()->getParent(); |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
68 const Type* Tys[1]; |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
69 Tys[0] = Len->getType(); |
|
1424
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
70 Function *MemSet = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys, 1); |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
71 Value *Align = ConstantInt::get(Type::Int32Ty, 1); |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
72 |
|
1424
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
73 CallSite CS = B.CreateCall4(MemSet, Dst, Val, Len, Align); |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
74 if (A.CGNode) |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
75 A.CGNode->addCalledFunction(CS, A.CG->getOrInsertFunction(MemSet)); |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
76 } |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
77 |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
78 static void EmitMemZero(IRBuilder<>& B, Value* Dst, Value* Len, |
|
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
79 const Analysis& A) { |
|
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
80 EmitMemSet(B, Dst, ConstantInt::get(Type::Int8Ty, 0), Len, A); |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
81 } |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
82 |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
83 |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
84 //===----------------------------------------------------------------------===// |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
85 // Helpers for specific types of GC calls. |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
86 //===----------------------------------------------------------------------===// |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
87 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
88 namespace { |
| 1306 | 89 class FunctionInfo { |
| 90 protected: | |
| 91 const Type* Ty; | |
| 92 | |
| 93 public: | |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
94 unsigned TypeInfoArgNr; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
95 bool SafeToDelete; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
96 |
| 1306 | 97 // Analyze the current call, filling in some fields. Returns true if |
| 98 // this is an allocation we can stack-allocate. | |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
99 virtual bool analyze(CallSite CS, const Analysis& A) { |
| 1306 | 100 Value* TypeInfo = CS.getArgument(TypeInfoArgNr); |
| 101 Ty = A.getTypeFor(TypeInfo); | |
| 102 return (Ty != NULL); | |
| 103 } | |
| 104 | |
| 105 // Returns the alloca to replace this call. | |
| 106 // It will always be inserted before the call. | |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
107 virtual AllocaInst* promote(CallSite CS, IRBuilder<>& B, const Analysis& A) { |
| 1306 | 108 NumGcToStack++; |
| 109 | |
| 110 Instruction* Begin = CS.getCaller()->getEntryBlock().begin(); | |
|
1350
15e9762bb620
Adds explicit alignment information for alloca instructions in general, there's a few cases that still needs to be looked at but this should catch the majority. Fixes ticket #293 .
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1344
diff
changeset
|
111 return new AllocaInst(Ty, ".nongc_mem", Begin); // FIXME: align? |
| 1306 | 112 } |
| 113 | |
|
1548
a326f145a57b
ConstantInt::get{True,False} moved to LLVMContext
Benjamin Kramer <benny.kra@gmail.com>
parents:
1545
diff
changeset
|
114 FunctionInfo(unsigned typeInfoArgNr, bool safeToDelete) |
|
a326f145a57b
ConstantInt::get{True,False} moved to LLVMContext
Benjamin Kramer <benny.kra@gmail.com>
parents:
1545
diff
changeset
|
115 : TypeInfoArgNr(typeInfoArgNr), SafeToDelete(safeToDelete) {} |
| 1306 | 116 }; |
| 117 | |
| 118 class ArrayFI : public FunctionInfo { | |
| 119 Value* arrSize; | |
| 120 int ArrSizeArgNr; | |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
121 bool Initialized; |
| 1306 | 122 |
| 123 public: | |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
124 ArrayFI(unsigned tiArgNr, bool safeToDelete, bool initialized, |
|
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
125 unsigned arrSizeArgNr) |
|
1548
a326f145a57b
ConstantInt::get{True,False} moved to LLVMContext
Benjamin Kramer <benny.kra@gmail.com>
parents:
1545
diff
changeset
|
126 : FunctionInfo(tiArgNr, safeToDelete), |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
127 ArrSizeArgNr(arrSizeArgNr), |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
128 Initialized(initialized) |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
129 {} |
| 1306 | 130 |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
131 virtual bool analyze(CallSite CS, const Analysis& A) { |
|
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
132 if (!FunctionInfo::analyze(CS, A)) |
| 1306 | 133 return false; |
| 134 | |
| 135 arrSize = CS.getArgument(ArrSizeArgNr); | |
| 136 const IntegerType* SizeType = | |
| 137 dyn_cast<IntegerType>(arrSize->getType()); | |
| 138 if (!SizeType) | |
| 139 return false; | |
| 140 unsigned bits = SizeType->getBitWidth(); | |
| 141 if (bits > 32) { | |
| 142 // The array size of an alloca must be an i32, so make sure | |
| 143 // the conversion is safe. | |
| 144 APInt Mask = APInt::getHighBitsSet(bits, bits - 32); | |
| 145 APInt KnownZero(bits, 0), KnownOne(bits, 0); | |
| 146 ComputeMaskedBits(arrSize, Mask, KnownZero, KnownOne, &A.TD); | |
| 147 if ((KnownZero & Mask) != Mask) | |
| 148 return false; | |
| 149 } | |
| 150 // Extract the element type from the array type. | |
| 151 const StructType* ArrTy = dyn_cast<StructType>(Ty); | |
| 152 assert(ArrTy && "Dynamic array type not a struct?"); | |
| 153 assert(isa<IntegerType>(ArrTy->getElementType(0))); | |
| 154 const PointerType* PtrTy = | |
| 155 cast<PointerType>(ArrTy->getElementType(1)); | |
| 156 Ty = PtrTy->getElementType(); | |
| 157 return true; | |
| 158 } | |
| 159 | |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
160 virtual AllocaInst* promote(CallSite CS, IRBuilder<>& B, const Analysis& A) { |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
161 IRBuilder<> Builder = B; |
| 1306 | 162 // If the allocation is of constant size it's best to put it in the |
| 163 // entry block, so do so if we're not already there. | |
| 164 // For dynamically-sized allocations it's best to avoid the overhead | |
| 165 // of allocating them if possible, so leave those where they are. | |
| 166 // While we're at it, update statistics too. | |
| 167 if (isa<Constant>(arrSize)) { | |
| 168 BasicBlock& Entry = CS.getCaller()->getEntryBlock(); | |
| 169 if (Builder.GetInsertBlock() != &Entry) | |
| 170 Builder.SetInsertPoint(&Entry, Entry.begin()); | |
| 171 NumGcToStack++; | |
| 172 } else { | |
| 173 NumToDynSize++; | |
| 174 } | |
| 175 | |
| 176 // Convert array size to 32 bits if necessary | |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
177 Value* count = Builder.CreateIntCast(arrSize, Type::Int32Ty, false); |
|
1350
15e9762bb620
Adds explicit alignment information for alloca instructions in general, there's a few cases that still needs to be looked at but this should catch the majority. Fixes ticket #293 .
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1344
diff
changeset
|
178 AllocaInst* alloca = Builder.CreateAlloca(Ty, count, ".nongc_mem"); // FIXME: align? |
| 1306 | 179 |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
180 if (Initialized) { |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
181 // For now, only zero-init is supported. |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
182 uint64_t size = A.TD.getTypeStoreSize(Ty); |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
183 Value* TypeSize = ConstantInt::get(arrSize->getType(), size); |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
184 // Use the original B to put initialization at the |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
185 // allocation site. |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
186 Value* Size = B.CreateMul(TypeSize, arrSize); |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
187 EmitMemZero(B, alloca, Size, A); |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
188 } |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
189 |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
190 return alloca; |
| 1306 | 191 } |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
192 }; |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
193 |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
194 // FunctionInfo for _d_allocclass |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
195 class AllocClassFI : public FunctionInfo { |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
196 public: |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
197 virtual bool analyze(CallSite CS, const Analysis& A) { |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
198 // This call contains no TypeInfo parameter, so don't call the |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
199 // base class implementation here... |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
200 if (CS.arg_size() != 1) |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
201 return false; |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
202 Value* arg = CS.getArgument(0)->stripPointerCasts(); |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
203 GlobalVariable* ClassInfo = dyn_cast<GlobalVariable>(arg); |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
204 if (!ClassInfo) |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
205 return false; |
|
1555
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
206 |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
207 std::string metaname = CD_PREFIX; |
|
1553
f55ca8a1598c
Value::getNameStart and Value::getNameLength were removed
Benjamin Kramer <benny.kra@gmail.com>
parents:
1551
diff
changeset
|
208 metaname += ClassInfo->getName(); |
|
1555
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
209 |
|
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
210 NamedMDNode* meta = A.M.getNamedMetadata(metaname); |
|
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
211 if (!meta) |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
212 return false; |
|
1555
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
213 |
|
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
214 MDNode* node = static_cast<MDNode*>(meta->getElement(0)); |
|
1343
c21a6654cce2
Update for metadata changes in LLVM trunk.
Frits van Bommel <fvbommel wxs.nl>
parents:
1317
diff
changeset
|
215 if (!node || MD_GetNumElements(node) != CD_NumFields) |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
216 return false; |
|
1555
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
217 |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
218 // Inserting destructor calls is not implemented yet, so classes |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
219 // with destructors are ignored for now. |
|
1343
c21a6654cce2
Update for metadata changes in LLVM trunk.
Frits van Bommel <fvbommel wxs.nl>
parents:
1317
diff
changeset
|
220 Constant* hasDestructor = dyn_cast<Constant>(MD_GetElement(node, CD_Finalize)); |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
221 // We can't stack-allocate if the class has a custom deallocator |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
222 // (Custom allocators don't get turned into this runtime call, so |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
223 // those can be ignored) |
|
1343
c21a6654cce2
Update for metadata changes in LLVM trunk.
Frits van Bommel <fvbommel wxs.nl>
parents:
1317
diff
changeset
|
224 Constant* hasCustomDelete = dyn_cast<Constant>(MD_GetElement(node, CD_CustomDelete)); |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
225 if (hasDestructor == NULL || hasCustomDelete == NULL) |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
226 return false; |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
227 |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
228 if (ConstantExpr::getOr(hasDestructor, hasCustomDelete) |
|
1559
06d5cc873350
getTrue/getFalse were moved back to ConstantInt
Benjamin Kramer <benny.kra@gmail.com>
parents:
1558
diff
changeset
|
229 != ConstantInt::getFalse(A.M.getContext())) |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
230 return false; |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
231 |
|
1343
c21a6654cce2
Update for metadata changes in LLVM trunk.
Frits van Bommel <fvbommel wxs.nl>
parents:
1317
diff
changeset
|
232 Ty = MD_GetElement(node, CD_BodyType)->getType(); |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
233 return true; |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
234 } |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
235 |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
236 // The default promote() should be fine. |
|
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
237 |
|
1548
a326f145a57b
ConstantInt::get{True,False} moved to LLVMContext
Benjamin Kramer <benny.kra@gmail.com>
parents:
1545
diff
changeset
|
238 AllocClassFI() : FunctionInfo(~0u, true) {} |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
239 }; |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
240 } |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
241 |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
242 |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
243 //===----------------------------------------------------------------------===// |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
244 // GarbageCollect2Stack Pass Implementation |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
245 //===----------------------------------------------------------------------===// |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
246 |
|
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
247 namespace { |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
248 /// This pass replaces GC calls with alloca's |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
249 /// |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
250 class VISIBILITY_HIDDEN GarbageCollect2Stack : public FunctionPass { |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
251 StringMap<FunctionInfo*> KnownFunctions; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
252 Module* M; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
253 |
| 1306 | 254 FunctionInfo AllocMemoryT; |
| 255 ArrayFI NewArrayVT; | |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
256 ArrayFI NewArrayT; |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
257 AllocClassFI AllocClass; |
| 1306 | 258 |
| 259 public: | |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
260 static char ID; // Pass identification |
| 1306 | 261 GarbageCollect2Stack(); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
262 |
| 1306 | 263 bool doInitialization(Module &M) { |
| 264 this->M = &M; | |
|
1438
c363d131c1ef
Add some missing returns.
Frits van Bommel <fvbommel wxs.nl>
parents:
1424
diff
changeset
|
265 return false; |
| 1306 | 266 } |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
267 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
268 bool runOnFunction(Function &F); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
269 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
270 virtual void getAnalysisUsage(AnalysisUsage &AU) const { |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
271 AU.addRequired<TargetData>(); |
|
1486
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
272 AU.addRequired<DominatorTree>(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
273 |
|
1424
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
274 AU.addPreserved<CallGraph>(); |
|
1486
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
275 AU.addPreserved<DominatorTree>(); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
276 } |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
277 }; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
278 char GarbageCollect2Stack::ID = 0; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
279 } // end anonymous namespace. |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
280 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
281 static RegisterPass<GarbageCollect2Stack> |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
282 X("dgc2stack", "Promote (GC'ed) heap allocations to stack"); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
283 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
284 // Public interface to the pass. |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
285 FunctionPass *createGarbageCollect2Stack() { |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
286 return new GarbageCollect2Stack(); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
287 } |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
288 |
| 1306 | 289 GarbageCollect2Stack::GarbageCollect2Stack() |
| 290 : FunctionPass(&ID), | |
|
1548
a326f145a57b
ConstantInt::get{True,False} moved to LLVMContext
Benjamin Kramer <benny.kra@gmail.com>
parents:
1545
diff
changeset
|
291 AllocMemoryT(0, true), |
|
a326f145a57b
ConstantInt::get{True,False} moved to LLVMContext
Benjamin Kramer <benny.kra@gmail.com>
parents:
1545
diff
changeset
|
292 NewArrayVT(0, true, false, 1), |
|
a326f145a57b
ConstantInt::get{True,False} moved to LLVMContext
Benjamin Kramer <benny.kra@gmail.com>
parents:
1545
diff
changeset
|
293 NewArrayT(0, true, true, 1) |
| 1306 | 294 { |
| 295 KnownFunctions["_d_allocmemoryT"] = &AllocMemoryT; | |
| 296 KnownFunctions["_d_newarrayvT"] = &NewArrayVT; | |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
297 KnownFunctions["_d_newarrayT"] = &NewArrayT; |
|
1317
4099548c80e0
Allocate objects on the stack if they (a) don't have a destructor, and
Frits van Bommel <fvbommel wxs.nl>
parents:
1316
diff
changeset
|
298 KnownFunctions["_d_allocclass"] = &AllocClass; |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
299 } |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
300 |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
301 static void RemoveCall(CallSite CS, const Analysis& A) { |
|
1424
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
302 if (CS.isInvoke()) { |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
303 InvokeInst* Invoke = cast<InvokeInst>(CS.getInstruction()); |
|
1298
7e303f9f16c7
Don't forget to update the control flow when deleting an invoke.
Frits van Bommel <fvbommel wxs.nl>
parents:
1297
diff
changeset
|
304 // If this was an invoke instruction, we need to do some extra |
|
7e303f9f16c7
Don't forget to update the control flow when deleting an invoke.
Frits van Bommel <fvbommel wxs.nl>
parents:
1297
diff
changeset
|
305 // work to preserve the control flow. |
|
7e303f9f16c7
Don't forget to update the control flow when deleting an invoke.
Frits van Bommel <fvbommel wxs.nl>
parents:
1297
diff
changeset
|
306 |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
307 // Create a "conditional" branch that -simplifycfg can clean up, so we |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
308 // can keep using the DominatorTree without updating it. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
309 BranchInst::Create(Invoke->getNormalDest(), Invoke->getUnwindDest(), |
|
1559
06d5cc873350
getTrue/getFalse were moved back to ConstantInt
Benjamin Kramer <benny.kra@gmail.com>
parents:
1558
diff
changeset
|
310 ConstantInt::getTrue(A.M.getContext()), Invoke->getParent()); |
|
1298
7e303f9f16c7
Don't forget to update the control flow when deleting an invoke.
Frits van Bommel <fvbommel wxs.nl>
parents:
1297
diff
changeset
|
311 } |
|
7e303f9f16c7
Don't forget to update the control flow when deleting an invoke.
Frits van Bommel <fvbommel wxs.nl>
parents:
1297
diff
changeset
|
312 // Remove the runtime call. |
|
1424
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
313 if (A.CGNode) |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
314 A.CGNode->removeCallEdgeFor(CS); |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
315 CS.getInstruction()->eraseFromParent(); |
|
1298
7e303f9f16c7
Don't forget to update the control flow when deleting an invoke.
Frits van Bommel <fvbommel wxs.nl>
parents:
1297
diff
changeset
|
316 } |
|
7e303f9f16c7
Don't forget to update the control flow when deleting an invoke.
Frits van Bommel <fvbommel wxs.nl>
parents:
1297
diff
changeset
|
317 |
|
1488
ca31a8e9c42b
Oops, I accidentally pushed r1486 before the last touches were committed.
Frits van Bommel <fvbommel wxs.nl>
parents:
1486
diff
changeset
|
318 static bool isSafeToStackAllocate(Instruction* Alloc, DominatorTree& DT); |
|
ca31a8e9c42b
Oops, I accidentally pushed r1486 before the last touches were committed.
Frits van Bommel <fvbommel wxs.nl>
parents:
1486
diff
changeset
|
319 |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
320 /// runOnFunction - Top level algorithm. |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
321 /// |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
322 bool GarbageCollect2Stack::runOnFunction(Function &F) { |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
323 DEBUG(errs() << "\nRunning -dgc2stack on function " << F.getName() << '\n'); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
324 |
|
1486
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
325 TargetData& TD = getAnalysis<TargetData>(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
326 DominatorTree& DT = getAnalysis<DominatorTree>(); |
|
1424
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
327 CallGraph* CG = getAnalysisIfAvailable<CallGraph>(); |
|
ad999630aa35
Teach -dgc2stack to preserve the call graph. This should allow for more
Frits van Bommel <fvbommel wxs.nl>
parents:
1361
diff
changeset
|
328 CallGraphNode* CGNode = CG ? (*CG)[&F] : NULL; |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
329 |
|
1488
ca31a8e9c42b
Oops, I accidentally pushed r1486 before the last touches were committed.
Frits van Bommel <fvbommel wxs.nl>
parents:
1486
diff
changeset
|
330 Analysis A = { TD, *M, CG, CGNode }; |
| 1306 | 331 |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
332 BasicBlock& Entry = F.getEntryBlock(); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
333 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
334 IRBuilder<> AllocaBuilder(&Entry, Entry.begin()); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
335 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
336 bool Changed = false; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
337 for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
338 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) { |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
339 // Ignore non-calls. |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
340 Instruction* Inst = I++; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
341 CallSite CS = CallSite::get(Inst); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
342 if (!CS.getInstruction()) |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
343 continue; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
344 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
345 // Ignore indirect calls and calls to non-external functions. |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
346 Function *Callee = CS.getCalledFunction(); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
347 if (Callee == 0 || !Callee->isDeclaration() || |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
348 !(Callee->hasExternalLinkage() || Callee->hasDLLImportLinkage())) |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
349 continue; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
350 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
351 // Ignore unknown calls. |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
352 StringMap<FunctionInfo*>::iterator OMI = |
|
1553
f55ca8a1598c
Value::getNameStart and Value::getNameLength were removed
Benjamin Kramer <benny.kra@gmail.com>
parents:
1551
diff
changeset
|
353 KnownFunctions.find(Callee->getName()); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
354 if (OMI == KnownFunctions.end()) continue; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
355 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
356 assert(isa<PointerType>(Inst->getType()) |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
357 && "GC function doesn't return a pointer?"); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
358 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
359 FunctionInfo* info = OMI->getValue(); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
360 |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
361 if (Inst->use_empty() && info->SafeToDelete) { |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
362 Changed = true; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
363 NumDeleted++; |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
364 RemoveCall(CS, A); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
365 continue; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
366 } |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
367 |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
368 DEBUG(errs() << "GarbageCollect2Stack inspecting: " << *Inst); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
369 |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
370 if (!info->analyze(CS, A) || !isSafeToStackAllocate(Inst, DT)) |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
371 continue; |
|
1305
8215dbf0e09f
Postpone (expensive) escape analysis until we're sure it's needed.
Frits van Bommel <fvbommel wxs.nl>
parents:
1298
diff
changeset
|
372 |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
373 // Let's alloca this! |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
374 Changed = true; |
|
1297
8e8552601ecd
Stack promotion for _d_newarrayvT. Array literals, concatenations (a ~ b) and
Frits van Bommel <fvbommel wxs.nl>
parents:
1295
diff
changeset
|
375 |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
376 IRBuilder<> Builder(BB, Inst); |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
377 Value* newVal = info->promote(CS, Builder, A); |
|
1297
8e8552601ecd
Stack promotion for _d_newarrayvT. Array literals, concatenations (a ~ b) and
Frits van Bommel <fvbommel wxs.nl>
parents:
1295
diff
changeset
|
378 |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
379 DEBUG(errs() << "Promoted to: " << *newVal); |
|
1343
c21a6654cce2
Update for metadata changes in LLVM trunk.
Frits van Bommel <fvbommel wxs.nl>
parents:
1317
diff
changeset
|
380 |
|
1297
8e8552601ecd
Stack promotion for _d_newarrayvT. Array literals, concatenations (a ~ b) and
Frits van Bommel <fvbommel wxs.nl>
parents:
1295
diff
changeset
|
381 // Make sure the type is the same as it was before, and replace all |
|
8e8552601ecd
Stack promotion for _d_newarrayvT. Array literals, concatenations (a ~ b) and
Frits van Bommel <fvbommel wxs.nl>
parents:
1295
diff
changeset
|
382 // uses of the runtime call with the alloca. |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
383 if (newVal->getType() != Inst->getType()) |
|
1307
e2ec50329af1
Stack-allocate zero-initialized arrays.
Frits van Bommel <fvbommel wxs.nl>
parents:
1306
diff
changeset
|
384 newVal = Builder.CreateBitCast(newVal, Inst->getType()); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
385 Inst->replaceAllUsesWith(newVal); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
386 |
|
1554
d6e8d5db259f
LLVMContext changes up to r77366
Benjamin Kramer <benny.kra@gmail.com>
parents:
1553
diff
changeset
|
387 RemoveCall(CS, A); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
388 } |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
389 } |
|
1297
8e8552601ecd
Stack promotion for _d_newarrayvT. Array literals, concatenations (a ~ b) and
Frits van Bommel <fvbommel wxs.nl>
parents:
1295
diff
changeset
|
390 |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
391 return Changed; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
392 } |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
393 |
| 1306 | 394 const Type* Analysis::getTypeFor(Value* typeinfo) const { |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
395 GlobalVariable* ti_global = dyn_cast<GlobalVariable>(typeinfo->stripPointerCasts()); |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
396 if (!ti_global) |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
397 return NULL; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
398 |
|
1291
875afb7a93b6
Factor out some constants into the header so producers and consumers of
Frits van Bommel <fvbommel wxs.nl>
parents:
1285
diff
changeset
|
399 std::string metaname = TD_PREFIX; |
|
1553
f55ca8a1598c
Value::getNameStart and Value::getNameLength were removed
Benjamin Kramer <benny.kra@gmail.com>
parents:
1551
diff
changeset
|
400 metaname += ti_global->getName(); |
|
1555
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
401 |
|
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
402 NamedMDNode* meta = M.getNamedMetadata(metaname); |
|
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
403 if (!meta) |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
404 return NULL; |
|
1555
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
405 |
|
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
406 MDNode* node = static_cast<MDNode*>(meta->getElement(0)); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
407 if (!node) |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
408 return NULL; |
|
1555
ed0cffe895ec
use the new NamedMDNode class
Benjamin Kramer <benny.kra@gmail.com>
parents:
1554
diff
changeset
|
409 |
|
1344
3297edb697eb
Re-enable consistency check for fixed LLVM versions.
Frits van Bommel <fvbommel wxs.nl>
parents:
1343
diff
changeset
|
410 if (MD_GetNumElements(node) != TD_NumFields) |
|
3297edb697eb
Re-enable consistency check for fixed LLVM versions.
Frits van Bommel <fvbommel wxs.nl>
parents:
1343
diff
changeset
|
411 return NULL; |
|
3297edb697eb
Re-enable consistency check for fixed LLVM versions.
Frits van Bommel <fvbommel wxs.nl>
parents:
1343
diff
changeset
|
412 if (TD_Confirm >= 0 && (!MD_GetElement(node, TD_Confirm) || |
|
3297edb697eb
Re-enable consistency check for fixed LLVM versions.
Frits van Bommel <fvbommel wxs.nl>
parents:
1343
diff
changeset
|
413 MD_GetElement(node, TD_Confirm)->stripPointerCasts() != ti_global)) |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
414 return NULL; |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
415 |
|
1343
c21a6654cce2
Update for metadata changes in LLVM trunk.
Frits van Bommel <fvbommel wxs.nl>
parents:
1317
diff
changeset
|
416 return MD_GetElement(node, TD_Type)->getType(); |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
417 } |
|
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
418 |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
419 /// Returns whether Def is used by any instruction that is reachable from Alloc |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
420 /// (without executing Def again). |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
421 static bool mayBeUsedAfterRealloc(Instruction* Def, Instruction* Alloc, DominatorTree& DT) { |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
422 DEBUG(errs() << "### mayBeUsedAfterRealloc()\n" << *Def << *Alloc); |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
423 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
424 // If the definition isn't used it obviously won't be used after the |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
425 // allocation. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
426 // If it does not dominate the allocation, there's no way for it to be used |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
427 // without going through Def again first, since the definition couldn't |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
428 // dominate the user either. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
429 if (Def->use_empty() || !DT.dominates(Def, Alloc)) { |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
430 DEBUG(errs() << "### No uses or does not dominate allocation\n"); |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
431 return false; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
432 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
433 |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
434 DEBUG(errs() << "### Def dominates Alloc\n"); |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
435 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
436 BasicBlock* DefBlock = Def->getParent(); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
437 BasicBlock* AllocBlock = Alloc->getParent(); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
438 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
439 // Create a set of users and one of blocks containing users. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
440 SmallSet<User*, 16> Users; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
441 SmallSet<BasicBlock*, 16> UserBlocks; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
442 for (Instruction::use_iterator UI = Def->use_begin(), UE = Def->use_end(); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
443 UI != UE; ++UI) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
444 Instruction* User = cast<Instruction>(*UI); |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
445 DEBUG(errs() << "USER: " << *User); |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
446 BasicBlock* UserBlock = User->getParent(); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
447 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
448 // This dominance check is not performed if they're in the same block |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
449 // because it will just walk the instruction list to figure it out. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
450 // We will instead do that ourselves in the first iteration (for all |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
451 // users at once). |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
452 if (AllocBlock != UserBlock && DT.dominates(AllocBlock, UserBlock)) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
453 // There's definitely a path from alloc to this user that does not |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
454 // go through Def, namely any path that ends up in that user. |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
455 DEBUG(errs() << "### Alloc dominates user " << *User); |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
456 return true; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
457 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
458 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
459 // Phi nodes are checked separately, so no need to enter them here. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
460 if (!isa<PHINode>(User)) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
461 Users.insert(User); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
462 UserBlocks.insert(UserBlock); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
463 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
464 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
465 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
466 // Contains first instruction of block to inspect. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
467 typedef std::pair<BasicBlock*, BasicBlock::iterator> StartPoint; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
468 SmallVector<StartPoint, 16> Worklist; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
469 // Keeps track of successors that have been added to the work list. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
470 SmallSet<BasicBlock*, 16> Visited; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
471 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
472 // Start just after the allocation. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
473 // Note that we don't insert AllocBlock into the Visited set here so the |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
474 // start of the block will get inspected if it's reachable. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
475 BasicBlock::iterator Start = Alloc; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
476 ++Start; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
477 Worklist.push_back(StartPoint(AllocBlock, Start)); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
478 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
479 while (!Worklist.empty()) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
480 StartPoint sp = Worklist.pop_back_val(); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
481 BasicBlock* B = sp.first; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
482 BasicBlock::iterator BBI = sp.second; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
483 // BBI is either just after the allocation (in the first iteration) |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
484 // or just after the last phi node in B (in subsequent iterations) here. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
485 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
486 // This whole 'if' is just a way to avoid performing the inner 'for' |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
487 // loop when it can be determined not to be necessary, avoiding |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
488 // potentially expensive walks of the instruction list. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
489 // It should be equivalent to just doing the loop. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
490 if (UserBlocks.count(B)) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
491 if (B != DefBlock && B != AllocBlock) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
492 // This block does not contain the definition or the allocation, |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
493 // so any user in this block is definitely reachable without |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
494 // finding either the definition or the allocation. |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
495 DEBUG(errs() << "### Block " << B->getName() |
|
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
496 << " contains a reachable user\n"); |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
497 return true; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
498 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
499 // We need to walk the instructions in the block to see whether we |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
500 // reach a user before we reach the definition or the allocation. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
501 for (BasicBlock::iterator E = B->end(); BBI != E; ++BBI) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
502 if (&*BBI == Alloc || &*BBI == Def) |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
503 break; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
504 if (Users.count(BBI)) { |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
505 DEBUG(errs() << "### Problematic user: " << *BBI); |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
506 return true; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
507 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
508 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
509 } else if (B == DefBlock || (B == AllocBlock && BBI != Start)) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
510 // There are no users in the block so the def or the allocation |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
511 // will be encountered before any users though this path. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
512 // Skip to the next item on the worklist. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
513 continue; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
514 } else { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
515 // No users and no definition or allocation after the start point, |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
516 // so just keep going. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
517 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
518 |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
519 // All instructions after the starting point in this block have been |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
520 // accounted for. Look for successors to add to the work list. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
521 TerminatorInst* Term = B->getTerminator(); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
522 unsigned SuccCount = Term->getNumSuccessors(); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
523 for (unsigned i = 0; i < SuccCount; i++) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
524 BasicBlock* Succ = Term->getSuccessor(i); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
525 BBI = Succ->begin(); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
526 // Check phi nodes here because we only care about the operand |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
527 // coming in from this block. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
528 bool SeenDef = false; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
529 while (isa<PHINode>(BBI)) { |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
530 if (Def == cast<PHINode>(BBI)->getIncomingValueForBlock(B)) { |
|
1551
ed0feda76820
DOUT is deprecated, use DEBUG(errs()) instead
Benjamin Kramer <benny.kra@gmail.com>
parents:
1548
diff
changeset
|
531 DEBUG(errs() << "### Problematic phi user: " << *BBI); |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
532 return true; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
533 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
534 SeenDef |= (Def == &*BBI); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
535 ++BBI; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
536 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
537 // If none of the phis we just looked at were the definition, we |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
538 // haven't seen this block yet, and it's dominated by the def |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
539 // (meaning paths through it could lead to users), add the block and |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
540 // the first non-phi to the worklist. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
541 if (!SeenDef && Visited.insert(Succ) && DT.dominates(DefBlock, Succ)) |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
542 Worklist.push_back(StartPoint(Succ, BBI)); |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
543 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
544 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
545 // No users found in any block reachable from Alloc |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
546 // without going through the definition again. |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
547 return false; |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
548 } |
|
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
549 |
|
1285
91d9386d4a5a
Implement another D-specific pass: -dgc2stack
Frits van Bommel <fvbommel wxs.nl>
parents:
diff
changeset
|
550 |
|
1486
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
551 /// isSafeToStackAllocate - Return true if the GC call passed in is safe to turn |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
552 /// into a stack allocation. This requires that the return value does not |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
553 /// escape from the function and no derived pointers are live at the call site |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
554 /// (i.e. if it's in a loop then the function can't use any pointer returned |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
555 /// from an earlier call after a new call has been made) |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
556 /// |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
557 /// This is currently conservative where loops are involved: it can handle |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
558 /// simple loops, but returns false if any derived pointer is used in a |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
559 /// subsequent iteration. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
560 /// |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
561 /// Based on LLVM's PointerMayBeCaptured(), which only does escape analysis but |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
562 /// doesn't care about loops. |
|
1488
ca31a8e9c42b
Oops, I accidentally pushed r1486 before the last touches were committed.
Frits van Bommel <fvbommel wxs.nl>
parents:
1486
diff
changeset
|
563 bool isSafeToStackAllocate(Instruction* Alloc, DominatorTree& DT) { |
|
ca31a8e9c42b
Oops, I accidentally pushed r1486 before the last touches were committed.
Frits van Bommel <fvbommel wxs.nl>
parents:
1486
diff
changeset
|
564 assert(isa<PointerType>(Alloc->getType()) && "Allocation is not a pointer?"); |
|
1486
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
565 Value* V = Alloc; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
566 |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
567 SmallVector<Use*, 16> Worklist; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
568 SmallSet<Use*, 16> Visited; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
569 |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
570 for (Value::use_iterator UI = V->use_begin(), UE = V->use_end(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
571 UI != UE; ++UI) { |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
572 Use *U = &UI.getUse(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
573 Visited.insert(U); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
574 Worklist.push_back(U); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
575 } |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
576 |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
577 while (!Worklist.empty()) { |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
578 Use *U = Worklist.pop_back_val(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
579 Instruction *I = cast<Instruction>(U->getUser()); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
580 V = U->get(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
581 |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
582 switch (I->getOpcode()) { |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
583 case Instruction::Call: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
584 case Instruction::Invoke: { |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
585 CallSite CS = CallSite::get(I); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
586 // Not captured if the callee is readonly, doesn't return a copy through |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
587 // its return value and doesn't unwind (a readonly function can leak bits |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
588 // by throwing an exception or not depending on the input value). |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
589 if (CS.onlyReadsMemory() && CS.doesNotThrow() && |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
590 I->getType() == Type::VoidTy) |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
591 break; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
592 |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
593 // Not captured if only passed via 'nocapture' arguments. Note that |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
594 // calling a function pointer does not in itself cause the pointer to |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
595 // be captured. This is a subtle point considering that (for example) |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
596 // the callee might return its own address. It is analogous to saying |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
597 // that loading a value from a pointer does not cause the pointer to be |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
598 // captured, even though the loaded value might be the pointer itself |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
599 // (think of self-referential objects). |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
600 CallSite::arg_iterator B = CS.arg_begin(), E = CS.arg_end(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
601 for (CallSite::arg_iterator A = B; A != E; ++A) |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
602 if (A->get() == V && !CS.paramHasAttr(A - B + 1, Attribute::NoCapture)) |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
603 // The parameter is not marked 'nocapture' - captured. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
604 return false; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
605 // Only passed via 'nocapture' arguments, or is the called function - not |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
606 // captured. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
607 break; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
608 } |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
609 case Instruction::Free: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
610 // Freeing a pointer does not cause it to be captured. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
611 break; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
612 case Instruction::Load: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
613 // Loading from a pointer does not cause it to be captured. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
614 break; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
615 case Instruction::Store: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
616 if (V == I->getOperand(0)) |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
617 // Stored the pointer - it may be captured. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
618 return false; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
619 // Storing to the pointee does not cause the pointer to be captured. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
620 break; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
621 case Instruction::BitCast: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
622 case Instruction::GetElementPtr: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
623 case Instruction::PHI: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
624 case Instruction::Select: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
625 // It's not safe to stack-allocate if this derived pointer is live across |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
626 // the original allocation. |
|
1491
360a8e8eea51
Teach stack promotion to walk the CFG when a potential reuse of an allocation
Frits van Bommel <fvbommel wxs.nl>
parents:
1488
diff
changeset
|
627 if (mayBeUsedAfterRealloc(I, Alloc, DT)) |
|
1486
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
628 return false; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
629 |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
630 // The original value is not captured via this if the new value isn't. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
631 for (Instruction::use_iterator UI = I->use_begin(), UE = I->use_end(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
632 UI != UE; ++UI) { |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
633 Use *U = &UI.getUse(); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
634 if (Visited.insert(U)) |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
635 Worklist.push_back(U); |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
636 } |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
637 break; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
638 default: |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
639 // Something else - be conservative and say it is captured. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
640 return false; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
641 } |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
642 } |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
643 |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
644 // All uses examined - not captured or live across original allocation. |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
645 return true; |
|
9ed0695cb93c
Teach `-dgc2stack` to promote GC allocations in simple loops to stack
Frits van Bommel <fvbommel wxs.nl>
parents:
1438
diff
changeset
|
646 } |
|
1558
3adcb70700cb
Added back option to disable metadata generation and users. Set USE_METADATA to OFF in ccmake.
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1555
diff
changeset
|
647 |
|
3adcb70700cb
Added back option to disable metadata generation and users. Set USE_METADATA to OFF in ccmake.
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1555
diff
changeset
|
648 #endif // USE_METADATA |