From 15c13d3e63d7745bccad74d547af4e3482193eaa Mon Sep 17 00:00:00 2001 From: Michael Ilseman Date: Tue, 27 Nov 2012 00:42:44 +0000 Subject: Fast-math flags for LLVM IR parsing and printing Added in the ability to read LLVM IR text that contains fast-math flags as a sequence of capital letters separated by spaces in any order. Added in the printing of the fast-math flags in a canonical order, and don't print the other flags when 'fast' is specified, as 'fast' implies all the others. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@168645 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/AsmParser/LLLexer.cpp | 7 ++++++- lib/AsmParser/LLParser.cpp | 14 +++++++++++--- lib/AsmParser/LLParser.h | 16 ++++++++++++++++ lib/AsmParser/LLToken.h | 5 +++++ lib/VMCore/AsmWriter.cpp | 16 ++++++++++++++++ 5 files changed, 54 insertions(+), 4 deletions(-) diff --git a/lib/AsmParser/LLLexer.cpp b/lib/AsmParser/LLLexer.cpp index d8ffe8fb73..eb176aefcb 100644 --- a/lib/AsmParser/LLLexer.cpp +++ b/lib/AsmParser/LLLexer.cpp @@ -402,7 +402,7 @@ lltok::Kind LLLexer::LexExclaim() { } return lltok::exclaim; } - + /// LexIdentifier: Handle several related productions: /// Label [-a-zA-Z$._0-9]+: /// IntegerType i[0-9]+ @@ -498,6 +498,11 @@ lltok::Kind LLLexer::LexIdentifier() { KEYWORD(seq_cst); KEYWORD(singlethread); + KEYWORD(nnan) + KEYWORD(ninf) + KEYWORD(nsz) + KEYWORD(arcp) + KEYWORD(fast) KEYWORD(nuw); KEYWORD(nsw); KEYWORD(exact); diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp index 41cca68576..65f4245062 100644 --- a/lib/AsmParser/LLParser.cpp +++ b/lib/AsmParser/LLParser.cpp @@ -3012,7 +3012,17 @@ int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, } case lltok::kw_fadd: case lltok::kw_fsub: - case lltok::kw_fmul: return ParseArithmetic(Inst, PFS, KeywordVal, 2); + case lltok::kw_fmul: + case lltok::kw_fdiv: + case lltok::kw_frem: { + FastMathFlags FMF = EatFastMathFlagsIfPresent(); + int Res = ParseArithmetic(Inst, PFS, KeywordVal, 2); + if (Res != 0) + return Res; + if (FMF.any()) + Inst->setFastMathFlags(FMF); + return 0; + } case lltok::kw_sdiv: case lltok::kw_udiv: @@ -3027,8 +3037,6 @@ int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, case lltok::kw_urem: case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1); - case lltok::kw_fdiv: - case lltok::kw_frem: return ParseArithmetic(Inst, PFS, KeywordVal, 2); case lltok::kw_and: case lltok::kw_or: case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal); diff --git a/lib/AsmParser/LLParser.h b/lib/AsmParser/LLParser.h index 9f9672d67b..8e04705a7b 100644 --- a/lib/AsmParser/LLParser.h +++ b/lib/AsmParser/LLParser.h @@ -18,6 +18,7 @@ #include "llvm/Attributes.h" #include "llvm/Instructions.h" #include "llvm/Module.h" +#include "llvm/Operator.h" #include "llvm/Type.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/StringMap.h" @@ -154,6 +155,21 @@ namespace llvm { Lex.Lex(); return true; } + + FastMathFlags EatFastMathFlagsIfPresent() { + FastMathFlags FMF; + while (true) + switch (Lex.getKind()) { + case lltok::kw_fast: FMF.UnsafeAlgebra = true; Lex.Lex(); continue; + case lltok::kw_nnan: FMF.NoNaNs = true; Lex.Lex(); continue; + case lltok::kw_ninf: FMF.NoInfs = true; Lex.Lex(); continue; + case lltok::kw_nsz: FMF.NoSignedZeros = true; Lex.Lex(); continue; + case lltok::kw_arcp: FMF.AllowReciprocal = true; Lex.Lex(); continue; + default: return FMF; + } + return FMF; + } + bool ParseOptionalToken(lltok::Kind T, bool &Present, LocTy *Loc = 0) { if (Lex.getKind() != T) { Present = false; diff --git a/lib/AsmParser/LLToken.h b/lib/AsmParser/LLToken.h index 036686d318..1ec1b1e126 100644 --- a/lib/AsmParser/LLToken.h +++ b/lib/AsmParser/LLToken.h @@ -60,6 +60,11 @@ namespace lltok { kw_atomic, kw_unordered, kw_monotonic, kw_acquire, kw_release, kw_acq_rel, kw_seq_cst, kw_singlethread, + kw_nnan, + kw_ninf, + kw_nsz, + kw_arcp, + kw_fast, kw_nuw, kw_nsw, kw_exact, diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index c45a04f12b..433f3e011d 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -703,6 +703,22 @@ static void writeAtomicRMWOperation(raw_ostream &Out, } static void WriteOptimizationInfo(raw_ostream &Out, const User *U) { + if (const FPMathOperator *FPO = dyn_cast(U)) { + // Unsafe algebra implies all the others, no need to write them all out + if (FPO->hasUnsafeAlgebra()) + Out << " fast"; + else { + if (FPO->hasNoNaNs()) + Out << " nnan"; + if (FPO->hasNoInfs()) + Out << " ninf"; + if (FPO->hasNoSignedZeros()) + Out << " nsz"; + if (FPO->hasAllowReciprocal()) + Out << " arcp"; + } + } + if (const OverflowingBinaryOperator *OBO = dyn_cast(U)) { if (OBO->hasNoUnsignedWrap()) -- cgit v1.2.3