blob: a625fa85d40cf6283a27b09b6a790b375b3a81f2 [file] [log] [blame]
Chris Lattner91c6a822010-02-24 07:06:50 +00001//===- DAGISelMatcherOpt.cpp - Optimize a DAG Matcher ---------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the DAG Matcher optimizer.
11//
12//===----------------------------------------------------------------------===//
13
Chris Lattner82781b92010-02-27 07:49:13 +000014#define DEBUG_TYPE "isel-opt"
Chris Lattner91c6a822010-02-24 07:06:50 +000015#include "DAGISelMatcher.h"
Chris Lattnerc78f2a32010-02-28 20:49:53 +000016#include "CodeGenDAGPatterns.h"
Chris Lattner04db82d2010-02-25 07:45:24 +000017#include "llvm/ADT/DenseMap.h"
Chris Lattnereb669212010-03-01 06:59:22 +000018#include "llvm/ADT/StringSet.h"
Chris Lattner82781b92010-02-27 07:49:13 +000019#include "llvm/Support/Debug.h"
20#include "llvm/Support/raw_ostream.h"
Chris Lattner04db82d2010-02-25 07:45:24 +000021#include <vector>
Chris Lattner91c6a822010-02-24 07:06:50 +000022using namespace llvm;
23
Chris Lattnerd323fd42010-02-27 06:22:57 +000024/// ContractNodes - Turn multiple matcher node patterns like 'MoveChild+Record'
25/// into single compound nodes like RecordChild.
Chris Lattnerc78f2a32010-02-28 20:49:53 +000026static void ContractNodes(OwningPtr<Matcher> &MatcherPtr,
27 const CodeGenDAGPatterns &CGP) {
Chris Lattner19b5a752010-02-24 07:31:45 +000028 // If we reached the end of the chain, we're done.
Chris Lattnerb21ba712010-02-25 02:04:40 +000029 Matcher *N = MatcherPtr.get();
Chris Lattner19b5a752010-02-24 07:31:45 +000030 if (N == 0) return;
31
Chris Lattnerd6c84722010-02-25 19:00:39 +000032 // If we have a scope node, walk down all of the children.
33 if (ScopeMatcher *Scope = dyn_cast<ScopeMatcher>(N)) {
34 for (unsigned i = 0, e = Scope->getNumChildren(); i != e; ++i) {
35 OwningPtr<Matcher> Child(Scope->takeChild(i));
Chris Lattnerc78f2a32010-02-28 20:49:53 +000036 ContractNodes(Child, CGP);
Chris Lattnerd6c84722010-02-25 19:00:39 +000037 Scope->resetChild(i, Child.take());
38 }
39 return;
40 }
Chris Lattner19b5a752010-02-24 07:31:45 +000041
Chris Lattner22c48b32010-02-24 19:52:48 +000042 // If we found a movechild node with a node that comes in a 'foochild' form,
43 // transform it.
Chris Lattnerb21ba712010-02-25 02:04:40 +000044 if (MoveChildMatcher *MC = dyn_cast<MoveChildMatcher>(N)) {
45 Matcher *New = 0;
46 if (RecordMatcher *RM = dyn_cast<RecordMatcher>(MC->getNext()))
Chris Lattner0cebe612010-03-01 02:24:17 +000047 New = new RecordChildMatcher(MC->getChildNo(), RM->getWhatFor(),
48 RM->getResultNo());
Chris Lattner23cfda72010-02-24 20:15:25 +000049
Chris Lattnerb21ba712010-02-25 02:04:40 +000050 if (CheckTypeMatcher *CT= dyn_cast<CheckTypeMatcher>(MC->getNext()))
51 New = new CheckChildTypeMatcher(MC->getChildNo(), CT->getType());
Chris Lattner23cfda72010-02-24 20:15:25 +000052
53 if (New) {
54 // Insert the new node.
Chris Lattner60df53e2010-02-25 01:56:48 +000055 New->setNext(MatcherPtr.take());
56 MatcherPtr.reset(New);
Chris Lattner23cfda72010-02-24 20:15:25 +000057 // Remove the old one.
58 MC->setNext(MC->getNext()->takeNext());
Chris Lattnerc78f2a32010-02-28 20:49:53 +000059 return ContractNodes(MatcherPtr, CGP);
Chris Lattner22c48b32010-02-24 19:52:48 +000060 }
Chris Lattner19b5a752010-02-24 07:31:45 +000061 }
Chris Lattner22c48b32010-02-24 19:52:48 +000062
Chris Lattnere86097a2010-02-28 02:31:26 +000063 // Zap movechild -> moveparent.
Chris Lattnerb21ba712010-02-25 02:04:40 +000064 if (MoveChildMatcher *MC = dyn_cast<MoveChildMatcher>(N))
65 if (MoveParentMatcher *MP =
66 dyn_cast<MoveParentMatcher>(MC->getNext())) {
Chris Lattner60df53e2010-02-25 01:56:48 +000067 MatcherPtr.reset(MP->takeNext());
Chris Lattnerc78f2a32010-02-28 20:49:53 +000068 return ContractNodes(MatcherPtr, CGP);
Chris Lattner22c48b32010-02-24 19:52:48 +000069 }
Chris Lattnerccd23cc2010-02-28 23:00:47 +000070
Chris Lattnerc99b5a22010-03-01 02:33:14 +000071 // Turn EmitNode->MarkFlagResults->CompleteMatch into
72 // MarkFlagResults->EmitNode->CompleteMatch when we can to encourage
73 // MorphNodeTo formation. This is safe because MarkFlagResults never refers
74 // to the root of the pattern.
75 if (isa<EmitNodeMatcher>(N) && isa<MarkFlagResultsMatcher>(N->getNext()) &&
76 isa<CompleteMatchMatcher>(N->getNext()->getNext())) {
77 // Unlink the two nodes from the list.
78 Matcher *EmitNode = MatcherPtr.take();
79 Matcher *MFR = EmitNode->takeNext();
80 Matcher *Tail = MFR->takeNext();
81
82 // Relink them.
83 MatcherPtr.reset(MFR);
84 MFR->setNext(EmitNode);
85 EmitNode->setNext(Tail);
86 return ContractNodes(MatcherPtr, CGP);
87 }
Chris Lattnerccd23cc2010-02-28 23:00:47 +000088
Chris Lattner9a215002010-02-28 20:55:18 +000089 // Turn EmitNode->CompleteMatch into MorphNodeTo if we can.
Chris Lattnere86097a2010-02-28 02:31:26 +000090 if (EmitNodeMatcher *EN = dyn_cast<EmitNodeMatcher>(N))
Chris Lattner6281cda2010-02-28 02:41:25 +000091 if (CompleteMatchMatcher *CM =
92 dyn_cast<CompleteMatchMatcher>(EN->getNext())) {
Chris Lattner9a215002010-02-28 20:55:18 +000093 // We can only use MorphNodeTo if the result values match up.
Chris Lattnerc78f2a32010-02-28 20:49:53 +000094 unsigned RootResultFirst = EN->getFirstResultSlot();
95 bool ResultsMatch = true;
96 for (unsigned i = 0, e = CM->getNumResults(); i != e; ++i)
97 if (CM->getResult(i) != RootResultFirst+i)
98 ResultsMatch = false;
99
100 // If the selected node defines a subset of the flag/chain results, we
Chris Lattner9a215002010-02-28 20:55:18 +0000101 // can't use MorphNodeTo. For example, we can't use MorphNodeTo if the
Chris Lattnerc78f2a32010-02-28 20:49:53 +0000102 // matched pattern has a chain but the root node doesn't.
103 const PatternToMatch &Pattern = CM->getPattern();
104
105 if (!EN->hasChain() &&
106 Pattern.getSrcPattern()->NodeHasProperty(SDNPHasChain, CGP))
107 ResultsMatch = false;
108
109 // If the matched node has a flag and the output root doesn't, we can't
Chris Lattner9a215002010-02-28 20:55:18 +0000110 // use MorphNodeTo.
Chris Lattnerc78f2a32010-02-28 20:49:53 +0000111 //
112 // NOTE: Strictly speaking, we don't have to check for the flag here
113 // because the code in the pattern generator doesn't handle it right. We
114 // do it anyway for thoroughness.
Chris Lattnerff7fb602010-02-28 21:53:42 +0000115 if (!EN->hasOutFlag() &&
Chris Lattnerc78f2a32010-02-28 20:49:53 +0000116 Pattern.getSrcPattern()->NodeHasProperty(SDNPOutFlag, CGP))
117 ResultsMatch = false;
118
119
120 // If the root result node defines more results than the source root node
121 // *and* has a chain or flag input, then we can't match it because it
122 // would end up replacing the extra result with the chain/flag.
123#if 0
124 if ((EN->hasFlag() || EN->hasChain()) &&
125 EN->getNumNonChainFlagVTs() > ... need to get no results reliably ...)
126 ResultMatch = false;
127#endif
128
129 if (ResultsMatch) {
130 const SmallVectorImpl<MVT::SimpleValueType> &VTs = EN->getVTList();
131 const SmallVectorImpl<unsigned> &Operands = EN->getOperandList();
Chris Lattner9a215002010-02-28 20:55:18 +0000132 MatcherPtr.reset(new MorphNodeToMatcher(EN->getOpcodeName(),
Chris Lattnerff7fb602010-02-28 21:53:42 +0000133 VTs.data(), VTs.size(),
Chris Lattner9a215002010-02-28 20:55:18 +0000134 Operands.data(),Operands.size(),
Chris Lattnerff7fb602010-02-28 21:53:42 +0000135 EN->hasChain(), EN->hasInFlag(),
136 EN->hasOutFlag(),
Chris Lattner9a215002010-02-28 20:55:18 +0000137 EN->hasMemRefs(),
138 EN->getNumFixedArityOperands(),
139 Pattern));
Chris Lattnerc78f2a32010-02-28 20:49:53 +0000140 return;
141 }
142
Chris Lattner405f1252010-03-01 22:29:19 +0000143 // FIXME2: Kill off all the SelectionDAG::SelectNodeTo and getMachineNode
Chris Lattner9a215002010-02-28 20:55:18 +0000144 // variants.
Chris Lattnere86097a2010-02-28 02:31:26 +0000145 }
146
Chris Lattnerc78f2a32010-02-28 20:49:53 +0000147 ContractNodes(N->getNextPtr(), CGP);
Chris Lattnere9eeda82010-03-01 02:15:34 +0000148
149
150 // If we have a CheckType/CheckChildType/Record node followed by a
151 // CheckOpcode, invert the two nodes. We prefer to do structural checks
152 // before type checks, as this opens opportunities for factoring on targets
153 // like X86 where many operations are valid on multiple types.
154 if ((isa<CheckTypeMatcher>(N) || isa<CheckChildTypeMatcher>(N) ||
155 isa<RecordMatcher>(N)) &&
Chris Lattnerfa342fa2010-03-01 07:17:40 +0000156 isa<CheckOpcodeMatcher>(N->getNext())) {
Chris Lattnere9eeda82010-03-01 02:15:34 +0000157 // Unlink the two nodes from the list.
158 Matcher *CheckType = MatcherPtr.take();
159 Matcher *CheckOpcode = CheckType->takeNext();
160 Matcher *Tail = CheckOpcode->takeNext();
161
162 // Relink them.
163 MatcherPtr.reset(CheckOpcode);
164 CheckOpcode->setNext(CheckType);
165 CheckType->setNext(Tail);
166 return ContractNodes(MatcherPtr, CGP);
167 }
Chris Lattner19b5a752010-02-24 07:31:45 +0000168}
169
Chris Lattnerd323fd42010-02-27 06:22:57 +0000170/// SinkPatternPredicates - Pattern predicates can be checked at any level of
171/// the matching tree. The generator dumps them at the top level of the pattern
172/// though, which prevents factoring from being able to see past them. This
173/// optimization sinks them as far down into the pattern as possible.
174///
175/// Conceptually, we'd like to sink these predicates all the way to the last
176/// matcher predicate in the series. However, it turns out that some
177/// ComplexPatterns have side effects on the graph, so we really don't want to
178/// run a the complex pattern if the pattern predicate will fail. For this
179/// reason, we refuse to sink the pattern predicate past a ComplexPattern.
180///
181static void SinkPatternPredicates(OwningPtr<Matcher> &MatcherPtr) {
182 // Recursively scan for a PatternPredicate.
183 // If we reached the end of the chain, we're done.
184 Matcher *N = MatcherPtr.get();
185 if (N == 0) return;
186
187 // Walk down all members of a scope node.
188 if (ScopeMatcher *Scope = dyn_cast<ScopeMatcher>(N)) {
189 for (unsigned i = 0, e = Scope->getNumChildren(); i != e; ++i) {
190 OwningPtr<Matcher> Child(Scope->takeChild(i));
191 SinkPatternPredicates(Child);
192 Scope->resetChild(i, Child.take());
193 }
194 return;
195 }
196
197 // If this node isn't a CheckPatternPredicateMatcher we keep scanning until
198 // we find one.
199 CheckPatternPredicateMatcher *CPPM =dyn_cast<CheckPatternPredicateMatcher>(N);
200 if (CPPM == 0)
201 return SinkPatternPredicates(N->getNextPtr());
202
203 // Ok, we found one, lets try to sink it. Check if we can sink it past the
204 // next node in the chain. If not, we won't be able to change anything and
205 // might as well bail.
206 if (!CPPM->getNext()->isSafeToReorderWithPatternPredicate())
207 return;
208
209 // Okay, we know we can sink it past at least one node. Unlink it from the
210 // chain and scan for the new insertion point.
211 MatcherPtr.take(); // Don't delete CPPM.
212 MatcherPtr.reset(CPPM->takeNext());
213
214 N = MatcherPtr.get();
215 while (N->getNext()->isSafeToReorderWithPatternPredicate())
216 N = N->getNext();
217
218 // At this point, we want to insert CPPM after N.
219 CPPM->setNext(N->takeNext());
220 N->setNext(CPPM);
221}
222
223/// FactorNodes - Turn matches like this:
224/// Scope
225/// OPC_CheckType i32
226/// ABC
227/// OPC_CheckType i32
228/// XYZ
229/// into:
230/// OPC_CheckType i32
231/// Scope
232/// ABC
233/// XYZ
234///
Chris Lattnerb21ba712010-02-25 02:04:40 +0000235static void FactorNodes(OwningPtr<Matcher> &MatcherPtr) {
Chris Lattner06158402010-02-25 01:57:41 +0000236 // If we reached the end of the chain, we're done.
Chris Lattnerb21ba712010-02-25 02:04:40 +0000237 Matcher *N = MatcherPtr.get();
Chris Lattner06158402010-02-25 01:57:41 +0000238 if (N == 0) return;
239
240 // If this is not a push node, just scan for one.
Chris Lattnerd6c84722010-02-25 19:00:39 +0000241 ScopeMatcher *Scope = dyn_cast<ScopeMatcher>(N);
242 if (Scope == 0)
Chris Lattner06158402010-02-25 01:57:41 +0000243 return FactorNodes(N->getNextPtr());
244
Chris Lattnerd6c84722010-02-25 19:00:39 +0000245 // Okay, pull together the children of the scope node into a vector so we can
Chris Lattner04db82d2010-02-25 07:45:24 +0000246 // inspect it more easily. While we're at it, bucket them up by the hash
247 // code of their first predicate.
Chris Lattnerb21ba712010-02-25 02:04:40 +0000248 SmallVector<Matcher*, 32> OptionsToMatch;
Chris Lattner06158402010-02-25 01:57:41 +0000249
Chris Lattnerd6c84722010-02-25 19:00:39 +0000250 for (unsigned i = 0, e = Scope->getNumChildren(); i != e; ++i) {
Chris Lattner04db82d2010-02-25 07:45:24 +0000251 // Factor the subexpression.
Chris Lattnerd6c84722010-02-25 19:00:39 +0000252 OwningPtr<Matcher> Child(Scope->takeChild(i));
253 FactorNodes(Child);
254
Chris Lattnerd6f06022010-02-26 08:08:41 +0000255 if (Matcher *N = Child.take())
Chris Lattnerd6c84722010-02-25 19:00:39 +0000256 OptionsToMatch.push_back(N);
Chris Lattner04db82d2010-02-25 07:45:24 +0000257 }
Chris Lattner06158402010-02-25 01:57:41 +0000258
Chris Lattner04db82d2010-02-25 07:45:24 +0000259 SmallVector<Matcher*, 32> NewOptionsToMatch;
Chris Lattnereb669212010-03-01 06:59:22 +0000260
Chris Lattnerd6f06022010-02-26 08:08:41 +0000261 // Loop over options to match, merging neighboring patterns with identical
262 // starting nodes into a shared matcher.
Chris Lattner82781b92010-02-27 07:49:13 +0000263 for (unsigned OptionIdx = 0, e = OptionsToMatch.size(); OptionIdx != e;) {
Chris Lattner04db82d2010-02-25 07:45:24 +0000264 // Find the set of matchers that start with this node.
Chris Lattner82781b92010-02-27 07:49:13 +0000265 Matcher *Optn = OptionsToMatch[OptionIdx++];
266
267 if (OptionIdx == e) {
Chris Lattner04db82d2010-02-25 07:45:24 +0000268 NewOptionsToMatch.push_back(Optn);
269 continue;
270 }
271
Chris Lattner82781b92010-02-27 07:49:13 +0000272 // See if the next option starts with the same matcher. If the two
273 // neighbors *do* start with the same matcher, we can factor the matcher out
274 // of at least these two patterns. See what the maximal set we can merge
275 // together is.
Chris Lattnerd6f06022010-02-26 08:08:41 +0000276 SmallVector<Matcher*, 8> EqualMatchers;
277 EqualMatchers.push_back(Optn);
Chris Lattnerd6f06022010-02-26 08:08:41 +0000278
Chris Lattner82781b92010-02-27 07:49:13 +0000279 // Factor all of the known-equal matchers after this one into the same
280 // group.
281 while (OptionIdx != e && OptionsToMatch[OptionIdx]->isEqual(Optn))
282 EqualMatchers.push_back(OptionsToMatch[OptionIdx++]);
283
284 // If we found a non-equal matcher, see if it is contradictory with the
285 // current node. If so, we know that the ordering relation between the
286 // current sets of nodes and this node don't matter. Look past it to see if
287 // we can merge anything else into this matching group.
288 unsigned Scan = OptionIdx;
289 while (1) {
290 while (Scan != e && Optn->isContradictory(OptionsToMatch[Scan]))
291 ++Scan;
292
293 // Ok, we found something that isn't known to be contradictory. If it is
294 // equal, we can merge it into the set of nodes to factor, if not, we have
295 // to cease factoring.
296 if (Scan == e || !Optn->isEqual(OptionsToMatch[Scan])) break;
297
298 // If is equal after all, add the option to EqualMatchers and remove it
299 // from OptionsToMatch.
300 EqualMatchers.push_back(OptionsToMatch[Scan]);
301 OptionsToMatch.erase(OptionsToMatch.begin()+Scan);
302 --e;
303 }
304
Chris Lattnera230f962010-02-27 21:48:43 +0000305 if (Scan != e &&
306 // Don't print it's obvious nothing extra could be merged anyway.
307 Scan+1 != e) {
Chris Lattner24789622010-02-27 08:11:15 +0000308 DEBUG(errs() << "Couldn't merge this:\n";
309 Optn->print(errs(), 4);
310 errs() << "into this:\n";
311 OptionsToMatch[Scan]->print(errs(), 4);
Chris Lattnerdb8b6222010-02-27 08:13:23 +0000312 if (Scan+1 != e)
Chris Lattner24789622010-02-27 08:11:15 +0000313 OptionsToMatch[Scan+1]->printOne(errs());
Chris Lattnerdb8b6222010-02-27 08:13:23 +0000314 if (Scan+2 < e)
Chris Lattner24789622010-02-27 08:11:15 +0000315 OptionsToMatch[Scan+2]->printOne(errs());
Chris Lattner82781b92010-02-27 07:49:13 +0000316 errs() << "\n");
317 }
318
319 // If we only found one option starting with this matcher, no factoring is
320 // possible.
321 if (EqualMatchers.size() == 1) {
322 NewOptionsToMatch.push_back(EqualMatchers[0]);
323 continue;
324 }
Chris Lattnerd6f06022010-02-26 08:08:41 +0000325
Chris Lattner04db82d2010-02-25 07:45:24 +0000326 // Factor these checks by pulling the first node off each entry and
Chris Lattnerd4397b92010-02-26 07:36:37 +0000327 // discarding it. Take the first one off the first entry to reuse.
328 Matcher *Shared = Optn;
329 Optn = Optn->takeNext();
330 EqualMatchers[0] = Optn;
331
Chris Lattnerd6f06022010-02-26 08:08:41 +0000332 // Remove and delete the first node from the other matchers we're factoring.
333 for (unsigned i = 1, e = EqualMatchers.size(); i != e; ++i) {
334 Matcher *Tmp = EqualMatchers[i]->takeNext();
335 delete EqualMatchers[i];
336 EqualMatchers[i] = Tmp;
337 }
Chris Lattner04db82d2010-02-25 07:45:24 +0000338
Chris Lattnerd4397b92010-02-26 07:36:37 +0000339 Shared->setNext(new ScopeMatcher(&EqualMatchers[0], EqualMatchers.size()));
340
341 // Recursively factor the newly created node.
342 FactorNodes(Shared->getNextPtr());
343
344 NewOptionsToMatch.push_back(Shared);
Chris Lattner04db82d2010-02-25 07:45:24 +0000345 }
Chris Lattnereb669212010-03-01 06:59:22 +0000346
347 // If we're down to a single pattern to match, then we don't need this scope
348 // anymore.
349 if (NewOptionsToMatch.size() == 1) {
350 MatcherPtr.reset(NewOptionsToMatch[0]);
351 return;
352 }
353
Chris Lattnerf94bc542010-03-01 22:04:33 +0000354 if (NewOptionsToMatch.empty()) {
355 MatcherPtr.reset(0);
356 return;
357 }
358
Chris Lattnereb669212010-03-01 06:59:22 +0000359 // If our factoring failed (didn't achieve anything) see if we can simplify in
360 // other ways.
361
362 // Check to see if all of the leading entries are now opcode checks. If so,
363 // we can convert this Scope to be a OpcodeSwitch instead.
364 bool AllOpcodeChecks = true;
365 for (unsigned i = 0, e = NewOptionsToMatch.size(); i != e; ++i) {
366 if (isa<CheckOpcodeMatcher>(NewOptionsToMatch[i])) continue;
367
368#if 0
369 if (i > 3) {
370 errs() << "FAILING OPC #" << i << "\n";
371 NewOptionsToMatch[i]->dump();
372 }
373#endif
374
375 AllOpcodeChecks = false;
376 break;
377 }
378
379 // If all the options are CheckOpcode's, we can form the SwitchOpcode, woot.
380 if (AllOpcodeChecks) {
381 StringSet<> Opcodes;
382 SmallVector<std::pair<const SDNodeInfo*, Matcher*>, 8> Cases;
383 for (unsigned i = 0, e = NewOptionsToMatch.size(); i != e; ++i) {
384 CheckOpcodeMatcher *COM =cast<CheckOpcodeMatcher>(NewOptionsToMatch[i]);
385 assert(Opcodes.insert(COM->getOpcode().getEnumName()) &&
386 "Duplicate opcodes not factored?");
387 Cases.push_back(std::make_pair(&COM->getOpcode(), COM->getNext()));
388 }
389
390 MatcherPtr.reset(new SwitchOpcodeMatcher(&Cases[0], Cases.size()));
391 return;
392 }
393
Chris Lattner04db82d2010-02-25 07:45:24 +0000394
Chris Lattner7c720fc2010-03-01 22:19:47 +0000395 // Reassemble the Scope node with the adjusted children.
396 Scope->setNumChildren(NewOptionsToMatch.size());
397 for (unsigned i = 0, e = NewOptionsToMatch.size(); i != e; ++i)
398 Scope->resetChild(i, NewOptionsToMatch[i]);
Chris Lattner06158402010-02-25 01:57:41 +0000399}
400
Chris Lattnerc78f2a32010-02-28 20:49:53 +0000401Matcher *llvm::OptimizeMatcher(Matcher *TheMatcher,
402 const CodeGenDAGPatterns &CGP) {
Chris Lattnerb21ba712010-02-25 02:04:40 +0000403 OwningPtr<Matcher> MatcherPtr(TheMatcher);
Chris Lattnerc78f2a32010-02-28 20:49:53 +0000404 ContractNodes(MatcherPtr, CGP);
Chris Lattnerd323fd42010-02-27 06:22:57 +0000405 SinkPatternPredicates(MatcherPtr);
Chris Lattner06158402010-02-25 01:57:41 +0000406 FactorNodes(MatcherPtr);
Chris Lattner19b5a752010-02-24 07:31:45 +0000407 return MatcherPtr.take();
Chris Lattner91c6a822010-02-24 07:06:50 +0000408}