FileCheckImpl.h Source File (original) (raw)

15#ifndef LLVM_LIB_FILECHECK_FILECHECKIMPL_H

16#define LLVM_LIB_FILECHECK_FILECHECKIMPL_H

25#include

26#include

27#include

28#include

30namespace llvm {

54private:

56 unsigned Precision = 0;

58 bool AlternateForm = false;

60public:

68 Precision == Other.Precision && AlternateForm == Other.AlternateForm;

69 }

72 return !(*this == Other);

73 }

75 bool operator==(Kind OtherValue) const { return Value == OtherValue; }

77 bool operator!=(Kind OtherValue) const { return !(*this == OtherValue); }

85 : Value(Value), Precision(Precision){};

87 : Value(Value), Precision(Precision), AlternateForm(AlternateForm){};

100

103};

104

105

106

108public:

110

112 return std::make_error_code(std::errc::value_too_large);

113 }

114

115 void log(raw_ostream &OS) const override { OS << "overflow error"; }

116};

117

118

119

121 bool &Overflow);

123 bool &Overflow);

125 bool &Overflow);

127 bool &Overflow);

128Expected exprMax(const APInt &Lhs, const APInt &Rhs, bool &Overflow);

129Expected exprMin(const APInt &Lhs, const APInt &Rhs, bool &Overflow);

130

131

133private:

135

136public:

138

140

142

143

144

146

147

148

149

150

155};

156

157

159private:

160

162

163public:

166

167

169};

170

171

172

174private:

176

177public:

179

181

183

187

188

190 OS << "undefined variable: " << VarName;

191 }

192};

193

194

196private:

197

198 std::unique_ptr AST;

199

200

202

203public:

204

205

207 : AST(std::move(AST)), Format(Format) {}

208

209

210

212

214};

215

216

218private:

219

221

222

223

225

226

227 std::optional Value;

228

229

230

231 std::optional StrValue;

232

233

234

235

236 std::optional<size_t> DefLineNumber;

237

238public:

239

240

241

243 std::optional<size_t> DefLineNumber = std::nullopt)

244 : Name(Name), ImplicitFormat(ImplicitFormat),

245 DefLineNumber(DefLineNumber) {}

246

247

249

250

252

253

254 std::optional getValue() const { return Value; }

255

256

257

258

259

260

261 std::optional getStringValue() const { return StrValue; }

262

263

264

265

267 std::optional NewStrValue = std::nullopt) {

268 Value = NewValue;

269 StrValue = NewStrValue;

270 }

271

272

273

275 Value = std::nullopt;

276 StrValue = std::nullopt;

277 }

278

279

280

282};

283

284

285

287private:

288

290

291public:

294

296

297

300 return Variable->getImplicitFormat();

301 }

302};

303

304

306

307

309private:

310

311 std::unique_ptr LeftOperand;

312

313

314 std::unique_ptr RightOperand;

315

316

318

319public:

321 std::unique_ptr LeftOp,

322 std::unique_ptr RightOp)

323 : ExpressionAST(ExpressionStr), EvalBinop(EvalBinop) {

324 LeftOperand = std::move(LeftOp);

325 RightOperand = std::move(RightOp);

326 }

327

328

329

330

331

333

334

335

336

337

339 getImplicitFormat(const SourceMgr &SM) const override;

340};

341

342class FileCheckPatternContext;

343

344

346protected:

347

348

349

350

351

352

354

355

356

358

359

361

362public:

366

368

369

371

372

374

375

376

377

379

380

381

382

384};

385

387public:

391

392

393

395

396

397

398

400};

401

403private:

404

405

406 std::unique_ptr ExpressionPointer;

407

408public:

410 std::unique_ptr ExpressionPointer,

413 ExpressionPointer(std::move(ExpressionPointer)) {}

414

415

416

418

419

420

421

423};

424

425

426

427

428

429

430

431

434

435private:

436

437

438

439

441

442

443

444

446

447

448

449

450

452

453

454

456

457

458

459 std::vector<std::unique_ptr> NumericVariables;

460

461

462

