From 06329d8c0a74aeddd68f393cb2183c295f1b311d Mon Sep 17 00:00:00 2001 From: Craig Topper Date: Sun, 5 May 2019 17:19:19 +0000 Subject: [PATCH] [LLParser] Simplify type checking in ParseArithmetic and ParseUnaryOp. Summary: These methods previously took a 0, 1, or 2 to indicate what types were allowed, but the 0 encoding which meant both fp and integer types has been unused for years. Its leftover from when add/sub/mul used to be shared between int and fp Simplify it by changing it to just a bool to distinquish int and fp. Reviewers: spatel, dblaikie, jyknight, arsenm Reviewed By: spatel Subscribers: wdng, hiraditya, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D61561 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@359986 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/AsmParser/LLParser.cpp | 51 ++++++++++++-------------------------- lib/AsmParser/LLParser.h | 4 +-- 2 files changed, 18 insertions(+), 37 deletions(-) diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp index ebb174d39c6..30144f40e25 100644 --- a/lib/AsmParser/LLParser.cpp +++ b/lib/AsmParser/LLParser.cpp @@ -5629,7 +5629,7 @@ int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, // Unary Operators. case lltok::kw_fneg: { FastMathFlags FMF = EatFastMathFlagsIfPresent(); - int Res = ParseUnaryOp(Inst, PFS, KeywordVal, 2); + int Res = ParseUnaryOp(Inst, PFS, KeywordVal, /*IsFP*/true); if (Res != 0) return Res; if (FMF.any()) @@ -5645,7 +5645,7 @@ int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, bool NSW = EatIfPresent(lltok::kw_nsw); if (!NUW) NUW = EatIfPresent(lltok::kw_nuw); - if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true; + if (ParseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/false)) return true; if (NUW) cast(Inst)->setHasNoUnsignedWrap(true); if (NSW) cast(Inst)->setHasNoSignedWrap(true); @@ -5657,7 +5657,7 @@ int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, case lltok::kw_fdiv: case lltok::kw_frem: { FastMathFlags FMF = EatFastMathFlagsIfPresent(); - int Res = ParseArithmetic(Inst, PFS, KeywordVal, 2); + int Res = ParseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/true); if (Res != 0) return Res; if (FMF.any()) @@ -5671,13 +5671,14 @@ int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, case lltok::kw_ashr: { bool Exact = EatIfPresent(lltok::kw_exact); - if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true; + if (ParseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/false)) return true; if (Exact) cast(Inst)->setIsExact(true); return false; } case lltok::kw_urem: - case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1); + case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, + /*IsFP*/false); case lltok::kw_and: case lltok::kw_or: case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal); @@ -6214,28 +6215,16 @@ bool LLParser::ParseCleanupPad(Instruction *&Inst, PerFunctionState &PFS) { /// ParseUnaryOp /// ::= UnaryOp TypeAndValue ',' Value /// -/// If OperandType is 0, then any FP or integer operand is allowed. If it is 1, -/// then any integer operand is allowed, if it is 2, any fp operand is allowed. +/// If IsFP is false, then any integer operand is allowed, if it is true, any fp +/// operand is allowed. bool LLParser::ParseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, - unsigned Opc, unsigned OperandType) { + unsigned Opc, bool IsFP) { LocTy Loc; Value *LHS; if (ParseTypeAndValue(LHS, Loc, PFS)) return true; - bool Valid; - switch (OperandType) { - default: llvm_unreachable("Unknown operand type!"); - case 0: // int or FP. - Valid = LHS->getType()->isIntOrIntVectorTy() || - LHS->getType()->isFPOrFPVectorTy(); - break; - case 1: - Valid = LHS->getType()->isIntOrIntVectorTy(); - break; - case 2: - Valid = LHS->getType()->isFPOrFPVectorTy(); - break; - } + bool Valid = IsFP ? LHS->getType()->isFPOrFPVectorTy() + : LHS->getType()->isIntOrIntVectorTy(); if (!Valid) return Error(Loc, "invalid operand type for instruction"); @@ -6369,26 +6358,18 @@ bool LLParser::ParseCallBr(Instruction *&Inst, PerFunctionState &PFS) { /// ParseArithmetic /// ::= ArithmeticOps TypeAndValue ',' Value /// -/// If OperandType is 0, then any FP or integer operand is allowed. If it is 1, -/// then any integer operand is allowed, if it is 2, any fp operand is allowed. +/// If IsFP is false, then any integer operand is allowed, if it is true, any fp +/// operand is allowed. bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, - unsigned Opc, unsigned OperandType) { + unsigned Opc, bool IsFP) { LocTy Loc; Value *LHS, *RHS; if (ParseTypeAndValue(LHS, Loc, PFS) || ParseToken(lltok::comma, "expected ',' in arithmetic operation") || ParseValue(LHS->getType(), RHS, PFS)) return true; - bool Valid; - switch (OperandType) { - default: llvm_unreachable("Unknown operand type!"); - case 0: // int or FP. - Valid = LHS->getType()->isIntOrIntVectorTy() || - LHS->getType()->isFPOrFPVectorTy(); - break; - case 1: Valid = LHS->getType()->isIntOrIntVectorTy(); break; - case 2: Valid = LHS->getType()->isFPOrFPVectorTy(); break; - } + bool Valid = IsFP ? LHS->getType()->isFPOrFPVectorTy() + : LHS->getType()->isIntOrIntVectorTy(); if (!Valid) return Error(Loc, "invalid operand type for instruction"); diff --git a/lib/AsmParser/LLParser.h b/lib/AsmParser/LLParser.h index 452492b862a..ad169afb935 100644 --- a/lib/AsmParser/LLParser.h +++ b/lib/AsmParser/LLParser.h @@ -573,9 +573,9 @@ namespace llvm { bool ParseCallBr(Instruction *&Inst, PerFunctionState &PFS); bool ParseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc, - unsigned OperandType); + bool IsFP); bool ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc, - unsigned OperandType); + bool IsFP); bool ParseLogical(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc); bool ParseCompare(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc); bool ParseCast(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc); -- 2.50.1