Lines Matching refs:Result
128 std::string Result;
135 if (i) Result += ':';
136 Result += VTName;
140 return Result;
141 return "{" + Result + "}";
659 std::string Result =
661 return Result + ImmCode;
673 std::string Result;
675 Result = " SDNode *N = Node;\n";
677 Result = " " + ClassName + "*N = cast<" + ClassName + ">(Node);\n";
679 return Result + getPredCode();
808 /// N, and the result number in ResNo.
838 unsigned ResNo = 0; // The result number being referenced.
975 "We only work with nodes with zero or one result so far!");
976 assert(ResNo == 0 && "Only handles single result nodes so far");
979 // Make sure that this applies to the correct node result.
1023 // Get the result tree.
1247 assert(ResNo == 0 && "Regoperand ref only has one result!");
1257 assert(ResNo == 0 && "Regclass ref only has one result!");
1271 assert(ResNo == 0 && "Registers only produce one result!");
1279 assert(ResNo == 0 && "SubRegisterIndices only produce one result!");
1284 assert(ResNo == 0 && "This node only has one result!");
1297 assert(ResNo == 0 && "Regclass can only have one result!");
1481 // Apply the result type to the node.
1528 // Apply the result types to the node, these come from the things in the
1530 // FIXME: Cap at one result so far.
1553 // If the instruction has implicit defs, we apply the first one as a result.
1868 TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults);
1869 Result->setName(OpName);
1872 assert(Result->getName().empty());
1873 Result->setName(Dag->getName());
1875 return Result;
1958 "FIXME: cannot name multiple result nodes yet");
1970 "FIXME: cannot name multiple result nodes yet");
2171 // If debugging, print out the pattern fragment result.
2535 // result, as we have no detailed info.
2548 // Assume the first operand is the result.
2675 // Construct the result for the dest-pattern operand list.
2678 // No predicate is useful on the result.
2699 // Copy fully inferred output node type to instruction result pattern.
2709 // constructed result is correct. This depends on the instruction already
2834 /// Given a pattern result with an unresolved type, see if we can find one
2835 /// instruction with an unresolved result type. Force this result type to an
2878 TreePattern *Result = new TreePattern(CurPattern, LI, false, *this);
2881 Result->InlinePatternFragments();
2883 if (Result->getNumTrees() != 1)
2884 Result->error("Cannot handle instructions producing instructions "
2898 Result->InferAllTypes(&Pattern->getNamedNodesMap());
2902 // Apply the type of the result to the source pattern. This helps us
2904 // is considered resolved), but the result knows it needs to be 32- or
2906 for (unsigned i = 0, e = std::min(Result->getTree(0)->getNumTypes(),
2910 UpdateNodeType(i, Result->getTree(0)->getExtType(i), *Result);
2911 IterateInference |= Result->getTree(0)->
2912 UpdateNodeType(i, Pattern->getTree(0)->getExtType(i), *Result);
2916 // resolved but the result pattern is not fully resolved, we may have a
2917 // situation where we have two instructions in the result pattern and
2923 // arbitrary types to the result pattern's nodes.
2926 IterateInference = ForceArbitraryInstResultType(Result->getTree(0),
2927 *Result);
2931 // pattern and result. If these fire the user has to add type casts.
2936 Result->error("Could not infer all types in pattern result!");
2949 TreePatternNode *DstPattern = Result->getOnlyTree();
2961 DstPattern = Result->getOnlyTree();
2967 for (unsigned i = 0, e = Result->getOnlyTree()->getNumTypes(); i != e; ++i)
2968 DstPattern->setType(i, Result->getOnlyTree()->getExtType(i));
2970 TreePattern Temp(Result->getRecord(), DstPattern, false, *this);
2996 // The end result is an all-pairs construction of the resultant pattern.
3148 // Combine those into the result: (x op x) op x
3156 // Combine those into the result: x op (x op x)