463 std::vector<std::unique_ptr> Expressions;

464

465

466

467 std::vector<std::unique_ptr> Substitutions;

468

469public:

470

471

473

474

475

476

477

480

481

482

484

485

486

487

488

490

491private:

492

493

494 template <class... Types> NumericVariable *makeNumericVariable(Types... args);

495

496

497

499

500

501

503 std::unique_ptr Expression,

504 size_t InsertIdx);

505};

506

507

508

510private:

513

514public:

516

518 : Diagnostic(Diag), Range(Range) {}

519

523

524

525 void log(raw_ostream &OS) const override { Diagnostic.print(nullptr, OS); }

526

529

535

539 return get(SM, Start, ErrMsg, SMRange(Start, End));

540 }

541};

542

544public:

546

550

551

553 OS << "String not found in input";

554 }

555};

556

557

558

559

560

561

562

563

564

565

566

568public:

570

574

575

577 OS << "error previously reported";

578 }

579

581 if (HasErrorReported)

584 }

585};

586

588 SMLoc PatternLoc;

589

590

591

593

594

595

596 std::string RegExStr;

597

598

599

600

601

602

603

604 std::vector<Substitution *> Substitutions;

605

606

607

608

609

610

611

612

613

614

615

616

617 std::map<StringRef, unsigned> VariableDefs;

618

619

620

621

622

623 struct NumericVariableMatch {

624

625

627

628

629

630 unsigned CaptureParenGroup;

631 };

632

633

634

635

637

638

639

640

641

642

643

645

647

648

649

650

651 std::optional<size_t> LineNumber;

652

653

654 bool IgnoreCase = false;

655

656public:

658 std::optional<size_t> Line = std::nullopt)

659 : Context(Context), CheckTy(Ty), LineNumber(Line) {}

660

661

663

664

665

667

668

670

671

676

677

678

679

680

681

684

685

686

687

688

689

690

691

692

693

696 StringRef Expr, std::optional<NumericVariable *> &DefinedNumericVariable,

697 bool IsLegacyLineExpr, std::optional<size_t> LineNumber,

699

700

701

702

703

704

705

721

722

723

724

725

726

727

728

729

730

731

734

737 std::vector *Diags) const;

739 std::vector *Diags) const;

740

742 return !(Substitutions.empty() && VariableDefs.empty());

743 }

746 std::vector *Diags) const;

747

749

750 int getCount() const { return CheckTy.getCount(); }

751

752private:

753 bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM);

754 void AddBackrefToRegEx(unsigned BackrefNum);

755

756

757

758 unsigned computeMatchDistance(StringRef Buffer) const;

759

760

761

762

763

764

766

767

768

769

770

771

774 std::optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,

776

777

778

779

780

781

783 StringRef Name, bool IsPseudo, std::optional<size_t> LineNumber,

785 enum class AllowedOperand { LineVar, LegacyLiteral, Any };

786

787

788

789

790

791

792

793

794

795 static Expected<std::unique_ptr>

796 parseNumericOperand(StringRef &Expr, AllowedOperand AO, bool ConstraintParsed,

797 std::optional<size_t> LineNumber,

798 FileCheckPatternContext *Context, const SourceMgr &SM);

799

800

801

802

803

804

805

806

807

808 static Expected<std::unique_ptr>

809 parseBinop(StringRef Expr, StringRef &RemainingExpr,

810 std::unique_ptr LeftOp, bool IsLegacyLineExpr,

811 std::optional<size_t> LineNumber, FileCheckPatternContext *Context,

812 const SourceMgr &SM);

813

814

815

816

817

818

819

820 static Expected<std::unique_ptr>

821 parseParenExpr(StringRef &Expr, std::optional<size_t> LineNumber,

822 FileCheckPatternContext *Context, const SourceMgr &SM);

823

824

825

826

827

828

829

830

831 static Expected<std::unique_ptr>

832 parseCallExpr(StringRef &Expr, StringRef FuncName,

833 std::optional<size_t> LineNumber,

834 FileCheckPatternContext *Context, const SourceMgr &SM);

