Lines Matching defs:Result
131 std::string Result;
138 if (i) Result += ':';
139 Result += VTName;
143 return Result;
144 return "{" + Result + "}";
662 std::string Result =
664 return Result + ImmCode;
676 std::string Result;
678 Result = " SDNode *N = Node;\n";
680 Result = " " + ClassName + "*N = cast<" + ClassName + ">(Node);\n";
682 return Result + getPredCode();
811 /// N, and the result number in ResNo.
841 unsigned ResNo = 0; // The result number being referenced.
977 "We only work with nodes with zero or one result so far!");
978 assert(ResNo == 0 && "Only handles single result nodes so far");
981 // Make sure that this applies to the correct node result.
1025 // Get the result tree.
1249 assert(ResNo == 0 && "Regoperand ref only has one result!");
1259 assert(ResNo == 0 && "Regclass ref only has one result!");
1273 assert(ResNo == 0 && "Registers only produce one result!");
1281 assert(ResNo == 0 && "SubRegisterIndices only produce one result!");
1286 assert(ResNo == 0 && "This node only has one result!");
1299 assert(ResNo == 0 && "Regclass can only have one result!");
1477 // Apply the result type to the node.
1524 // Apply the result types to the node, these come from the things in the
1526 // FIXME: Cap at one result so far.
1549 // If the instruction has implicit defs, we apply the first one as a result.
1863 TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults);
1864 Result->setName(OpName);
1867 assert(Result->getName().empty());
1868 Result->setName(Dag->getName());
1870 return Result;
1953 "FIXME: cannot name multiple result nodes yet");
1965 "FIXME: cannot name multiple result nodes yet");
2169 // If debugging, print out the pattern fragment result.
2564 // result, as we have no detailed info. A pattern which references the
2580 // Assume the first operand is the result.
2705 // Construct the result for the dest-pattern operand list.
2708 // No predicate is useful on the result.
2729 // Copy fully inferred output node type to instruction result pattern.
2739 // constructed result is correct. This depends on the instruction already
3001 /// Given a pattern result with an unresolved type, see if we can find one
3002 /// instruction with an unresolved result type. Force this result type to an
3050 TreePattern *Result = new TreePattern(CurPattern, LI, false, *this);
3053 Result->InlinePatternFragments();
3055 if (Result->getNumTrees() != 1)
3056 Result->error("Cannot handle instructions producing instructions "
3070 Result->InferAllTypes(&Pattern->getNamedNodesMap());
3074 // Apply the type of the result to the source pattern. This helps us
3076 // is considered resolved), but the result knows it needs to be 32- or
3078 for (unsigned i = 0, e = std::min(Result->getTree(0)->getNumTypes(),
3082 UpdateNodeType(i, Result->getTree(0)->getExtType(i), *Result);
3083 IterateInference |= Result->getTree(0)->
3084 UpdateNodeType(i, Pattern->getTree(0)->getExtType(i), *Result);
3088 // resolved but the result pattern is not fully resolved, we may have a
3089 // situation where we have two instructions in the result pattern and
3095 // arbitrary types to the result pattern's nodes.
3098 IterateInference = ForceArbitraryInstResultType(Result->getTree(0),
3099 *Result);
3103 // pattern and result. If these fire the user has to add type casts.
3108 Resultresult!");
3121 TreePatternNode *DstPattern = Result->getOnlyTree();
3133 DstPattern = Result->getOnlyTree();
3139 for (unsigned i = 0, e = Result->getOnlyTree()->getNumTypes(); i != e; ++i)
3140 DstPattern->setType(i, Result->getOnlyTree()->getExtType(i));
3142 TreePattern Temp(Result->getRecord(), DstPattern, false, *this);
3168 // The end result is an all-pairs construction of the resultant pattern.
3320 // Combine those into the result: (x op x) op x
3328 // Combine those into the result: x op (x op x)
