mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 02:52:53 +02:00
728c2ac3b1
Summary: GIMatchTree's job is to build a decision tree by zipping all the GIMatchDag's together. Each DAG is added to the tree builder as a leaf and partitioners are used to subdivide each node until there are no more partitioners to apply. At this point, the code generator is responsible for testing any untested predicates and following any unvisited traversals (there shouldn't be any of the latter as the getVRegDef partitioner handles them all). Note that the leaves don't always fit into partitions cleanly and the partitions may overlap as a result. This is resolved by cloning the leaf into every partition it belongs to. One example of this is a rule that can match one of N opcodes. The leaf for this rule would end up in N partitions when processed by the opcode partitioner. A similar example is the getVRegDef partitioner where having rules (add $a, $b), and (add ($a, $b), $c) will result in the former being in the partition for successfully following the vreg-def and failing to do so as it doesn't care which happens. Depends on D69151 Fixed the issues with the windows bots which were caused by stdout/stderr interleaving. Reviewers: bogner, volkan Reviewed By: volkan Subscribers: lkail, mgorny, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D69152
71 lines
2.4 KiB
C++
71 lines
2.4 KiB
C++
//===- GIMatchDagEdge.h - Represent a shared operand list for nodes -------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_UTILS_TABLEGEN_GIMATCHDAGEDGE_H
|
|
#define LLVM_UTILS_TABLEGEN_GIMATCHDAGEDGE_H
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
|
|
namespace llvm {
|
|
class raw_ostream;
|
|
class GIMatchDagInstr;
|
|
class GIMatchDagOperand;
|
|
|
|
/// Represents an edge that connects two instructions together via a pair of
|
|
/// operands. For example:
|
|
/// %a = FOO ...
|
|
/// %0 = BAR %a
|
|
/// %1 = BAZ %a
|
|
/// would have two edges for %a like so:
|
|
/// BAR:Op#1 --[a]----> Op#0:FOO
|
|
/// ^
|
|
/// BAZ:Op#1 --[a]------/
|
|
/// Ideally, all edges in the DAG are from a use to a def as this is a many
|
|
/// to one edge but edges from defs to uses are supported too.
|
|
class GIMatchDagEdge {
|
|
/// The name of the edge. For example,
|
|
/// (FOO $a, $b, $c)
|
|
/// (BAR $d, $e, $a)
|
|
/// will create an edge named 'a' to connect FOO to BAR. Although the name
|
|
/// refers to the edge, the canonical value of 'a' is the operand that defines
|
|
/// it.
|
|
StringRef Name;
|
|
const GIMatchDagInstr *FromMI;
|
|
const GIMatchDagOperand *FromMO;
|
|
const GIMatchDagInstr *ToMI;
|
|
const GIMatchDagOperand *ToMO;
|
|
|
|
public:
|
|
GIMatchDagEdge(StringRef Name, const GIMatchDagInstr *FromMI, const GIMatchDagOperand *FromMO,
|
|
const GIMatchDagInstr *ToMI, const GIMatchDagOperand *ToMO)
|
|
: Name(Name), FromMI(FromMI), FromMO(FromMO), ToMI(ToMI), ToMO(ToMO) {}
|
|
|
|
StringRef getName() const { return Name; }
|
|
const GIMatchDagInstr *getFromMI() const { return FromMI; }
|
|
const GIMatchDagOperand *getFromMO() const { return FromMO; }
|
|
const GIMatchDagInstr *getToMI() const { return ToMI; }
|
|
const GIMatchDagOperand *getToMO() const { return ToMO; }
|
|
|
|
/// Flip the direction of the edge.
|
|
void reverse();
|
|
|
|
/// Does this edge run from a def to (one of many) uses?
|
|
bool isDefToUse() const;
|
|
|
|
LLVM_DUMP_METHOD void print(raw_ostream &OS) const;
|
|
|
|
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
|
LLVM_DUMP_METHOD void dump() const;
|
|
#endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
|
};
|
|
|
|
raw_ostream &operator<<(raw_ostream &OS, const GIMatchDagEdge &E);
|
|
|
|
} // end namespace llvm
|
|
#endif // ifndef LLVM_UTILS_TABLEGEN_GIMATCHDAGEDGE_H
|