835};

836

837

838

839

840

841

843

845

846

848

849

851

852

853

854

862

863

865

867 std::vector &&D)

869

870

873 std::vector *Diags) const;

874

875

876

878

879

881

882

883

885 const std::vector<const DagNotPrefixInfo *> &NotStrings,

887 std::vector *Diags) const;

888

890 std::vector<const DagNotPrefixInfo *> &NotStrings,

892 std::vector *Diags) const;

893};

894

895}

896

897#endif

This file defines the StringMap class.

This file implements a class to represent arbitrary precision integral constant values and operations...

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

#define LLVM_ABI_FOR_TEST

ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))

Class for arbitrary precision integers.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

BinaryOperation(StringRef ExpressionStr, binop_eval_t EvalBinop, std::unique_ptr< ExpressionAST > LeftOp, std::unique_ptr< ExpressionAST > RightOp)

Definition FileCheckImpl.h:320

StringRef getMessage() const

Definition FileCheckImpl.h:527

ErrorDiagnostic(SMDiagnostic &&Diag, SMRange Range)

Definition FileCheckImpl.h:517

std::error_code convertToErrorCode() const override

Convert this error to a std::error_code.

Definition FileCheckImpl.h:520

static LLVM_ABI_FOR_TEST char ID

Definition FileCheckImpl.h:515

void log(raw_ostream &OS) const override

Print diagnostic associated with this error when printing the error.

Definition FileCheckImpl.h:525

static Error get(const SourceMgr &SM, SMLoc Loc, const Twine &ErrMsg, SMRange Range={})

Definition FileCheckImpl.h:530

SMRange getRange() const

Definition FileCheckImpl.h:528

static Error get(const SourceMgr &SM, StringRef Buffer, const Twine &ErrMsg)

Definition FileCheckImpl.h:536

Base class for user error types.

An error that has already been reported.

Definition FileCheckImpl.h:567

static Error reportedOrSuccess(bool HasErrorReported)

Definition FileCheckImpl.h:580

static char ID

Definition FileCheckImpl.h:569

void log(raw_ostream &OS) const override

Print diagnostic associated with this error when printing the error.

Definition FileCheckImpl.h:576

std::error_code convertToErrorCode() const override

Convert this error to a std::error_code.

Definition FileCheckImpl.h:571

Lightweight error class with error context and mandatory checking.

static ErrorSuccess success()

Create a success value.

Tagged union holding either a T or a Error.

Base class representing the AST of a given expression.

Definition FileCheckImpl.h:132

ExpressionAST(StringRef ExpressionStr)

Definition FileCheckImpl.h:137

virtual Expected< APInt > eval() const =0

Evaluates and.

StringRef getExpressionStr() const

Definition FileCheckImpl.h:141

virtual ~ExpressionAST()=default

virtual Expected< ExpressionFormat > getImplicitFormat(const SourceMgr &SM) const

Definition FileCheckImpl.h:152

ExpressionLiteral(StringRef ExpressionStr, APInt Val)

Definition FileCheckImpl.h:164

Expected< APInt > eval() const override

Definition FileCheckImpl.h:168

Class representing an expression and its matching format.

Definition FileCheckImpl.h:195

ExpressionFormat getFormat() const

Definition FileCheckImpl.h:213

Expression(std::unique_ptr< ExpressionAST > AST, ExpressionFormat Format)

Generic constructor for an expression represented by the given AST and whose matching format is Forma...

Definition FileCheckImpl.h:206

ExpressionAST * getAST() const

Definition FileCheckImpl.h:211

Class holding the Pattern global state, shared by all patterns: tables holding values of variables an...

Definition FileCheckImpl.h:432

LLVM_ABI_FOR_TEST Error defineCmdlineVariables(ArrayRef< StringRef > CmdlineDefines, SourceMgr &SM)

Defines string and numeric variables from definitions given on the command line, passed as a vector o...

LLVM_ABI_FOR_TEST void createLineVariable()

Create @LINE pseudo variable.

LLVM_ABI_FOR_TEST Expected< StringRef > getPatternVarValue(StringRef VarName)

