llvm/llvm/utils/TableGen/Common/GlobalISel/PatternParser.cpp

//===- PatternParser.cpp ----------------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "Common/GlobalISel/PatternParser.h"
#include "Basic/CodeGenIntrinsics.h"
#include "Common/CodeGenTarget.h"
#include "Common/GlobalISel/CombinerUtils.h"
#include "Common/GlobalISel/Patterns.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/SaveAndRestore.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"

namespace llvm {
namespace gi {
static constexpr StringLiteral MIFlagsEnumClassName = …;

namespace {
class PrettyStackTraceParse : public PrettyStackTraceEntry { … };
} // namespace

bool PatternParser::parsePatternList(
    const DagInit &List,
    function_ref<bool(std::unique_ptr<Pattern>)> ParseAction,
    StringRef Operator, StringRef AnonPatNamePrefix) { … }

static const CodeGenInstruction &
getInstrForIntrinsic(const CodeGenTarget &CGT, const CodeGenIntrinsic *I) { … }

std::unique_ptr<Pattern>
PatternParser::parseInstructionPattern(const Init &Arg, StringRef Name) { … }

std::unique_ptr<Pattern>
PatternParser::parseWipMatchOpcodeMatcher(const Init &Arg, StringRef Name) { … }

bool PatternParser::parseInstructionPatternOperand(InstructionPattern &IP,
                                                   const Init *OpInit,
                                                   const StringInit *OpName) { … }

bool PatternParser::parseInstructionPatternMIFlags(InstructionPattern &IP,
                                                   const DagInit *Op) { … }

std::unique_ptr<PatFrag> PatternParser::parsePatFragImpl(const Record *Def) { … }

bool PatternParser::parsePatFragParamList(
    const DagInit &OpsList,
    function_ref<bool(StringRef, unsigned)> ParseAction) { … }

const PatFrag *PatternParser::parsePatFrag(const Record *Def) { … }

} // namespace gi
} // namespace llvm