maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "[FPEnv] Allow CompoundStmt to keep FP options" 

On some buildbots test `ast-print-fp-pragmas.c` fails, need to investigate it.

This reverts commit 0401fd12d4.
This reverts commit b822efc740.
This commit is contained in:
Serge Pavlov 2022-07-01 15:32:56 +07:00
parent 0dd4fb0408
commit dc34d8df4c
23 changed files with 33 additions and 805 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clang/include/clang/AST/JSONNodeDumper.h
View File

@ -160,7 +160,6 @@ class JSONNodeDumper
std::string createPointerRepresentation(const void *Ptr);
llvm::json::Object createQualType(QualType QT, bool Desugar = true);
llvm::json::Object createBareDeclRef(const Decl *D);
llvm::json::Object createFPOptions(FPOptionsOverride FPO);
void writeBareDeclRef(const Decl *D);
llvm::json::Object createCXXRecordDefinitionData(const CXXRecordDecl *RD);
llvm::json::Object createCXXBaseSpecifier(const CXXBaseSpecifier &BS);
@ -318,7 +317,6 @@ public:
void VisitGotoStmt(const GotoStmt *GS);
void VisitWhileStmt(const WhileStmt *WS);
void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *OACS);
void VisitCompoundStmt(const CompoundStmt *IS);
void VisitNullTemplateArgument(const TemplateArgument &TA);
void VisitTypeTemplateArgument(const TemplateArgument &TA);

38
clang/include/clang/AST/Stmt.h
View File

@ -19,7 +19,6 @@
#include "clang/Basic/CapturedStmt.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/Specifiers.h"
#include "llvm/ADT/ArrayRef.h"
@ -129,10 +128,6 @@ protected:
unsigned : NumStmtBits;
/// True if the compound statement has one or more pragmas that set some
/// floating-point features.
unsigned HasFPFeatures : 1;
unsigned NumStmts;
};
@ -1403,9 +1398,8 @@ public:
};
/// CompoundStmt - This represents a group of statements like { stmt stmt }.
class CompoundStmt final
: public Stmt,
private llvm::TrailingObjects<CompoundStmt, Stmt *, FPOptionsOverride> {
class CompoundStmt final : public Stmt,
private llvm::TrailingObjects<CompoundStmt, Stmt *> {
friend class ASTStmtReader;
friend TrailingObjects;
@ -1415,49 +1409,27 @@ class CompoundStmt final
/// The location of the closing "}".
SourceLocation RBraceLoc;
CompoundStmt(ArrayRef<Stmt *> Stmts, FPOptionsOverride FPFeatures,
SourceLocation LB, SourceLocation RB);
CompoundStmt(ArrayRef<Stmt *> Stmts, SourceLocation LB, SourceLocation RB);
explicit CompoundStmt(EmptyShell Empty) : Stmt(CompoundStmtClass, Empty) {}
void setStmts(ArrayRef<Stmt *> Stmts);
/// Set FPOptionsOverride in trailing storage. Used only by Serialization.
void setStoredFPFeatures(FPOptionsOverride F) {
assert(hasStoredFPFeatures());
*getTrailingObjects<FPOptionsOverride>() = F;
}
size_t numTrailingObjects(OverloadToken<Stmt *>) const {
return CompoundStmtBits.NumStmts;
}
public:
static CompoundStmt *Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,
FPOptionsOverride FPFeatures, SourceLocation LB,
SourceLocation RB);
SourceLocation LB, SourceLocation RB);
// Build an empty compound statement with a location.
explicit CompoundStmt(SourceLocation Loc)
: Stmt(CompoundStmtClass), LBraceLoc(Loc), RBraceLoc(Loc) {
CompoundStmtBits.NumStmts = 0;
CompoundStmtBits.HasFPFeatures = 0;
}
// Build an empty compound statement.
static CompoundStmt *CreateEmpty(const ASTContext &C, unsigned NumStmts,
bool HasFPFeatures);
static CompoundStmt *CreateEmpty(const ASTContext &C, unsigned NumStmts);
bool body_empty() const { return CompoundStmtBits.NumStmts == 0; }
unsigned size() const { return CompoundStmtBits.NumStmts; }
bool hasStoredFPFeatures() const { return CompoundStmtBits.HasFPFeatures; }
/// Get FPOptionsOverride from trailing storage.
FPOptionsOverride getStoredFPFeatures() const {
assert(hasStoredFPFeatures());
return *getTrailingObjects<FPOptionsOverride>();
}
using body_iterator = Stmt **;
using body_range = llvm::iterator_range<body_iterator>;