friend class Pattern

Definition FileCheckImpl.h:433

LLVM_ABI_FOR_TEST void clearLocalVars()

Undefines local variables (variables whose name does not start with a '$' sign), i....

Definition FileCheckImpl.h:543

std::error_code convertToErrorCode() const override

Convert this error to a std::error_code.

Definition FileCheckImpl.h:547

void log(raw_ostream &OS) const override

Print diagnostic associated with this error when printing the error.

Definition FileCheckImpl.h:552

static LLVM_ABI_FOR_TEST char ID

Definition FileCheckImpl.h:545

NumericSubstitution(FileCheckPatternContext *Context, StringRef ExpressionStr, std::unique_ptr< Expression > ExpressionPointer, size_t InsertIdx)

Definition FileCheckImpl.h:409

NumericVariableUse(StringRef Name, NumericVariable *Variable)

Definition FileCheckImpl.h:292

Expected< ExpressionFormat > getImplicitFormat(const SourceMgr &SM) const override

Definition FileCheckImpl.h:299

Class representing a numeric variable and its associated current value.

Definition FileCheckImpl.h:217

void clearValue()

Clears value of this numeric variable, regardless of whether it is currently defined or not.

Definition FileCheckImpl.h:274

void setValue(APInt NewValue, std::optional< StringRef > NewStrValue=std::nullopt)

Sets value of this numeric variable to NewValue, and sets the input buffer string from which it was p...

Definition FileCheckImpl.h:266

ExpressionFormat getImplicitFormat() const

Definition FileCheckImpl.h:251

StringRef getName() const

Definition FileCheckImpl.h:248

std::optional< StringRef > getStringValue() const

Definition FileCheckImpl.h:261

std::optional< APInt > getValue() const

Definition FileCheckImpl.h:254

NumericVariable(StringRef Name, ExpressionFormat ImplicitFormat, std::optional< size_t > DefLineNumber=std::nullopt)

Constructor for a variable Name with implicit format ImplicitFormat defined at line DefLineNumber or ...

Definition FileCheckImpl.h:242

std::optional< size_t > getDefLineNumber() const

Definition FileCheckImpl.h:281

Class to represent an overflow error that might result when manipulating a value.

Definition FileCheckImpl.h:107

static LLVM_ABI_FOR_TEST char ID

Definition FileCheckImpl.h:109

void log(raw_ostream &OS) const override

Print an error message to an output stream.

Definition FileCheckImpl.h:115

std::error_code convertToErrorCode() const override

Convert this error to a std::error_code.

Definition FileCheckImpl.h:111

Definition FileCheckImpl.h:587

static LLVM_ABI_FOR_TEST Expected< VariableProperties > parseVariable(StringRef &Str, const SourceMgr &SM)

Parses the string at the start of Str for a variable name.

LLVM_ABI_FOR_TEST MatchResult match(StringRef Buffer, const SourceMgr &SM) const

Matches the pattern string against the input buffer Buffer.

void printFuzzyMatch(const SourceMgr &SM, StringRef Buffer, std::vector< FileCheckDiag > *Diags) const

void printSubstitutions(const SourceMgr &SM, StringRef Buffer, SMRange MatchRange, FileCheckDiag::MatchType MatchTy, std::vector< FileCheckDiag > *Diags) const

Prints the value of successful substitutions.

bool hasVariable() const

Definition FileCheckImpl.h:741

SMLoc getLoc() const

Definition FileCheckImpl.h:662

FileCheckPatternContext * getContext() const

Definition FileCheckImpl.h:666

static LLVM_ABI_FOR_TEST Expected< std::unique_ptr< Expression > > parseNumericSubstitutionBlock(StringRef Expr, std::optional< NumericVariable * > &DefinedNumericVariable, bool IsLegacyLineExpr, std::optional< size_t > LineNumber, FileCheckPatternContext *Context, const SourceMgr &SM)

Parses Expr for a numeric substitution block at line LineNumber, or before input is parsed if LineNum...

