llvm/llvm/utils/TableGen/FastISelEmitter.cpp

///===- FastISelEmitter.cpp - Generate an instruction selector ------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This tablegen backend emits code for use by the "fast" instruction
// selection algorithm. See the comments at the top of
// lib/CodeGen/SelectionDAG/FastISel.cpp for background.
//
// This file scans through the target's tablegen instruction-info files
// and extracts instructions with obvious-looking patterns, and it emits
// code to look up these instructions by type and operator.
//
//===----------------------------------------------------------------------===//

#include "Common/CodeGenDAGPatterns.h"
#include "Common/CodeGenInstruction.h"
#include "Common/CodeGenRegisters.h"
#include "Common/CodeGenTarget.h"
#include "Common/InfoByHwMode.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
#include "llvm/TableGen/TableGenBackend.h"
#include <set>
#include <utility>
usingnamespacellvm;

/// InstructionMemo - This class holds additional information about an
/// instruction needed to emit code for it.
///
namespace {
struct InstructionMemo { … };
} // End anonymous namespace

/// ImmPredicateSet - This uniques predicates (represented as a string) and
/// gives them unique (small) integer ID's that start at 0.
namespace {
class ImmPredicateSet { … };
} // End anonymous namespace

/// OperandsSignature - This class holds a description of a list of operand
/// types. It has utility methods for emitting text based on the operands.
///
namespace {
struct OperandsSignature { … };
} // End anonymous namespace

namespace {
class FastISelMap { … };
} // End anonymous namespace

static std::string getOpcodeName(const Record *Op,
                                 const CodeGenDAGPatterns &CGP) { … }

static std::string getLegalCName(std::string OpName) { … }

FastISelMap::FastISelMap(StringRef instns) : … { … }

static std::string PhyRegForNode(TreePatternNode &Op,
                                 const CodeGenTarget &Target) { … }

void FastISelMap::collectPatterns(const CodeGenDAGPatterns &CGP) { … }

void FastISelMap::printImmediatePredicates(raw_ostream &OS) { … }

void FastISelMap::emitInstructionCode(raw_ostream &OS,
                                      const OperandsSignature &Operands,
                                      const PredMap &PM,
                                      const std::string &RetVTName) { … }

void FastISelMap::printFunctionDefinitions(raw_ostream &OS) { … }

static void EmitFastISel(const RecordKeeper &RK, raw_ostream &OS) { … }

static TableGen::Emitter::Opt X("gen-fast-isel", EmitFastISel,
                                "Generate a \"fast\" instruction selector");