1
clang/include/clang/AST/TextNodeDumper.h
View File

@ -246,7 +246,6 @@ public:
void VisitLabelStmt(const LabelStmt *Node);
void VisitGotoStmt(const GotoStmt *Node);
void VisitCaseStmt(const CaseStmt *Node);
void VisitCompoundStmt(const CompoundStmt *Node);
void VisitConstantExpr(const ConstantExpr *Node);
void VisitCallExpr(const CallExpr *Node);
void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node);

13
clang/include/clang/Basic/LangOptions.h
View File

@ -653,8 +653,6 @@ public:
private:
storage_type Value;
FPOptionsOverride getChangesSlow(const FPOptions &Base) const;
public:
FPOptions() : Value(0) {
setFPContractMode(LangOptions::FPM_Off);
@ -745,9 +743,6 @@ public:
return Opts;
}
/// Return difference with the given option set.
FPOptionsOverride getChangesFrom(const FPOptions &Base) const;
// We can define most of the accessors automatically:
#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
TYPE get##NAME() const { \
@ -796,8 +791,6 @@ public:
: Options(LO), OverrideMask(OverrideMaskBits) {}
FPOptionsOverride(FPOptions FPO)
: Options(FPO), OverrideMask(OverrideMaskBits) {}
FPOptionsOverride(FPOptions FPO, FPOptions::storage_type Mask)
: Options(FPO), OverrideMask(Mask) {}
bool requiresTrailingStorage() const { return OverrideMask != 0; }
@ -878,12 +871,6 @@ public:
LLVM_DUMP_METHOD void dump();
};
inline FPOptionsOverride FPOptions::getChangesFrom(const FPOptions &Base) const {
if (Value == Base.Value)
return FPOptionsOverride();
return getChangesSlow(Base);
}
/// Describes the kind of translation unit being processed.
enum TranslationUnitKind {
/// The translation unit is a complete translation unit.

7
clang/include/clang/Sema/ScopeInfo.h
View File

@ -74,12 +74,7 @@ public:
/// expression.
bool IsStmtExpr;
/// FP options at the beginning of the compound statement, prior to
/// any pragma.
FPOptions InitialFPFeatures;
CompoundScopeInfo(bool IsStmtExpr, FPOptions FPO)
: IsStmtExpr(IsStmtExpr), InitialFPFeatures(FPO) {}
CompoundScopeInfo(bool IsStmtExpr) : IsStmtExpr(IsStmtExpr) {}
void setHasEmptyLoopBodies() {
HasEmptyLoopBodies = true;

7
clang/lib/AST/ASTImporter.cpp
View File

@ -6339,10 +6339,9 @@ ExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
if (!ToRBracLocOrErr)
return ToRBracLocOrErr.takeError();
FPOptionsOverride FPO =
S->hasStoredFPFeatures() ? S->getStoredFPFeatures() : FPOptionsOverride();
return CompoundStmt::Create(Importer.getToContext(), ToStmts, FPO,
*ToLBracLocOrErr, *ToRBracLocOrErr);
return CompoundStmt::Create(
Importer.getToContext(), ToStmts,
*ToLBracLocOrErr, *ToRBracLocOrErr);
}
ExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {

15
clang/lib/AST/JSONNodeDumper.cpp
View File

@ -1692,18 +1692,3 @@ void JSONNodeDumper::visitVerbatimLineComment(
const comments::VerbatimLineComment *C, const comments::FullComment *) {
JOS.attribute("text", C->getText());
}
llvm::json::Object JSONNodeDumper::createFPOptions(FPOptionsOverride FPO) {
llvm::json::Object Ret;
#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
if (FPO.has##NAME##Override()) \
Ret.try_emplace(#NAME, static_cast<unsigned>(FPO.get##NAME##Override()));
#include "clang/Basic/FPOptions.def"
return Ret;
}
void JSONNodeDumper::VisitCompoundStmt(const CompoundStmt *S) {
VisitStmt(S);
if (S->hasStoredFPFeatures())
JOS.attribute("fpoptions", createFPOptions(S->getStoredFPFeatures()));
}

24
clang/lib/AST/Stmt.cpp
View File

@ -361,14 +361,11 @@ int64_t Stmt::getID(const ASTContext &Context) const {
return Context.getAllocator().identifyKnownAlignedObject<Stmt>(this);
}
CompoundStmt::CompoundStmt(ArrayRef<Stmt *> Stmts, FPOptionsOverride FPFeatures,
SourceLocation LB, SourceLocation RB)
CompoundStmt::CompoundStmt(ArrayRef<Stmt *> Stmts, SourceLocation LB,
SourceLocation RB)
: Stmt(CompoundStmtClass), LBraceLoc(LB), RBraceLoc(RB) {
CompoundStmtBits.NumStmts = Stmts.size();
CompoundStmtBits.HasFPFeatures = FPFeatures.requiresTrailingStorage();
setStmts(Stmts);
if (hasStoredFPFeatures())
setStoredFPFeatures(FPFeatures);
}
void CompoundStmt::setStmts(ArrayRef<Stmt *> Stmts) {
@ -379,23 +376,18 @@ void CompoundStmt::setStmts(ArrayRef<Stmt *> Stmts) {
}
CompoundStmt *CompoundStmt::Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,
FPOptionsOverride FPFeatures,
SourceLocation LB, SourceLocation RB) {
void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *, FPOptionsOverride>(
Stmts.size(), FPFeatures.requiresTrailingStorage()),
alignof(CompoundStmt));
return new (Mem) CompoundStmt(Stmts, FPFeatures, LB, RB);
C.Allocate(totalSizeToAlloc<Stmt *>(Stmts.size()), alignof(CompoundStmt));
return new (Mem) CompoundStmt(Stmts, LB, RB);
}
CompoundStmt *CompoundStmt::CreateEmpty(const ASTContext &C, unsigned NumStmts,
bool HasFPFeatures) {
void *Mem = C.Allocate(
totalSizeToAlloc<Stmt *, FPOptionsOverride>(NumStmts, HasFPFeatures),
alignof(CompoundStmt));
CompoundStmt *CompoundStmt::CreateEmpty(const ASTContext &C,
unsigned NumStmts) {
void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(NumStmts), alignof(CompoundStmt));
CompoundStmt *New = new (Mem) CompoundStmt(EmptyShell());
New->CompoundStmtBits.NumStmts = NumStmts;
New->CompoundStmtBits.HasFPFeatures = HasFPFeatures;
return New;
}

62
clang/lib/AST/StmtPrinter.cpp
View File

@ -128,7 +128,6 @@ namespace {
void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
void PrintOMPExecutableDirective(OMPExecutableDirective *S,
bool ForceNoStmt = false);
void PrintFPPragmas(CompoundStmt *S);
void PrintExpr(Expr *E) {
if (E)
@ -175,73 +174,12 @@ namespace {
/// with no newline after the }.
void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
OS << "{" << NL;
PrintFPPragmas(Node);
for (auto *I : Node->body())
PrintStmt(I);
Indent() << "}";
}
void StmtPrinter::PrintFPPragmas(CompoundStmt *S) {
if (!S->hasStoredFPFeatures())
return;
FPOptionsOverride FPO = S->getStoredFPFeatures();
bool FEnvAccess = false;
if (FPO.hasAllowFEnvAccessOverride()) {
FEnvAccess = FPO.getAllowFEnvAccessOverride();
Indent() << "#pragma STDC FENV_ACCESS " << (FEnvAccess ? "ON" : "OFF")
<< NL;
}
if (FPO.hasSpecifiedExceptionModeOverride()) {
LangOptions::FPExceptionModeKind EM =
FPO.getSpecifiedExceptionModeOverride();
if (!FEnvAccess || EM != LangOptions::FPE_Strict) {
Indent() << "#pragma clang fp exceptions(";
switch (FPO.getSpecifiedExceptionModeOverride()) {
default:
break;
case LangOptions::FPE_Ignore:
OS << "ignore";
break;
case LangOptions::FPE_MayTrap:
OS << "maytrap";
break;
case LangOptions::FPE_Strict:
OS << "strict";
break;
}
OS << ")\n";
}
}
if (FPO.hasConstRoundingModeOverride()) {
LangOptions::RoundingMode RM = FPO.getConstRoundingModeOverride();
Indent() << "#pragma STDC FENV_ROUND ";
switch (RM) {
case llvm::RoundingMode::TowardZero:
OS << "FE_TOWARDZERO";
break;
case llvm::RoundingMode::NearestTiesToEven:
OS << "FE_TONEAREST";
break;
case llvm::RoundingMode::TowardPositive:
OS << "FE_DOWNWARD";
break;
case llvm::RoundingMode::TowardNegative:
OS << "FE_UPWARD";
break;
case llvm::RoundingMode::NearestTiesToAway:
OS << "FE_TONEARESTFROMZERO";
break;
case llvm::RoundingMode::Dynamic:
OS << "FE_DYNAMIC";
break;
default:
llvm_unreachable("Invalid rounding mode");
}
OS << NL;
}
}
void StmtPrinter::PrintRawDecl(Decl *D) {
D->print(OS, Policy, IndentLevel);
}

6
clang/lib/AST/TextNodeDumper.cpp
View File

@ -2371,9 +2371,3 @@ void TextNodeDumper::VisitBlockDecl(const BlockDecl *D) {
void TextNodeDumper::VisitConceptDecl(const ConceptDecl *D) {
dumpName(D);
}
void TextNodeDumper::VisitCompoundStmt(const CompoundStmt *S) {
VisitStmt(S);
if (S->hasStoredFPFeatures())
printFPOptions(S->getStoredFPFeatures());
}

3
clang/lib/Analysis/BodyFarm.cpp
View File

@ -134,8 +134,7 @@ BinaryOperator *ASTMaker::makeComparison(const Expr *LHS, const Expr *RHS,
}
CompoundStmt *ASTMaker::makeCompound(ArrayRef<Stmt *> Stmts) {
return CompoundStmt::Create(C, Stmts, FPOptionsOverride(), SourceLocation(),
SourceLocation());
return CompoundStmt::Create(C, Stmts, SourceLocation(), SourceLocation());
}
DeclRefExpr *ASTMaker::makeDeclRefExpr(

9
clang/lib/Basic/LangOptions.cpp
View File

@ -204,15 +204,6 @@ FPOptions FPOptions::defaultWithoutTrailingStorage(const LangOptions &LO) {
return result;
}
FPOptionsOverride FPOptions::getChangesSlow(const FPOptions &Base) const {
FPOptions::storage_type OverrideMask = 0;
#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
if (get##NAME() != Base.get##NAME()) \
OverrideMask |= NAME##Mask;
#include "clang/Basic/FPOptions.def"
return FPOptionsOverride(*this, OverrideMask);
}
LLVM_DUMP_METHOD void FPOptions::dump() {
#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
llvm::errs() << "\n " #NAME " " << get##NAME();

4
clang/lib/CodeGen/CGCoroutine.cpp
View File

@ -238,8 +238,8 @@ static LValueOrRValue emitSuspendExpression(CodeGenFunction &CGF, CGCoroData &Co
auto Loc = S.getResumeExpr()->getExprLoc();
auto *Catch = new (CGF.getContext())
CXXCatchStmt(Loc, /*exDecl=*/nullptr, Coro.ExceptionHandler);
auto *TryBody = CompoundStmt::Create(CGF.getContext(), S.getResumeExpr(),
FPOptionsOverride(), Loc, Loc);
auto *TryBody =
CompoundStmt::Create(CGF.getContext(), S.getResumeExpr(), Loc, Loc);
TryStmt = CXXTryStmt::Create(CGF.getContext(), Loc, TryBody, Catch);
CGF.EnterCXXTryStmt(*TryStmt);
}

3
clang/lib/Sema/Sema.cpp
View File

@ -2219,8 +2219,7 @@ operator()(sema::FunctionScopeInfo *Scope) const {
}
void Sema::PushCompoundScope(bool IsStmtExpr) {
getCurFunction()->CompoundScopes.push_back(
CompoundScopeInfo(IsStmtExpr, getCurFPFeatures()));
getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
}
void Sema::PopCompoundScope() {

8
clang/lib/Sema/SemaDeclCXX.cpp
View File

@ -15353,8 +15353,8 @@ void Sema::DefineImplicitLambdaToFunctionPointerConversion(
VK_LValue, Conv->getLocation());
assert(FunctionRef && "Can't refer to __invoke function?");
Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
Conv->setBody(CompoundStmt::Create(Context, Return, FPOptionsOverride(),
Conv->getLocation(), Conv->getLocation()));
Conv->setBody(CompoundStmt::Create(Context, Return, Conv->getLocation(),
Conv->getLocation()));
Conv->markUsed(Context);
Conv->setReferenced();
@ -15408,8 +15408,8 @@ void Sema::DefineImplicitLambdaToBlockPointerConversion(
// Set the body of the conversion function.
Stmt *ReturnS = Return.get();
Conv->setBody(CompoundStmt::Create(Context, ReturnS, FPOptionsOverride(),
Conv->getLocation(), Conv->getLocation()));
Conv->setBody(CompoundStmt::Create(Context, ReturnS, Conv->getLocation(),
Conv->getLocation()));
Conv->markUsed(Context);
// We're done; notify the mutation listener, if any.

5
clang/lib/Sema/SemaExprCXX.cpp
View File

@ -7295,9 +7295,8 @@ Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
// a StmtExpr; currently this is only used for asm statements.
// This is hacky, either create a new CXXStmtWithTemporaries statement or
// a new AsmStmtWithTemporaries.
CompoundStmt *CompStmt =
CompoundStmt::Create(Context, SubStmt, FPOptionsOverride(),
SourceLocation(), SourceLocation());
CompoundStmt *CompStmt = CompoundStmt::Create(
Context, SubStmt, SourceLocation(), SourceLocation());
Expr *E = new (Context)
StmtExpr(CompStmt, Context.VoidTy, SourceLocation(), SourceLocation(),
/*FIXME TemplateDepth=*/0);

9
clang/lib/Sema/SemaOpenMP.cpp
View File

@ -14454,8 +14454,8 @@ StmtResult Sema::ActOnOpenMPTileDirective(ArrayRef<OMPClause *> Clauses,
SmallVector<Stmt *, 4> BodyParts;
BodyParts.append(LoopHelper.Updates.begin(), LoopHelper.Updates.end());
BodyParts.push_back(Inner);
Inner = CompoundStmt::Create(Context, BodyParts, FPOptionsOverride(),
Inner->getBeginLoc(), Inner->getEndLoc());
Inner = CompoundStmt::Create(Context, BodyParts, Inner->getBeginLoc(),
Inner->getEndLoc());
Inner = new (Context)
ForStmt(Context, InitStmt.get(), CondExpr.get(), nullptr,
IncrStmt.get(), Inner, LoopHelper.Init->getBeginLoc(),
@ -14729,9 +14729,8 @@ StmtResult Sema::ActOnOpenMPUnrollDirective(ArrayRef<OMPClause *> Clauses,
SmallVector<Stmt *> InnerBodyStmts;
InnerBodyStmts.append(LoopHelper.Updates.begin(), LoopHelper.Updates.end());
InnerBodyStmts.push_back(Body);
CompoundStmt *InnerBody =
CompoundStmt::Create(Context, InnerBodyStmts, FPOptionsOverride(),
Body->getBeginLoc(), Body->getEndLoc());
CompoundStmt *InnerBody = CompoundStmt::Create(
Context, InnerBodyStmts, Body->getBeginLoc(), Body->getEndLoc());
ForStmt *InnerFor = new (Context)
ForStmt(Context, InnerInit.get(), InnerCond.get(), nullptr,
InnerIncr.get(), InnerBody, LoopHelper.Init->getBeginLoc(),

11
clang/lib/Sema/SemaStmt.cpp
View File

@ -442,16 +442,7 @@ StmtResult Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
DiagnoseEmptyLoopBody(Elts[i], Elts[i + 1]);
}
// Calculate difference between FP options in this compound statement and in
// the enclosing one. If this is a function body, take the difference against
// default options. In this case the difference will indicate options that are
// changed upon entry to the statement.
FPOptions FPO = (getCurFunction()->CompoundScopes.size() == 1)
? FPOptions(getLangOpts())
: getCurCompoundScope().InitialFPFeatures;
FPOptionsOverride FPDiff = getCurFPFeatures().getChangesFrom(FPO);
return CompoundStmt::Create(Context, Elts, FPDiff, L, R);
return CompoundStmt::Create(Context, Elts, L, R);
}
ExprResult

8
clang/lib/Serialization/ASTReaderStmt.cpp
View File

@ -152,14 +152,9 @@ void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
VisitStmt(S);
SmallVector<Stmt *, 16> Stmts;
unsigned NumStmts = Record.readInt();
unsigned HasFPFeatures = Record.readInt();
assert(S->hasStoredFPFeatures() == HasFPFeatures);
while (NumStmts--)
Stmts.push_back(Record.readSubStmt());
S->setStmts(Stmts);
if (HasFPFeatures)
S->setStoredFPFeatures(
FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
S->LBraceLoc = readSourceLocation();
S->RBraceLoc = readSourceLocation();
}
@ -2768,8 +2763,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
case STMT_COMPOUND:
S = CompoundStmt::CreateEmpty(
Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields],
/*HasFPFeatures=*/Record[ASTStmtReader::NumStmtFields + 1]);
Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields]);
break;
case STMT_CASE:

3
clang/lib/Serialization/ASTWriterStmt.cpp
View File

@ -81,11 +81,8 @@ void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
VisitStmt(S);
Record.push_back(S->size());
Record.push_back(S->hasStoredFPFeatures());
for (auto *CS : S->body())
Record.AddStmt(CS);
if (S->hasStoredFPFeatures())
Record.push_back(S->getStoredFPFeatures().getAsOpaqueInt());
Record.AddSourceLocation(S->getLBracLoc());
Record.AddSourceLocation(S->getRBracLoc());
Code = serialization::STMT_COMPOUND;

46
clang/test/AST/ast-dump-fpfeatures.cpp
View File

@ -141,49 +141,3 @@ float func_15(float x, float y) {
// CHECK: CompoundStmt
// CHECK-NEXT: ReturnStmt
// CHECK-NEXT: BinaryOperator {{.*}} 'float' '+' ConstRoundingMode=towardzero
float func_16(float x, float y) {
#pragma STDC FENV_ROUND FE_TOWARDZERO
if (x < 0) {
#pragma STDC FENV_ROUND FE_UPWARD
return x - y;
}
return x + y;
}
// CHECK-LABEL: FunctionDecl {{.*}} func_16 'float (float, float)'
// CHECK: CompoundStmt {{.*}} ConstRoundingMode=towardzero
// CHECK: IfStmt
// CHECK: CompoundStmt {{.*}} ConstRoundingMode=upward
// CHECK: ReturnStmt
// CHECK: BinaryOperator {{.*}} ConstRoundingMode=upward
// CHECK: ReturnStmt
// CHECK: BinaryOperator {{.*}} ConstRoundingMode=towardzero
float func_17(float x, float y) {
#pragma STDC FENV_ROUND FE_TOWARDZERO
if (x < 0) {
#pragma STDC FENV_ROUND FE_TOWARDZERO
return x - y;
}
return x + y;
}
// CHECK-LABEL: FunctionDecl {{.*}} func_17 'float (float, float)'
// CHECK: CompoundStmt {{.*}} ConstRoundingMode=towardzero
// CHECK: IfStmt
// CHECK: CompoundStmt {{.*}}
// CHECK: ReturnStmt
// CHECK: BinaryOperator {{.*}} ConstRoundingMode=towardzero
// CHECK: ReturnStmt
// CHECK: BinaryOperator {{.*}} ConstRoundingMode=towardzero
#pragma STDC FENV_ROUND FE_DOWNWARD
float func_18(float x, float y) {
return x + y;
}
// CHECK-LABEL: FunctionDecl {{.*}} func_18 'float (float, float)'
// CHECK: CompoundStmt {{.*}} ConstRoundingMode=downward
// CHECK: ReturnStmt
// CHECK: BinaryOperator {{.*}} ConstRoundingMode=downward

485
clang/test/AST/ast-dump-pragma-json.c
View File

@ -1,485 +0,0 @@
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -ast-dump=json %s | FileCheck %s
float func_16(float x, float y) {
#pragma STDC FENV_ROUND FE_TOWARDZERO
if (x < 0) {
#pragma STDC FENV_ROUND FE_UPWARD
return x - y;
}
return x + y;
}
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
// using --filters=CompoundStmt
// CHECK-NOT: {{^}}Dumping
// CHECK: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 116,
// CHECK-NEXT: "col": 33,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 249,
// CHECK-NEXT: "line": 10,
// CHECK-NEXT: "col": 1,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "fpoptions": {
// CHECK-NEXT: "ConstRoundingMode": 0
// CHECK-NEXT: },
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "IfStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 160,
// CHECK-NEXT: "line": 5,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 2
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 231,
// CHECK-NEXT: "line": 8,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 164,
// CHECK-NEXT: "line": 5,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 168,
// CHECK-NEXT: "col": 11,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "<",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 164,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 164,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 164,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 164,
// CHECK-NEXT: "col": 7,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 168,
// CHECK-NEXT: "col": 11,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 168,
// CHECK-NEXT: "col": 11,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "IntegralToFloating",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "IntegerLiteral",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 168,
// CHECK-NEXT: "col": 11,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 168,
// CHECK-NEXT: "col": 11,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "value": "0"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "CompoundStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 171,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 231,
// CHECK-NEXT: "line": 8,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "fpoptions": {
// CHECK-NEXT: "ConstRoundingMode": 2
// CHECK-NEXT: },
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ReturnStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 215,
// CHECK-NEXT: "line": 7,
// CHECK-NEXT: "col": 5,
// CHECK-NEXT: "tokLen": 6
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 226,
// CHECK-NEXT: "col": 16,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 222,
// CHECK-NEXT: "col": 12,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 226,
// CHECK-NEXT: "col": 16,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "-",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 222,
// CHECK-NEXT: "col": 12,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 222,
// CHECK-NEXT: "col": 12,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 222,
// CHECK-NEXT: "col": 12,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 222,
// CHECK-NEXT: "col": 12,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 226,
// CHECK-NEXT: "col": 16,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 226,
// CHECK-NEXT: "col": 16,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 226,
// CHECK-NEXT: "col": 16,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 226,
// CHECK-NEXT: "col": 16,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "y",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ReturnStmt",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 235,
// CHECK-NEXT: "line": 9,
// CHECK-NEXT: "col": 3,
// CHECK-NEXT: "tokLen": 6
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 246,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "BinaryOperator",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 242,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 246,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "opcode": "+",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 242,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 242,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 242,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 242,
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 246,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 246,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "prvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "offset": 246,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "offset": 246,
// CHECK-NEXT: "col": 14,
// CHECK-NEXT: "tokLen": 1
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "y",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "float"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }

69
clang/test/AST/ast-print-fp-pragmas.c
View File

@ -1,69 +0,0 @@
// RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s
float func_1(float x, float y) {
#pragma STDC FENV_ACCESS ON
if (x != 0) {
return y;
}
return x + y;
}
// CHECK-LABEL: float func_1(float x, float y) {
// CHECK-NEXT: #pragma STDC FENV_ACCESS ON
// CHECK-NEXT: if (x != 0) {
// CHECK-NEXT: return y;
// CHECK-NEXT: }
// CHECK-NEXT: return x + y;
// CHECK-NEXT: }
float func_2(float x, float y) {
#pragma STDC FENV_ACCESS ON
if (x != 0) {
#pragma STDC FENV_ACCESS OFF
return y;
}
return x + y;
}
// CHECK-LABEL: float func_2(float x, float y) {
// CHECK-NEXT: #pragma STDC FENV_ACCESS ON
// CHECK-NEXT: if (x != 0) {
// CHECK-NEXT: #pragma STDC FENV_ACCESS OFF
// CHECK-NEXT: return y;
// CHECK-NEXT: }
// CHECK-NEXT: return x + y;
// CHECK-NEXT: }
float func_3(float x, float y) {
#pragma STDC FENV_ROUND FE_DOWNWARD
return x + y;
}
// CHECK-LABEL: float func_3(float x, float y) {
// CHECK-NEXT: #pragma STDC FENV_ROUND FE_UPWARD
// CHECK-NEXT: return x + y;
// CHECK-NEXT: }
float func_4(float x, float y, float z) {
#pragma STDC FENV_ACCESS ON
#pragma clang fp exceptions(maytrap)
#pragma STDC FENV_ROUND FE_UPWARD
if (z != 0) {
#pragma STDC FENV_ACCESS OFF
#pragma STDC FENV_ROUND FE_TOWARDZERO
return z + x;
}
return x + y;
}
// CHECK-LABEL: float func_4(float x, float y, float z) {
// CHECK-NEXT: #pragma STDC FENV_ACCESS ON
// CHECK-NEXT: #pragma clang fp exceptions(maytrap)
// CHECK-NEXT: #pragma STDC FENV_ROUND FE_DOWNWARD
// CHECK-NEXT: if (z != 0) {
// CHECK-NEXT: #pragma STDC FENV_ACCESS OFF
// CHECK-NEXT: #pragma STDC FENV_ROUND FE_TOWARDZERO
// CHECK-NEXT: return z + x;
// CHECK-NEXT: }
// CHECK-NEXT: return x + y;
// CHECK-NEXT: }