From e15e969a4faca759fe7f0e4ab0f54aed43f98bbc Mon Sep 17 00:00:00 2001 From: Thomas Preud'homme Date: Mon, 3 Jul 2023 22:51:55 +0000 Subject: [FileCheck, 4/4] NFC: Stop using ExpressionValue Use APInt directly instead. Depends On D150880 Reviewed By: arichardson Differential Revision: https://reviews.llvm.org/D154430 --- llvm/lib/FileCheck/FileCheck.cpp | 89 +++++++++++++++----------------------- llvm/lib/FileCheck/FileCheckImpl.h | 57 ++++++++---------------- 2 files changed, 52 insertions(+), 94 deletions(-) (limited to 'llvm/lib/FileCheck') diff --git a/llvm/lib/FileCheck/FileCheck.cpp b/llvm/lib/FileCheck/FileCheck.cpp index b344b71..60a0d59 100644 --- a/llvm/lib/FileCheck/FileCheck.cpp +++ b/llvm/lib/FileCheck/FileCheck.cpp @@ -78,8 +78,7 @@ Expected ExpressionFormat::getWildcardRegex() const { } Expected -ExpressionFormat::getMatchingString(ExpressionValue IntegerValue) const { - APInt IntValue = IntegerValue.getAPIntValue(); +ExpressionFormat::getMatchingString(APInt IntValue) const { if (Value != Kind::Signed && IntValue.isNegative()) return make_error(); @@ -135,7 +134,7 @@ static APInt toSigned(APInt AbsVal, bool Negative) { return Result; } -Expected +Expected ExpressionFormat::valueFromStringRepr(StringRef StrVal, const SourceMgr &SM) const { bool ValueIsSigned = Value == Kind::Signed; @@ -155,76 +154,59 @@ ExpressionFormat::valueFromStringRepr(StringRef StrVal, if (ParseFailure) return ErrorDiagnostic::get(SM, StrVal, "unable to represent numeric value"); - return ExpressionValue(toSigned(ResultValue, Negative)); + return toSigned(ResultValue, Negative); } -Expected llvm::exprAdd(const ExpressionValue &LeftOperand, - const ExpressionValue &RightOperand, - bool &Overflow) { - APInt Result = LeftOperand.getAPIntValue().sadd_ov( - RightOperand.getAPIntValue(), Overflow); - return ExpressionValue(Result); +Expected llvm::exprAdd(const APInt &LeftOperand, + const APInt &RightOperand, bool &Overflow) { + return LeftOperand.sadd_ov(RightOperand, Overflow); } -Expected llvm::exprSub(const ExpressionValue &LeftOperand, - const ExpressionValue &RightOperand, - bool &Overflow) { - APInt Result = LeftOperand.getAPIntValue().ssub_ov( - RightOperand.getAPIntValue(), Overflow); - return ExpressionValue(Result); +Expected llvm::exprSub(const APInt &LeftOperand, + const APInt &RightOperand, bool &Overflow) { + return LeftOperand.ssub_ov(RightOperand, Overflow); } -Expected llvm::exprMul(const ExpressionValue &LeftOperand, - const ExpressionValue &RightOperand, - bool &Overflow) { - APInt Result = LeftOperand.getAPIntValue().smul_ov( - RightOperand.getAPIntValue(), Overflow); - return ExpressionValue(Result); +Expected llvm::exprMul(const APInt &LeftOperand, + const APInt &RightOperand, bool &Overflow) { + return LeftOperand.smul_ov(RightOperand, Overflow); } -Expected llvm::exprDiv(const ExpressionValue &LeftOperand, - const ExpressionValue &RightOperand, - bool &Overflow) { +Expected llvm::exprDiv(const APInt &LeftOperand, + const APInt &RightOperand, bool &Overflow) { // Check for division by zero. - if (RightOperand.getAPIntValue().isZero()) + if (RightOperand.isZero()) return make_error(); - APInt Result = LeftOperand.getAPIntValue().sdiv_ov( - RightOperand.getAPIntValue(), Overflow); - return ExpressionValue(Result); + return LeftOperand.sdiv_ov(RightOperand, Overflow); } -Expected llvm::exprMax(const ExpressionValue &LeftOperand, - const ExpressionValue &RightOperand, - bool &Overflow) { +Expected llvm::exprMax(const APInt &LeftOperand, + const APInt &RightOperand, bool &Overflow) { Overflow = false; - return LeftOperand.getAPIntValue().slt(RightOperand.getAPIntValue()) - ? RightOperand - : LeftOperand; + return LeftOperand.slt(RightOperand) ? RightOperand : LeftOperand; } -Expected llvm::exprMin(const ExpressionValue &LeftOperand, - const ExpressionValue &RightOperand, - bool &Overflow) { +Expected llvm::exprMin(const APInt &LeftOperand, + const APInt &RightOperand, bool &Overflow) { Overflow = false; - if (cantFail(exprMax(LeftOperand, RightOperand, Overflow)).getAPIntValue() == - LeftOperand.getAPIntValue()) + if (cantFail(exprMax(LeftOperand, RightOperand, Overflow)) == LeftOperand) return RightOperand; return LeftOperand; } -Expected NumericVariableUse::eval() const { - std::optional Value = Variable->getValue(); +Expected NumericVariableUse::eval() const { + std::optional Value = Variable->getValue(); if (Value) return *Value; return make_error(getExpressionStr()); } -Expected BinaryOperation::eval() const { - Expected MaybeLeftOp = LeftOperand->eval(); - Expected MaybeRightOp = RightOperand->eval(); +Expected BinaryOperation::eval() const { + Expected MaybeLeftOp = LeftOperand->eval(); + Expected MaybeRightOp = RightOperand->eval(); // Bubble up any error (e.g. undefined variables) in the recursive // evaluation. @@ -237,8 +219,8 @@ Expected BinaryOperation::eval() const { return std::move(Err); } - APInt LeftOp = MaybeLeftOp->getAPIntValue(); - APInt RightOp = MaybeRightOp->getAPIntValue(); + APInt LeftOp = *MaybeLeftOp; + APInt RightOp = *MaybeRightOp; bool Overflow; // Ensure both operands have the same bitwidth. unsigned LeftBitWidth = LeftOp.getBitWidth(); @@ -247,8 +229,7 @@ Expected BinaryOperation::eval() const { LeftOp = LeftOp.sext(NewBitWidth); RightOp = RightOp.sext(NewBitWidth); do { - Expected MaybeResult = - EvalBinop(ExpressionValue(LeftOp), ExpressionValue(RightOp), Overflow); + Expected MaybeResult = EvalBinop(LeftOp, RightOp, Overflow); if (!MaybeResult) return MaybeResult.takeError(); @@ -291,8 +272,7 @@ BinaryOperation::getImplicitFormat(const SourceMgr &SM) const { Expected NumericSubstitution::getResult() const { assert(ExpressionPointer->getAST() != nullptr && "Substituting empty expression"); - Expected EvaluatedValue = - ExpressionPointer->getAST()->eval(); + Expected EvaluatedValue = ExpressionPointer->getAST()->eval(); if (!EvaluatedValue) return EvaluatedValue.takeError(); ExpressionFormat Format = ExpressionPointer->getFormat(); @@ -1117,7 +1097,7 @@ Pattern::MatchResult Pattern::match(StringRef Buffer, TmpStr = RegExStr; if (LineNumber) Context->LineVariable->setValue( - ExpressionValue(APInt(sizeof(*LineNumber) * 8, *LineNumber))); + APInt(sizeof(*LineNumber) * 8, *LineNumber)); size_t InsertOffset = 0; // Substitute all string variables and expressions whose values are only @@ -1196,8 +1176,7 @@ Pattern::MatchResult Pattern::match(StringRef Buffer, StringRef MatchedValue = MatchInfo[CaptureParenGroup]; ExpressionFormat Format = DefinedNumericVariable->getImplicitFormat(); - Expected Value = - Format.valueFromStringRepr(MatchedValue, SM); + Expected Value = Format.valueFromStringRepr(MatchedValue, SM); if (!Value) return MatchResult(TheMatch, Value.takeError()); DefinedNumericVariable->setValue(*Value, MatchedValue); @@ -2583,7 +2562,7 @@ Error FileCheckPatternContext::defineCmdlineVariables( // to, since the expression of a command-line variable definition should // only use variables defined earlier on the command-line. If not, this // is an error and we report it. - Expected Value = Expression->getAST()->eval(); + Expected Value = Expression->getAST()->eval(); if (!Value) { Errs = joinErrors(std::move(Errs), Value.takeError()); continue; diff --git a/llvm/lib/FileCheck/FileCheckImpl.h b/llvm/lib/FileCheck/FileCheckImpl.h index ff87a1e..f5f8ea2 100644 --- a/llvm/lib/FileCheck/FileCheckImpl.h +++ b/llvm/lib/FileCheck/FileCheckImpl.h @@ -32,8 +32,6 @@ namespace llvm { // Numeric substitution handling code. //===----------------------------------------------------------------------===// -class ExpressionValue; - /// Type representing the format an expression value should be textualized into /// for matching. Used to represent both explicit format specifiers as well as /// implicit format from using numeric variables. @@ -95,14 +93,14 @@ public: /// \returns the string representation of \p Value in the format represented /// by this instance, or an error if conversion to this format failed or the /// format is NoFormat. - Expected getMatchingString(ExpressionValue Value) const; + Expected getMatchingString(APInt Value) const; /// \returns the value corresponding to string representation \p StrVal /// according to the matching format represented by this instance or an error /// with diagnostic against \p SM if \p StrVal does not correspond to a valid /// and representable value. - Expected valueFromStringRepr(StringRef StrVal, - const SourceMgr &SM) const; + Expected valueFromStringRepr(StringRef StrVal, + const SourceMgr &SM) const; }; /// Class to represent an overflow error that might result when manipulating a @@ -118,31 +116,14 @@ public: void log(raw_ostream &OS) const override { OS << "overflow error"; } }; -/// Class representing a numeric value. -class ExpressionValue { -private: - APInt Value; - -public: - ExpressionValue(APInt Val) : Value(Val) {} - - APInt getAPIntValue() const { return Value; } -}; - /// Performs operation and \returns its result or an error in case of failure, /// such as if an overflow occurs. -Expected exprAdd(const ExpressionValue &Lhs, - const ExpressionValue &Rhs, bool &Overflow); -Expected exprSub(const ExpressionValue &Lhs, - const ExpressionValue &Rhs, bool &Overflow); -Expected exprMul(const ExpressionValue &Lhs, - const ExpressionValue &Rhs, bool &Overflow); -Expected exprDiv(const ExpressionValue &Lhs, - const ExpressionValue &Rhs, bool &Overflow); -Expected exprMax(const ExpressionValue &Lhs, - const ExpressionValue &Rhs, bool &Overflow); -Expected exprMin(const ExpressionValue &Lhs, - const ExpressionValue &Rhs, bool &Overflow); +Expected exprAdd(const APInt &Lhs, const APInt &Rhs, bool &Overflow); +Expected exprSub(const APInt &Lhs, const APInt &Rhs, bool &Overflow); +Expected exprMul(const APInt &Lhs, const APInt &Rhs, bool &Overflow); +Expected exprDiv(const APInt &Lhs, const APInt &Rhs, bool &Overflow); +Expected exprMax(const APInt &Lhs, const APInt &Rhs, bool &Overflow); +Expected exprMin(const APInt &Lhs, const APInt &Rhs, bool &Overflow); /// Base class representing the AST of a given expression. class ExpressionAST { @@ -158,7 +139,7 @@ public: /// Evaluates and \returns the value of the expression represented by this /// AST or an error if evaluation fails. - virtual Expected eval() const = 0; + virtual Expected eval() const = 0; /// \returns either the implicit format of this AST, a diagnostic against /// \p SM if implicit formats of the AST's components conflict, or NoFormat @@ -174,14 +155,14 @@ public: class ExpressionLiteral : public ExpressionAST { private: /// Actual value of the literal. - ExpressionValue Value; + APInt Value; public: explicit ExpressionLiteral(StringRef ExpressionStr, APInt Val) : ExpressionAST(ExpressionStr), Value(Val) {} /// \returns the literal's value. - Expected eval() const override { return Value; } + Expected eval() const override { return Value; } }; /// Class to represent an undefined variable error, which quotes that @@ -240,7 +221,7 @@ private: ExpressionFormat ImplicitFormat; /// Value of numeric variable, if defined, or std::nullopt otherwise. - std::optional Value; + std::optional Value; /// The input buffer's string from which Value was parsed, or std::nullopt. /// See comments on getStringValue for a discussion of the std::nullopt case. @@ -267,7 +248,7 @@ public: ExpressionFormat getImplicitFormat() const { return ImplicitFormat; } /// \returns this variable's value. - std::optional getValue() const { return Value; } + std::optional getValue() const { return Value; } /// \returns the input buffer's string from which this variable's value was /// parsed, or std::nullopt if the value is not yet defined or was not parsed @@ -279,7 +260,7 @@ public: /// Sets value of this numeric variable to \p NewValue, and sets the input /// buffer string from which it was parsed to \p NewStrValue. See comments on /// getStringValue for a discussion of when the latter can be std::nullopt. - void setValue(ExpressionValue NewValue, + void setValue(APInt NewValue, std::optional NewStrValue = std::nullopt) { Value = NewValue; StrValue = NewStrValue; @@ -308,7 +289,7 @@ public: NumericVariableUse(StringRef Name, NumericVariable *Variable) : ExpressionAST(Name), Variable(Variable) {} /// \returns the value of the variable referenced by this instance. - Expected eval() const override; + Expected eval() const override; /// \returns implicit format of this numeric variable. Expected @@ -318,9 +299,7 @@ public: }; /// Type of functions evaluating a given binary operation. -using binop_eval_t = Expected (*)(const ExpressionValue &, - const ExpressionValue &, - bool &); +using binop_eval_t = Expected (*)(const APInt &, const APInt &, bool &); /// Class representing a single binary operation in the AST of an expression. class BinaryOperation : public ExpressionAST { @@ -347,7 +326,7 @@ public: /// using EvalBinop on the result of recursively evaluating the operands. /// \returns the expression value or an error if an undefined numeric /// variable is used in one of the operands. - Expected eval() const override; + Expected eval() const override; /// \returns the implicit format of this AST, if any, a diagnostic against /// \p SM if the implicit formats of the AST's components conflict, or no -- cgit v1.1