Pattern(Check::FileCheckType Ty, FileCheckPatternContext *Context, std::optional< size_t > Line=std::nullopt)

Definition FileCheckImpl.h:657

LLVM_ABI_FOR_TEST void printVariableDefs(const SourceMgr &SM, FileCheckDiag::MatchType MatchTy, std::vector< FileCheckDiag > *Diags) const

static LLVM_ABI_FOR_TEST bool isValidVarNameStart(char C)

int getCount() const

Definition FileCheckImpl.h:750

Check::FileCheckType getCheckTy() const

Definition FileCheckImpl.h:748

LLVM_ABI_FOR_TEST bool parsePattern(StringRef PatternStr, StringRef Prefix, SourceMgr &SM, const FileCheckRequest &Req)

Parses the pattern in PatternStr and initializes this Pattern instance accordingly.

Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...

Represents a location in source code.

static SMLoc getFromPointer(const char *Ptr)

Represents a range in source code.

This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.

LLVM_ABI SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges={}, ArrayRef< SMFixIt > FixIts={}) const

Return an SMDiagnostic at the specified location with the specified string.

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

StringRef - Represent a constant reference to a string, i.e.

constexpr size_t size() const

size - Get the string size.

constexpr const char * data() const

data - Get a pointer to the start of the string (which may not be null terminated).

StringSubstitution(FileCheckPatternContext *Context, StringRef VarName, size_t InsertIdx)

Definition FileCheckImpl.h:388

Class representing a substitution to perform in the RegExStr string.

Definition FileCheckImpl.h:345

virtual ~Substitution()=default

Substitution(FileCheckPatternContext *Context, StringRef VarName, size_t InsertIdx)

Definition FileCheckImpl.h:363

StringRef getFromString() const

Definition FileCheckImpl.h:370

size_t InsertIdx

Definition FileCheckImpl.h:360

size_t getIndex() const

Definition FileCheckImpl.h:373

FileCheckPatternContext * Context

Pointer to a class instance holding, among other things, the table with the values of live string var...

Definition FileCheckImpl.h:353

virtual Expected< std::string > getResultRegex() const =0

virtual Expected< std::string > getResultForDiagnostics() const =0

StringRef FromStr

The string that needs to be substituted for something else.

Definition FileCheckImpl.h:357

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

UndefVarError(StringRef VarName)

Definition FileCheckImpl.h:180

std::error_code convertToErrorCode() const override

Convert this error to a std::error_code.

Definition FileCheckImpl.h:184

StringRef getVarName() const

Definition FileCheckImpl.h:182

static LLVM_ABI_FOR_TEST char ID

Definition FileCheckImpl.h:178

void log(raw_ostream &OS) const override

Print name of variable associated with this error.

Definition FileCheckImpl.h:189

LLVM Value Representation.

This class implements an extremely fast bulk output stream that can only output to a stream.

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI std::error_code inconvertibleErrorCode()

The value returned by this function can be returned from convertToErrorCode for Error values where no...

LLVM_ABI_FOR_TEST Expected< APInt > exprAdd(const APInt &Lhs, const APInt &Rhs, bool &Overflow)

Performs operation and.

Expected< APInt >(*)(const APInt &, const APInt &, bool &) binop_eval_t

Type of functions evaluating a given binary operation.

Definition FileCheckImpl.h:305

LLVM_ABI_FOR_TEST Expected< APInt > exprMul(const APInt &Lhs, const APInt &Rhs, bool &Overflow)

Error make_error(ArgTs &&... Args)

Make a Error instance representing failure using the given error info type.

OutputIt move(R &&Range, OutputIt Out)

Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.

Expected< APInt > exprMax(const APInt &Lhs, const APInt &Rhs, bool &Overflow)

LLVM_ABI_FOR_TEST Expected< APInt > exprDiv(const APInt &Lhs, const APInt &Rhs, bool &Overflow)

Expected< APInt > exprMin(const APInt &Lhs, const APInt &Rhs, bool &Overflow)

LLVM_ABI_FOR_TEST Expected< APInt > exprSub(const APInt &Lhs, const APInt &Rhs, bool &Overflow)

Implement std::hash so that hash_code can be used in STL containers.

Type representing the format an expression value should be textualized into for matching.

Definition FileCheckImpl.h:39

LLVM_ABI_FOR_TEST APInt valueFromStringRepr(StringRef StrVal, const SourceMgr &SM) const

StringRef toString() const

bool operator!=(const ExpressionFormat &Other) const

Definition FileCheckImpl.h:71

bool operator==(Kind OtherValue) const

Definition FileCheckImpl.h:75

LLVM_ABI_FOR_TEST Expected< std::string > getMatchingString(APInt Value) const

LLVM_ABI_FOR_TEST Expected< std::string > getWildcardRegex() const

ExpressionFormat(Kind Value)

Definition FileCheckImpl.h:83

Kind

Definition FileCheckImpl.h:40

@ HexLower

Value should be printed as a lowercase hex number.

Definition FileCheckImpl.h:51

@ HexUpper

Value should be printed as an uppercase hex number.

Definition FileCheckImpl.h:49

@ Signed

Value is a signed integer and should be printed as a decimal number.

Definition FileCheckImpl.h:47

@ Unsigned

Value is an unsigned integer and should be printed as a decimal number.

Definition FileCheckImpl.h:45

@ NoFormat

Denote absence of format.

Definition FileCheckImpl.h:43

ExpressionFormat(Kind Value, unsigned Precision)

Definition FileCheckImpl.h:84

bool operator!=(Kind OtherValue) const

Definition FileCheckImpl.h:77

ExpressionFormat()=default

bool operator==(const ExpressionFormat &Other) const

Define format equality: formats are equal if neither is NoFormat and their kinds and precision are th...

Definition FileCheckImpl.h:66

ExpressionFormat(Kind Value, unsigned Precision, bool AlternateForm)

Definition FileCheckImpl.h:86

MatchType

What type of match result does this diagnostic describe?

Contains info about various FileCheck options.

Pattern DagNotPat

Definition FileCheckImpl.h:856

StringRef DagNotPrefix

Definition FileCheckImpl.h:857

DagNotPrefixInfo(const Pattern &P, StringRef S)

Definition FileCheckImpl.h:859

bool CheckNext(const SourceMgr &SM, StringRef Buffer) const

Verifies that there is a single line in the given Buffer.

Pattern Pat

The pattern to match.

Definition FileCheckImpl.h:844

bool CheckSame(const SourceMgr &SM, StringRef Buffer) const

Verifies that there is no newline in the given Buffer.

std::vector< DagNotPrefixInfo > DagNotStrings

Hold the DAG/NOT strings occurring in the input file.

Definition FileCheckImpl.h:864

SMLoc Loc

The location in the match file that the check string was specified.

Definition FileCheckImpl.h:850

StringRef Prefix

Which prefix name this check matched.

Definition FileCheckImpl.h:847

FileCheckString(Pattern &&P, StringRef S, SMLoc L, std::vector< DagNotPrefixInfo > &&D)

Definition FileCheckImpl.h:866

size_t CheckDag(const SourceMgr &SM, StringRef Buffer, std::vector< const DagNotPrefixInfo * > &NotStrings, const FileCheckRequest &Req, std::vector< FileCheckDiag > *Diags) const

Matches "dag strings" and their mixed "not strings".

bool CheckNot(const SourceMgr &SM, StringRef Buffer, const std::vector< const DagNotPrefixInfo * > &NotStrings, const FileCheckRequest &Req, std::vector< FileCheckDiag > *Diags) const

Verifies that none of the strings in NotStrings are found in the given Buffer.

Error TheError

Definition FileCheckImpl.h:715

MatchResult(Match M, Error E)

Definition FileCheckImpl.h:718

MatchResult(size_t MatchPos, size_t MatchLen, Error E)

Definition FileCheckImpl.h:716

std::optional< Match > TheMatch

Definition FileCheckImpl.h:714

MatchResult(Error E)

Definition FileCheckImpl.h:719

Definition FileCheckImpl.h:709