diff --git a/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp b/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp index cbec56fbf7a59b..fefa56ae5ef5ed 100644 --- a/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp +++ b/clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp @@ -649,9 +649,14 @@ StringRef LoopConvertCheck::getContainerString(ASTContext *Context, const ForStmt *Loop, const Expr *ContainerExpr) { StringRef ContainerString; - if (isa(ContainerExpr->IgnoreParenImpCasts())) { + ContainerExpr = ContainerExpr->IgnoreParenImpCasts(); + if (isa(ContainerExpr)) { ContainerString = "this"; } else { + // For CXXOperatorCallExpr (e.g. vector_ptr->size()), its first argument is + // the class object (vector_ptr) we are targeting. + if (const auto* E = dyn_cast(ContainerExpr)) + ContainerExpr = E->getArg(0); ContainerString = getStringFromRange(Context->getSourceManager(), Context->getLangOpts(), ContainerExpr->getSourceRange()); diff --git a/clang-tools-extra/clangd/unittests/SelectionTests.cpp b/clang-tools-extra/clangd/unittests/SelectionTests.cpp index 7316dea42bd2b9..e1c873a22b13a8 100644 --- a/clang-tools-extra/clangd/unittests/SelectionTests.cpp +++ b/clang-tools-extra/clangd/unittests/SelectionTests.cpp @@ -380,6 +380,14 @@ TEST(SelectionTest, CommonAncestor) { {"struct foo { [[^~foo()]]; };", "CXXDestructorDecl"}, // FIXME: The following to should be class itself instead. {"struct foo { [[fo^o(){}]] };", "CXXConstructorDecl"}, + + {R"cpp( + struct S1 { void f(); }; + struct S2 { S1 * operator->(); }; + void test(S2 s2) { + s2[[-^>]]f(); + } + )cpp", "DeclRefExpr"} // DeclRefExpr to the "operator->" method. }; for (const Case &C : Cases) { Annotations Test(C.Code); diff --git a/clang-tools-extra/clangd/unittests/XRefsTests.cpp b/clang-tools-extra/clangd/unittests/XRefsTests.cpp index d387fd219a08b4..1e687fd109e340 100644 --- a/clang-tools-extra/clangd/unittests/XRefsTests.cpp +++ b/clang-tools-extra/clangd/unittests/XRefsTests.cpp @@ -452,6 +452,14 @@ TEST(LocateSymbol, All) { } )cpp", + R"cpp( + struct S1 { void f(); }; + struct S2 { S1 * $decl[[operator]]->(); }; + void test(S2 s2) { + s2-^>f(); + } + )cpp", + R"cpp(// Declaration of explicit template specialization template struct $decl[[Foo]] {}; diff --git a/clang/include/clang/AST/ComputeDependence.h b/clang/include/clang/AST/ComputeDependence.h new file mode 100644 index 00000000000000..593ff3a6eb163a --- /dev/null +++ b/clang/include/clang/AST/ComputeDependence.h @@ -0,0 +1,182 @@ +//===--- ComputeDependence.h -------------------------------------- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// Calculate various template dependency flags for the AST. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_AST_COMPUTE_DEPENDENCE_H +#define LLVM_CLANG_AST_COMPUTE_DEPENDENCE_H + +#include "clang/AST/DependenceFlags.h" +#include "clang/Basic/ExceptionSpecificationType.h" +#include "llvm/ADT/ArrayRef.h" + +namespace clang { + +class ASTContext; + +class Expr; +class FullExpr; +class OpaqueValueExpr; +class ParenExpr; +class UnaryOperator; +class UnaryExprOrTypeTraitExpr; +class ArraySubscriptExpr; +class CompoundLiteralExpr; +class CastExpr; +class BinaryOperator; +class ConditionalOperator; +class BinaryConditionalOperator; +class StmtExpr; +class ConvertVectorExpr; +class VAArgExpr; +class ChooseExpr; +class NoInitExpr; +class ArrayInitLoopExpr; +class ImplicitValueInitExpr; +class InitListExpr; +class ExtVectorElementExpr; +class BlockExpr; +class AsTypeExpr; +class DeclRefExpr; +class CXXRewrittenBinaryOperator; +class CXXStdInitializerListExpr; +class CXXTypeidExpr; +class MSPropertyRefExpr; +class MSPropertySubscriptExpr; +class CXXUuidofExpr; +class CXXThisExpr; +class CXXThrowExpr; +class CXXBindTemporaryExpr; +class CXXScalarValueInitExpr; +class CXXDeleteExpr; +class ArrayTypeTraitExpr; +class ExpressionTraitExpr; +class CXXNoexceptExpr; +class SubstNonTypeTemplateParmExpr; +class CoroutineSuspendExpr; +class DependentCoawaitExpr; +class CXXNewExpr; +class CXXPseudoDestructorExpr; +class OverloadExpr; +class DependentScopeDeclRefExpr; +class CXXConstructExpr; +class LambdaExpr; +class CXXUnresolvedConstructExpr; +class CXXDependentScopeMemberExpr; +class MaterializeTemporaryExpr; +class TypeTraitExpr; +class ConceptSpecializationExpr; +class PredefinedExpr; +class CallExpr; +class OffsetOfExpr; +class MemberExpr; +class ShuffleVectorExpr; +class GenericSelectionExpr; +class DesignatedInitExpr; +class ParenListExpr; +class PseudoObjectExpr; +class AtomicExpr; +class OMPArraySectionExpr; +class ObjCArrayLiteral; +class ObjCDictionaryLiteral; +class ObjCBoxedExpr; +class ObjCEncodeExpr; +class ObjCIvarRefExpr; +class ObjCPropertyRefExpr; +class ObjCSubscriptRefExpr; +class ObjCIsaExpr; +class ObjCIndirectCopyRestoreExpr; +class ObjCMessageExpr; + +// The following functions are called from constructors of `Expr`, so they +// should not access anything beyond basic +ExprDependence computeDependence(FullExpr *E); +ExprDependence computeDependence(OpaqueValueExpr *E); +ExprDependence computeDependence(ParenExpr *E); +ExprDependence computeDependence(UnaryOperator *E); +ExprDependence computeDependence(UnaryExprOrTypeTraitExpr *E); +ExprDependence computeDependence(ArraySubscriptExpr *E); +ExprDependence computeDependence(CompoundLiteralExpr *E); +ExprDependence computeDependence(CastExpr *E); +ExprDependence computeDependence(BinaryOperator *E); +ExprDependence computeDependence(ConditionalOperator *E); +ExprDependence computeDependence(BinaryConditionalOperator *E); +ExprDependence computeDependence(StmtExpr *E, unsigned TemplateDepth); +ExprDependence computeDependence(ConvertVectorExpr *E); +ExprDependence computeDependence(VAArgExpr *E); +ExprDependence computeDependence(ChooseExpr *E); +ExprDependence computeDependence(NoInitExpr *E); +ExprDependence computeDependence(ArrayInitLoopExpr *E); +ExprDependence computeDependence(ImplicitValueInitExpr *E); +ExprDependence computeDependence(InitListExpr *E); +ExprDependence computeDependence(ExtVectorElementExpr *E); +ExprDependence computeDependence(BlockExpr *E); +ExprDependence computeDependence(AsTypeExpr *E); +ExprDependence computeDependence(DeclRefExpr *E, const ASTContext &Ctx); +ExprDependence computeDependence(CXXRewrittenBinaryOperator *E); +ExprDependence computeDependence(CXXStdInitializerListExpr *E); +ExprDependence computeDependence(CXXTypeidExpr *E); +ExprDependence computeDependence(MSPropertyRefExpr *E); +ExprDependence computeDependence(MSPropertySubscriptExpr *E); +ExprDependence computeDependence(CXXUuidofExpr *E); +ExprDependence computeDependence(CXXThisExpr *E); +ExprDependence computeDependence(CXXThrowExpr *E); +ExprDependence computeDependence(CXXBindTemporaryExpr *E); +ExprDependence computeDependence(CXXScalarValueInitExpr *E); +ExprDependence computeDependence(CXXDeleteExpr *E); +ExprDependence computeDependence(ArrayTypeTraitExpr *E); +ExprDependence computeDependence(ExpressionTraitExpr *E); +ExprDependence computeDependence(CXXNoexceptExpr *E, CanThrowResult CT); +ExprDependence computeDependence(SubstNonTypeTemplateParmExpr *E); +ExprDependence computeDependence(CoroutineSuspendExpr *E); +ExprDependence computeDependence(DependentCoawaitExpr *E); +ExprDependence computeDependence(CXXNewExpr *E); +ExprDependence computeDependence(CXXPseudoDestructorExpr *E); +ExprDependence computeDependence(OverloadExpr *E, bool KnownDependent, + bool KnownInstantiationDependent, + bool KnownContainsUnexpandedParameterPack); +ExprDependence computeDependence(DependentScopeDeclRefExpr *E); +ExprDependence computeDependence(CXXConstructExpr *E); +ExprDependence computeDependence(LambdaExpr *E, + bool ContainsUnexpandedParameterPack); +ExprDependence computeDependence(CXXUnresolvedConstructExpr *E); +ExprDependence computeDependence(CXXDependentScopeMemberExpr *E); +ExprDependence computeDependence(MaterializeTemporaryExpr *E); +ExprDependence computeDependence(TypeTraitExpr *E); +ExprDependence computeDependence(ConceptSpecializationExpr *E, + bool ValueDependent); + +ExprDependence computeDependence(PredefinedExpr *E); +ExprDependence computeDependence(CallExpr *E, llvm::ArrayRef PreArgs); +ExprDependence computeDependence(OffsetOfExpr *E); +ExprDependence computeDependence(MemberExpr *E); +ExprDependence computeDependence(ShuffleVectorExpr *E); +ExprDependence computeDependence(GenericSelectionExpr *E, + bool ContainsUnexpandedPack); +ExprDependence computeDependence(DesignatedInitExpr *E); +ExprDependence computeDependence(ParenListExpr *E); +ExprDependence computeDependence(PseudoObjectExpr *E); +ExprDependence computeDependence(AtomicExpr *E); + +ExprDependence computeDependence(OMPArraySectionExpr *E); + +ExprDependence computeDependence(ObjCArrayLiteral *E); +ExprDependence computeDependence(ObjCDictionaryLiteral *E); +ExprDependence computeDependence(ObjCBoxedExpr *E); +ExprDependence computeDependence(ObjCEncodeExpr *E); +ExprDependence computeDependence(ObjCIvarRefExpr *E); +ExprDependence computeDependence(ObjCPropertyRefExpr *E); +ExprDependence computeDependence(ObjCSubscriptRefExpr *E); +ExprDependence computeDependence(ObjCIsaExpr *E); +ExprDependence computeDependence(ObjCIndirectCopyRestoreExpr *E); +ExprDependence computeDependence(ObjCMessageExpr *E); + +} // namespace clang +#endif diff --git a/clang/include/clang/AST/DeclCXX.h b/clang/include/clang/AST/DeclCXX.h index 987738f73676b4..60d99f1a487f85 100644 --- a/clang/include/clang/AST/DeclCXX.h +++ b/clang/include/clang/AST/DeclCXX.h @@ -2415,17 +2415,6 @@ class CXXConstructorDecl final : ExplicitSpecKind::ResolvedFalse); } - void setExplicitSpecifier(ExplicitSpecifier ES) { - assert((!ES.getExpr() || - CXXConstructorDeclBits.HasTrailingExplicitSpecifier) && - "cannot set this explicit specifier. no trail-allocated space for " - "explicit"); - if (ES.getExpr()) - *getCanonicalDecl()->getTrailingObjects() = ES; - else - CXXConstructorDeclBits.IsSimpleExplicit = ES.isExplicit(); - } - enum TraillingAllocKind { TAKInheritsConstructor = 1, TAKHasTailExplicit = 1 << 1, @@ -2451,6 +2440,17 @@ class CXXConstructorDecl final InheritedConstructor Inherited = InheritedConstructor(), Expr *TrailingRequiresClause = nullptr); + void setExplicitSpecifier(ExplicitSpecifier ES) { + assert((!ES.getExpr() || + CXXConstructorDeclBits.HasTrailingExplicitSpecifier) && + "cannot set this explicit specifier. no trail-allocated space for " + "explicit"); + if (ES.getExpr()) + *getCanonicalDecl()->getTrailingObjects() = ES; + else + CXXConstructorDeclBits.IsSimpleExplicit = ES.isExplicit(); + } + ExplicitSpecifier getExplicitSpecifier() { return getCanonicalDecl()->getExplicitSpecifierInternal(); } diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h index def1ab18706c15..e9c4879b41e896 100755 --- a/clang/include/clang/AST/DeclTemplate.h +++ b/clang/include/clang/AST/DeclTemplate.h @@ -1927,6 +1927,10 @@ class ClassTemplateSpecializationDecl getTemplateSpecializationKind()); } + void setSpecializedTemplate(ClassTemplateDecl *Specialized) { + SpecializedTemplate = Specialized; + } + void setSpecializationKind(TemplateSpecializationKind TSK) { SpecializationKind = TSK; } diff --git a/clang/include/clang/AST/DependenceFlags.h b/clang/include/clang/AST/DependenceFlags.h index 8aeb828b8e8c13..21daf0a203ac88 100644 --- a/clang/include/clang/AST/DependenceFlags.h +++ b/clang/include/clang/AST/DependenceFlags.h @@ -23,6 +23,7 @@ struct ExprDependenceScope { None = 0, All = 15, + TypeValue = Type | Value, TypeInstantiation = Type | Instantiation, ValueInstantiation = Value | Instantiation, TypeValueInstantiation = Type | Value | Instantiation, @@ -94,6 +95,12 @@ inline ExprDependence toExprDependence(TypeDependence TD) { return toExprDependence(static_cast( TD & ~TypeDependence::VariablyModified)); } +inline ExprDependence toExprDependence(NestedNameSpecifierDependence NSD) { + // This hack works because TypeDependence and TemplateArgumentDependence + // share the same bit representation. + return toExprDependence(static_cast(NSD)) & + ~ExprDependence::TypeValue; +} inline ExprDependence turnTypeToValueDependence(ExprDependence D) { // Type-dependent expressions are always be value-dependent, so we simply drop // type dependency. diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h index 372d64763c4bc3..7448281c928905 100644 --- a/clang/include/clang/AST/Expr.h +++ b/clang/include/clang/AST/Expr.h @@ -15,6 +15,7 @@ #include "clang/AST/APValue.h" #include "clang/AST/ASTVector.h" +#include "clang/AST/ComputeDependence.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclAccessPair.h" #include "clang/AST/DependenceFlags.h" @@ -117,21 +118,9 @@ class Expr : public ValueStmt { Expr &operator=(Expr&&) = delete; protected: - Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK, - bool TD, bool VD, bool ID, bool ContainsUnexpandedParameterPack) - : ValueStmt(SC) - { - auto D = ExprDependence::None; - if (TD) - D |= ExprDependence::Type; - if (VD) - D |= ExprDependence::Value; - if (ID) - D |= ExprDependence::Instantiation; - if (ContainsUnexpandedParameterPack) - D |= ExprDependence::UnexpandedPack; - - ExprBits.Dependent = static_cast(D); + Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK) + : ValueStmt(SC) { + ExprBits.Dependent = 0; ExprBits.ValueKind = VK; ExprBits.ObjectKind = OK; assert(ExprBits.ObjectKind == OK && "truncated kind"); @@ -160,6 +149,8 @@ class Expr : public ValueStmt { return static_cast(ExprBits.Dependent); } + /// Each concrete expr subclass is expected to compute its dependence and call + /// this in the constructor. void setDependence(ExprDependence Deps) { ExprBits.Dependent = static_cast(Deps); } @@ -958,11 +949,11 @@ class FullExpr : public Expr { Stmt *SubExpr; FullExpr(StmtClass SC, Expr *subexpr) - : Expr(SC, subexpr->getType(), - subexpr->getValueKind(), subexpr->getObjectKind(), - subexpr->isTypeDependent(), subexpr->isValueDependent(), - subexpr->isInstantiationDependent(), - subexpr->containsUnexpandedParameterPack()), SubExpr(subexpr) {} + : Expr(SC, subexpr->getType(), subexpr->getValueKind(), + subexpr->getObjectKind()), + SubExpr(subexpr) { + setDependence(computeDependence(this)); + } FullExpr(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) {} public: @@ -1088,19 +1079,11 @@ class OpaqueValueExpr : public Expr { public: OpaqueValueExpr(SourceLocation Loc, QualType T, ExprValueKind VK, - ExprObjectKind OK = OK_Ordinary, - Expr *SourceExpr = nullptr) - : Expr(OpaqueValueExprClass, T, VK, OK, - T->isDependentType() || - (SourceExpr && SourceExpr->isTypeDependent()), - T->isDependentType() || - (SourceExpr && SourceExpr->isValueDependent()), - T->isInstantiationDependentType() || - (SourceExpr && SourceExpr->isInstantiationDependent()), - false), - SourceExpr(SourceExpr) { + ExprObjectKind OK = OK_Ordinary, Expr *SourceExpr = nullptr) + : Expr(OpaqueValueExprClass, T, VK, OK), SourceExpr(SourceExpr) { setIsUnique(false); OpaqueValueExprBits.Loc = Loc; + setDependence(computeDependence(this)); } /// Given an expression which invokes a copy constructor --- i.e. a @@ -1550,10 +1533,10 @@ class CharacterLiteral : public Expr { // type should be IntTy CharacterLiteral(unsigned value, CharacterKind kind, QualType type, SourceLocation l) - : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary, false, false, - false, false), - Value(value), Loc(l) { + : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary), Value(value), + Loc(l) { CharacterLiteralBits.Kind = kind; + setDependence(ExprDependence::None); } /// Construct an empty character literal. @@ -1669,9 +1652,9 @@ class ImaginaryLiteral : public Expr { Stmt *Val; public: ImaginaryLiteral(Expr *val, QualType Ty) - : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary, false, false, - false, false), - Val(val) {} + : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary), Val(val) { + setDependence(ExprDependence::None); + } /// Build an empty imaginary literal. explicit ImaginaryLiteral(EmptyShell Empty) @@ -2002,12 +1985,11 @@ class ParenExpr : public Expr { Stmt *Val; public: ParenExpr(SourceLocation l, SourceLocation r, Expr *val) - : Expr(ParenExprClass, val->getType(), - val->getValueKind(), val->getObjectKind(), - val->isTypeDependent(), val->isValueDependent(), - val->isInstantiationDependent(), - val->containsUnexpandedParameterPack()), - L(l), R(r), Val(val) {} + : Expr(ParenExprClass, val->getType(), val->getValueKind(), + val->getObjectKind()), + L(l), R(r), Val(val) { + setDependence(computeDependence(this)); + } /// Construct an empty parenthesized expression. explicit ParenExpr(EmptyShell Empty) @@ -2057,16 +2039,11 @@ class UnaryOperator : public Expr { UnaryOperator(Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow) - : Expr(UnaryOperatorClass, type, VK, OK, - input->isTypeDependent() || type->isDependentType(), - input->isValueDependent(), - (input->isInstantiationDependent() || - type->isInstantiationDependentType()), - input->containsUnexpandedParameterPack()), - Val(input) { + : Expr(UnaryOperatorClass, type, VK, OK), Val(input) { UnaryOperatorBits.Opc = opc; UnaryOperatorBits.CanOverflow = CanOverflow; UnaryOperatorBits.Loc = l; + setDependence(computeDependence(this)); } /// Build an empty unary operator. @@ -2385,17 +2362,13 @@ class UnaryExprOrTypeTraitExpr : public Expr { public: UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo, QualType resultType, SourceLocation op, - SourceLocation rp) : - Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary, - false, // Never type-dependent (C++ [temp.dep.expr]p3). - // Value-dependent if the argument is type-dependent. - TInfo->getType()->isDependentType(), - TInfo->getType()->isInstantiationDependentType(), - TInfo->getType()->containsUnexpandedParameterPack()), - OpLoc(op), RParenLoc(rp) { + SourceLocation rp) + : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary), + OpLoc(op), RParenLoc(rp) { UnaryExprOrTypeTraitExprBits.Kind = ExprKind; UnaryExprOrTypeTraitExprBits.IsType = true; Argument.Ty = TInfo; + setDependence(computeDependence(this)); } UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, Expr *E, @@ -2472,19 +2445,13 @@ class ArraySubscriptExpr : public Expr { bool lhsIsBase() const { return getRHS()->getType()->isIntegerType(); } public: - ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t, - ExprValueKind VK, ExprObjectKind OK, - SourceLocation rbracketloc) - : Expr(ArraySubscriptExprClass, t, VK, OK, - lhs->isTypeDependent() || rhs->isTypeDependent(), - lhs->isValueDependent() || rhs->isValueDependent(), - (lhs->isInstantiationDependent() || - rhs->isInstantiationDependent()), - (lhs->containsUnexpandedParameterPack() || - rhs->containsUnexpandedParameterPack())) { + ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t, ExprValueKind VK, + ExprObjectKind OK, SourceLocation rbracketloc) + : Expr(ArraySubscriptExprClass, t, VK, OK) { SubExprs[LHS] = lhs; SubExprs[RHS] = rhs; ArraySubscriptExprBits.RBracketLoc = rbracketloc; + setDependence(computeDependence(this)); } /// Create an empty array subscript expression. @@ -3092,13 +3059,10 @@ class CompoundLiteralExpr : public Expr { public: CompoundLiteralExpr(SourceLocation lparenloc, TypeSourceInfo *tinfo, QualType T, ExprValueKind VK, Expr *init, bool fileScope) - : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary, - tinfo->getType()->isDependentType(), - init->isValueDependent(), - (init->isInstantiationDependent() || - tinfo->getType()->isInstantiationDependentType()), - init->containsUnexpandedParameterPack()), - LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) {} + : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary), + LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) { + setDependence(computeDependence(this)); + } /// Construct an empty compound literal. explicit CompoundLiteralExpr(EmptyShell Empty) @@ -3164,26 +3128,13 @@ class CastExpr : public Expr { protected: CastExpr(StmtClass SC, QualType ty, ExprValueKind VK, const CastKind kind, Expr *op, unsigned BasePathSize) - : Expr(SC, ty, VK, OK_Ordinary, - // Cast expressions are type-dependent if the type is - // dependent (C++ [temp.dep.expr]p3). - ty->isDependentType(), - // Cast expressions are value-dependent if the type is - // dependent or if the subexpression is value-dependent. - ty->isDependentType() || (op && op->isValueDependent()), - (ty->isInstantiationDependentType() || - (op && op->isInstantiationDependent())), - // An implicit cast expression doesn't (lexically) contain an - // unexpanded pack, even if its target type does. - ((SC != ImplicitCastExprClass && - ty->containsUnexpandedParameterPack()) || - (op && op->containsUnexpandedParameterPack()))), - Op(op) { + : Expr(SC, ty, VK, OK_Ordinary), Op(op) { CastExprBits.Kind = kind; CastExprBits.PartOfExplicitCast = false; CastExprBits.BasePathSize = BasePathSize; assert((CastExprBits.BasePathSize == BasePathSize) && "BasePathSize overflow!"); + setDependence(computeDependence(this)); assert(CastConsistency()); } @@ -3443,15 +3394,9 @@ class BinaryOperator : public Expr { typedef BinaryOperatorKind Opcode; BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, - ExprValueKind VK, ExprObjectKind OK, - SourceLocation opLoc, FPOptions FPFeatures) - : Expr(BinaryOperatorClass, ResTy, VK, OK, - lhs->isTypeDependent() || rhs->isTypeDependent(), - lhs->isValueDependent() || rhs->isValueDependent(), - (lhs->isInstantiationDependent() || - rhs->isInstantiationDependent()), - (lhs->containsUnexpandedParameterPack() || - rhs->containsUnexpandedParameterPack())) { + ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, + FPOptions FPFeatures) + : Expr(BinaryOperatorClass, ResTy, VK, OK) { BinaryOperatorBits.Opc = opc; BinaryOperatorBits.FPFeatures = FPFeatures.getInt(); BinaryOperatorBits.OpLoc = opLoc; @@ -3459,6 +3404,7 @@ class BinaryOperator : public Expr { SubExprs[RHS] = rhs; assert(!isCompoundAssignmentOp() && "Use CompoundAssignOperator for compound assignments"); + setDependence(computeDependence(this)); } /// Construct an empty binary operator. @@ -3628,20 +3574,15 @@ class BinaryOperator : public Expr { protected: BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, - ExprValueKind VK, ExprObjectKind OK, - SourceLocation opLoc, FPOptions FPFeatures, bool dead2) - : Expr(CompoundAssignOperatorClass, ResTy, VK, OK, - lhs->isTypeDependent() || rhs->isTypeDependent(), - lhs->isValueDependent() || rhs->isValueDependent(), - (lhs->isInstantiationDependent() || - rhs->isInstantiationDependent()), - (lhs->containsUnexpandedParameterPack() || - rhs->containsUnexpandedParameterPack())) { + ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, + FPOptions FPFeatures, bool dead2) + : Expr(CompoundAssignOperatorClass, ResTy, VK, OK) { BinaryOperatorBits.Opc = opc; BinaryOperatorBits.FPFeatures = FPFeatures.getInt(); BinaryOperatorBits.OpLoc = opLoc; SubExprs[LHS] = lhs; SubExprs[RHS] = rhs; + setDependence(computeDependence(this)); } BinaryOperator(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) { @@ -3696,14 +3637,10 @@ class AbstractConditionalOperator : public Expr { friend class ASTStmtReader; protected: - AbstractConditionalOperator(StmtClass SC, QualType T, - ExprValueKind VK, ExprObjectKind OK, - bool TD, bool VD, bool ID, - bool ContainsUnexpandedParameterPack, - SourceLocation qloc, + AbstractConditionalOperator(StmtClass SC, QualType T, ExprValueKind VK, + ExprObjectKind OK, SourceLocation qloc, SourceLocation cloc) - : Expr(SC, T, VK, OK, TD, VD, ID, ContainsUnexpandedParameterPack), - QuestionLoc(qloc), ColonLoc(cloc) {} + : Expr(SC, T, VK, OK), QuestionLoc(qloc), ColonLoc(cloc) {} AbstractConditionalOperator(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) { } @@ -3742,26 +3679,12 @@ class ConditionalOperator : public AbstractConditionalOperator { ConditionalOperator(Expr *cond, SourceLocation QLoc, Expr *lhs, SourceLocation CLoc, Expr *rhs, QualType t, ExprValueKind VK, ExprObjectKind OK) - : AbstractConditionalOperator( - ConditionalOperatorClass, t, VK, OK, - // The type of the conditional operator depends on the type - // of the conditional to support the GCC vector conditional - // extension. Additionally, [temp.dep.expr] does specify state that - // this should be dependent on ALL sub expressions. - (cond->isTypeDependent() || lhs->isTypeDependent() || - rhs->isTypeDependent()), - (cond->isValueDependent() || lhs->isValueDependent() || - rhs->isValueDependent()), - (cond->isInstantiationDependent() || - lhs->isInstantiationDependent() || - rhs->isInstantiationDependent()), - (cond->containsUnexpandedParameterPack() || - lhs->containsUnexpandedParameterPack() || - rhs->containsUnexpandedParameterPack()), - QLoc, CLoc) { + : AbstractConditionalOperator(ConditionalOperatorClass, t, VK, OK, QLoc, + CLoc) { SubExprs[COND] = cond; SubExprs[LHS] = lhs; SubExprs[RHS] = rhs; + setDependence(computeDependence(this)); } /// Build an empty conditional operator. @@ -3826,20 +3749,15 @@ class BinaryConditionalOperator : public AbstractConditionalOperator { Expr *cond, Expr *lhs, Expr *rhs, SourceLocation qloc, SourceLocation cloc, QualType t, ExprValueKind VK, ExprObjectKind OK) - : AbstractConditionalOperator(BinaryConditionalOperatorClass, t, VK, OK, - (common->isTypeDependent() || rhs->isTypeDependent()), - (common->isValueDependent() || rhs->isValueDependent()), - (common->isInstantiationDependent() || - rhs->isInstantiationDependent()), - (common->containsUnexpandedParameterPack() || - rhs->containsUnexpandedParameterPack()), - qloc, cloc), - OpaqueValue(opaqueValue) { + : AbstractConditionalOperator(BinaryConditionalOperatorClass, t, VK, OK, + qloc, cloc), + OpaqueValue(opaqueValue) { SubExprs[COMMON] = common; SubExprs[COND] = cond; SubExprs[LHS] = lhs; SubExprs[RHS] = rhs; assert(OpaqueValue->getSourceExpr() == common && "Wrong opaque value"); + setDependence(computeDependence(this)); } /// Build an empty conditional operator. @@ -3917,9 +3835,10 @@ class AddrLabelExpr : public Expr { public: AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelDecl *L, QualType t) - : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary, false, false, false, - false), - AmpAmpLoc(AALoc), LabelLoc(LLoc), Label(L) {} + : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary), AmpAmpLoc(AALoc), + LabelLoc(LLoc), Label(L) { + setDependence(ExprDependence::None); + } /// Build an empty address of a label expression. explicit AddrLabelExpr(EmptyShell Empty) @@ -3961,12 +3880,9 @@ class StmtExpr : public Expr { public: StmtExpr(CompoundStmt *SubStmt, QualType T, SourceLocation LParenLoc, SourceLocation RParenLoc, unsigned TemplateDepth) - : // We treat a statement-expression in a dependent context as - // always being value- and instantiation-dependent. This matches the - // behavior of lambda-expressions and GCC. - Expr(StmtExprClass, T, VK_RValue, OK_Ordinary, T->isDependentType(), - TemplateDepth != 0, TemplateDepth != 0, false), - SubStmt(SubStmt), LParenLoc(LParenLoc), RParenLoc(RParenLoc) { + : Expr(StmtExprClass, T, VK_RValue, OK_Ordinary), SubStmt(SubStmt), + LParenLoc(LParenLoc), RParenLoc(RParenLoc) { + setDependence(computeDependence(this, TemplateDepth)); // FIXME: A templated statement expression should have an associated // DeclContext so that nested declarations always have a dependent context. StmtExprBits.TemplateDepth = TemplateDepth; @@ -4085,17 +4001,13 @@ class ConvertVectorExpr : public Expr { explicit ConvertVectorExpr(EmptyShell Empty) : Expr(ConvertVectorExprClass, Empty) {} public: - ConvertVectorExpr(Expr* SrcExpr, TypeSourceInfo *TI, QualType DstType, - ExprValueKind VK, ExprObjectKind OK, - SourceLocation BuiltinLoc, SourceLocation RParenLoc) - : Expr(ConvertVectorExprClass, DstType, VK, OK, - DstType->isDependentType(), - DstType->isDependentType() || SrcExpr->isValueDependent(), - (DstType->isInstantiationDependentType() || - SrcExpr->isInstantiationDependent()), - (DstType->containsUnexpandedParameterPack() || - SrcExpr->containsUnexpandedParameterPack())), - SrcExpr(SrcExpr), TInfo(TI), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {} + ConvertVectorExpr(Expr *SrcExpr, TypeSourceInfo *TI, QualType DstType, + ExprValueKind VK, ExprObjectKind OK, + SourceLocation BuiltinLoc, SourceLocation RParenLoc) + : Expr(ConvertVectorExprClass, DstType, VK, OK), SrcExpr(SrcExpr), + TInfo(TI), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) { + setDependence(computeDependence(this)); + } /// getSrcExpr - Return the Expr to be converted. Expr *getSrcExpr() const { return cast(SrcExpr); } @@ -4143,22 +4055,17 @@ class ChooseExpr : public Expr { SourceLocation BuiltinLoc, RParenLoc; bool CondIsTrue; public: - ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, - QualType t, ExprValueKind VK, ExprObjectKind OK, - SourceLocation RP, bool condIsTrue, - bool TypeDependent, bool ValueDependent) - : Expr(ChooseExprClass, t, VK, OK, TypeDependent, ValueDependent, - (cond->isInstantiationDependent() || - lhs->isInstantiationDependent() || - rhs->isInstantiationDependent()), - (cond->containsUnexpandedParameterPack() || - lhs->containsUnexpandedParameterPack() || - rhs->containsUnexpandedParameterPack())), - BuiltinLoc(BLoc), RParenLoc(RP), CondIsTrue(condIsTrue) { - SubExprs[COND] = cond; - SubExprs[LHS] = lhs; - SubExprs[RHS] = rhs; - } + ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, QualType t, + ExprValueKind VK, ExprObjectKind OK, SourceLocation RP, + bool condIsTrue) + : Expr(ChooseExprClass, t, VK, OK), BuiltinLoc(BLoc), RParenLoc(RP), + CondIsTrue(condIsTrue) { + SubExprs[COND] = cond; + SubExprs[LHS] = lhs; + SubExprs[RHS] = rhs; + + setDependence(computeDependence(this)); + } /// Build an empty __builtin_choose_expr. explicit ChooseExpr(EmptyShell Empty) : Expr(ChooseExprClass, Empty) { } @@ -4223,9 +4130,9 @@ class GNUNullExpr : public Expr { public: GNUNullExpr(QualType Ty, SourceLocation Loc) - : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary, false, false, false, - false), - TokenLoc(Loc) { } + : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary), TokenLoc(Loc) { + setDependence(ExprDependence::None); + } /// Build an empty GNU __null expression. explicit GNUNullExpr(EmptyShell Empty) : Expr(GNUNullExprClass, Empty) { } @@ -4258,12 +4165,10 @@ class VAArgExpr : public Expr { public: VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo, SourceLocation RPLoc, QualType t, bool IsMS) - : Expr(VAArgExprClass, t, VK_RValue, OK_Ordinary, t->isDependentType(), - false, (TInfo->getType()->isInstantiationDependentType() || - e->isInstantiationDependent()), - (TInfo->getType()->containsUnexpandedParameterPack() || - e->containsUnexpandedParameterPack())), - Val(e), TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) {} + : Expr(VAArgExprClass, t, VK_RValue, OK_Ordinary), Val(e), + TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) { + setDependence(computeDependence(this)); + } /// Create an empty __builtin_va_arg expression. explicit VAArgExpr(EmptyShell Empty) @@ -4942,8 +4847,9 @@ class DesignatedInitExpr final class NoInitExpr : public Expr { public: explicit NoInitExpr(QualType ty) - : Expr(NoInitExprClass, ty, VK_RValue, OK_Ordinary, - false, false, ty->isInstantiationDependentType(), false) { } + : Expr(NoInitExprClass, ty, VK_RValue, OK_Ordinary) { + setDependence(computeDependence(this)); + } explicit NoInitExpr(EmptyShell Empty) : Expr(NoInitExprClass, Empty) { } @@ -5037,12 +4943,10 @@ class ArrayInitLoopExpr : public Expr { public: explicit ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit) - : Expr(ArrayInitLoopExprClass, T, VK_RValue, OK_Ordinary, false, - CommonInit->isValueDependent() || ElementInit->isValueDependent(), - T->isInstantiationDependentType(), - CommonInit->containsUnexpandedParameterPack() || - ElementInit->containsUnexpandedParameterPack()), - SubExprs{CommonInit, ElementInit} {} + : Expr(ArrayInitLoopExprClass, T, VK_RValue, OK_Ordinary), + SubExprs{CommonInit, ElementInit} { + setDependence(computeDependence(this)); + } /// Get the common subexpression shared by all initializations (the source /// array). @@ -5090,8 +4994,9 @@ class ArrayInitIndexExpr : public Expr { public: explicit ArrayInitIndexExpr(QualType T) - : Expr(ArrayInitIndexExprClass, T, VK_RValue, OK_Ordinary, - false, false, false, false) {} + : Expr(ArrayInitIndexExprClass, T, VK_RValue, OK_Ordinary) { + setDependence(ExprDependence::None); + } static bool classof(const Stmt *S) { return S->getStmtClass() == ArrayInitIndexExprClass; @@ -5122,8 +5027,9 @@ class ArrayInitIndexExpr : public Expr { class ImplicitValueInitExpr : public Expr { public: explicit ImplicitValueInitExpr(QualType ty) - : Expr(ImplicitValueInitExprClass, ty, VK_RValue, OK_Ordinary, - false, false, ty->isInstantiationDependentType(), false) { } + : Expr(ImplicitValueInitExprClass, ty, VK_RValue, OK_Ordinary) { + setDependence(computeDependence(this)); + } /// Construct an empty implicit value initialization. explicit ImplicitValueInitExpr(EmptyShell Empty) @@ -5525,12 +5431,11 @@ class ExtVectorElementExpr : public Expr { public: ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base, IdentifierInfo &accessor, SourceLocation loc) - : Expr(ExtVectorElementExprClass, ty, VK, - (VK == VK_RValue ? OK_Ordinary : OK_VectorComponent), - base->isTypeDependent(), base->isValueDependent(), - base->isInstantiationDependent(), - base->containsUnexpandedParameterPack()), - Base(base), Accessor(&accessor), AccessorLoc(loc) {} + : Expr(ExtVectorElementExprClass, ty, VK, + (VK == VK_RValue ? OK_Ordinary : OK_VectorComponent)), + Base(base), Accessor(&accessor), AccessorLoc(loc) { + setDependence(computeDependence(this)); + } /// Build an empty vector element expression. explicit ExtVectorElementExpr(EmptyShell Empty) @@ -5584,11 +5489,9 @@ class BlockExpr : public Expr { BlockDecl *TheBlock; public: BlockExpr(BlockDecl *BD, QualType ty) - : Expr(BlockExprClass, ty, VK_RValue, OK_Ordinary, - ty->isDependentType(), ty->isDependentType(), - ty->isInstantiationDependentType() || BD->isDependentContext(), - false), - TheBlock(BD) {} + : Expr(BlockExprClass, ty, VK_RValue, OK_Ordinary), TheBlock(BD) { + setDependence(computeDependence(this)); + } /// Build an empty block expression. explicit BlockExpr(EmptyShell Empty) : Expr(BlockExprClass, Empty) { } @@ -5652,17 +5555,13 @@ class AsTypeExpr : public Expr { explicit AsTypeExpr(EmptyShell Empty) : Expr(AsTypeExprClass, Empty) {} public: - AsTypeExpr(Expr* SrcExpr, QualType DstType, - ExprValueKind VK, ExprObjectKind OK, - SourceLocation BuiltinLoc, SourceLocation RParenLoc) - : Expr(AsTypeExprClass, DstType, VK, OK, - DstType->isDependentType(), - DstType->isDependentType() || SrcExpr->isValueDependent(), - (DstType->isInstantiationDependentType() || - SrcExpr->isInstantiationDependent()), - (DstType->containsUnexpandedParameterPack() || - SrcExpr->containsUnexpandedParameterPack())), - SrcExpr(SrcExpr), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {} + AsTypeExpr(Expr *SrcExpr, QualType DstType, ExprValueKind VK, + ExprObjectKind OK, SourceLocation BuiltinLoc, + SourceLocation RParenLoc) + : Expr(AsTypeExprClass, DstType, VK, OK), SrcExpr(SrcExpr), + BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) { + setDependence(computeDependence(this)); + } /// getSrcExpr - Return the Expr to be converted. Expr *getSrcExpr() const { return cast(SrcExpr); } @@ -5980,13 +5879,9 @@ class AtomicExpr : public Expr { /// still needs to be performed and/or an error diagnostic emitted. class TypoExpr : public Expr { public: - TypoExpr(QualType T) - : Expr(TypoExprClass, T, VK_LValue, OK_Ordinary, - /*isTypeDependent*/ true, - /*isValueDependent*/ true, - /*isInstantiationDependent*/ true, - /*containsUnexpandedParameterPack*/ false) { + TypoExpr(QualType T) : Expr(TypoExprClass, T, VK_LValue, OK_Ordinary) { assert(T->isDependentType() && "TypoExpr given a non-dependent type"); + setDependence(ExprDependence::TypeValueInstantiation); } child_range children() { diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h index 694575790f48be..33ea3f6346b227 100644 --- a/clang/include/clang/AST/ExprCXX.h +++ b/clang/include/clang/AST/ExprCXX.h @@ -14,11 +14,14 @@ #ifndef LLVM_CLANG_AST_EXPRCXX_H #define LLVM_CLANG_AST_EXPRCXX_H +#include "clang/AST/ASTConcept.h" +#include "clang/AST/ComputeDependence.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclarationName.h" +#include "clang/AST/DependenceFlags.h" #include "clang/AST/Expr.h" #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/OperationKinds.h" @@ -295,12 +298,10 @@ class CXXRewrittenBinaryOperator : public Expr { public: CXXRewrittenBinaryOperator(Expr *SemanticForm, bool IsReversed) : Expr(CXXRewrittenBinaryOperatorClass, SemanticForm->getType(), - SemanticForm->getValueKind(), SemanticForm->getObjectKind(), - SemanticForm->isTypeDependent(), SemanticForm->isValueDependent(), - SemanticForm->isInstantiationDependent(), - SemanticForm->containsUnexpandedParameterPack()), + SemanticForm->getValueKind(), SemanticForm->getObjectKind()), SemanticForm(SemanticForm) { CXXRewrittenBinaryOperatorBits.IsReversed = IsReversed; + setDependence(computeDependence(this)); } CXXRewrittenBinaryOperator(EmptyShell Empty) : Expr(CXXRewrittenBinaryOperatorClass, Empty), SemanticForm() {} @@ -661,10 +662,10 @@ class UserDefinedLiteral final : public CallExpr { class CXXBoolLiteralExpr : public Expr { public: CXXBoolLiteralExpr(bool Val, QualType Ty, SourceLocation Loc) - : Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false, - false, false) { + : Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary) { CXXBoolLiteralExprBits.Value = Val; CXXBoolLiteralExprBits.Loc = Loc; + setDependence(ExprDependence::None); } explicit CXXBoolLiteralExpr(EmptyShell Empty) @@ -699,9 +700,9 @@ class CXXBoolLiteralExpr : public Expr { class CXXNullPtrLiteralExpr : public Expr { public: CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc) - : Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, - false, false, false) { + : Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary) { CXXNullPtrLiteralExprBits.Loc = Loc; + setDependence(ExprDependence::None); } explicit CXXNullPtrLiteralExpr(EmptyShell Empty) @@ -739,11 +740,10 @@ class CXXStdInitializerListExpr : public Expr { friend class ASTStmtReader; CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr) - : Expr(CXXStdInitializerListExprClass, Ty, VK_RValue, OK_Ordinary, - Ty->isDependentType(), SubExpr->isValueDependent(), - SubExpr->isInstantiationDependent(), - SubExpr->containsUnexpandedParameterPack()), - SubExpr(SubExpr) {} + : Expr(CXXStdInitializerListExprClass, Ty, VK_RValue, OK_Ordinary), + SubExpr(SubExpr) { + setDependence(computeDependence(this)); + } Expr *getSubExpr() { return static_cast(SubExpr); } const Expr *getSubExpr() const { return static_cast(SubExpr); } @@ -784,26 +784,16 @@ class CXXTypeidExpr : public Expr { public: CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R) - : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary, - // typeid is never type-dependent (C++ [temp.dep.expr]p4) - false, - // typeid is value-dependent if the type or expression are - // dependent - Operand->getType()->isDependentType(), - Operand->getType()->isInstantiationDependentType(), - Operand->getType()->containsUnexpandedParameterPack()), - Operand(Operand), Range(R) {} + : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand), + Range(R) { + setDependence(computeDependence(this)); + } CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R) - : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary, - // typeid is never type-dependent (C++ [temp.dep.expr]p4) - false, - // typeid is value-dependent if the type or expression are - // dependent - Operand->isTypeDependent() || Operand->isValueDependent(), - Operand->isInstantiationDependent(), - Operand->containsUnexpandedParameterPack()), - Operand(Operand), Range(R) {} + : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand), + Range(R) { + setDependence(computeDependence(this)); + } CXXTypeidExpr(EmptyShell Empty, bool isExpr) : Expr(CXXTypeidExprClass, Empty) { @@ -888,15 +878,12 @@ class MSPropertyRefExpr : public Expr { MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow, QualType ty, ExprValueKind VK, - NestedNameSpecifierLoc qualifierLoc, - SourceLocation nameLoc) - : Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary, - /*type-dependent*/ false, baseExpr->isValueDependent(), - baseExpr->isInstantiationDependent(), - baseExpr->containsUnexpandedParameterPack()), - BaseExpr(baseExpr), TheDecl(decl), - MemberLoc(nameLoc), IsArrow(isArrow), - QualifierLoc(qualifierLoc) {} + NestedNameSpecifierLoc qualifierLoc, SourceLocation nameLoc) + : Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary), BaseExpr(baseExpr), + TheDecl(decl), MemberLoc(nameLoc), IsArrow(isArrow), + QualifierLoc(qualifierLoc) { + setDependence(computeDependence(this)); + } MSPropertyRefExpr(EmptyShell Empty) : Expr(MSPropertyRefExprClass, Empty) {} @@ -964,12 +951,11 @@ class MSPropertySubscriptExpr : public Expr { public: MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK, ExprObjectKind OK, SourceLocation RBracketLoc) - : Expr(MSPropertySubscriptExprClass, Ty, VK, OK, Idx->isTypeDependent(), - Idx->isValueDependent(), Idx->isInstantiationDependent(), - Idx->containsUnexpandedParameterPack()), + : Expr(MSPropertySubscriptExprClass, Ty, VK, OK), RBracketLoc(RBracketLoc) { SubExprs[BASE_EXPR] = Base; SubExprs[IDX_EXPR] = Idx; + setDependence(computeDependence(this)); } /// Create an empty array subscript expression. @@ -1022,17 +1008,16 @@ class CXXUuidofExpr : public Expr { public: CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, StringRef UuidStr, SourceRange R) - : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary, false, - Operand->getType()->isDependentType(), - Operand->getType()->isInstantiationDependentType(), - Operand->getType()->containsUnexpandedParameterPack()), - Operand(Operand), UuidStr(UuidStr), Range(R) {} + : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand), + UuidStr(UuidStr), Range(R) { + setDependence(computeDependence(this)); + } CXXUuidofExpr(QualType Ty, Expr *Operand, StringRef UuidStr, SourceRange R) - : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary, false, - Operand->isTypeDependent(), Operand->isInstantiationDependent(), - Operand->containsUnexpandedParameterPack()), - Operand(Operand), UuidStr(UuidStr), Range(R) {} + : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand), + UuidStr(UuidStr), Range(R) { + setDependence(computeDependence(this)); + } CXXUuidofExpr(EmptyShell Empty, bool isExpr) : Expr(CXXUuidofExprClass, Empty) { @@ -1113,14 +1098,10 @@ class CXXUuidofExpr : public Expr { class CXXThisExpr : public Expr { public: CXXThisExpr(SourceLocation L, QualType Ty, bool IsImplicit) - : Expr(CXXThisExprClass, Ty, VK_RValue, OK_Ordinary, - // 'this' is type-dependent if the class type of the enclosing - // member function is dependent (C++ [temp.dep.expr]p2) - Ty->isDependentType(), Ty->isDependentType(), - Ty->isInstantiationDependentType(), - /*ContainsUnexpandedParameterPack=*/false) { + : Expr(CXXThisExprClass, Ty, VK_RValue, OK_Ordinary) { CXXThisExprBits.IsImplicit = IsImplicit; CXXThisExprBits.Loc = L; + setDependence(computeDependence(this)); } CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {} @@ -1166,12 +1147,10 @@ class CXXThrowExpr : public Expr { // null if not present. CXXThrowExpr(Expr *Operand, QualType Ty, SourceLocation Loc, bool IsThrownVariableInScope) - : Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary, false, false, - Operand && Operand->isInstantiationDependent(), - Operand && Operand->containsUnexpandedParameterPack()), - Operand(Operand) { + : Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary), Operand(Operand) { CXXThrowExprBits.ThrowLoc = Loc; CXXThrowExprBits.IsThrownVariableInScope = IsThrownVariableInScope; + setDependence(computeDependence(this)); } CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {} @@ -1225,16 +1204,16 @@ class CXXDefaultArgExpr final : public Expr { DeclContext *UsedContext; CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param, - DeclContext *UsedContext) + DeclContext *UsedContext) : Expr(SC, Param->hasUnparsedDefaultArg() ? Param->getType().getNonReferenceType() : Param->getDefaultArg()->getType(), Param->getDefaultArg()->getValueKind(), - Param->getDefaultArg()->getObjectKind(), false, false, false, - false), + Param->getDefaultArg()->getObjectKind()), Param(Param), UsedContext(UsedContext) { CXXDefaultArgExprBits.Loc = Loc; + setDependence(ExprDependence::None); } public: @@ -1390,13 +1369,12 @@ class CXXBindTemporaryExpr : public Expr { CXXTemporary *Temp = nullptr; Stmt *SubExpr = nullptr; - CXXBindTemporaryExpr(CXXTemporary *temp, Expr* SubExpr) - : Expr(CXXBindTemporaryExprClass, SubExpr->getType(), - VK_RValue, OK_Ordinary, SubExpr->isTypeDependent(), - SubExpr->isValueDependent(), - SubExpr->isInstantiationDependent(), - SubExpr->containsUnexpandedParameterPack()), - Temp(temp), SubExpr(SubExpr) {} + CXXBindTemporaryExpr(CXXTemporary *temp, Expr *SubExpr) + : Expr(CXXBindTemporaryExprClass, SubExpr->getType(), VK_RValue, + OK_Ordinary), + Temp(temp), SubExpr(SubExpr) { + setDependence(computeDependence(this)); + } public: CXXBindTemporaryExpr(EmptyShell Empty) @@ -1647,12 +1625,12 @@ class CXXInheritedCtorInitExpr : public Expr { CXXInheritedCtorInitExpr(SourceLocation Loc, QualType T, CXXConstructorDecl *Ctor, bool ConstructsVirtualBase, bool InheritedFromVirtualBase) - : Expr(CXXInheritedCtorInitExprClass, T, VK_RValue, OK_Ordinary, false, - false, false, false), + : Expr(CXXInheritedCtorInitExprClass, T, VK_RValue, OK_Ordinary), Constructor(Ctor), Loc(Loc), ConstructsVirtualBase(ConstructsVirtualBase), InheritedFromVirtualBase(InheritedFromVirtualBase) { assert(!T->isDependentType()); + setDependence(ExprDependence::None); } /// Construct an empty C++ inheriting construction expression. @@ -2076,11 +2054,10 @@ class CXXScalarValueInitExpr : public Expr { /// expression. CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo, SourceLocation RParenLoc) - : Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary, false, - false, Type->isInstantiationDependentType(), - Type->containsUnexpandedParameterPack()), + : Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary), TypeInfo(TypeInfo) { CXXScalarValueInitExprBits.RParenLoc = RParenLoc; + setDependence(computeDependence(this)); } explicit CXXScalarValueInitExpr(EmptyShell Shell) @@ -2385,15 +2362,14 @@ class CXXDeleteExpr : public Expr { CXXDeleteExpr(QualType Ty, bool GlobalDelete, bool ArrayForm, bool ArrayFormAsWritten, bool UsualArrayDeleteWantsSize, FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc) - : Expr(CXXDeleteExprClass, Ty, VK_RValue, OK_Ordinary, false, - Arg->isValueDependent(), Arg->isInstantiationDependent(), - Arg->containsUnexpandedParameterPack()), + : Expr(CXXDeleteExprClass, Ty, VK_RValue, OK_Ordinary), OperatorDelete(OperatorDelete), Argument(Arg) { CXXDeleteExprBits.GlobalDelete = GlobalDelete; CXXDeleteExprBits.ArrayForm = ArrayForm; CXXDeleteExprBits.ArrayFormAsWritten = ArrayFormAsWritten; CXXDeleteExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize; CXXDeleteExprBits.Loc = Loc; + setDependence(computeDependence(this)); } explicit CXXDeleteExpr(EmptyShell Shell) : Expr(CXXDeleteExprClass, Shell) {} @@ -2751,15 +2727,13 @@ class ArrayTypeTraitExpr : public Expr { friend class ASTStmtReader; ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att, - TypeSourceInfo *queried, uint64_t value, - Expr *dimension, SourceLocation rparen, QualType ty) - : Expr(ArrayTypeTraitExprClass, ty, VK_RValue, OK_Ordinary, - false, queried->getType()->isDependentType(), - (queried->getType()->isInstantiationDependentType() || - (dimension && dimension->isInstantiationDependent())), - queried->getType()->containsUnexpandedParameterPack()), - ATT(att), Value(value), Dimension(dimension), - Loc(loc), RParen(rparen), QueriedType(queried) {} + TypeSourceInfo *queried, uint64_t value, Expr *dimension, + SourceLocation rparen, QualType ty) + : Expr(ArrayTypeTraitExprClass, ty, VK_RValue, OK_Ordinary), ATT(att), + Value(value), Dimension(dimension), Loc(loc), RParen(rparen), + QueriedType(queried) { + setDependence(computeDependence(this)); + } explicit ArrayTypeTraitExpr(EmptyShell Empty) : Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {} @@ -2817,17 +2791,13 @@ class ExpressionTraitExpr : public Expr { public: friend class ASTStmtReader; - ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, - Expr *queried, bool value, - SourceLocation rparen, QualType resultType) - : Expr(ExpressionTraitExprClass, resultType, VK_RValue, OK_Ordinary, - false, // Not type-dependent - // Value-dependent if the argument is type-dependent. - queried->isTypeDependent(), - queried->isInstantiationDependent(), - queried->containsUnexpandedParameterPack()), + ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried, + bool value, SourceLocation rparen, QualType resultType) + : Expr(ExpressionTraitExprClass, resultType, VK_RValue, OK_Ordinary), ET(et), Value(value), Loc(loc), RParen(rparen), - QueriedExpression(queried) {} + QueriedExpression(queried) { + setDependence(computeDependence(this)); + } explicit ExpressionTraitExpr(EmptyShell Empty) : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false) {} @@ -3982,13 +3952,10 @@ class CXXNoexceptExpr : public Expr { public: CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val, SourceLocation Keyword, SourceLocation RParen) - : Expr(CXXNoexceptExprClass, Ty, VK_RValue, OK_Ordinary, - /*TypeDependent*/ false, - /*ValueDependent*/ Val == CT_Dependent, - Val == CT_Dependent || Operand->isInstantiationDependent(), - Operand->containsUnexpandedParameterPack()), + : Expr(CXXNoexceptExprClass, Ty, VK_RValue, OK_Ordinary), Operand(Operand), Range(Keyword, RParen) { CXXNoexceptExprBits.Value = Val == CT_Cannot; + setDependence(computeDependence(this, Val)); } CXXNoexceptExpr(EmptyShell Empty) : Expr(CXXNoexceptExprClass, Empty) {} @@ -4049,12 +4016,12 @@ class PackExpansionExpr : public Expr { PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc, Optional NumExpansions) : Expr(PackExpansionExprClass, T, Pattern->getValueKind(), - Pattern->getObjectKind(), /*TypeDependent=*/true, - /*ValueDependent=*/true, /*InstantiationDependent=*/true, - /*ContainsUnexpandedParameterPack=*/false), + Pattern->getObjectKind()), EllipsisLoc(EllipsisLoc), NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), - Pattern(Pattern) {} + Pattern(Pattern) { + setDependence(ExprDependence::TypeValueInstantiation); + } PackExpansionExpr(EmptyShell Empty) : Expr(PackExpansionExprClass, Empty) {} @@ -4141,17 +4108,17 @@ class SizeOfPackExpr final /// the given parameter pack. SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, - Optional Length, ArrayRef PartialArgs) - : Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary, - /*TypeDependent=*/false, /*ValueDependent=*/!Length, - /*InstantiationDependent=*/!Length, - /*ContainsUnexpandedParameterPack=*/false), + Optional Length, + ArrayRef PartialArgs) + : Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary), OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc), Length(Length ? *Length : PartialArgs.size()), Pack(Pack) { assert((!Length || PartialArgs.empty()) && "have partial args for non-dependent sizeof... expression"); auto *Args = getTrailingObjects(); std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args); + setDependence(Length ? ExprDependence::None + : ExprDependence::ValueInstantiation); } /// Create an empty expression. @@ -4242,12 +4209,10 @@ class SubstNonTypeTemplateParmExpr : public Expr { SourceLocation Loc, NonTypeTemplateParmDecl *Param, Expr *Replacement) - : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary, - Replacement->isTypeDependent(), Replacement->isValueDependent(), - Replacement->isInstantiationDependent(), - Replacement->containsUnexpandedParameterPack()), + : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary), Param(Param), Replacement(Replacement) { SubstNonTypeTemplateParmExprBits.NameLoc = Loc; + setDependence(computeDependence(this)); } SourceLocation getNameLoc() const { @@ -4561,13 +4526,12 @@ class CXXFoldExpr : public Expr { CXXFoldExpr(QualType T, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, Optional NumExpansions) - : Expr(CXXFoldExprClass, T, VK_RValue, OK_Ordinary, - /*Dependent*/ true, true, true, - /*ContainsUnexpandedParameterPack*/ false), - LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc), + : Expr(CXXFoldExprClass, T, VK_RValue, OK_Ordinary), LParenLoc(LParenLoc), + EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc), NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) { SubExprs[0] = LHS; SubExprs[1] = RHS; + setDependence(ExprDependence::TypeValueInstantiation); } CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {} @@ -4642,27 +4606,25 @@ class CoroutineSuspendExpr : public Expr { Expr *Ready, Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue) : Expr(SC, Resume->getType(), Resume->getValueKind(), - Resume->getObjectKind(), Resume->isTypeDependent(), - Resume->isValueDependent(), Common->isInstantiationDependent(), - Common->containsUnexpandedParameterPack()), + Resume->getObjectKind()), KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) { SubExprs[SubExpr::Common] = Common; SubExprs[SubExpr::Ready] = Ready; SubExprs[SubExpr::Suspend] = Suspend; SubExprs[SubExpr::Resume] = Resume; + setDependence(computeDependence(this)); } CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty, Expr *Common) - : Expr(SC, Ty, VK_RValue, OK_Ordinary, true, true, true, - Common->containsUnexpandedParameterPack()), - KeywordLoc(KeywordLoc) { + : Expr(SC, Ty, VK_RValue, OK_Ordinary), KeywordLoc(KeywordLoc) { assert(Common->isTypeDependent() && Ty->isDependentType() && "wrong constructor for non-dependent co_await/co_yield expression"); SubExprs[SubExpr::Common] = Common; SubExprs[SubExpr::Ready] = nullptr; SubExprs[SubExpr::Suspend] = nullptr; SubExprs[SubExpr::Resume] = nullptr; + setDependence(computeDependence(this)); } CoroutineSuspendExpr(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) { @@ -4759,10 +4721,7 @@ class DependentCoawaitExpr : public Expr { public: DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op, UnresolvedLookupExpr *OpCoawait) - : Expr(DependentCoawaitExprClass, Ty, VK_RValue, OK_Ordinary, - /*TypeDependent*/ true, /*ValueDependent*/ true, - /*InstantiationDependent*/ true, - Op->containsUnexpandedParameterPack()), + : Expr(DependentCoawaitExprClass, Ty, VK_RValue, OK_Ordinary), KeywordLoc(KeywordLoc) { // NOTE: A co_await expression is dependent on the coroutines promise // type and may be dependent even when the `Op` expression is not. @@ -4770,6 +4729,7 @@ class DependentCoawaitExpr : public Expr { "wrong constructor for non-dependent co_await/co_yield expression"); SubExprs[0] = Op; SubExprs[1] = OpCoawait; + setDependence(computeDependence(this)); } DependentCoawaitExpr(EmptyShell Empty) diff --git a/clang/include/clang/AST/ExprObjC.h b/clang/include/clang/AST/ExprObjC.h index d76b3a26b1f946..4b39d9ab96a6a7 100644 --- a/clang/include/clang/AST/ExprObjC.h +++ b/clang/include/clang/AST/ExprObjC.h @@ -13,8 +13,10 @@ #ifndef LLVM_CLANG_AST_EXPROBJC_H #define LLVM_CLANG_AST_EXPROBJC_H +#include "clang/AST/ComputeDependence.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclObjC.h" +#include "clang/AST/DependenceFlags.h" #include "clang/AST/Expr.h" #include "clang/AST/OperationKinds.h" #include "clang/AST/SelectorLocationsKind.h" @@ -53,9 +55,10 @@ class ObjCStringLiteral : public Expr { public: ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L) - : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary, false, false, - false, false), - String(SL), AtLoc(L) {} + : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary), String(SL), + AtLoc(L) { + setDependence(ExprDependence::None); + } explicit ObjCStringLiteral(EmptyShell Empty) : Expr(ObjCStringLiteralClass, Empty) {} @@ -88,9 +91,10 @@ class ObjCBoolLiteralExpr : public Expr { public: ObjCBoolLiteralExpr(bool val, QualType Ty, SourceLocation l) - : Expr(ObjCBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false, - false, false), - Value(val), Loc(l) {} + : Expr(ObjCBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary), Value(val), + Loc(l) { + setDependence(ExprDependence::None); + } explicit ObjCBoolLiteralExpr(EmptyShell Empty) : Expr(ObjCBoolLiteralExprClass, Empty) {} @@ -129,13 +133,11 @@ class ObjCBoxedExpr : public Expr { public: friend class ASTStmtReader; - ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method, - SourceRange R) - : Expr(ObjCBoxedExprClass, T, VK_RValue, OK_Ordinary, - E->isTypeDependent(), E->isValueDependent(), - E->isInstantiationDependent(), - E->containsUnexpandedParameterPack()), - SubExpr(E), BoxingMethod(method), Range(R) {} + ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method, SourceRange R) + : Expr(ObjCBoxedExprClass, T, VK_RValue, OK_Ordinary), SubExpr(E), + BoxingMethod(method), Range(R) { + setDependence(computeDependence(this)); + } explicit ObjCBoxedExpr(EmptyShell Empty) : Expr(ObjCBoxedExprClass, Empty) {} @@ -409,14 +411,12 @@ class ObjCEncodeExpr : public Expr { SourceLocation AtLoc, RParenLoc; public: - ObjCEncodeExpr(QualType T, TypeSourceInfo *EncodedType, - SourceLocation at, SourceLocation rp) - : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary, - EncodedType->getType()->isDependentType(), - EncodedType->getType()->isDependentType(), - EncodedType->getType()->isInstantiationDependentType(), - EncodedType->getType()->containsUnexpandedParameterPack()), - EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) {} + ObjCEncodeExpr(QualType T, TypeSourceInfo *EncodedType, SourceLocation at, + SourceLocation rp) + : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary), + EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) { + setDependence(computeDependence(this)); + } explicit ObjCEncodeExpr(EmptyShell Empty) : Expr(ObjCEncodeExprClass, Empty){} @@ -456,11 +456,12 @@ class ObjCSelectorExpr : public Expr { SourceLocation AtLoc, RParenLoc; public: - ObjCSelectorExpr(QualType T, Selector selInfo, - SourceLocation at, SourceLocation rp) - : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary, false, false, - false, false), - SelName(selInfo), AtLoc(at), RParenLoc(rp) {} + ObjCSelectorExpr(QualType T, Selector selInfo, SourceLocation at, + SourceLocation rp) + : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary), + SelName(selInfo), AtLoc(at), RParenLoc(rp) { + setDependence(ExprDependence::None); + } explicit ObjCSelectorExpr(EmptyShell Empty) : Expr(ObjCSelectorExprClass, Empty) {} @@ -508,11 +509,12 @@ class ObjCProtocolExpr : public Expr { friend class ASTStmtReader; friend class ASTStmtWriter; - ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, - SourceLocation at, SourceLocation protoLoc, SourceLocation rp) - : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary, false, false, - false, false), - TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) {} + ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, SourceLocation at, + SourceLocation protoLoc, SourceLocation rp) + : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary), + TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) { + setDependence(ExprDependence::None); + } explicit ObjCProtocolExpr(EmptyShell Empty) : Expr(ObjCProtocolExprClass, Empty) {} @@ -558,17 +560,15 @@ class ObjCIvarRefExpr : public Expr { bool IsFreeIvar : 1; public: - ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t, - SourceLocation l, SourceLocation oploc, - Expr *base, - bool arrow = false, bool freeIvar = false) + ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t, SourceLocation l, + SourceLocation oploc, Expr *base, bool arrow = false, + bool freeIvar = false) : Expr(ObjCIvarRefExprClass, t, VK_LValue, - d->isBitField() ? OK_BitField : OK_Ordinary, - /*TypeDependent=*/false, base->isValueDependent(), - base->isInstantiationDependent(), - base->containsUnexpandedParameterPack()), + d->isBitField() ? OK_BitField : OK_Ordinary), D(d), Base(base), Loc(l), OpLoc(oploc), IsArrow(arrow), - IsFreeIvar(freeIvar) {} + IsFreeIvar(freeIvar) { + setDependence(computeDependence(this)); + } explicit ObjCIvarRefExpr(EmptyShell Empty) : Expr(ObjCIvarRefExprClass, Empty) {} @@ -645,57 +645,53 @@ class ObjCPropertyRefExpr : public Expr { llvm::PointerUnion Receiver; public: - ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, - ExprValueKind VK, ExprObjectKind OK, - SourceLocation l, Expr *base) - : Expr(ObjCPropertyRefExprClass, t, VK, OK, - /*TypeDependent=*/false, base->isValueDependent(), - base->isInstantiationDependent(), - base->containsUnexpandedParameterPack()), - PropertyOrGetter(PD, false), IdLoc(l), Receiver(base) { + ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK, + ExprObjectKind OK, SourceLocation l, Expr *base) + : Expr(ObjCPropertyRefExprClass, t, VK, OK), PropertyOrGetter(PD, false), + IdLoc(l), Receiver(base) { assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject)); + setDependence(computeDependence(this)); } - ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, - ExprValueKind VK, ExprObjectKind OK, - SourceLocation l, SourceLocation sl, QualType st) - : Expr(ObjCPropertyRefExprClass, t, VK, OK, - /*TypeDependent=*/false, false, st->isInstantiationDependentType(), - st->containsUnexpandedParameterPack()), - PropertyOrGetter(PD, false), IdLoc(l), ReceiverLoc(sl), - Receiver(st.getTypePtr()) { + ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK, + ExprObjectKind OK, SourceLocation l, SourceLocation sl, + QualType st) + : Expr(ObjCPropertyRefExprClass, t, VK, OK), PropertyOrGetter(PD, false), + IdLoc(l), ReceiverLoc(sl), Receiver(st.getTypePtr()) { assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject)); + setDependence(computeDependence(this)); } ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter, QualType T, ExprValueKind VK, ExprObjectKind OK, SourceLocation IdLoc, Expr *Base) - : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, - Base->isValueDependent(), Base->isInstantiationDependent(), - Base->containsUnexpandedParameterPack()), + : Expr(ObjCPropertyRefExprClass, T, VK, OK), PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0), IdLoc(IdLoc), Receiver(Base) { assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject)); + setDependence(computeDependence(this)); } ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter, QualType T, ExprValueKind VK, ExprObjectKind OK, - SourceLocation IdLoc, - SourceLocation SuperLoc, QualType SuperTy) - : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false), + SourceLocation IdLoc, SourceLocation SuperLoc, + QualType SuperTy) + : Expr(ObjCPropertyRefExprClass, T, VK, OK), PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0), IdLoc(IdLoc), ReceiverLoc(SuperLoc), Receiver(SuperTy.getTypePtr()) { assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject)); + setDependence(computeDependence(this)); } ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter, QualType T, ExprValueKind VK, ExprObjectKind OK, - SourceLocation IdLoc, - SourceLocation ReceiverLoc, ObjCInterfaceDecl *Receiver) - : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false), + SourceLocation IdLoc, SourceLocation ReceiverLoc, + ObjCInterfaceDecl *Receiver) + : Expr(ObjCPropertyRefExprClass, T, VK, OK), PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0), IdLoc(IdLoc), ReceiverLoc(ReceiverLoc), Receiver(Receiver) { assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject)); + setDependence(computeDependence(this)); } explicit ObjCPropertyRefExpr(EmptyShell Empty) @@ -859,20 +855,14 @@ class ObjCSubscriptRefExpr : public Expr { ObjCMethodDecl *SetAtIndexMethodDecl; public: - ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T, - ExprValueKind VK, ExprObjectKind OK, - ObjCMethodDecl *getMethod, + ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T, ExprValueKind VK, + ExprObjectKind OK, ObjCMethodDecl *getMethod, ObjCMethodDecl *setMethod, SourceLocation RB) - : Expr(ObjCSubscriptRefExprClass, T, VK, OK, - base->isTypeDependent() || key->isTypeDependent(), - base->isValueDependent() || key->isValueDependent(), - (base->isInstantiationDependent() || - key->isInstantiationDependent()), - (base->containsUnexpandedParameterPack() || - key->containsUnexpandedParameterPack())), - RBracket(RB), GetAtIndexMethodDecl(getMethod), - SetAtIndexMethodDecl(setMethod) { - SubExprs[BASE] = base; SubExprs[KEY] = key; + : Expr(ObjCSubscriptRefExprClass, T, VK, OK), RBracket(RB), + GetAtIndexMethodDecl(getMethod), SetAtIndexMethodDecl(setMethod) { + SubExprs[BASE] = base; + SubExprs[KEY] = key; + setDependence(computeDependence(this)); } explicit ObjCSubscriptRefExpr(EmptyShell Empty) @@ -1505,11 +1495,10 @@ class ObjCIsaExpr : public Expr { public: ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, SourceLocation oploc, QualType ty) - : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary, - /*TypeDependent=*/false, base->isValueDependent(), - base->isInstantiationDependent(), - /*ContainsUnexpandedParameterPack=*/false), - Base(base), IsaMemberLoc(l), OpLoc(oploc), IsArrow(isarrow) {} + : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary), Base(base), + IsaMemberLoc(l), OpLoc(oploc), IsArrow(isarrow) { + setDependence(computeDependence(this)); + } /// Build an empty expression. explicit ObjCIsaExpr(EmptyShell Empty) : Expr(ObjCIsaExprClass, Empty) {} @@ -1591,12 +1580,10 @@ class ObjCIndirectCopyRestoreExpr : public Expr { public: ObjCIndirectCopyRestoreExpr(Expr *operand, QualType type, bool shouldCopy) - : Expr(ObjCIndirectCopyRestoreExprClass, type, VK_LValue, OK_Ordinary, - operand->isTypeDependent(), operand->isValueDependent(), - operand->isInstantiationDependent(), - operand->containsUnexpandedParameterPack()), + : Expr(ObjCIndirectCopyRestoreExprClass, type, VK_LValue, OK_Ordinary), Operand(operand) { setShouldCopy(shouldCopy); + setDependence(computeDependence(this)); } Expr *getSubExpr() { return cast(Operand); } @@ -1705,9 +1692,10 @@ class ObjCAvailabilityCheckExpr : public Expr { public: ObjCAvailabilityCheckExpr(VersionTuple VersionToCheck, SourceLocation AtLoc, SourceLocation RParen, QualType Ty) - : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_RValue, OK_Ordinary, false, - false, false, false), - VersionToCheck(VersionToCheck), AtLoc(AtLoc), RParen(RParen) {} + : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_RValue, OK_Ordinary), + VersionToCheck(VersionToCheck), AtLoc(AtLoc), RParen(RParen) { + setDependence(ExprDependence::None); + } explicit ObjCAvailabilityCheckExpr(EmptyShell Shell) : Expr(ObjCAvailabilityCheckExprClass, Shell) {} diff --git a/clang/include/clang/AST/ExprOpenMP.h b/clang/include/clang/AST/ExprOpenMP.h index 5607d2d1dc5881..f971ed8457bcd5 100644 --- a/clang/include/clang/AST/ExprOpenMP.h +++ b/clang/include/clang/AST/ExprOpenMP.h @@ -13,6 +13,7 @@ #ifndef LLVM_CLANG_AST_EXPROPENMP_H #define LLVM_CLANG_AST_EXPROPENMP_H +#include "clang/AST/ComputeDependence.h" #include "clang/AST/Expr.h" namespace clang { @@ -51,24 +52,12 @@ class OMPArraySectionExpr : public Expr { OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type, ExprValueKind VK, ExprObjectKind OK, SourceLocation ColonLoc, SourceLocation RBracketLoc) - : Expr( - OMPArraySectionExprClass, Type, VK, OK, - Base->isTypeDependent() || - (LowerBound && LowerBound->isTypeDependent()) || - (Length && Length->isTypeDependent()), - Base->isValueDependent() || - (LowerBound && LowerBound->isValueDependent()) || - (Length && Length->isValueDependent()), - Base->isInstantiationDependent() || - (LowerBound && LowerBound->isInstantiationDependent()) || - (Length && Length->isInstantiationDependent()), - Base->containsUnexpandedParameterPack() || - (LowerBound && LowerBound->containsUnexpandedParameterPack()) || - (Length && Length->containsUnexpandedParameterPack())), - ColonLoc(ColonLoc), RBracketLoc(RBracketLoc) { + : Expr(OMPArraySectionExprClass, Type, VK, OK), ColonLoc(ColonLoc), + RBracketLoc(RBracketLoc) { SubExprs[BASE] = Base; SubExprs[LOWER_BOUND] = LowerBound; SubExprs[LENGTH] = Length; + setDependence(computeDependence(this)); } /// Create an empty array section expression. diff --git a/clang/include/clang/AST/TemplateBase.h b/clang/include/clang/AST/TemplateBase.h index 1875e3eda03951..a8529dc2cf54c7 100644 --- a/clang/include/clang/AST/TemplateBase.h +++ b/clang/include/clang/AST/TemplateBase.h @@ -669,6 +669,9 @@ struct alignas(void *) ASTTemplateKWAndArgsInfo { void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray); + // FIXME: The parameter Deps is the result populated by this method, the + // caller doesn't need it since it is populated by computeDependence. remove + // it. void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray, diff --git a/clang/include/clang/Basic/AArch64SVETypeFlags.h b/clang/include/clang/Basic/AArch64SVETypeFlags.h deleted file mode 100644 index 2b11fe6f9b2bbd..00000000000000 --- a/clang/include/clang/Basic/AArch64SVETypeFlags.h +++ /dev/null @@ -1,67 +0,0 @@ -//===- AArch64SVETypeFlags.h - Flags used to generate ACLE builtins- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CLANG_BASIC_AARCH64SVETYPEFLAGS_H -#define LLVM_CLANG_BASIC_AARCH64SVETYPEFLAGS_H - -#include - -namespace clang { - -/// Flags to identify the types for overloaded SVE builtins. -class SVETypeFlags { - uint64_t Flags; - -public: - /// These must be kept in sync with the flags in - /// include/clang/Basic/arm_sve.td. - static const uint64_t MemEltTypeOffset = 4; // Bit offset of MemEltTypeMask - static const uint64_t EltTypeMask = 0x00000000000f; - static const uint64_t MemEltTypeMask = 0x000000000070; - static const uint64_t IsLoad = 0x000000000080; - - enum EltType { - Invalid, - Int8, - Int16, - Int32, - Int64, - Float16, - Float32, - Float64, - Bool8, - Bool16, - Bool32, - Bool64 - }; - - enum MemEltTy { - MemEltTyDefault, - MemEltTyInt8, - MemEltTyInt16, - MemEltTyInt32, - MemEltTyInt64 - }; - - SVETypeFlags(uint64_t F) : Flags(F) { } - SVETypeFlags(EltType ET, bool IsUnsigned) : Flags(ET) { } - - EltType getEltType() const { return (EltType)(Flags & EltTypeMask); } - MemEltTy getMemEltType() const { - return (MemEltTy)((Flags & MemEltTypeMask) >> MemEltTypeOffset); - } - - bool isLoad() const { return Flags & IsLoad; } - - uint64_t getBits() const { return Flags; } - bool isFlagSet(uint64_t Flag) const { return Flags & Flag; } -}; - -} // end namespace clang - -#endif diff --git a/clang/include/clang/Basic/BuiltinsAArch64.def b/clang/include/clang/Basic/BuiltinsAArch64.def index f07c567053dea6..8f3a24c2e1f65e 100644 --- a/clang/include/clang/Basic/BuiltinsAArch64.def +++ b/clang/include/clang/Basic/BuiltinsAArch64.def @@ -99,6 +99,19 @@ BUILTIN(__builtin_arm_tcommit, "v", "n") BUILTIN(__builtin_arm_tcancel, "vWUIi", "n") BUILTIN(__builtin_arm_ttest, "WUi", "nc") +// SVE +BUILTIN(__builtin_sve_svld1_s16, "q8sq16bSsC*", "n") +BUILTIN(__builtin_sve_svld1_s32, "q4iq16bSiC*", "n") +BUILTIN(__builtin_sve_svld1_s64, "q2Wiq16bSWiC*", "n") +BUILTIN(__builtin_sve_svld1_s8, "q16Scq16bScC*", "n") +BUILTIN(__builtin_sve_svld1_u16, "q8Usq16bUsC*", "n") +BUILTIN(__builtin_sve_svld1_u32, "q4Uiq16bUiC*", "n") +BUILTIN(__builtin_sve_svld1_u64, "q2UWiq16bUWiC*", "n") +BUILTIN(__builtin_sve_svld1_u8, "q16Ucq16bUcC*", "n") +BUILTIN(__builtin_sve_svld1_f64, "q2dq16bdC*", "n") +BUILTIN(__builtin_sve_svld1_f32, "q4fq16bfC*", "n") +BUILTIN(__builtin_sve_svld1_f16, "q8hq16bhC*", "n") + TARGET_HEADER_BUILTIN(_BitScanForward, "UcUNi*UNi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_BitScanReverse, "UcUNi*UNi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_BitScanForward64, "UcUNi*ULLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") diff --git a/clang/include/clang/Basic/BuiltinsSVE.def b/clang/include/clang/Basic/BuiltinsSVE.def deleted file mode 100644 index 2839ca992d98cc..00000000000000 --- a/clang/include/clang/Basic/BuiltinsSVE.def +++ /dev/null @@ -1,20 +0,0 @@ -//===--- BuiltinsSVE.def - SVE Builtin function database --------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file defines the SVE-specific builtin function database. Users of -// this file must define the BUILTIN macro to make use of this information. -// -//===----------------------------------------------------------------------===// - -// The format of this database matches clang/Basic/Builtins.def. - -#define GET_SVE_BUILTINS -#include "clang/Basic/arm_sve_builtins.inc" -#undef GET_SVE_BUILTINS - -#undef BUILTIN diff --git a/clang/include/clang/Basic/CMakeLists.txt b/clang/include/clang/Basic/CMakeLists.txt index 2ce38c631eeccd..ea011a8af177f7 100644 --- a/clang/include/clang/Basic/CMakeLists.txt +++ b/clang/include/clang/Basic/CMakeLists.txt @@ -60,12 +60,7 @@ clang_tablegen(arm_mve_builtin_sema.inc -gen-arm-mve-builtin-sema clang_tablegen(arm_mve_builtin_aliases.inc -gen-arm-mve-builtin-aliases SOURCE arm_mve.td TARGET ClangARMMveBuiltinAliases) -clang_tablegen(arm_sve_builtins.inc -gen-arm-sve-builtins - SOURCE arm_sve.td - TARGET ClangARMSveBuiltins) -clang_tablegen(arm_sve_codegenmap.inc -gen-arm-sve-codegenmap - SOURCE arm_sve.td - TARGET ClangARMSveCodeGenMap) + clang_tablegen(arm_cde_builtins.inc -gen-arm-cde-builtin-def SOURCE arm_cde.td TARGET ClangARMCdeBuiltinsDef) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index cc815a4993d525..77df05fbaf0544 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -1537,6 +1537,9 @@ def err_distant_exception_spec : Error< def err_incomplete_in_exception_spec : Error< "%select{|pointer to |reference to }0incomplete type %1 is not allowed " "in exception specification">; +def err_sizeless_in_exception_spec : Error< + "%select{|reference to }0sizeless type %1 is not allowed " + "in exception specification">; def ext_incomplete_in_exception_spec : ExtWarn, InGroup; def err_rref_in_exception_spec : Error< @@ -6126,8 +6129,8 @@ def err_typecheck_subscript_not_integer : Error< "array subscript is not an integer">; def err_subscript_function_type : Error< "subscript of pointer to function type %0">; -def err_subscript_incomplete_type : Error< - "subscript of pointer to incomplete type %0">; +def err_subscript_incomplete_or_sizeless_type : Error< + "subscript of pointer to %select{incomplete|sizeless}0 type %1">; def err_dereference_incomplete_type : Error< "dereference of pointer to incomplete type %0">; def ext_gnu_subscript_void_type : Extension< @@ -6237,8 +6240,8 @@ def err_typecheck_illegal_increment_decrement : Error< "cannot %select{decrement|increment}1 value of type %0">; def err_typecheck_expect_int : Error< "used type %0 where integer is required">; -def err_typecheck_arithmetic_incomplete_type : Error< - "arithmetic on a pointer to an incomplete type %0">; +def err_typecheck_arithmetic_incomplete_or_sizeless_type : Error< + "arithmetic on a pointer to %select{an incomplete|sizeless}0 type %1">; def err_typecheck_pointer_arith_function_type : Error< "arithmetic on%select{ a|}0 pointer%select{|s}0 to%select{ the|}2 " "function type%select{|s}2 %1%select{| and %3}2">; @@ -6894,8 +6897,8 @@ def err_array_new_needs_size : Error< "array size must be specified in new expression with no initializer">; def err_bad_new_type : Error< "cannot allocate %select{function|reference}1 type %0 with new">; -def err_new_incomplete_type : Error< - "allocation of incomplete type %0">; +def err_new_incomplete_or_sizeless_type : Error< + "allocation of %select{incomplete|sizeless}0 type %1">; def err_new_array_nonconst : Error< "only the first dimension of an allocated array may have dynamic size">; def err_new_array_size_unknown_from_init : Error< @@ -7012,6 +7015,8 @@ def err_catch_incomplete_ptr : Error< def err_catch_incomplete_ref : Error< "cannot catch reference to incomplete type %0">; def err_catch_incomplete : Error<"cannot catch incomplete type %0">; +def err_catch_sizeless : Error< + "cannot catch %select{|reference to }0sizeless type %1">; def err_catch_rvalue_ref : Error<"cannot catch exceptions by rvalue reference">; def err_catch_variably_modified : Error< "cannot catch variably modified type %0">; @@ -7117,6 +7122,8 @@ def err_throw_incomplete : Error< "cannot throw object of incomplete type %0">; def err_throw_incomplete_ptr : Error< "cannot throw pointer to object of incomplete type %0">; +def err_throw_sizeless : Error< + "cannot throw object of sizeless type %0">; def warn_throw_underaligned_obj : Warning< "underaligned exception object thrown">, InGroup; diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def index 53b87b73756894..4ba8c766269c2c 100644 --- a/clang/include/clang/Basic/LangOptions.def +++ b/clang/include/clang/Basic/LangOptions.def @@ -176,6 +176,7 @@ VALUE_LANGOPT(PackStruct , 32, 0, VALUE_LANGOPT(MaxTypeAlign , 32, 0, "default maximum alignment for types") VALUE_LANGOPT(AlignDouble , 1, 0, "Controls if doubles should be aligned to 8 bytes (x86 only)") +VALUE_LANGOPT(DoubleSize , 32, 0, "width of double") VALUE_LANGOPT(LongDoubleSize , 32, 0, "width of long double") LANGOPT(PPCIEEELongDouble , 1, 0, "use IEEE 754 quadruple-precision for long double") COMPATIBLE_VALUE_LANGOPT(PICLevel , 2, 0, "__PIC__ level") diff --git a/clang/include/clang/Basic/TargetBuiltins.h b/clang/include/clang/Basic/TargetBuiltins.h index 9ef7837353a0be..0e2f0753b0c59e 100644 --- a/clang/include/clang/Basic/TargetBuiltins.h +++ b/clang/include/clang/Basic/TargetBuiltins.h @@ -41,22 +41,11 @@ namespace clang { }; } - namespace SVE { - enum { - LastNEONBuiltin = NEON::FirstTSBuiltin - 1, -#define BUILTIN(ID, TYPE, ATTRS) BI##ID, -#include "clang/Basic/BuiltinsSVE.def" - FirstTSBuiltin, - }; - } - /// AArch64 builtins namespace AArch64 { enum { LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1, LastNEONBuiltin = NEON::FirstTSBuiltin - 1, - FirstSVEBuiltin = NEON::FirstTSBuiltin, - LastSVEBuiltin = SVE::FirstTSBuiltin - 1, #define BUILTIN(ID, TYPE, ATTRS) BI##ID, #include "clang/Basic/BuiltinsAArch64.def" LastTSBuiltin diff --git a/clang/include/clang/Basic/arm_sve.td b/clang/include/clang/Basic/arm_sve.td index afaab8a76e2852..10417cdfcdea1e 100644 --- a/clang/include/clang/Basic/arm_sve.td +++ b/clang/include/clang/Basic/arm_sve.td @@ -12,110 +12,3 @@ // https://developer.arm.com/architectures/system-architectures/software-standards/acle // //===----------------------------------------------------------------------===// - -//===----------------------------------------------------------------------===// -// Instruction definitions -//===----------------------------------------------------------------------===// -// Every intrinsic subclasses "Inst". An intrinsic has a name, a prototype and -// a sequence of typespecs. -// -// The name is the base name of the intrinsic, for example "svld1". This is -// then mangled by the tblgen backend to add type information ("svld1_s16"). -// -// A typespec is a sequence of uppercase characters (modifiers) followed by one -// lowercase character. A typespec encodes a particular "base type" of the -// intrinsic. -// -// An example typespec is "Us" - unsigned short - svuint16_t. The available -// typespec codes are given below. -// -// The string given to an Inst class is a sequence of typespecs. The intrinsic -// is instantiated for every typespec in the sequence. For example "sdUsUd". -// -// The prototype is a string that defines the return type of the intrinsic -// and the type of each argument. The return type and every argument gets a -// "modifier" that can change in some way the "base type" of the intrinsic. -// -// The modifier 'd' means "default" and does not modify the base type in any -// way. The available modifiers are given below. -// -// Typespecs -// --------- -// c: char -// s: short -// i: int -// l: long -// f: float -// h: half-float -// d: double - -// Typespec modifiers -// ------------------ -// P: boolean -// U: unsigned - -// Prototype modifiers -// ------------------- -// prototype: return (arg, arg, ...) -// -// d: default -// c: const pointer type -// P: predicate type - -class MergeType { - int Value = val; -} -def MergeNone : MergeType<0>; -def MergeAny : MergeType<1>; -def MergeOp1 : MergeType<2>; -def MergeZero : MergeType<3>; -def MergeAnyExp : MergeType<4>; // Use merged builtin with explicit -def MergeZeroExp : MergeType<5>; // generation of its inactive argument. - -class MemEltTy { - int Value = val; -} -def MemEltTyDefault : MemEltTy<0>; -def MemEltTyInt8 : MemEltTy<1>; -def MemEltTyInt16 : MemEltTy<2>; -def MemEltTyInt32 : MemEltTy<3>; -def MemEltTyInt64 : MemEltTy<4>; - -class FlagType { - int Value = val; -} - -// These must be kept in sync with the flags in utils/TableGen/SveEmitter.h -// and include/clang/Basic/TargetBuiltins.h -def NoFlags : FlagType<0x00000000>; -// 0x00000001 => EltType -// ... -// 0x0000000f => EltType -// 0x00000010 => MemEltType -// ... -// 0x00000070 => MemEltType -def IsLoad : FlagType<0x00000080>; - -// Every intrinsic subclasses Inst. -class Inst ft, MemEltTy met> { - string Name = n; - string Prototype = p; - string Types = t; - string ArchGuard = ""; - int Merge = mt.Value; - string LLVMIntrinsic = i; - list Flags = ft; - int MemEltType = met.Value; -} - -// MInst: Instructions which access memory -class MInst f, - MemEltTy met=MemEltTyDefault, string i=""> - : Inst {} - -//////////////////////////////////////////////////////////////////////////////// -// Loads - -// Load one vector (scalar base) -def SVLD1 : MInst<"svld1[_{2}]", "dPc", "csilUcUsUiUlhfd", [IsLoad]>; diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index bdcd771ff713b9..3a4830c8448311 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -2179,6 +2179,8 @@ def mbranches_within_32B_boundaries : Flag<["-"], "mbranches-within-32B-boundari def mfancy_math_387 : Flag<["-"], "mfancy-math-387">, Group; def mlong_calls : Flag<["-"], "mlong-calls">, Group, HelpText<"Generate branches with extended addressability, usually via indirect jumps.">; +def mdouble_EQ : Joined<["-"], "mdouble=">, Group, Values<"32,64">, Flags<[CC1Option]>, + HelpText<"Force double to be 32 bits or 64 bits">; def LongDouble_Group : OptionGroup<"">, Group, DocName<"Long double flags">, DocBrief<[{Selects the long double implementation}]>; diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index fd58c00640b059..121ceb7e5d367f 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -6986,7 +6986,8 @@ class Sema final { QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, SourceLocation TemplateKWLoc = SourceLocation(), - AssumedTemplateKind *ATK = nullptr); + AssumedTemplateKind *ATK = nullptr, + bool Disambiguation = false); TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, @@ -6995,7 +6996,8 @@ class Sema final { ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, - bool &MemberOfUnknownSpecialization); + bool &MemberOfUnknownSpecialization, + bool Disambiguation = false); /// Try to resolve an undeclared template name as a type template. /// diff --git a/clang/include/clang/Tooling/Syntax/Nodes.h b/clang/include/clang/Tooling/Syntax/Nodes.h index 25acc1757428c8..82fcac33f99bd0 100644 --- a/clang/include/clang/Tooling/Syntax/Nodes.h +++ b/clang/include/clang/Tooling/Syntax/Nodes.h @@ -38,10 +38,10 @@ enum class NodeKind : uint16_t { Leaf, TranslationUnit, - // Expressions + // Expressions. UnknownExpression, - // Statements + // Statements. UnknownStatement, DeclarationStatement, EmptyStatement, @@ -58,7 +58,7 @@ enum class NodeKind : uint16_t { ExpressionStatement, CompoundStatement, - // Declarations + // Declarations. UnknownDeclaration, EmptyDeclaration, StaticAssertDeclaration, @@ -68,7 +68,16 @@ enum class NodeKind : uint16_t { NamespaceAliasDefinition, UsingNamespaceDirective, UsingDeclaration, - TypeAliasDeclaration + TypeAliasDeclaration, + + // Declarators. + SimpleDeclarator, + ParenDeclarator, + + ArraySubscript, + TrailingReturnType, + ParametersAndQualifiers, + MemberPointer }; /// For debugging purposes. llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NodeKind K); @@ -101,11 +110,19 @@ enum class NodeRole : uint8_t { ExpressionStatement_expression, CompoundStatement_statement, StaticAssertDeclaration_condition, - StaticAssertDeclaration_message + StaticAssertDeclaration_message, + SimpleDeclaration_declarator, + ArraySubscript_sizeExpression, + TrailingReturnType_arrow, + TrailingReturnType_declarator, + ParametersAndQualifiers_parameter, + ParametersAndQualifiers_trailingReturn }; /// For debugging purposes. llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NodeRole R); +class SimpleDeclarator; + /// A root node for a translation unit. Parent is always null. class TranslationUnit final : public Tree { public: @@ -375,6 +392,8 @@ class SimpleDeclaration final : public Declaration { static bool classof(const Node *N) { return N->kind() == NodeKind::SimpleDeclaration; } + /// FIXME: use custom iterator instead of 'vector'. + std::vector declarators(); }; /// namespace { } @@ -424,6 +443,113 @@ class TypeAliasDeclaration final : public Declaration { } }; +/// Covers a name, an initializer and a part of the type outside declaration +/// specifiers. Examples are: +/// `*a` in `int *a` +/// `a[10]` in `int a[10]` +/// `*a = nullptr` in `int *a = nullptr` +/// Declarators can be unnamed too: +/// `**` in `new int**` +/// `* = nullptr` in `void foo(int* = nullptr)` +/// Most declarators you encounter are instances of SimpleDeclarator. They may +/// contain an inner declarator inside parentheses, we represent it as +/// ParenDeclarator. E.g. +/// `(*a)` in `int (*a) = 10` +class Declarator : public Tree { +public: + Declarator(NodeKind K) : Tree(K) {} + static bool classof(const Node *N) { + return NodeKind::SimpleDeclarator <= N->kind() && + N->kind() <= NodeKind::ParenDeclarator; + } +}; + +/// A top-level declarator without parentheses. See comment of Declarator for +/// more details. +class SimpleDeclarator final : public Declarator { +public: + SimpleDeclarator() : Declarator(NodeKind::SimpleDeclarator) {} + static bool classof(const Node *N) { + return N->kind() == NodeKind::SimpleDeclarator; + } +}; + +/// Declarator inside parentheses. +/// E.g. `(***a)` from `int (***a) = nullptr;` +/// See comment of Declarator for more details. +class ParenDeclarator final : public Declarator { +public: + ParenDeclarator() : Declarator(NodeKind::ParenDeclarator) {} + static bool classof(const Node *N) { + return N->kind() == NodeKind::ParenDeclarator; + } + syntax::Leaf *lparen(); + syntax::Leaf *rparen(); +}; + +/// Array size specified inside a declarator. +/// E.g: +/// `[10]` in `int a[10];` +/// `[static 10]` in `void f(int xs[static 10]);` +class ArraySubscript final : public Tree { +public: + ArraySubscript() : Tree(NodeKind::ArraySubscript) {} + static bool classof(const Node *N) { + return N->kind() == NodeKind::ArraySubscript; + } + // TODO: add an accessor for the "static" keyword. + syntax::Leaf *lbracket(); + syntax::Expression *sizeExpression(); + syntax::Leaf *rbracket(); +}; + +/// Trailing return type after the parameter list, including the arrow token. +/// E.g. `-> int***`. +class TrailingReturnType final : public Tree { +public: + TrailingReturnType() : Tree(NodeKind::TrailingReturnType) {} + static bool classof(const Node *N) { + return N->kind() == NodeKind::TrailingReturnType; + } + // TODO: add accessors for specifiers. + syntax::Leaf *arrow(); + syntax::SimpleDeclarator *declarator(); +}; + +/// Parameter list for a function type and a trailing return type, if the +/// function has one. +/// E.g.: +/// `(int a) volatile ` in `int foo(int a) volatile;` +/// `(int a) &&` in `int foo(int a) &&;` +/// `() -> int` in `auto foo() -> int;` +/// `() const` in `int foo() const;` +/// `() noexcept` in `int foo() noexcept;` +/// `() throw()` in `int foo() throw();` +/// +/// (!) override doesn't belong here. +class ParametersAndQualifiers final : public Tree { +public: + ParametersAndQualifiers() : Tree(NodeKind::ParametersAndQualifiers) {} + static bool classof(const Node *N) { + return N->kind() == NodeKind::ParametersAndQualifiers; + } + syntax::Leaf *lparen(); + /// FIXME: use custom iterator instead of 'vector'. + std::vector parameters(); + syntax::Leaf *rparen(); + syntax::TrailingReturnType *trailingReturn(); +}; + +/// Member pointer inside a declarator +/// E.g. `X::*` in `int X::* a = 0;` +class MemberPointer final : public Tree { +public: + MemberPointer() : Tree(NodeKind::MemberPointer) {} + static bool classof(const Node *N) { + return N->kind() == NodeKind::MemberPointer; + } +}; + } // namespace syntax } // namespace clang #endif diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp index c135e95a3dd590..73622f22bcec55 100644 --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -6340,16 +6340,13 @@ ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) { ExprValueKind VK = E->getValueKind(); ExprObjectKind OK = E->getObjectKind(); - bool TypeDependent = ToCond->isTypeDependent(); - bool ValueDependent = ToCond->isValueDependent(); - // The value of CondIsTrue only matters if the value is not // condition-dependent. bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue(); return new (Importer.getToContext()) ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK, - ToRParenLoc, CondIsTrue, TypeDependent, ValueDependent); + ToRParenLoc, CondIsTrue); } ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) { diff --git a/clang/lib/AST/CMakeLists.txt b/clang/lib/AST/CMakeLists.txt index da7b808e4f5190..6018d32af8f8fd 100644 --- a/clang/lib/AST/CMakeLists.txt +++ b/clang/lib/AST/CMakeLists.txt @@ -32,6 +32,7 @@ add_clang_library(clangAST CommentParser.cpp CommentSema.cpp ComparisonCategories.cpp + ComputeDependence.cpp CXXInheritance.cpp DataCollection.cpp Decl.cpp diff --git a/clang/lib/AST/ComputeDependence.cpp b/clang/lib/AST/ComputeDependence.cpp new file mode 100644 index 00000000000000..4ca4eacde8b77d --- /dev/null +++ b/clang/lib/AST/ComputeDependence.cpp @@ -0,0 +1,701 @@ +//===- ComputeDependence.cpp ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/AST/ComputeDependence.h" +#include "clang/AST/Attr.h" +#include "clang/AST/DeclCXX.h" +#include "clang/AST/DeclarationName.h" +#include "clang/AST/DependenceFlags.h" +#include "clang/AST/Expr.h" +#include "clang/AST/ExprCXX.h" +#include "clang/AST/ExprConcepts.h" +#include "clang/AST/ExprObjC.h" +#include "clang/AST/ExprOpenMP.h" +#include "clang/Basic/ExceptionSpecificationType.h" +#include "llvm/ADT/ArrayRef.h" + +using namespace clang; + +ExprDependence clang::computeDependence(FullExpr *E) { + return E->getSubExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(OpaqueValueExpr *E) { + auto D = toExprDependence(E->getType()->getDependence()); + if (auto *S = E->getSourceExpr()) + D |= S->getDependence(); + assert(!(D & ExprDependence::UnexpandedPack)); + return D; +} + +ExprDependence clang::computeDependence(ParenExpr *E) { + return E->getSubExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(UnaryOperator *E) { + return toExprDependence(E->getType()->getDependence()) | + E->getSubExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(UnaryExprOrTypeTraitExpr *E) { + // Never type-dependent (C++ [temp.dep.expr]p3). + // Value-dependent if the argument is type-dependent. + if (E->isArgumentType()) + return turnTypeToValueDependence( + toExprDependence(E->getArgumentType()->getDependence())); + + auto ArgDeps = E->getArgumentExpr()->getDependence(); + auto Deps = ArgDeps & ~ExprDependence::TypeValue; + // Value-dependent if the argument is type-dependent. + if (ArgDeps & ExprDependence::Type) + Deps |= ExprDependence::Value; + // Check to see if we are in the situation where alignof(decl) should be + // dependent because decl's alignment is dependent. + auto ExprKind = E->getKind(); + if (ExprKind != UETT_AlignOf && ExprKind != UETT_PreferredAlignOf) + return Deps; + if ((Deps & ExprDependence::Value) && (Deps & ExprDependence::Instantiation)) + return Deps; + + auto *NoParens = E->getArgumentExpr()->IgnoreParens(); + const ValueDecl *D = nullptr; + if (const auto *DRE = dyn_cast(NoParens)) + D = DRE->getDecl(); + else if (const auto *ME = dyn_cast(NoParens)) + D = ME->getMemberDecl(); + if (!D) + return Deps; + for (const auto *I : D->specific_attrs()) { + if (I->isAlignmentDependent()) + return Deps | ExprDependence::ValueInstantiation; + } + return Deps; +} + +ExprDependence clang::computeDependence(ArraySubscriptExpr *E) { + return E->getLHS()->getDependence() | E->getRHS()->getDependence(); +} + +ExprDependence clang::computeDependence(CompoundLiteralExpr *E) { + return toExprDependence(E->getTypeSourceInfo()->getType()->getDependence()) | + turnTypeToValueDependence(E->getInitializer()->getDependence()); +} + +ExprDependence clang::computeDependence(CastExpr *E) { + // Cast expressions are type-dependent if the type is + // dependent (C++ [temp.dep.expr]p3). + // Cast expressions are value-dependent if the type is + // dependent or if the subexpression is value-dependent. + auto D = toExprDependence(E->getType()->getDependence()); + if (E->getStmtClass() == Stmt::ImplicitCastExprClass) { + // An implicit cast expression doesn't (lexically) contain an + // unexpanded pack, even if its target type does. + D &= ~ExprDependence::UnexpandedPack; + } + if (auto *S = E->getSubExpr()) + D |= S->getDependence() & ~ExprDependence::Type; + return D; +} + +ExprDependence clang::computeDependence(BinaryOperator *E) { + return E->getLHS()->getDependence() | E->getRHS()->getDependence(); +} + +ExprDependence clang::computeDependence(ConditionalOperator *E) { + // The type of the conditional operator depends on the type of the conditional + // to support the GCC vector conditional extension. Additionally, + // [temp.dep.expr] does specify state that this should be dependent on ALL sub + // expressions. + return E->getCond()->getDependence() | E->getLHS()->getDependence() | + E->getRHS()->getDependence(); +} + +ExprDependence clang::computeDependence(BinaryConditionalOperator *E) { + return E->getCommon()->getDependence() | E->getFalseExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(StmtExpr *E, unsigned TemplateDepth) { + auto D = ExprDependence::None; + if (E->getType()->isDependentType()) + D |= ExprDependence::Type; + // Note: we treat a statement-expression in a dependent context as always + // being value- and instantiation-dependent. This matches the behavior of + // lambda-expressions and GCC. + if (TemplateDepth) + D |= ExprDependence::ValueInstantiation; + return D; +} + +ExprDependence clang::computeDependence(ConvertVectorExpr *E) { + auto D = toExprDependence(E->getType()->getDependence()) | + E->getSrcExpr()->getDependence(); + if (!E->getType()->isDependentType()) + D &= ~ExprDependence::Type; + return D; +} + +ExprDependence clang::computeDependence(ChooseExpr *E) { + if (E->isConditionDependent()) + return ExprDependence::TypeValueInstantiation | + E->getCond()->getDependence() | E->getLHS()->getDependence() | + E->getRHS()->getDependence(); + + auto Cond = E->getCond()->getDependence(); + auto Active = E->getLHS()->getDependence(); + auto Inactive = E->getRHS()->getDependence(); + if (!E->isConditionTrue()) + std::swap(Active, Inactive); + // Take type- and value- dependency from the active branch. Propagate all + // other flags from all branches. + return (Active & ExprDependence::TypeValue) | + ((Cond | Active | Inactive) & ~ExprDependence::TypeValue); +} + +ExprDependence clang::computeDependence(ParenListExpr *P) { + auto D = ExprDependence::None; + for (auto *E : P->exprs()) + D |= E->getDependence(); + return D; +} + +ExprDependence clang::computeDependence(VAArgExpr *E) { + auto D = + toExprDependence(E->getWrittenTypeInfo()->getType()->getDependence()) | + (E->getSubExpr()->getDependence() & ~ExprDependence::Type); + return D & ~ExprDependence::Value; +} + +ExprDependence clang::computeDependence(NoInitExpr *E) { + return toExprDependence(E->getType()->getDependence()) & + ExprDependence::Instantiation; +} + +ExprDependence clang::computeDependence(ArrayInitLoopExpr *E) { + auto D = E->getCommonExpr()->getDependence() | + E->getSubExpr()->getDependence() | ExprDependence::Instantiation; + if (!E->getType()->isInstantiationDependentType()) + D &= ~ExprDependence::Instantiation; + return turnTypeToValueDependence(D); +} + +ExprDependence clang::computeDependence(ImplicitValueInitExpr *E) { + return toExprDependence(E->getType()->getDependence()) & + ExprDependence::Instantiation; +} + +ExprDependence clang::computeDependence(ExtVectorElementExpr *E) { + return E->getBase()->getDependence(); +} + +ExprDependence clang::computeDependence(BlockExpr *E) { + auto D = toExprDependence(E->getType()->getDependence()); + if (E->getBlockDecl()->isDependentContext()) + D |= ExprDependence::Instantiation; + return D & ~ExprDependence::UnexpandedPack; +} + +ExprDependence clang::computeDependence(AsTypeExpr *E) { + auto D = toExprDependence(E->getType()->getDependence()) | + E->getSrcExpr()->getDependence(); + if (!E->getType()->isDependentType()) + D &= ~ExprDependence::Type; + return D; +} + +ExprDependence clang::computeDependence(CXXRewrittenBinaryOperator *E) { + return E->getSemanticForm()->getDependence(); +} + +ExprDependence clang::computeDependence(CXXStdInitializerListExpr *E) { + auto D = turnTypeToValueDependence(E->getSubExpr()->getDependence()); + if (E->getType()->isDependentType()) + D |= ExprDependence::Type; + return D; +} + +ExprDependence clang::computeDependence(CXXTypeidExpr *E) { + auto D = ExprDependence::None; + if (E->isTypeOperand()) + D = toExprDependence( + E->getTypeOperandSourceInfo()->getType()->getDependence()); + else + D = turnTypeToValueDependence(E->getExprOperand()->getDependence()); + // typeid is never type-dependent (C++ [temp.dep.expr]p4) + return D & ~ExprDependence::Type; +} + +ExprDependence clang::computeDependence(MSPropertyRefExpr *E) { + return E->getBaseExpr()->getDependence() & ~ExprDependence::Type; +} + +ExprDependence clang::computeDependence(MSPropertySubscriptExpr *E) { + return E->getIdx()->getDependence(); +} + +ExprDependence clang::computeDependence(CXXUuidofExpr *E) { + if (E->isTypeOperand()) + return turnTypeToValueDependence(toExprDependence( + E->getTypeOperandSourceInfo()->getType()->getDependence())); + + return turnTypeToValueDependence(E->getExprOperand()->getDependence()); +} + +ExprDependence clang::computeDependence(CXXThisExpr *E) { + // 'this' is type-dependent if the class type of the enclosing + // member function is dependent (C++ [temp.dep.expr]p2) + auto D = toExprDependence(E->getType()->getDependence()); + assert(!(D & ExprDependence::UnexpandedPack)); + return D; +} + +ExprDependence clang::computeDependence(CXXThrowExpr *E) { + auto *Op = E->getSubExpr(); + if (!Op) + return ExprDependence::None; + return Op->getDependence() & ~ExprDependence::TypeValue; +} + +ExprDependence clang::computeDependence(CXXBindTemporaryExpr *E) { + return E->getSubExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(CXXScalarValueInitExpr *E) { + return toExprDependence(E->getType()->getDependence()) & + ~ExprDependence::TypeValue; +} + +ExprDependence clang::computeDependence(CXXDeleteExpr *E) { + return turnTypeToValueDependence(E->getArgument()->getDependence()); +} + +ExprDependence clang::computeDependence(ArrayTypeTraitExpr *E) { + auto D = toExprDependence(E->getQueriedType()->getDependence()); + if (auto *Dim = E->getDimensionExpression()) + D |= Dim->getDependence(); + return turnTypeToValueDependence(D); +} + +ExprDependence clang::computeDependence(ExpressionTraitExpr *E) { + // Never type-dependent. + auto D = E->getQueriedExpression()->getDependence() & ~ExprDependence::Type; + // Value-dependent if the argument is type-dependent. + if (E->getQueriedExpression()->isTypeDependent()) + D |= ExprDependence::Value; + return D; +} + +ExprDependence clang::computeDependence(CXXNoexceptExpr *E, CanThrowResult CT) { + auto D = E->getOperand()->getDependence() & ~ExprDependence::TypeValue; + if (CT == CT_Dependent) + D |= ExprDependence::ValueInstantiation; + return D; +} + +ExprDependence clang::computeDependence(SubstNonTypeTemplateParmExpr *E) { + return E->getReplacement()->getDependence(); +} + +ExprDependence clang::computeDependence(CoroutineSuspendExpr *E) { + if (auto *Resume = E->getResumeExpr()) + return (Resume->getDependence() & ExprDependence::TypeValue) | + (E->getCommonExpr()->getDependence() & ~ExprDependence::TypeValue); + return E->getCommonExpr()->getDependence() | + ExprDependence::TypeValueInstantiation; +} + +ExprDependence clang::computeDependence(DependentCoawaitExpr *E) { + return E->getOperand()->getDependence() | + ExprDependence::TypeValueInstantiation; +} + +ExprDependence clang::computeDependence(ObjCBoxedExpr *E) { + return E->getSubExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(ObjCEncodeExpr *E) { + return toExprDependence(E->getEncodedType()->getDependence()); +} + +ExprDependence clang::computeDependence(ObjCIvarRefExpr *E) { + return turnTypeToValueDependence(E->getBase()->getDependence()); +} + +ExprDependence clang::computeDependence(ObjCPropertyRefExpr *E) { + if (E->isObjectReceiver()) + return E->getBase()->getDependence() & ~ExprDependence::Type; + if (E->isSuperReceiver()) + return toExprDependence(E->getSuperReceiverType()->getDependence()) & + ~ExprDependence::TypeValue; + assert(E->isClassReceiver()); + return ExprDependence::None; +} + +ExprDependence clang::computeDependence(ObjCSubscriptRefExpr *E) { + return E->getBaseExpr()->getDependence() | E->getKeyExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(ObjCIsaExpr *E) { + return E->getBase()->getDependence() & ~ExprDependence::Type & + ~ExprDependence::UnexpandedPack; +} + +ExprDependence clang::computeDependence(ObjCIndirectCopyRestoreExpr *E) { + return E->getSubExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(OMPArraySectionExpr *E) { + auto D = E->getBase()->getDependence(); + if (auto *LB = E->getLowerBound()) + D |= LB->getDependence(); + if (auto *Len = E->getLength()) + D |= Len->getDependence(); + return D; +} + +/// Compute the type-, value-, and instantiation-dependence of a +/// declaration reference +/// based on the declaration being referenced. +ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) { + auto Deps = ExprDependence::None; + + if (auto *NNS = E->getQualifier()) + Deps |= toExprDependence(NNS->getDependence()); + + if (auto *FirstArg = E->getTemplateArgs()) { + unsigned NumArgs = E->getNumTemplateArgs(); + for (auto *Arg = FirstArg, *End = FirstArg + NumArgs; Arg < End; ++Arg) + Deps |= toExprDependence(Arg->getArgument().getDependence()); + } + + auto *Decl = E->getDecl(); + auto Type = E->getType(); + + if (Decl->isParameterPack()) + Deps |= ExprDependence::UnexpandedPack; + + // (TD) C++ [temp.dep.expr]p3: + // An id-expression is type-dependent if it contains: + // + // and + // + // (VD) C++ [temp.dep.constexpr]p2: + // An identifier is value-dependent if it is: + + // (TD) - an identifier that was declared with dependent type + // (VD) - a name declared with a dependent type, + if (Type->isDependentType()) + return Deps | ExprDependence::TypeValueInstantiation; + else if (Type->isInstantiationDependentType()) + Deps |= ExprDependence::Instantiation; + + // (TD) - a conversion-function-id that specifies a dependent type + if (Decl->getDeclName().getNameKind() == + DeclarationName::CXXConversionFunctionName) { + QualType T = Decl->getDeclName().getCXXNameType(); + if (T->isDependentType()) + return Deps | ExprDependence::TypeValueInstantiation; + + if (T->isInstantiationDependentType()) + Deps |= ExprDependence::Instantiation; + } + + // (VD) - the name of a non-type template parameter, + if (isa(Decl)) + return Deps | ExprDependence::ValueInstantiation; + + // (VD) - a constant with integral or enumeration type and is + // initialized with an expression that is value-dependent. + // (VD) - a constant with literal type and is initialized with an + // expression that is value-dependent [C++11]. + // (VD) - FIXME: Missing from the standard: + // - an entity with reference type and is initialized with an + // expression that is value-dependent [C++11] + if (VarDecl *Var = dyn_cast(Decl)) { + if ((Ctx.getLangOpts().CPlusPlus11 + ? Var->getType()->isLiteralType(Ctx) + : Var->getType()->isIntegralOrEnumerationType()) && + (Var->getType().isConstQualified() || + Var->getType()->isReferenceType())) { + if (const Expr *Init = Var->getAnyInitializer()) + if (Init->isValueDependent()) { + Deps |= ExprDependence::ValueInstantiation; + } + } + + // (VD) - FIXME: Missing from the standard: + // - a member function or a static data member of the current + // instantiation + if (Var->isStaticDataMember() && + Var->getDeclContext()->isDependentContext()) { + Deps |= ExprDependence::ValueInstantiation; + TypeSourceInfo *TInfo = Var->getFirstDecl()->getTypeSourceInfo(); + if (TInfo->getType()->isIncompleteArrayType()) + Deps |= ExprDependence::Type; + } + + return Deps; + } + + // (VD) - FIXME: Missing from the standard: + // - a member function or a static data member of the current + // instantiation + if (isa(Decl) && Decl->getDeclContext()->isDependentContext()) + Deps |= ExprDependence::ValueInstantiation; + return Deps; +} + +ExprDependence clang::computeDependence(PredefinedExpr *E) { + return toExprDependence(E->getType()->getDependence()) & + ~ExprDependence::UnexpandedPack; +} + +ExprDependence clang::computeDependence(CallExpr *E, + llvm::ArrayRef PreArgs) { + auto D = E->getCallee()->getDependence(); + for (auto *A : llvm::makeArrayRef(E->getArgs(), E->getNumArgs())) { + if (A) + D |= A->getDependence(); + } + for (auto *A : PreArgs) + D |= A->getDependence(); + return D; +} + +ExprDependence clang::computeDependence(OffsetOfExpr *E) { + auto D = turnTypeToValueDependence( + toExprDependence(E->getTypeSourceInfo()->getType()->getDependence())); + for (unsigned I = 0, N = E->getNumExpressions(); I < N; ++I) + D |= turnTypeToValueDependence(E->getIndexExpr(I)->getDependence()); + return D; +} + +ExprDependence clang::computeDependence(MemberExpr *E) { + return E->getBase()->getDependence(); +} + +ExprDependence clang::computeDependence(InitListExpr *E) { + auto D = ExprDependence::None; + for (auto *A : E->inits()) + D |= A->getDependence(); + return D; +} + +ExprDependence clang::computeDependence(ShuffleVectorExpr *E) { + auto D = toExprDependence(E->getType()->getDependence()); + for (auto *C : llvm::makeArrayRef(E->getSubExprs(), E->getNumSubExprs())) + D |= C->getDependence(); + return D; +} + +ExprDependence clang::computeDependence(GenericSelectionExpr *E, + bool ContainsUnexpandedPack) { + auto D = ContainsUnexpandedPack ? ExprDependence::UnexpandedPack + : ExprDependence::None; + if (E->isResultDependent()) + return D | ExprDependence::TypeValueInstantiation; + return D | (E->getResultExpr()->getDependence() & + ~ExprDependence::UnexpandedPack); +} + +ExprDependence clang::computeDependence(DesignatedInitExpr *E) { + auto Deps = E->getInit()->getDependence(); + for (auto D : E->designators()) { + auto DesignatorDeps = ExprDependence::None; + if (D.isArrayDesignator()) + DesignatorDeps |= E->getArrayIndex(D)->getDependence(); + else if (D.isArrayRangeDesignator()) + DesignatorDeps |= E->getArrayRangeStart(D)->getDependence() | + E->getArrayRangeEnd(D)->getDependence(); + Deps |= DesignatorDeps; + if (DesignatorDeps & ExprDependence::TypeValue) + Deps |= ExprDependence::TypeValueInstantiation; + } + return Deps; +} + +ExprDependence clang::computeDependence(PseudoObjectExpr *O) { + auto D = O->getSyntacticForm()->getDependence(); + for (auto *E : O->semantics()) + D |= E->getDependence(); + return D; +} + +ExprDependence clang::computeDependence(AtomicExpr *A) { + auto D = ExprDependence::None; + for (auto *E : llvm::makeArrayRef(A->getSubExprs(), A->getNumSubExprs())) + D |= E->getDependence(); + return D; +} + +ExprDependence clang::computeDependence(CXXNewExpr *E) { + auto D = toExprDependence(E->getType()->getDependence()); + auto Size = E->getArraySize(); + if (Size.hasValue() && *Size) + D |= turnTypeToValueDependence((*Size)->getDependence()); + if (auto *I = E->getInitializer()) + D |= turnTypeToValueDependence(I->getDependence()); + for (auto *A : E->placement_arguments()) + D |= turnTypeToValueDependence(A->getDependence()); + return D; +} + +ExprDependence clang::computeDependence(CXXPseudoDestructorExpr *E) { + auto D = E->getBase()->getDependence(); + if (!E->getDestroyedType().isNull()) + D |= toExprDependence(E->getDestroyedType()->getDependence()); + if (auto *ST = E->getScopeTypeInfo()) + D |= turnTypeToValueDependence( + toExprDependence(ST->getType()->getDependence())); + if (auto *Q = E->getQualifier()) + D |= toExprDependence(Q->getDependence()); + return D; +} + +static inline ExprDependence getDependenceInExpr(DeclarationNameInfo Name) { + auto D = ExprDependence::None; + if (Name.isInstantiationDependent()) + D |= ExprDependence::Instantiation; + if (Name.containsUnexpandedParameterPack()) + D |= ExprDependence::UnexpandedPack; + return D; +} + +ExprDependence +clang::computeDependence(OverloadExpr *E, bool KnownDependent, + bool KnownInstantiationDependent, + bool KnownContainsUnexpandedParameterPack) { + auto Deps = ExprDependence::None; + if (KnownDependent) + Deps |= ExprDependence::TypeValue; + if (KnownInstantiationDependent) + Deps |= ExprDependence::Instantiation; + if (KnownContainsUnexpandedParameterPack) + Deps |= ExprDependence::UnexpandedPack; + Deps |= getDependenceInExpr(E->getNameInfo()); + if (auto *Q = E->getQualifier()) + Deps |= toExprDependence(Q->getDependence()); + for (auto *D : E->decls()) { + if (D->getDeclContext()->isDependentContext() || + isa(D)) + Deps |= ExprDependence::TypeValueInstantiation; + } + // If we have explicit template arguments, check for dependent + // template arguments and whether they contain any unexpanded pack + // expansions. + for (auto A : E->template_arguments()) + Deps |= toExprDependence(A.getArgument().getDependence()); + return Deps; +} + +ExprDependence clang::computeDependence(DependentScopeDeclRefExpr *E) { + auto D = ExprDependence::TypeValue; + D |= getDependenceInExpr(E->getNameInfo()); + if (auto *Q = E->getQualifier()) + D |= toExprDependence(Q->getDependence()); + for (auto A : E->template_arguments()) + D |= toExprDependence(A.getArgument().getDependence()); + return D; +} + +ExprDependence clang::computeDependence(CXXConstructExpr *E) { + auto D = toExprDependence(E->getType()->getDependence()); + for (auto *A : E->arguments()) + D |= A->getDependence() & ~ExprDependence::Type; + return D; +} + +ExprDependence clang::computeDependence(LambdaExpr *E, + bool ContainsUnexpandedParameterPack) { + auto D = toExprDependence(E->getType()->getDependence()); + if (ContainsUnexpandedParameterPack) + D |= ExprDependence::UnexpandedPack; + return D; +} + +ExprDependence clang::computeDependence(CXXUnresolvedConstructExpr *E) { + auto D = ExprDependence::ValueInstantiation; + D |= toExprDependence(E->getType()->getDependence()); + if (E->getType()->getContainedDeducedType()) + D |= ExprDependence::Type; + for (auto *A : E->arguments()) + D |= A->getDependence() & ExprDependence::UnexpandedPack; + return D; +} + +ExprDependence clang::computeDependence(CXXDependentScopeMemberExpr *E) { + auto D = ExprDependence::TypeValueInstantiation; + if (!E->isImplicitAccess()) + D |= E->getBase()->getDependence(); + if (auto *Q = E->getQualifier()) + D |= toExprDependence(Q->getDependence()); + D |= getDependenceInExpr(E->getMemberNameInfo()); + for (auto A : E->template_arguments()) + D |= toExprDependence(A.getArgument().getDependence()); + return D; +} + +ExprDependence clang::computeDependence(MaterializeTemporaryExpr *E) { + return E->getSubExpr()->getDependence(); +} + +ExprDependence clang::computeDependence(TypeTraitExpr *E) { + auto D = ExprDependence::None; + for (const auto *A : E->getArgs()) + D |= + toExprDependence(A->getType()->getDependence()) & ~ExprDependence::Type; + return D; +} + +ExprDependence clang::computeDependence(ConceptSpecializationExpr *E, + bool ValueDependent) { + auto TA = TemplateArgumentDependence::None; + const auto InterestingDeps = TemplateArgumentDependence::Instantiation | + TemplateArgumentDependence::UnexpandedPack; + for (const TemplateArgumentLoc &ArgLoc : + E->getTemplateArgsAsWritten()->arguments()) { + TA |= ArgLoc.getArgument().getDependence() & InterestingDeps; + if (TA == InterestingDeps) + break; + } + + ExprDependence D = + ValueDependent ? ExprDependence::Value : ExprDependence::None; + return D | toExprDependence(TA); +} + +ExprDependence clang::computeDependence(ObjCArrayLiteral *E) { + auto D = ExprDependence::None; + Expr **Elements = E->getElements(); + for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) + D |= turnTypeToValueDependence(Elements[I]->getDependence()); + return D; +} + +ExprDependence clang::computeDependence(ObjCDictionaryLiteral *E) { + auto Deps = ExprDependence::None; + for (unsigned I = 0, N = E->getNumElements(); I < N; ++I) { + auto KV = E->getKeyValueElement(I); + auto KVDeps = turnTypeToValueDependence(KV.Key->getDependence() | + KV.Value->getDependence()); + if (KV.EllipsisLoc.isValid()) + KVDeps &= ~ExprDependence::UnexpandedPack; + Deps |= KVDeps; + } + return Deps; +} + +ExprDependence clang::computeDependence(ObjCMessageExpr *E) { + auto D = ExprDependence::None; + if (auto *R = E->getInstanceReceiver()) + D |= R->getDependence(); + else + D |= toExprDependence(E->getType()->getDependence()); + for (auto *A : E->arguments()) + D |= A->getDependence(); + return D; +} diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index 4b2b9e4d5eb33d..1eb56c30283c6a 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -14,6 +14,7 @@ #include "clang/AST/APValue.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" +#include "clang/AST/ComputeDependence.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" @@ -369,93 +370,12 @@ APValue ConstantExpr::getAPValueResult() const { llvm_unreachable("invalid ResultKind"); } -/// Compute the type-, value-, and instantiation-dependence of a -/// declaration reference -/// based on the declaration being referenced. -static ExprDependence computeDeclRefDependence(const ASTContext &Ctx, - NamedDecl *D, QualType T) { - auto R = ExprDependence::None; - if (D->isParameterPack()) - R |= ExprDependence::UnexpandedPack; - - // (TD) C++ [temp.dep.expr]p3: - // An id-expression is type-dependent if it contains: - // - // and - // - // (VD) C++ [temp.dep.constexpr]p2: - // An identifier is value-dependent if it is: - - // (TD) - an identifier that was declared with dependent type - // (VD) - a name declared with a dependent type, - if (T->isDependentType()) - return R | ExprDependence::TypeValueInstantiation; - else if (T->isInstantiationDependentType()) - R |= ExprDependence::Instantiation; - - // (TD) - a conversion-function-id that specifies a dependent type - if (D->getDeclName().getNameKind() - == DeclarationName::CXXConversionFunctionName) { - QualType T = D->getDeclName().getCXXNameType(); - if (T->isDependentType()) - return R | ExprDependence::TypeValueInstantiation; - - if (T->isInstantiationDependentType()) - R |= ExprDependence::Instantiation; - } - - // (VD) - the name of a non-type template parameter, - if (isa(D)) - return R | ExprDependence::ValueInstantiation; - - // (VD) - a constant with integral or enumeration type and is - // initialized with an expression that is value-dependent. - // (VD) - a constant with literal type and is initialized with an - // expression that is value-dependent [C++11]. - // (VD) - FIXME: Missing from the standard: - // - an entity with reference type and is initialized with an - // expression that is value-dependent [C++11] - if (VarDecl *Var = dyn_cast(D)) { - if ((Ctx.getLangOpts().CPlusPlus11 ? - Var->getType()->isLiteralType(Ctx) : - Var->getType()->isIntegralOrEnumerationType()) && - (Var->getType().isConstQualified() || - Var->getType()->isReferenceType())) { - if (const Expr *Init = Var->getAnyInitializer()) - if (Init->isValueDependent()) { - R |= ExprDependence::ValueInstantiation; - } - } - - // (VD) - FIXME: Missing from the standard: - // - a member function or a static data member of the current - // instantiation - if (Var->isStaticDataMember() && - Var->getDeclContext()->isDependentContext()) { - R |= ExprDependence::ValueInstantiation; - TypeSourceInfo *TInfo = Var->getFirstDecl()->getTypeSourceInfo(); - if (TInfo->getType()->isIncompleteArrayType()) - R |= ExprDependence::Type; - } - - return R; - } - - // (VD) - FIXME: Missing from the standard: - // - a member function or a static data member of the current - // instantiation - if (isa(D) && D->getDeclContext()->isDependentContext()) - R |= ExprDependence::ValueInstantiation; - return R; -} - DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, QualType T, ExprValueKind VK, SourceLocation L, const DeclarationNameLoc &LocInfo, NonOdrUseReason NOUR) - : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false), - D(D), DNLoc(LocInfo) { + : Expr(DeclRefExprClass, T, VK, OK_Ordinary), D(D), DNLoc(LocInfo) { DeclRefExprBits.HasQualifier = false; DeclRefExprBits.HasTemplateKWAndArgsInfo = false; DeclRefExprBits.HasFoundDecl = false; @@ -464,7 +384,7 @@ DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, ValueDecl *D, RefersToEnclosingVariableOrCapture; DeclRefExprBits.NonOdrUseReason = NOUR; DeclRefExprBits.Loc = L; - addDependence(computeDeclRefDependence(Ctx, getDecl(), getType())); + setDependence(computeDependence(this, Ctx)); } DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, @@ -474,19 +394,13 @@ DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, const DeclarationNameInfo &NameInfo, NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, NonOdrUseReason NOUR) - : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false), - D(D), DNLoc(NameInfo.getInfo()) { + : Expr(DeclRefExprClass, T, VK, OK_Ordinary), D(D), + DNLoc(NameInfo.getInfo()) { DeclRefExprBits.Loc = NameInfo.getLoc(); DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0; - if (QualifierLoc) { + if (QualifierLoc) new (getTrailingObjects()) NestedNameSpecifierLoc(QualifierLoc); - auto *NNS = QualifierLoc.getNestedNameSpecifier(); - if (NNS->isInstantiationDependent()) - addDependence(ExprDependence::Instantiation); - if (NNS->containsUnexpandedParameterPack()) - addDependence(ExprDependence::UnexpandedPack); - } DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0; if (FoundD) *getTrailingObjects() = FoundD; @@ -502,13 +416,12 @@ DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, Deps); assert(!(Deps & TemplateArgumentDependence::Dependent) && "built a DeclRefExpr with dependent template args"); - addDependence(toExprDependence(Deps)); } else if (TemplateKWLoc.isValid()) { getTrailingObjects()->initializeFrom( TemplateKWLoc); } DeclRefExprBits.HadMultipleCandidates = 0; - addDependence(computeDeclRefDependence(Ctx, getDecl(), getType())); + setDependence(computeDependence(this, Ctx)); } DeclRefExpr *DeclRefExpr::Create(const ASTContext &Context, @@ -580,10 +493,7 @@ SourceLocation DeclRefExpr::getEndLoc() const { PredefinedExpr::PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK, StringLiteral *SL) - : Expr(PredefinedExprClass, FNTy, VK_LValue, OK_Ordinary, - FNTy->isDependentType(), FNTy->isDependentType(), - FNTy->isInstantiationDependentType(), - /*ContainsUnexpandedParameterPack=*/false) { + : Expr(PredefinedExprClass, FNTy, VK_LValue, OK_Ordinary) { PredefinedExprBits.Kind = IK; assert((getIdentKind() == IK) && "IdentKind do not fit in PredefinedExprBitfields!"); @@ -592,6 +502,7 @@ PredefinedExpr::PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK, PredefinedExprBits.Loc = L; if (HasFunctionName) setFunctionName(SL); + setDependence(computeDependence(this)); } PredefinedExpr::PredefinedExpr(EmptyShell Empty, bool HasFunctionName) @@ -888,13 +799,12 @@ void APNumericStorage::setIntValue(const ASTContext &C, IntegerLiteral::IntegerLiteral(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l) - : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary, false, false, - false, false), - Loc(l) { + : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary), Loc(l) { assert(type->isIntegerType() && "Illegal type in IntegerLiteral"); assert(V.getBitWidth() == C.getIntWidth(type) && "Integer type is not the correct size for constant."); setValue(C, V); + setDependence(ExprDependence::None); } IntegerLiteral * @@ -911,13 +821,13 @@ IntegerLiteral::Create(const ASTContext &C, EmptyShell Empty) { FixedPointLiteral::FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale) - : Expr(FixedPointLiteralClass, type, VK_RValue, OK_Ordinary, false, false, - false, false), - Loc(l), Scale(Scale) { + : Expr(FixedPointLiteralClass, type, VK_RValue, OK_Ordinary), Loc(l), + Scale(Scale) { assert(type->isFixedPointType() && "Illegal type in FixedPointLiteral"); assert(V.getBitWidth() == C.getTypeInfo(type).Width && "Fixed point type is not the correct size for constant."); setValue(C, V); + setDependence(ExprDependence::None); } FixedPointLiteral *FixedPointLiteral::CreateFromRawInt(const ASTContext &C, @@ -940,11 +850,11 @@ std::string FixedPointLiteral::getValueAsString(unsigned Radix) const { FloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L) - : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary, false, false, - false, false), Loc(L) { + : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary), Loc(L) { setSemantics(V.getSemantics()); FloatingLiteralBits.IsExact = isexact; setValue(C, V); + setDependence(ExprDependence::None); } FloatingLiteral::FloatingLiteral(const ASTContext &C, EmptyShell Empty) @@ -1004,8 +914,7 @@ StringLiteral::StringLiteral(const ASTContext &Ctx, StringRef Str, StringKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumConcatenated) - : Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary, false, false, false, - false) { + : Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary) { assert(Ctx.getAsConstantArrayType(Ty) && "StringLiteral must be of constant array type!"); unsigned CharByteWidth = mapCharByteWidth(Ctx.getTargetInfo(), Kind); @@ -1044,6 +953,8 @@ StringLiteral::StringLiteral(const ASTContext &Ctx, StringRef Str, // Initialize the trailing array of char holding the string data. std::memcpy(getTrailingObjects(), Str.data(), ByteLength); + + setDependence(ExprDependence::None); } StringLiteral::StringLiteral(EmptyShell Empty, unsigned NumConcatenated, @@ -1312,10 +1223,7 @@ CallExpr::CallExpr(StmtClass SC, Expr *Fn, ArrayRef PreArgs, ArrayRef Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, unsigned MinNumArgs, ADLCallKind UsesADL) - : Expr(SC, Ty, VK, OK_Ordinary, Fn->isTypeDependent(), - Fn->isValueDependent(), Fn->isInstantiationDependent(), - Fn->containsUnexpandedParameterPack()), - RParenLoc(RParenLoc) { + : Expr(SC, Ty, VK, OK_Ordinary), RParenLoc(RParenLoc) { NumArgs = std::max(Args.size(), MinNumArgs); unsigned NumPreArgs = PreArgs.size(); CallExprBits.NumPreArgs = NumPreArgs; @@ -1329,17 +1237,14 @@ CallExpr::CallExpr(StmtClass SC, Expr *Fn, ArrayRef PreArgs, CallExprBits.UsesADL = static_cast(UsesADL); setCallee(Fn); - for (unsigned I = 0; I != NumPreArgs; ++I) { - addDependence(PreArgs[I]->getDependence()); + for (unsigned I = 0; I != NumPreArgs; ++I) setPreArg(I, PreArgs[I]); - } - for (unsigned I = 0; I != Args.size(); ++I) { - addDependence(Args[I]->getDependence()); + for (unsigned I = 0; I != Args.size(); ++I) setArg(I, Args[I]); - } - for (unsigned I = Args.size(); I != NumArgs; ++I) { + for (unsigned I = Args.size(); I != NumArgs; ++I) setArg(I, nullptr); - } + + setDependence(computeDependence(this, PreArgs)); } CallExpr::CallExpr(StmtClass SC, unsigned NumPreArgs, unsigned NumArgs, @@ -1523,28 +1428,17 @@ OffsetOfExpr *OffsetOfExpr::CreateEmpty(const ASTContext &C, OffsetOfExpr::OffsetOfExpr(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, - ArrayRef comps, ArrayRef exprs, + ArrayRef comps, ArrayRef exprs, SourceLocation RParenLoc) - : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary, - /*TypeDependent=*/false, - /*ValueDependent=*/tsi->getType()->isDependentType(), - tsi->getType()->isInstantiationDependentType(), - tsi->getType()->containsUnexpandedParameterPack()), - OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi), - NumComps(comps.size()), NumExprs(exprs.size()) -{ - for (unsigned i = 0; i != comps.size(); ++i) { + : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary), + OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi), + NumComps(comps.size()), NumExprs(exprs.size()) { + for (unsigned i = 0; i != comps.size(); ++i) setComponent(i, comps[i]); - } - - for (unsigned i = 0; i != exprs.size(); ++i) { - if (exprs[i]->isTypeDependent() || exprs[i]->isValueDependent()) - addDependence(ExprDependence::Value); - if (exprs[i]->containsUnexpandedParameterPack()) - addDependence(ExprDependence ::UnexpandedPack); - + for (unsigned i = 0; i != exprs.size(); ++i) setIndexExpr(i, exprs[i]); - } + + setDependence(computeDependence(this)); } IdentifierInfo *OffsetOfNode::getFieldName() const { @@ -1558,38 +1452,12 @@ IdentifierInfo *OffsetOfNode::getFieldName() const { UnaryExprOrTypeTraitExpr::UnaryExprOrTypeTraitExpr( UnaryExprOrTypeTrait ExprKind, Expr *E, QualType resultType, SourceLocation op, SourceLocation rp) - : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary, - false, // Never type-dependent (C++ [temp.dep.expr]p3). - // Value-dependent if the argument is type-dependent. - E->isTypeDependent(), E->isInstantiationDependent(), - E->containsUnexpandedParameterPack()), + : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary), OpLoc(op), RParenLoc(rp) { UnaryExprOrTypeTraitExprBits.Kind = ExprKind; UnaryExprOrTypeTraitExprBits.IsType = false; Argument.Ex = E; - - // Check to see if we are in the situation where alignof(decl) should be - // dependent because decl's alignment is dependent. - if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) { - if (!isValueDependent() || !isInstantiationDependent()) { - E = E->IgnoreParens(); - - const ValueDecl *D = nullptr; - if (const auto *DRE = dyn_cast(E)) - D = DRE->getDecl(); - else if (const auto *ME = dyn_cast(E)) - D = ME->getMemberDecl(); - - if (D) { - for (const auto *I : D->specific_attrs()) { - if (I->isAlignmentDependent()) { - addDependence(ExprDependence::ValueInstantiation); - break; - } - } - } - } - } + setDependence(computeDependence(this)); } MemberExpr::MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc, @@ -1597,11 +1465,8 @@ MemberExpr::MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc, const DeclarationNameInfo &NameInfo, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR) - : Expr(MemberExprClass, T, VK, OK, Base->isTypeDependent(), - Base->isValueDependent(), Base->isInstantiationDependent(), - Base->containsUnexpandedParameterPack()), - Base(Base), MemberDecl(MemberDecl), MemberDNLoc(NameInfo.getInfo()), - MemberLoc(NameInfo.getLoc()) { + : Expr(MemberExprClass, T, VK, OK), Base(Base), MemberDecl(MemberDecl), + MemberDNLoc(NameInfo.getInfo()), MemberLoc(NameInfo.getLoc()) { assert(!NameInfo.getName() || MemberDecl->getDeclName() == NameInfo.getName()); MemberExprBits.IsArrow = IsArrow; @@ -1610,6 +1475,7 @@ MemberExpr::MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc, MemberExprBits.HadMultipleCandidates = false; MemberExprBits.NonOdrUseReason = NOUR; MemberExprBits.OperatorLoc = OperatorLoc; + setDependence(computeDependence(this)); } MemberExpr *MemberExpr::Create( @@ -2116,9 +1982,10 @@ SourceLocExpr::SourceLocExpr(const ASTContext &Ctx, IdentKind Kind, SourceLocation BLoc, SourceLocation RParenLoc, DeclContext *ParentContext) : Expr(SourceLocExprClass, getDecayedSourceLocExprType(Ctx, Kind), - VK_RValue, OK_Ordinary, false, false, false, false), + VK_RValue, OK_Ordinary), BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) { SourceLocExprBits.Kind = Kind; + setDependence(ExprDependence::None); } StringRef SourceLocExpr::getBuiltinStr() const { @@ -2182,17 +2049,14 @@ APValue SourceLocExpr::EvaluateInContext(const ASTContext &Ctx, } InitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc, - ArrayRef initExprs, SourceLocation rbraceloc) - : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false, - false, false), - InitExprs(C, initExprs.size()), - LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), AltForm(nullptr, true) -{ + ArrayRef initExprs, SourceLocation rbraceloc) + : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary), + InitExprs(C, initExprs.size()), LBraceLoc(lbraceloc), + RBraceLoc(rbraceloc), AltForm(nullptr, true) { sawArrayRangeDesignator(false); - for (unsigned I = 0; I != initExprs.size(); ++I) - addDependence(initExprs[I]->getDependence()); - InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end()); + + setDependence(computeDependence(this)); } void InitListExpr::reserveInits(const ASTContext &C, unsigned NumInits) { @@ -4101,20 +3965,16 @@ void ExtVectorElementExpr::getEncodedElementAccess( } } -ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef args, +ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef args, QualType Type, SourceLocation BLoc, SourceLocation RP) - : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary, - Type->isDependentType(), Type->isDependentType(), - Type->isInstantiationDependentType(), - Type->containsUnexpandedParameterPack()), - BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) -{ + : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary), + BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) { SubExprs = new (C) Stmt*[args.size()]; - for (unsigned i = 0; i != args.size(); i++) { - addDependence(args[i]->getDependence()); + for (unsigned i = 0; i != args.size(); i++) SubExprs[i] = args[i]; - } + + setDependence(computeDependence(this)); } void ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef Exprs) { @@ -4132,11 +3992,7 @@ GenericSelectionExpr::GenericSelectionExpr( bool ContainsUnexpandedParameterPack, unsigned ResultIndex) : Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(), AssocExprs[ResultIndex]->getValueKind(), - AssocExprs[ResultIndex]->getObjectKind(), - AssocExprs[ResultIndex]->isTypeDependent(), - AssocExprs[ResultIndex]->isValueDependent(), - AssocExprs[ResultIndex]->isInstantiationDependent(), - ContainsUnexpandedParameterPack), + AssocExprs[ResultIndex]->getObjectKind()), NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) { assert(AssocTypes.size() == AssocExprs.size() && @@ -4150,6 +4006,8 @@ GenericSelectionExpr::GenericSelectionExpr( getTrailingObjects() + AssocExprStartIndex); std::copy(AssocTypes.begin(), AssocTypes.end(), getTrailingObjects()); + + setDependence(computeDependence(this, ContainsUnexpandedParameterPack)); } GenericSelectionExpr::GenericSelectionExpr( @@ -4158,10 +4016,7 @@ GenericSelectionExpr::GenericSelectionExpr( SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack) : Expr(GenericSelectionExprClass, Context.DependentTy, VK_RValue, - OK_Ordinary, - /*isTypeDependent=*/true, - /*isValueDependent=*/true, - /*isInstantiationDependent=*/true, ContainsUnexpandedParameterPack), + OK_Ordinary), NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) { assert(AssocTypes.size() == AssocExprs.size() && @@ -4174,6 +4029,8 @@ GenericSelectionExpr::GenericSelectionExpr( getTrailingObjects() + AssocExprStartIndex); std::copy(AssocTypes.begin(), AssocTypes.end(), getTrailingObjects()); + + setDependence(computeDependence(this, ContainsUnexpandedParameterPack)); } GenericSelectionExpr::GenericSelectionExpr(EmptyShell Empty, unsigned NumAssocs) @@ -4232,15 +4089,11 @@ DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty, llvm::ArrayRef Designators, SourceLocation EqualOrColonLoc, bool GNUSyntax, - ArrayRef IndexExprs, - Expr *Init) - : Expr(DesignatedInitExprClass, Ty, - Init->getValueKind(), Init->getObjectKind(), - Init->isTypeDependent(), Init->isValueDependent(), - Init->isInstantiationDependent(), - Init->containsUnexpandedParameterPack()), - EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), - NumDesignators(Designators.size()), NumSubExprs(IndexExprs.size() + 1) { + ArrayRef IndexExprs, Expr *Init) + : Expr(DesignatedInitExprClass, Ty, Init->getValueKind(), + Init->getObjectKind()), + EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), + NumDesignators(Designators.size()), NumSubExprs(IndexExprs.size() + 1) { this->Designators = new (C) Designator[NumDesignators]; // Record the initializer itself. @@ -4252,29 +4105,10 @@ DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty, unsigned IndexIdx = 0; for (unsigned I = 0; I != NumDesignators; ++I) { this->Designators[I] = Designators[I]; - if (this->Designators[I].isArrayDesignator()) { - // Compute type- and value-dependence. - Expr *Index = IndexExprs[IndexIdx]; - - // Propagate dependence flags. - auto Deps = Index->getDependence(); - if (Deps & (ExprDependence::Type | ExprDependence::Value)) - Deps |= ExprDependence::Type | ExprDependence::Value; - addDependence(Deps); - // Copy the index expressions into permanent storage. *Child++ = IndexExprs[IndexIdx++]; } else if (this->Designators[I].isArrayRangeDesignator()) { - // Compute type- and value-dependence. - Expr *Start = IndexExprs[IndexIdx]; - Expr *End = IndexExprs[IndexIdx + 1]; - - auto Deps = Start->getDependence() | End->getDependence(); - if (Deps & (ExprDependence::Type | ExprDependence::Value)) - Deps |= ExprDependence::TypeValueInstantiation; - addDependence(Deps); - // Copy the start/end expressions into permanent storage. *Child++ = IndexExprs[IndexIdx++]; *Child++ = IndexExprs[IndexIdx++]; @@ -4282,6 +4116,7 @@ DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty, } assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions"); + setDependence(computeDependence(this)); } DesignatedInitExpr * @@ -4385,14 +4220,18 @@ void DesignatedInitExpr::ExpandDesignator(const ASTContext &C, unsigned Idx, } DesignatedInitUpdateExpr::DesignatedInitUpdateExpr(const ASTContext &C, - SourceLocation lBraceLoc, Expr *baseExpr, SourceLocation rBraceLoc) - : Expr(DesignatedInitUpdateExprClass, baseExpr->getType(), VK_RValue, - OK_Ordinary, false, false, false, false) { + SourceLocation lBraceLoc, + Expr *baseExpr, + SourceLocation rBraceLoc) + : Expr(DesignatedInitUpdateExprClass, baseExpr->getType(), VK_RValue, + OK_Ordinary) { BaseAndUpdaterExprs[0] = baseExpr; InitListExpr *ILE = new (C) InitListExpr(C, lBraceLoc, None, rBraceLoc); ILE->setType(baseExpr->getType()); BaseAndUpdaterExprs[1] = ILE; + + setDependence(ExprDependence::None); } SourceLocation DesignatedInitUpdateExpr::getBeginLoc() const { @@ -4405,15 +4244,13 @@ SourceLocation DesignatedInitUpdateExpr::getEndLoc() const { ParenListExpr::ParenListExpr(SourceLocation LParenLoc, ArrayRef Exprs, SourceLocation RParenLoc) - : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false, - false, false), + : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary), LParenLoc(LParenLoc), RParenLoc(RParenLoc) { ParenListExprBits.NumExprs = Exprs.size(); - for (unsigned I = 0, N = Exprs.size(); I != N; ++I) { - addDependence(Exprs[I]->getDependence()); + for (unsigned I = 0, N = Exprs.size(); I != N; ++I) getTrailingObjects()[I] = Exprs[I]; - } + setDependence(computeDependence(this)); } ParenListExpr::ParenListExpr(EmptyShell Empty, unsigned NumExprs) @@ -4487,10 +4324,9 @@ PseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &C, Expr *syntax, } PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK, - Expr *syntax, ArrayRef semantics, + Expr *syntax, ArrayRef semantics, unsigned resultIndex) - : Expr(PseudoObjectExprClass, type, VK, OK_Ordinary, - /*filled in at end of ctor*/ false, false, false, false) { + : Expr(PseudoObjectExprClass, type, VK, OK_Ordinary) { PseudoObjectExprBits.NumSubExprs = semantics.size() + 1; PseudoObjectExprBits.ResultIndex = resultIndex + 1; @@ -4498,13 +4334,13 @@ PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK, Expr *E = (i == 0 ? syntax : semantics[i-1]); getSubExprsBuffer()[i] = E; - addDependence(E->getDependence()); - if (isa(E)) assert(cast(E)->getSourceExpr() != nullptr && "opaque-value semantic expressions for pseudo-object " "operations must have sources"); } + + setDependence(computeDependence(this)); } //===----------------------------------------------------------------------===// @@ -4531,17 +4367,14 @@ Stmt::const_child_range UnaryExprOrTypeTraitExpr::children() const { return const_child_range(&Argument.Ex, &Argument.Ex + 1); } -AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef args, - QualType t, AtomicOp op, SourceLocation RP) - : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary, - false, false, false, false), - NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) -{ +AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef args, QualType t, + AtomicOp op, SourceLocation RP) + : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary), + NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) { assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions"); - for (unsigned i = 0; i != args.size(); i++) { - addDependence(args[i]->getDependence()); + for (unsigned i = 0; i != args.size(); i++) SubExprs[i] = args[i]; - } + setDependence(computeDependence(this)); } unsigned AtomicExpr::getNumSubExprs(AtomicOp Op) { diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp index 69db80f452aaa7..cc53b663cf4e17 100644 --- a/clang/lib/AST/ExprCXX.cpp +++ b/clang/lib/AST/ExprCXX.cpp @@ -13,6 +13,7 @@ #include "clang/AST/ExprCXX.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" +#include "clang/AST/ComputeDependence.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclAccessPair.h" #include "clang/AST/DeclBase.h" @@ -174,9 +175,7 @@ CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew, Expr *Initializer, QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, SourceRange DirectInitRange) - : Expr(CXXNewExprClass, Ty, VK_RValue, OK_Ordinary, Ty->isDependentType(), - Ty->isDependentType(), Ty->isInstantiationDependentType(), - Ty->containsUnexpandedParameterPack()), + : Expr(CXXNewExprClass, Ty, VK_RValue, OK_Ordinary), OperatorNew(OperatorNew), OperatorDelete(OperatorDelete), AllocatedTypeInfo(AllocatedTypeInfo), Range(Range), DirectInitRange(DirectInitRange) { @@ -194,26 +193,13 @@ CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew, CXXNewExprBits.IsParenTypeId = IsParenTypeId; CXXNewExprBits.NumPlacementArgs = PlacementArgs.size(); - if (ArraySize) { - if (Expr *SizeExpr = *ArraySize) - addDependence(SizeExpr->getDependence() & ~ExprDependence::Type); - + if (ArraySize) getTrailingObjects()[arraySizeOffset()] = *ArraySize; - } - - if (Initializer) { - addDependence(Initializer->getDependence() & ~ExprDependence::Type); - + if (Initializer) getTrailingObjects()[initExprOffset()] = Initializer; - } - - for (unsigned I = 0; I != PlacementArgs.size(); ++I) { - addDependence(PlacementArgs[I]->getDependence() & ~ExprDependence::Type); - + for (unsigned I = 0; I != PlacementArgs.size(); ++I) getTrailingObjects()[placementNewArgsOffset() + I] = PlacementArgs[I]; - } - if (IsParenTypeId) getTrailingObjects()[0] = TypeIdParens; @@ -229,6 +215,8 @@ CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew, this->Range.setEnd(TypeIdParens.getEnd()); break; } + + setDependence(computeDependence(this)); } CXXNewExpr::CXXNewExpr(EmptyShell Empty, bool IsArray, @@ -316,40 +304,19 @@ PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info) Location = Info->getTypeLoc().getLocalSourceRange().getBegin(); } -CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(const ASTContext &Context, - Expr *Base, bool isArrow, SourceLocation OperatorLoc, - NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, - SourceLocation ColonColonLoc, SourceLocation TildeLoc, - PseudoDestructorTypeStorage DestroyedType) - : Expr(CXXPseudoDestructorExprClass, - Context.BoundMemberTy, - VK_RValue, OK_Ordinary, - /*isTypeDependent=*/(Base->isTypeDependent() || - (DestroyedType.getTypeSourceInfo() && - DestroyedType.getTypeSourceInfo()->getType()->isDependentType())), - /*isValueDependent=*/Base->isValueDependent(), - (Base->isInstantiationDependent() || - (QualifierLoc && - QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) || - (ScopeType && - ScopeType->getType()->isInstantiationDependentType()) || - (DestroyedType.getTypeSourceInfo() && - DestroyedType.getTypeSourceInfo()->getType() - ->isInstantiationDependentType())), - // ContainsUnexpandedParameterPack - (Base->containsUnexpandedParameterPack() || - (QualifierLoc && - QualifierLoc.getNestedNameSpecifier() - ->containsUnexpandedParameterPack()) || - (ScopeType && - ScopeType->getType()->containsUnexpandedParameterPack()) || - (DestroyedType.getTypeSourceInfo() && - DestroyedType.getTypeSourceInfo()->getType() - ->containsUnexpandedParameterPack()))), - Base(static_cast(Base)), IsArrow(isArrow), - OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), - ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), - DestroyedType(DestroyedType) {} +CXXPseudoDestructorExpr::CXXPseudoDestructorExpr( + const ASTContext &Context, Expr *Base, bool isArrow, + SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, + TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc, + SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType) + : Expr(CXXPseudoDestructorExprClass, Context.BoundMemberTy, VK_RValue, + OK_Ordinary), + Base(static_cast(Base)), IsArrow(isArrow), + OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), + ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), + DestroyedType(DestroyedType) { + setDependence(computeDependence(this)); +} QualType CXXPseudoDestructorExpr::getDestroyedType() const { if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) @@ -439,49 +406,31 @@ OverloadExpr::OverloadExpr(StmtClass SC, const ASTContext &Context, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent, bool KnownContainsUnexpandedParameterPack) - : Expr( - SC, Context.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent, - KnownDependent, - (KnownInstantiationDependent || NameInfo.isInstantiationDependent() || - (QualifierLoc && - QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), - (KnownContainsUnexpandedParameterPack || - NameInfo.containsUnexpandedParameterPack() || - (QualifierLoc && QualifierLoc.getNestedNameSpecifier() - ->containsUnexpandedParameterPack()))), - NameInfo(NameInfo), QualifierLoc(QualifierLoc) { + : Expr(SC, Context.OverloadTy, VK_LValue, OK_Ordinary), NameInfo(NameInfo), + QualifierLoc(QualifierLoc) { unsigned NumResults = End - Begin; OverloadExprBits.NumResults = NumResults; OverloadExprBits.HasTemplateKWAndArgsInfo = (TemplateArgs != nullptr ) || TemplateKWLoc.isValid(); if (NumResults) { - // Determine whether this expression is type-dependent. - for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) { - if ((*I)->getDeclContext()->isDependentContext() || - isa(*I)) - addDependence(ExprDependence::TypeValueInstantiation); - } - // Copy the results to the trailing array past UnresolvedLookupExpr // or UnresolvedMemberExpr. DeclAccessPair *Results = getTrailingResults(); memcpy(Results, Begin.I, NumResults * sizeof(DeclAccessPair)); } - // If we have explicit template arguments, check for dependent - // template arguments and whether they contain any unexpanded pack - // expansions. if (TemplateArgs) { auto Deps = TemplateArgumentDependence::None; getTrailingASTTemplateKWAndArgsInfo()->initializeFrom( TemplateKWLoc, *TemplateArgs, getTrailingTemplateArgumentLoc(), Deps); - addDependence(toExprDependence(Deps)); - } else if (TemplateKWLoc.isValid()) { getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); } + setDependence(computeDependence(this, KnownDependent, + KnownInstantiationDependent, + KnownContainsUnexpandedParameterPack)); if (isTypeDependent()) setType(Context.DependentTy); } @@ -498,15 +447,7 @@ DependentScopeDeclRefExpr::DependentScopeDeclRefExpr( QualType Ty, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *Args) - : Expr( - DependentScopeDeclRefExprClass, Ty, VK_LValue, OK_Ordinary, true, - true, - (NameInfo.isInstantiationDependent() || - (QualifierLoc && - QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), - (NameInfo.containsUnexpandedParameterPack() || - (QualifierLoc && QualifierLoc.getNestedNameSpecifier() - ->containsUnexpandedParameterPack()))), + : Expr(DependentScopeDeclRefExprClass, Ty, VK_LValue, OK_Ordinary), QualifierLoc(QualifierLoc), NameInfo(NameInfo) { DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo = (Args != nullptr) || TemplateKWLoc.isValid(); @@ -514,12 +455,11 @@ DependentScopeDeclRefExpr::DependentScopeDeclRefExpr( auto Deps = TemplateArgumentDependence::None; getTrailingObjects()->initializeFrom( TemplateKWLoc, *Args, getTrailingObjects(), Deps); - if (Deps & TemplateArgumentDependence::UnexpandedPack) - addDependence(ExprDependence::UnexpandedPack); } else if (TemplateKWLoc.isValid()) { getTrailingObjects()->initializeFrom( TemplateKWLoc); } + setDependence(computeDependence(this)); } DependentScopeDeclRefExpr *DependentScopeDeclRefExpr::Create( @@ -637,7 +577,7 @@ SourceRange CXXOperatorCallExpr::getSourceRangeImpl() const { // Postfix operator return SourceRange(getArg(0)->getBeginLoc(), getOperatorLoc()); } else if (Kind == OO_Arrow) { - return getArg(0)->getSourceRange(); + return SourceRange(getArg(0)->getBeginLoc(), getOperatorLoc()); } else if (Kind == OO_Call) { return SourceRange(getArg(0)->getBeginLoc(), getRParenLoc()); } else if (Kind == OO_Subscript) { @@ -959,17 +899,19 @@ const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const { return cast(getCalleeDecl())->getLiteralIdentifier(); } -CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc, - FieldDecl *Field, QualType Ty, - DeclContext *UsedContext) +CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx, + SourceLocation Loc, FieldDecl *Field, + QualType Ty, DeclContext *UsedContext) : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx), - Ty->isLValueReferenceType() ? VK_LValue : Ty->isRValueReferenceType() - ? VK_XValue - : VK_RValue, - /*FIXME*/ OK_Ordinary, false, false, false, false), + Ty->isLValueReferenceType() + ? VK_LValue + : Ty->isRValueReferenceType() ? VK_XValue : VK_RValue, + /*FIXME*/ OK_Ordinary), Field(Field), UsedContext(UsedContext) { CXXDefaultInitExprBits.Loc = Loc; assert(Field->hasInClassInitializer()); + + setDependence(ExprDependence::None); } CXXTemporary *CXXTemporary::Create(const ASTContext &C, @@ -1067,11 +1009,8 @@ CXXConstructExpr::CXXConstructExpr( bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, ConstructionKind ConstructKind, SourceRange ParenOrBraceRange) - : Expr(SC, Ty, VK_RValue, OK_Ordinary, Ty->isDependentType(), - Ty->isDependentType(), Ty->isInstantiationDependentType(), - Ty->containsUnexpandedParameterPack()), - Constructor(Ctor), ParenOrBraceRange(ParenOrBraceRange), - NumArgs(Args.size()) { + : Expr(SC, Ty, VK_RValue, OK_Ordinary), Constructor(Ctor), + ParenOrBraceRange(ParenOrBraceRange), NumArgs(Args.size()) { CXXConstructExprBits.Elidable = Elidable; CXXConstructExprBits.HadMultipleCandidates = HadMultipleCandidates; CXXConstructExprBits.ListInitialization = ListInitialization; @@ -1083,10 +1022,10 @@ CXXConstructExpr::CXXConstructExpr( Stmt **TrailingArgs = getTrailingArgs(); for (unsigned I = 0, N = Args.size(); I != N; ++I) { assert(Args[I] && "NULL argument in CXXConstructExpr!"); - addDependence(Args[I]->getDependence() & ~ExprDependence::Type); - TrailingArgs[I] = Args[I]; } + + setDependence(computeDependence(this)); } CXXConstructExpr::CXXConstructExpr(StmtClass SC, EmptyShell Empty, @@ -1139,9 +1078,7 @@ LambdaExpr::LambdaExpr(QualType T, SourceRange IntroducerRange, bool ExplicitResultType, ArrayRef CaptureInits, SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack) - : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary, T->isDependentType(), - T->isDependentType(), T->isDependentType(), - ContainsUnexpandedParameterPack), + : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary), IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc), NumCaptures(Captures.size()), CaptureDefault(CaptureDefault), ExplicitParams(ExplicitParams), ExplicitResultType(ExplicitResultType), @@ -1173,6 +1110,8 @@ LambdaExpr::LambdaExpr(QualType T, SourceRange IntroducerRange, // Copy the body of the lambda. *Stored++ = getCallOperator()->getBody(); + + setDependence(computeDependence(this, ContainsUnexpandedParameterPack)); } LambdaExpr *LambdaExpr::Create( @@ -1324,19 +1263,13 @@ CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *TSI, ? VK_LValue : TSI->getType()->isRValueReferenceType() ? VK_XValue : VK_RValue), - OK_Ordinary, - TSI->getType()->isDependentType() || - TSI->getType()->getContainedDeducedType(), - true, true, TSI->getType()->containsUnexpandedParameterPack()), + OK_Ordinary), TSI(TSI), LParenLoc(LParenLoc), RParenLoc(RParenLoc) { CXXUnresolvedConstructExprBits.NumArgs = Args.size(); auto **StoredArgs = getTrailingObjects(); - for (unsigned I = 0; I != Args.size(); ++I) { - if (Args[I]->containsUnexpandedParameterPack()) - addDependence(ExprDependence::UnexpandedPack); - + for (unsigned I = 0; I != Args.size(); ++I) StoredArgs[I] = Args[I]; - } + setDependence(computeDependence(this)); } CXXUnresolvedConstructExpr *CXXUnresolvedConstructExpr::Create( @@ -1364,11 +1297,7 @@ CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr( DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs) : Expr(CXXDependentScopeMemberExprClass, Ctx.DependentTy, VK_LValue, - OK_Ordinary, true, true, true, - ((Base && Base->containsUnexpandedParameterPack()) || - (QualifierLoc && QualifierLoc.getNestedNameSpecifier() - ->containsUnexpandedParameterPack()) || - MemberNameInfo.containsUnexpandedParameterPack())), + OK_Ordinary), Base(Base), BaseType(BaseType), QualifierLoc(QualifierLoc), MemberNameInfo(MemberNameInfo) { CXXDependentScopeMemberExprBits.IsArrow = IsArrow; @@ -1383,8 +1312,6 @@ CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr( getTrailingObjects()->initializeFrom( TemplateKWLoc, *TemplateArgs, getTrailingObjects(), Deps); - if (Deps & TemplateArgumentDependence::UnexpandedPack) - addDependence(ExprDependence::UnexpandedPack); } else if (TemplateKWLoc.isValid()) { getTrailingObjects()->initializeFrom( TemplateKWLoc); @@ -1392,6 +1319,7 @@ CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr( if (hasFirstQualifierFoundInScope()) *getTrailingObjects() = FirstQualifierFoundInScope; + setDependence(computeDependence(this)); } CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr( @@ -1573,16 +1501,15 @@ SizeOfPackExpr *SizeOfPackExpr::CreateDeserialized(ASTContext &Context, return new (Storage) SizeOfPackExpr(EmptyShell(), NumPartialArgs); } -SubstNonTypeTemplateParmPackExpr:: -SubstNonTypeTemplateParmPackExpr(QualType T, - ExprValueKind ValueKind, - NonTypeTemplateParmDecl *Param, - SourceLocation NameLoc, - const TemplateArgument &ArgPack) - : Expr(SubstNonTypeTemplateParmPackExprClass, T, ValueKind, OK_Ordinary, - true, true, true, true), +SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr( + QualType T, ExprValueKind ValueKind, NonTypeTemplateParmDecl *Param, + SourceLocation NameLoc, const TemplateArgument &ArgPack) + : Expr(SubstNonTypeTemplateParmPackExprClass, T, ValueKind, OK_Ordinary), Param(Param), Arguments(ArgPack.pack_begin()), - NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) {} + NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { + setDependence(ExprDependence::TypeValueInstantiation | + ExprDependence::UnexpandedPack); +} TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { return TemplateArgument(llvm::makeArrayRef(Arguments, NumArguments)); @@ -1592,12 +1519,13 @@ FunctionParmPackExpr::FunctionParmPackExpr(QualType T, VarDecl *ParamPack, SourceLocation NameLoc, unsigned NumParams, VarDecl *const *Params) - : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary, true, true, - true, true), + : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary), ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) { if (Params) std::uninitialized_copy(Params, Params + NumParams, getTrailingObjects()); + setDependence(ExprDependence::TypeValueInstantiation | + ExprDependence::UnexpandedPack); } FunctionParmPackExpr * @@ -1619,16 +1547,14 @@ MaterializeTemporaryExpr::MaterializeTemporaryExpr( QualType T, Expr *Temporary, bool BoundToLvalueReference, LifetimeExtendedTemporaryDecl *MTD) : Expr(MaterializeTemporaryExprClass, T, - BoundToLvalueReference ? VK_LValue : VK_XValue, OK_Ordinary, - Temporary->isTypeDependent(), Temporary->isValueDependent(), - Temporary->isInstantiationDependent(), - Temporary->containsUnexpandedParameterPack()) { + BoundToLvalueReference ? VK_LValue : VK_XValue, OK_Ordinary) { if (MTD) { State = MTD; MTD->ExprWithTemporary = Temporary; return; } State = Temporary; + setDependence(computeDependence(this)); } void MaterializeTemporaryExpr::setExtendingDecl(ValueDecl *ExtendedBy, @@ -1650,25 +1576,18 @@ void MaterializeTemporaryExpr::setExtendingDecl(ValueDecl *ExtendedBy, TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef Args, - SourceLocation RParenLoc, - bool Value) - : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary, - /*TypeDependent=*/false, - /*ValueDependent=*/false, - /*InstantiationDependent=*/false, - /*ContainsUnexpandedParameterPack=*/false), - Loc(Loc), RParenLoc(RParenLoc) { + SourceLocation RParenLoc, bool Value) + : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary), Loc(Loc), + RParenLoc(RParenLoc) { TypeTraitExprBits.Kind = Kind; TypeTraitExprBits.Value = Value; TypeTraitExprBits.NumArgs = Args.size(); auto **ToArgs = getTrailingObjects(); - - for (unsigned I = 0, N = Args.size(); I != N; ++I) { - addDependence(toExprDependence(Args[I]->getType()->getDependence()) & - ~ExprDependence::Type); + for (unsigned I = 0, N = Args.size(); I != N; ++I) ToArgs[I] = Args[I]; - } + + setDependence(computeDependence(this)); } TypeTraitExpr *TypeTraitExpr::Create(const ASTContext &C, QualType T, @@ -1720,4 +1639,4 @@ CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(const ASTContext &Ctx, void *Mem = Ctx.Allocate(sizeof(CUDAKernelCallExpr) + SizeOfTrailingObjects, alignof(CUDAKernelCallExpr)); return new (Mem) CUDAKernelCallExpr(NumArgs, Empty); -} +} \ No newline at end of file diff --git a/clang/lib/AST/ExprConcepts.cpp b/clang/lib/AST/ExprConcepts.cpp index 479a88a14ecae8..b3a4bd9215d5c6 100644 --- a/clang/lib/AST/ExprConcepts.cpp +++ b/clang/lib/AST/ExprConcepts.cpp @@ -13,6 +13,7 @@ #include "clang/AST/ExprConcepts.h" #include "clang/AST/ASTConcept.h" #include "clang/AST/ASTContext.h" +#include "clang/AST/ComputeDependence.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclarationName.h" @@ -29,39 +30,28 @@ using namespace clang; -ConceptSpecializationExpr::ConceptSpecializationExpr(const ASTContext &C, - NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, - DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, - ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten, +ConceptSpecializationExpr::ConceptSpecializationExpr( + const ASTContext &C, NestedNameSpecifierLoc NNS, + SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, + NamedDecl *FoundDecl, ConceptDecl *NamedConcept, + const ASTTemplateArgumentListInfo *ArgsAsWritten, ArrayRef ConvertedArgs, const ConstraintSatisfaction *Satisfaction) - : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_RValue, OK_Ordinary, - /*TypeDependent=*/false, - // All the flags below are set in setTemplateArguments. - /*ValueDependent=*/!Satisfaction, /*InstantiationDependent=*/false, - /*ContainsUnexpandedParameterPacks=*/false), + : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_RValue, OK_Ordinary), ConceptReference(NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept, ArgsAsWritten), NumTemplateArgs(ConvertedArgs.size()), - Satisfaction(Satisfaction ? - ASTConstraintSatisfaction::Create(C, *Satisfaction) : - nullptr) { + Satisfaction(Satisfaction + ? ASTConstraintSatisfaction::Create(C, *Satisfaction) + : nullptr) { setTemplateArguments(ConvertedArgs); - auto Deps = TemplateArgumentDependence::None; - const auto InterestingDeps = TemplateArgumentDependence::Instantiation | - TemplateArgumentDependence::UnexpandedPack; - for (const TemplateArgumentLoc& ArgLoc : ArgsAsWritten->arguments()) { - Deps |= ArgLoc.getArgument().getDependence() & InterestingDeps; - if (Deps == InterestingDeps) - break; - } + setDependence(computeDependence(this, /*ValueDependent=*/!Satisfaction)); // Currently guaranteed by the fact concepts can only be at namespace-scope. assert(!NestedNameSpec || (!NestedNameSpec.getNestedNameSpecifier()->isInstantiationDependent() && !NestedNameSpec.getNestedNameSpecifier() ->containsUnexpandedParameterPack())); - addDependence(toExprDependence(Deps)); assert((!isValueDependent() || isInstantiationDependent()) && "should not be value-dependent"); } @@ -101,18 +91,23 @@ ConceptSpecializationExpr::ConceptSpecializationExpr( ArrayRef ConvertedArgs, const ConstraintSatisfaction *Satisfaction, bool Dependent, bool ContainsUnexpandedParameterPack) - : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_RValue, OK_Ordinary, - /*TypeDependent=*/false, - /*ValueDependent=*/!Satisfaction, Dependent, - ContainsUnexpandedParameterPack), + : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_RValue, OK_Ordinary), ConceptReference(NestedNameSpecifierLoc(), SourceLocation(), - DeclarationNameInfo(), NamedConcept, - NamedConcept, nullptr), + DeclarationNameInfo(), NamedConcept, NamedConcept, + nullptr), NumTemplateArgs(ConvertedArgs.size()), - Satisfaction(Satisfaction ? - ASTConstraintSatisfaction::Create(C, *Satisfaction) : - nullptr) { + Satisfaction(Satisfaction + ? ASTConstraintSatisfaction::Create(C, *Satisfaction) + : nullptr) { setTemplateArguments(ConvertedArgs); + ExprDependence D = ExprDependence::None; + if (!Satisfaction) + D |= ExprDependence::Value; + if (Dependent) + D |= ExprDependence::Instantiation; + if (ContainsUnexpandedParameterPack) + D |= ExprDependence::UnexpandedPack; + setDependence(D); } ConceptSpecializationExpr * @@ -151,11 +146,9 @@ RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc, ArrayRef LocalParameters, ArrayRef Requirements, SourceLocation RBraceLoc) - : Expr(RequiresExprClass, C.BoolTy, VK_RValue, OK_Ordinary, - /*TD=*/false, /*VD=*/false, /*ID=*/false, - /*ContainsUnexpandedParameterPack=*/false), - NumLocalParameters(LocalParameters.size()), - NumRequirements(Requirements.size()), Body(Body), RBraceLoc(RBraceLoc) { + : Expr(RequiresExprClass, C.BoolTy, VK_RValue, OK_Ordinary), + NumLocalParameters(LocalParameters.size()), + NumRequirements(Requirements.size()), Body(Body), RBraceLoc(RBraceLoc) { RequiresExprBits.IsSatisfied = false; RequiresExprBits.RequiresKWLoc = RequiresKWLoc; bool Dependent = false; @@ -180,6 +173,7 @@ RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc, std::copy(Requirements.begin(), Requirements.end(), getTrailingObjects()); RequiresExprBits.IsSatisfied |= Dependent; + // FIXME: move the computing dependency logic to ComputeDependence.h if (ContainsUnexpandedParameterPack) addDependence(ExprDependence::UnexpandedPack); // FIXME: this is incorrect for cases where we have a non-dependent diff --git a/clang/lib/AST/ExprObjC.cpp b/clang/lib/AST/ExprObjC.cpp index f2c060a084f66c..662bc325f12c84 100644 --- a/clang/lib/AST/ExprObjC.cpp +++ b/clang/lib/AST/ExprObjC.cpp @@ -12,6 +12,7 @@ #include "clang/AST/ExprObjC.h" #include "clang/AST/ASTContext.h" +#include "clang/AST/ComputeDependence.h" #include "clang/AST/DependenceFlags.h" #include "clang/AST/SelectorLocationsKind.h" #include "clang/AST/Type.h" @@ -26,14 +27,13 @@ using namespace clang; ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef Elements, QualType T, ObjCMethodDecl *Method, SourceRange SR) - : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary, false, false, - false, false), + : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary), NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) { Expr **SaveElements = getElements(); - for (unsigned I = 0, N = Elements.size(); I != N; ++I) { - addDependence(turnTypeToValueDependence(Elements[I]->getDependence())); + for (unsigned I = 0, N = Elements.size(); I != N; ++I) SaveElements[I] = Elements[I]; - } + + setDependence(computeDependence(this)); } ObjCArrayLiteral *ObjCArrayLiteral::Create(const ASTContext &C, @@ -54,20 +54,13 @@ ObjCDictionaryLiteral::ObjCDictionaryLiteral(ArrayRef VK, bool HasPackExpansions, QualType T, ObjCMethodDecl *method, SourceRange SR) - : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false, - false, false), + : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary), NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR), DictWithObjectsMethod(method) { KeyValuePair *KeyValues = getTrailingObjects(); ExpansionData *Expansions = HasPackExpansions ? getTrailingObjects() : nullptr; for (unsigned I = 0; I < NumElements; I++) { - auto Deps = turnTypeToValueDependence(VK[I].Key->getDependence() | - VK[I].Value->getDependence()); - if (VK[I].EllipsisLoc.isValid()) - Deps &= ~ExprDependence::UnexpandedPack; - addDependence(Deps); - KeyValues[I].Key = VK[I].Key; KeyValues[I].Value = VK[I].Value; if (Expansions) { @@ -78,6 +71,7 @@ ObjCDictionaryLiteral::ObjCDictionaryLiteral(ArrayRef VK, Expansions[I].NumExpansionsPlusOne = 0; } } + setDependence(computeDependence(this)); } ObjCDictionaryLiteral * @@ -117,10 +111,7 @@ ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK, SelectorLocationsKind SelLocsK, ObjCMethodDecl *Method, ArrayRef Args, SourceLocation RBracLoc, bool isImplicit) - : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, - /*TypeDependent=*/false, /*ValueDependent=*/false, - /*InstantiationDependent=*/false, - /*ContainsUnexpandedParameterPack=*/false), + : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary), SelectorOrMethod( reinterpret_cast(Method ? Method : Sel.getAsOpaquePtr())), Kind(IsInstanceSuper ? SuperInstance : SuperClass), @@ -129,6 +120,7 @@ ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK, RBracLoc(RBracLoc) { initArgsAndSelLocs(Args, SelLocs, SelLocsK); setReceiverPointer(SuperType.getAsOpaquePtr()); + setDependence(computeDependence(this)); } ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK, @@ -138,15 +130,14 @@ ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK, SelectorLocationsKind SelLocsK, ObjCMethodDecl *Method, ArrayRef Args, SourceLocation RBracLoc, bool isImplicit) - : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(), - T->isDependentType(), T->isInstantiationDependentType(), - T->containsUnexpandedParameterPack()), + : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary), SelectorOrMethod( reinterpret_cast(Method ? Method : Sel.getAsOpaquePtr())), Kind(Class), HasMethod(Method != nullptr), IsDelegateInitCall(false), IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) { initArgsAndSelLocs(Args, SelLocs, SelLocsK); setReceiverPointer(Receiver); + setDependence(computeDependence(this)); } ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK, @@ -155,16 +146,14 @@ ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK, SelectorLocationsKind SelLocsK, ObjCMethodDecl *Method, ArrayRef Args, SourceLocation RBracLoc, bool isImplicit) - : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, - Receiver->isTypeDependent(), Receiver->isTypeDependent(), - Receiver->isInstantiationDependent(), - Receiver->containsUnexpandedParameterPack()), + : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary), SelectorOrMethod( reinterpret_cast(Method ? Method : Sel.getAsOpaquePtr())), Kind(Instance), HasMethod(Method != nullptr), IsDelegateInitCall(false), IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) { initArgsAndSelLocs(Args, SelLocs, SelLocsK); setReceiverPointer(Receiver); + setDependence(computeDependence(this)); } void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef Args, @@ -172,10 +161,8 @@ void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef Args, SelectorLocationsKind SelLocsK) { setNumArgs(Args.size()); Expr **MyArgs = getArgs(); - for (unsigned I = 0; I != Args.size(); ++I) { - addDependence(Args[I]->getDependence()); + for (unsigned I = 0; I != Args.size(); ++I) MyArgs[I] = Args[I]; - } SelLocsKind = SelLocsK; if (!isImplicit()) { diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp index 58d018c5bd3e22..2330339bedfb2a 100644 --- a/clang/lib/Basic/TargetInfo.cpp +++ b/clang/lib/Basic/TargetInfo.cpp @@ -380,6 +380,20 @@ void TargetInfo::adjust(LangOptions &Opts) { LongDoubleFormat = &llvm::APFloat::IEEEquad(); } + if (Opts.DoubleSize) { + if (Opts.DoubleSize == 32) { + DoubleWidth = 32; + LongDoubleWidth = 32; + DoubleFormat = &llvm::APFloat::IEEEsingle(); + LongDoubleFormat = &llvm::APFloat::IEEEsingle(); + } else if (Opts.DoubleSize == 64) { + DoubleWidth = 64; + LongDoubleWidth = 64; + DoubleFormat = &llvm::APFloat::IEEEdouble(); + LongDoubleFormat = &llvm::APFloat::IEEEdouble(); + } + } + if (Opts.LongDoubleSize) { if (Opts.LongDoubleSize == DoubleWidth) { LongDoubleWidth = DoubleWidth; diff --git a/clang/lib/Basic/Targets/AArch64.cpp b/clang/lib/Basic/Targets/AArch64.cpp index f26aa1d1781a97..336c7491a5cc8d 100644 --- a/clang/lib/Basic/Targets/AArch64.cpp +++ b/clang/lib/Basic/Targets/AArch64.cpp @@ -26,10 +26,6 @@ const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = { {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr}, #include "clang/Basic/BuiltinsNEON.def" -#define BUILTIN(ID, TYPE, ATTRS) \ - {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr}, -#include "clang/Basic/BuiltinsSVE.def" - #define BUILTIN(ID, TYPE, ATTRS) \ {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr}, #define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \ @@ -490,17 +486,29 @@ bool AArch64TargetInfo::validateAsmConstraint( Info.setAllowsRegister(); return true; case 'U': + if (Name[1] == 'p' && (Name[2] == 'l' || Name[2] == 'a')) { + // SVE predicate registers ("Upa"=P0-15, "Upl"=P0-P7) + Info.setAllowsRegister(); + Name += 2; + return true; + } // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes. // Utf: A memory address suitable for ldp/stp in TF mode. // Usa: An absolute symbolic address. // Ush: The high part (bits 32:12) of a pc-relative symbolic address. - llvm_unreachable("FIXME: Unimplemented support for U* constraints."); + + // Better to return an error saying that it's an unrecognised constraint + // even if this is a valid constraint in gcc. + return false; case 'z': // Zero register, wzr or xzr Info.setAllowsRegister(); return true; case 'x': // Floating point and SIMD registers (V0-V15) Info.setAllowsRegister(); return true; + case 'y': // SVE registers (V0-V7) + Info.setAllowsRegister(); + return true; } return false; } diff --git a/clang/lib/Basic/Targets/AArch64.h b/clang/lib/Basic/Targets/AArch64.h index 5e78237743c908..befbf693ad8b7b 100644 --- a/clang/lib/Basic/Targets/AArch64.h +++ b/clang/lib/Basic/Targets/AArch64.h @@ -87,6 +87,21 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo { ArrayRef getGCCRegNames() const override; ArrayRef getGCCRegAliases() const override; + + std::string convertConstraint(const char *&Constraint) const override { + std::string R; + switch (*Constraint) { + case 'U': // Three-character constraint; add "@3" hint for later parsing. + R = std::string("@3") + std::string(Constraint, 3); + Constraint += 2; + break; + default: + R = std::string(1, *Constraint); + break; + } + return R; + } + bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &Info) const override; bool diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp index b6ca46e7e83511..28e4ecc7b4bf32 100644 --- a/clang/lib/CodeGen/BackendUtil.cpp +++ b/clang/lib/CodeGen/BackendUtil.cpp @@ -18,6 +18,7 @@ #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/Triple.h" +#include "llvm/Analysis/StackSafetyAnalysis.h" #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/Bitcode/BitcodeReader.h" @@ -345,6 +346,11 @@ static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder, PM.add(createDataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles)); } +static void addMemTagOptimizationPasses(const PassManagerBuilder &Builder, + legacy::PassManagerBase &PM) { + PM.add(createStackSafetyGlobalInfoWrapperPass(/*SetMetadata=*/true)); +} + static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple, const CodeGenOptions &CodeGenOpts) { TargetLibraryInfoImpl *TLII = new TargetLibraryInfoImpl(TargetTriple); @@ -696,6 +702,11 @@ void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM, addDataFlowSanitizerPass); } + if (LangOpts.Sanitize.has(SanitizerKind::MemTag)) { + PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast, + addMemTagOptimizationPasses); + } + // Set up the per-function pass manager. FPM.add(new TargetLibraryInfoWrapperPass(*TLII)); if (CodeGenOpts.VerifyModule) @@ -1300,6 +1311,11 @@ void EmitAssemblyHelper::EmitAssemblyWithNewPassManager( /*CompileKernel=*/true, /*Recover=*/true)); } + if (CodeGenOpts.OptimizationLevel > 0 && + LangOpts.Sanitize.has(SanitizerKind::MemTag)) { + MPM.addPass(StackSafetyGlobalAnnotatorPass()); + } + if (CodeGenOpts.OptimizationLevel == 0) { addCoroutinePassesAtO0(MPM, LangOpts, CodeGenOpts); addSanitizersAtO0(MPM, TargetTriple, LangOpts, CodeGenOpts); diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index a1312d289d57ce..d333aeffefd9ef 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -23,7 +23,6 @@ #include "clang/AST/Attr.h" #include "clang/AST/Decl.h" #include "clang/AST/OSLog.h" -#include "clang/Basic/AArch64SVETypeFlags.h" #include "clang/Basic/TargetBuiltins.h" #include "clang/Basic/TargetInfo.h" #include "clang/CodeGen/CGFunctionInfo.h" @@ -4577,7 +4576,7 @@ enum { }; namespace { -struct ARMVectorIntrinsicInfo { +struct NeonIntrinsicInfo { const char *NameHint; unsigned BuiltinID; unsigned LLVMIntrinsic; @@ -4587,7 +4586,7 @@ struct ARMVectorIntrinsicInfo { bool operator<(unsigned RHSBuiltinID) const { return BuiltinID < RHSBuiltinID; } - bool operator<(const ARMVectorIntrinsicInfo &TE) const { + bool operator<(const NeonIntrinsicInfo &TE) const { return BuiltinID < TE.BuiltinID; } }; @@ -4605,7 +4604,7 @@ struct ARMVectorIntrinsicInfo { Intrinsic::LLVMIntrinsic, Intrinsic::AltLLVMIntrinsic, \ TypeModifier } -static const ARMVectorIntrinsicInfo ARMSIMDIntrinsicMap [] = { +static const NeonIntrinsicInfo ARMSIMDIntrinsicMap [] = { NEONMAP2(vabd_v, arm_neon_vabdu, arm_neon_vabds, Add1ArgType | UnsignedAlts), NEONMAP2(vabdq_v, arm_neon_vabdu, arm_neon_vabds, Add1ArgType | UnsignedAlts), NEONMAP1(vabs_v, arm_neon_vabs, 0), @@ -4886,7 +4885,7 @@ static const ARMVectorIntrinsicInfo ARMSIMDIntrinsicMap [] = { NEONMAP0(vzipq_v) }; -static const ARMVectorIntrinsicInfo AArch64SIMDIntrinsicMap[] = { +static const NeonIntrinsicInfo AArch64SIMDIntrinsicMap[] = { NEONMAP1(vabs_v, aarch64_neon_abs, 0), NEONMAP1(vabsq_v, aarch64_neon_abs, 0), NEONMAP0(vaddhn_v), @@ -5055,7 +5054,7 @@ static const ARMVectorIntrinsicInfo AArch64SIMDIntrinsicMap[] = { NEONMAP0(vtstq_v), }; -static const ARMVectorIntrinsicInfo AArch64SISDIntrinsicMap[] = { +static const NeonIntrinsicInfo AArch64SISDIntrinsicMap[] = { NEONMAP1(vabdd_f64, aarch64_sisd_fabd, Add1ArgType), NEONMAP1(vabds_f32, aarch64_sisd_fabd, Add1ArgType), NEONMAP1(vabsd_s64, aarch64_neon_abs, Add1ArgType), @@ -5285,32 +5284,15 @@ static const ARMVectorIntrinsicInfo AArch64SISDIntrinsicMap[] = { #undef NEONMAP1 #undef NEONMAP2 -#define SVEMAP1(NameBase, LLVMIntrinsic, TypeModifier) \ - { \ - #NameBase, SVE::BI__builtin_sve_##NameBase, Intrinsic::LLVMIntrinsic, 0, \ - TypeModifier \ - } - -#define SVEMAP2(NameBase, TypeModifier) \ - { #NameBase, SVE::BI__builtin_sve_##NameBase, 0, 0, TypeModifier } -static const ARMVectorIntrinsicInfo AArch64SVEIntrinsicMap[] = { -#define GET_SVE_LLVM_INTRINSIC_MAP -#include "clang/Basic/arm_sve_codegenmap.inc" -#undef GET_SVE_LLVM_INTRINSIC_MAP -}; - -#undef SVEMAP1 -#undef SVEMAP2 - static bool NEONSIMDIntrinsicsProvenSorted = false; static bool AArch64SIMDIntrinsicsProvenSorted = false; static bool AArch64SISDIntrinsicsProvenSorted = false; -static bool AArch64SVEIntrinsicsProvenSorted = false; -static const ARMVectorIntrinsicInfo * -findARMVectorIntrinsicInMap(ArrayRef IntrinsicMap, - unsigned BuiltinID, bool &MapProvenSorted) { + +static const NeonIntrinsicInfo * +findNeonIntrinsicInMap(ArrayRef IntrinsicMap, + unsigned BuiltinID, bool &MapProvenSorted) { #ifndef NDEBUG if (!MapProvenSorted) { @@ -5319,8 +5301,7 @@ findARMVectorIntrinsicInMap(ArrayRef IntrinsicMap, } #endif - const ARMVectorIntrinsicInfo *Builtin = - llvm::lower_bound(IntrinsicMap, BuiltinID); + const NeonIntrinsicInfo *Builtin = llvm::lower_bound(IntrinsicMap, BuiltinID); if (Builtin != IntrinsicMap.end() && Builtin->BuiltinID == BuiltinID) return Builtin; @@ -5367,9 +5348,10 @@ Function *CodeGenFunction::LookupNeonLLVMIntrinsic(unsigned IntrinsicID, return CGM.getIntrinsic(IntrinsicID, Tys); } -static Value *EmitCommonNeonSISDBuiltinExpr( - CodeGenFunction &CGF, const ARMVectorIntrinsicInfo &SISDInfo, - SmallVectorImpl &Ops, const CallExpr *E) { +static Value *EmitCommonNeonSISDBuiltinExpr(CodeGenFunction &CGF, + const NeonIntrinsicInfo &SISDInfo, + SmallVectorImpl &Ops, + const CallExpr *E) { unsigned BuiltinID = SISDInfo.BuiltinID; unsigned int Int = SISDInfo.LLVMIntrinsic; unsigned Modifier = SISDInfo.TypeModifier; @@ -6882,7 +6864,7 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID, // Many NEON builtins have identical semantics and uses in ARM and // AArch64. Emit these in a single function. auto IntrinsicMap = makeArrayRef(ARMSIMDIntrinsicMap); - const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap( + const NeonIntrinsicInfo *Builtin = findNeonIntrinsicInMap( IntrinsicMap, BuiltinID, NEONSIMDIntrinsicsProvenSorted); if (Builtin) return EmitCommonNeonBuiltinExpr( @@ -7454,40 +7436,9 @@ Value *CodeGenFunction::EmitSVEMaskedLoad(llvm::Type *ReturnTy, return Builder.CreateMaskedLoad(BasePtr, Align(1), Predicate, Splat0); } -Value *CodeGenFunction::EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, - const CallExpr *E) { - // Find out if any arguments are required to be integer constant expressions. - unsigned ICEArguments = 0; - ASTContext::GetBuiltinTypeError Error; - getContext().GetBuiltinType(BuiltinID, Error, &ICEArguments); - assert(Error == ASTContext::GE_None && "Should not codegen an error"); - - llvm::SmallVector Ops; - for (unsigned i = 0, e = E->getNumArgs(); i != e; i++) { - if ((ICEArguments & (1 << i)) == 0) - Ops.push_back(EmitScalarExpr(E->getArg(i))); - else - llvm_unreachable("Not yet implemented"); - } - - auto *Builtin = findARMVectorIntrinsicInMap(AArch64SVEIntrinsicMap, BuiltinID, - AArch64SVEIntrinsicsProvenSorted); - SVETypeFlags TypeFlags(Builtin->TypeModifier); - llvm::Type *Ty = ConvertType(E->getType()); - if (TypeFlags.isLoad()) - return EmitSVEMaskedLoad(Ty, Ops); - - /// Should not happen - return nullptr; -} - Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, llvm::Triple::ArchType Arch) { - if (BuiltinID >= AArch64::FirstSVEBuiltin && - BuiltinID <= AArch64::LastSVEBuiltin) - return EmitAArch64SVEBuiltinExpr(BuiltinID, E); - unsigned HintID = static_cast(-1); switch (BuiltinID) { default: break; @@ -7521,6 +7472,27 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID, return Builder.CreateCall(F, llvm::ConstantInt::get(Int32Ty, HintID)); } + switch (BuiltinID) { + case AArch64::BI__builtin_sve_svld1_u8: + case AArch64::BI__builtin_sve_svld1_u16: + case AArch64::BI__builtin_sve_svld1_u32: + case AArch64::BI__builtin_sve_svld1_u64: + case AArch64::BI__builtin_sve_svld1_s8: + case AArch64::BI__builtin_sve_svld1_s16: + case AArch64::BI__builtin_sve_svld1_s32: + case AArch64::BI__builtin_sve_svld1_s64: + case AArch64::BI__builtin_sve_svld1_f16: + case AArch64::BI__builtin_sve_svld1_f32: + case AArch64::BI__builtin_sve_svld1_f64: { + llvm::SmallVector Ops = {EmitScalarExpr(E->getArg(0)), + EmitScalarExpr(E->getArg(1))}; + llvm::Type *Ty = ConvertType(E->getType()); + return EmitSVEMaskedLoad(Ty, Ops); + } + default: + break; + } + if (BuiltinID == AArch64::BI__builtin_arm_prefetch) { Value *Address = EmitScalarExpr(E->getArg(0)); Value *RW = EmitScalarExpr(E->getArg(1)); @@ -7919,7 +7891,7 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID, } auto SISDMap = makeArrayRef(AArch64SISDIntrinsicMap); - const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap( + const NeonIntrinsicInfo *Builtin = findNeonIntrinsicInMap( SISDMap, BuiltinID, AArch64SISDIntrinsicsProvenSorted); if (Builtin) { @@ -8759,8 +8731,8 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID, // Not all intrinsics handled by the common case work for AArch64 yet, so only // defer to common code if it's been added to our special map. - Builtin = findARMVectorIntrinsicInMap(AArch64SIMDIntrinsicMap, BuiltinID, - AArch64SIMDIntrinsicsProvenSorted); + Builtin = findNeonIntrinsicInMap(AArch64SIMDIntrinsicMap, BuiltinID, + AArch64SIMDIntrinsicsProvenSorted); if (Builtin) return EmitCommonNeonBuiltinExpr( diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index 1188ea39ba2c90..ad8ebd245b9351 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -4496,8 +4496,9 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo, // Update the largest vector width if any arguments have vector types. for (unsigned i = 0; i < IRCallArgs.size(); ++i) { if (auto *VT = dyn_cast(IRCallArgs[i]->getType())) - LargestVectorWidth = std::max((uint64_t)LargestVectorWidth, - VT->getPrimitiveSizeInBits().getFixedSize()); + LargestVectorWidth = + std::max((uint64_t)LargestVectorWidth, + VT->getPrimitiveSizeInBits().getKnownMinSize()); } // Compute the calling convention and attributes. @@ -4611,8 +4612,9 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo, // Update largest vector width from the return type. if (auto *VT = dyn_cast(CI->getType())) - LargestVectorWidth = std::max((uint64_t)LargestVectorWidth, - VT->getPrimitiveSizeInBits().getFixedSize()); + LargestVectorWidth = + std::max((uint64_t)LargestVectorWidth, + VT->getPrimitiveSizeInBits().getKnownMinSize()); // Insert instrumentation or attach profile metadata at indirect call sites. // For more details, see the comment before the definition of diff --git a/clang/lib/CodeGen/CGStmt.cpp b/clang/lib/CodeGen/CGStmt.cpp index a334bab06783ee..49f1725ed470d2 100644 --- a/clang/lib/CodeGen/CGStmt.cpp +++ b/clang/lib/CodeGen/CGStmt.cpp @@ -2095,8 +2095,9 @@ void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { // Update largest vector width for any vector types. if (auto *VT = dyn_cast(ResultRegTypes.back())) - LargestVectorWidth = std::max((uint64_t)LargestVectorWidth, - VT->getPrimitiveSizeInBits().getFixedSize()); + LargestVectorWidth = + std::max((uint64_t)LargestVectorWidth, + VT->getPrimitiveSizeInBits().getKnownMinSize()); } else { ArgTypes.push_back(Dest.getAddress(*this).getType()); Args.push_back(Dest.getPointer(*this)); @@ -2120,8 +2121,9 @@ void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { // Update largest vector width for any vector types. if (auto *VT = dyn_cast(Arg->getType())) - LargestVectorWidth = std::max((uint64_t)LargestVectorWidth, - VT->getPrimitiveSizeInBits().getFixedSize()); + LargestVectorWidth = + std::max((uint64_t)LargestVectorWidth, + VT->getPrimitiveSizeInBits().getKnownMinSize()); if (Info.allowsRegister()) InOutConstraints += llvm::utostr(i); else @@ -2207,8 +2209,9 @@ void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { // Update largest vector width for any vector types. if (auto *VT = dyn_cast(Arg->getType())) - LargestVectorWidth = std::max((uint64_t)LargestVectorWidth, - VT->getPrimitiveSizeInBits().getFixedSize()); + LargestVectorWidth = + std::max((uint64_t)LargestVectorWidth, + VT->getPrimitiveSizeInBits().getKnownMinSize()); ArgTypes.push_back(Arg->getType()); Args.push_back(Arg); diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h index 440b088330efb2..e470becbe42626 100644 --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/clang/lib/CodeGen/CodeGenFunction.h @@ -3904,7 +3904,6 @@ class CodeGenFunction : public CodeGenTypeCache { llvm::Value *EmitSVEPredicateCast(llvm::Value *Pred, llvm::VectorType *VTy); llvm::Value *EmitSVEMaskedLoad(llvm::Type *ReturnTy, SmallVectorImpl &Ops); - llvm::Value *EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E); llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, llvm::Triple::ArchType Arch); diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index cb993e75b88cf3..1193dde5a67934 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -4580,6 +4580,14 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, RenderFloatingPointOptions(TC, D, OFastEnabled, Args, CmdArgs, JA.getOffloadingDeviceKind()); + if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) { + if (TC.getArch() == llvm::Triple::avr) + A->render(Args, CmdArgs); + else + D.Diag(diag::err_drv_unsupported_opt_for_target) + << A->getAsString(Args) << TripleStr; + } + if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) { if (TC.getTriple().isX86()) A->render(Args, CmdArgs); diff --git a/clang/lib/Driver/ToolChains/PS4CPU.cpp b/clang/lib/Driver/ToolChains/PS4CPU.cpp index 93d86e6d04b180..9ecbb7241d454d 100644 --- a/clang/lib/Driver/ToolChains/PS4CPU.cpp +++ b/clang/lib/Driver/ToolChains/PS4CPU.cpp @@ -30,13 +30,17 @@ void tools::PS4cpu::addProfileRTArgs(const ToolChain &TC, const ArgList &Args, if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs, false) || Args.hasFlag(options::OPT_fprofile_generate, - options::OPT_fno_profile_instr_generate, false) || + options::OPT_fno_profile_generate, false) || Args.hasFlag(options::OPT_fprofile_generate_EQ, - options::OPT_fno_profile_instr_generate, false) || + options::OPT_fno_profile_generate, false) || Args.hasFlag(options::OPT_fprofile_instr_generate, options::OPT_fno_profile_instr_generate, false) || Args.hasFlag(options::OPT_fprofile_instr_generate_EQ, options::OPT_fno_profile_instr_generate, false) || + Args.hasFlag(options::OPT_fcs_profile_generate, + options::OPT_fno_profile_generate, false) || + Args.hasFlag(options::OPT_fcs_profile_generate_EQ, + options::OPT_fno_profile_generate, false) || Args.hasArg(options::OPT_fcreate_profile) || Args.hasArg(options::OPT_coverage))) CmdArgs.push_back("--dependent-lib=libclang_rt.profile-x86_64.a"); diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp index 08a0b9831e0c65..e2b24f0cfcea1d 100644 --- a/clang/lib/Frontend/CompilerInvocation.cpp +++ b/clang/lib/Frontend/CompilerInvocation.cpp @@ -2937,6 +2937,7 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags); Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags); Opts.AlignDouble = Args.hasArg(OPT_malign_double); + Opts.DoubleSize = getLastArgIntValue(Args, OPT_mdouble_EQ, 0, Diags); Opts.LongDoubleSize = Args.hasArg(OPT_mlong_double_128) ? 128 : Args.hasArg(OPT_mlong_double_64) ? 64 : 0; diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp index 6356d82f2d46d2..09d1732739b8ea 100644 --- a/clang/lib/Parse/ParseDecl.cpp +++ b/clang/lib/Parse/ParseDecl.cpp @@ -3253,6 +3253,9 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, goto DoneWithDeclSpec; if (isTypeConstraintAnnotation()) continue; + if (NextToken().is(tok::annot_template_id)) + // Might have been annotated by TryAnnotateTypeConstraint. + continue; // Eat the scope spec so the identifier is current. ConsumeAnnotationToken(); ParsedAttributesWithRange Attrs(AttrFactory); @@ -3406,6 +3409,9 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, goto DoneWithDeclSpec; if (isTypeConstraintAnnotation()) continue; + if (Tok.is(tok::annot_template_id)) + // Might have been annotated by TryAnnotateTypeConstraint. + continue; ParsedAttributesWithRange Attrs(AttrFactory); if (ParseImplicitInt(DS, nullptr, TemplateInfo, AS, DSContext, Attrs)) { if (!Attrs.empty()) { diff --git a/clang/lib/Parse/ParseTemplate.cpp b/clang/lib/Parse/ParseTemplate.cpp index 53c4829f43f4e7..0406820f74a334 100644 --- a/clang/lib/Parse/ParseTemplate.cpp +++ b/clang/lib/Parse/ParseTemplate.cpp @@ -710,7 +710,8 @@ bool Parser::TryAnnotateTypeConstraint() { /*ObjectType=*/ParsedType(), /*EnteringContext=*/false, PossibleConcept, - MemberOfUnknownSpecialization); + MemberOfUnknownSpecialization, + /*Disambiguation=*/true); if (MemberOfUnknownSpecialization || !PossibleConcept || TNK != TNK_Concept_template) { if (SS.isNotEmpty()) diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 4ffa84604fbbfd..2cc770e5f3d1e9 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -15564,6 +15564,11 @@ VarDecl *Sema::BuildExceptionDeclaration(Scope *S, !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK)) Invalid = true; + if (!Invalid && Mode != 1 && BaseType->isSizelessType()) { + Diag(Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType; + Invalid = true; + } + if (!Invalid && !ExDeclType->isDependentType() && RequireNonAbstractType(Loc, ExDeclType, diag::err_abstract_type_in_decl, diff --git a/clang/lib/Sema/SemaExceptionSpec.cpp b/clang/lib/Sema/SemaExceptionSpec.cpp index 1e892aa622df76..5c9844e1cd281b 100644 --- a/clang/lib/Sema/SemaExceptionSpec.cpp +++ b/clang/lib/Sema/SemaExceptionSpec.cpp @@ -167,6 +167,14 @@ bool Sema::CheckSpecifiedExceptionType(QualType &T, SourceRange Range) { RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range)) return ReturnValueOnError; + // The MSVC compatibility mode doesn't extend to sizeless types, + // so diagnose them separately. + if (PointeeT->isSizelessType() && Kind != 1) { + Diag(Range.getBegin(), diag::err_sizeless_in_exception_spec) + << (Kind == 2 ? 1 : 0) << PointeeT << Range; + return true; + } + return false; } diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 3cfaf9fa006835..c1bfb962677add 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -4885,8 +4885,9 @@ Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, // See IsCForbiddenLValueType. if (!ResultType.hasQualifiers()) VK = VK_RValue; } else if (!ResultType->isDependentType() && - RequireCompleteType(LLoc, ResultType, - diag::err_subscript_incomplete_type, BaseExpr)) + RequireCompleteSizedType( + LLoc, ResultType, + diag::err_subscript_incomplete_or_sizeless_type, BaseExpr)) return ExprError(); assert(VK == VK_RValue || LangOpts.CPlusPlus || @@ -9533,9 +9534,10 @@ static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, assert(ResType->isAnyPointerType() && !ResType->isDependentType()); QualType PointeeTy = ResType->getPointeeType(); - return S.RequireCompleteType(Loc, PointeeTy, - diag::err_typecheck_arithmetic_incomplete_type, - PointeeTy, Operand->getSourceRange()); + return S.RequireCompleteSizedType( + Loc, PointeeTy, + diag::err_typecheck_arithmetic_incomplete_or_sizeless_type, + Operand->getSourceRange()); } /// Check the validity of an arithmetic pointer operand. @@ -14204,11 +14206,9 @@ ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, ExprValueKind VK = VK_RValue; ExprObjectKind OK = OK_Ordinary; QualType resType; - bool ValueDependent = false; bool CondIsTrue = false; if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) { resType = Context.DependentTy; - ValueDependent = true; } else { // The conditional expression is required to be a constant expression. llvm::APSInt condEval(32); @@ -14224,14 +14224,12 @@ ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr; resType = ActiveExpr->getType(); - ValueDependent = ActiveExpr->isValueDependent(); VK = ActiveExpr->getValueKind(); OK = ActiveExpr->getObjectKind(); } - return new (Context) - ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, resType, VK, OK, RPLoc, - CondIsTrue, resType->isDependentType(), ValueDependent); + return new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, + resType, VK, OK, RPLoc, CondIsTrue); } //===----------------------------------------------------------------------===// diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index f81aabb55e4c8b..24e312ef6d0138 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -956,6 +956,11 @@ bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, E->getSourceRange())) return true; + if (!isPointer && Ty->isSizelessType()) { + Diag(ThrowLoc, diag::err_throw_sizeless) << Ty << E->getSourceRange(); + return true; + } + if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy, diag::err_throw_abstract_type, E)) return true; @@ -2335,7 +2340,8 @@ bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, return Diag(Loc, diag::err_bad_new_type) << AllocType << 1 << R; else if (!AllocType->isDependentType() && - RequireCompleteType(Loc, AllocType, diag::err_new_incomplete_type,R)) + RequireCompleteSizedType( + Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R)) return true; else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type)) @@ -3461,7 +3467,8 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, // this, so we treat it as a warning unless we're in a SFINAE context. Diag(StartLoc, diag::ext_delete_void_ptr_operand) << Type << Ex.get()->getSourceRange(); - } else if (Pointee->isFunctionType() || Pointee->isVoidType()) { + } else if (Pointee->isFunctionType() || Pointee->isVoidType() || + Pointee->isSizelessType()) { return ExprError(Diag(StartLoc, diag::err_delete_operand) << Type << Ex.get()->getSourceRange()); } else if (!Pointee->isDependentType()) { diff --git a/clang/lib/Sema/SemaPseudoObject.cpp b/clang/lib/Sema/SemaPseudoObject.cpp index 5587e0d24c7f45..87c3c264b472ef 100644 --- a/clang/lib/Sema/SemaPseudoObject.cpp +++ b/clang/lib/Sema/SemaPseudoObject.cpp @@ -167,16 +167,11 @@ namespace { Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS; rebuiltExpr = rebuild(rebuiltExpr); - return new (S.Context) ChooseExpr(ce->getBuiltinLoc(), - ce->getCond(), - LHS, RHS, - rebuiltExpr->getType(), - rebuiltExpr->getValueKind(), - rebuiltExpr->getObjectKind(), - ce->getRParenLoc(), - ce->isConditionTrue(), - rebuiltExpr->isTypeDependent(), - rebuiltExpr->isValueDependent()); + return new (S.Context) + ChooseExpr(ce->getBuiltinLoc(), ce->getCond(), LHS, RHS, + rebuiltExpr->getType(), rebuiltExpr->getValueKind(), + rebuiltExpr->getObjectKind(), ce->getRParenLoc(), + ce->isConditionTrue()); } llvm_unreachable("bad expression to rebuild!"); diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 4923d0a6dad2a0..1ba66d4a976a2f 100755 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -174,7 +174,8 @@ TemplateNameKind Sema::isTemplateName(Scope *S, ParsedType ObjectTypePtr, bool EnteringContext, TemplateTy &TemplateResult, - bool &MemberOfUnknownSpecialization) { + bool &MemberOfUnknownSpecialization, + bool Disambiguation) { assert(getLangOpts().CPlusPlus && "No template names in C!"); DeclarationName TName; @@ -204,7 +205,7 @@ TemplateNameKind Sema::isTemplateName(Scope *S, LookupResult R(*this, TName, Name.getBeginLoc(), LookupOrdinaryName); if (LookupTemplateName(R, S, SS, ObjectType, EnteringContext, MemberOfUnknownSpecialization, SourceLocation(), - &AssumedTemplate)) + &AssumedTemplate, Disambiguation)) return TNK_Non_template; if (AssumedTemplate != AssumedTemplateKind::None) { @@ -371,7 +372,8 @@ bool Sema::LookupTemplateName(LookupResult &Found, bool EnteringContext, bool &MemberOfUnknownSpecialization, SourceLocation TemplateKWLoc, - AssumedTemplateKind *ATK) { + AssumedTemplateKind *ATK, + bool Disambiguation) { if (ATK) *ATK = AssumedTemplateKind::None; @@ -494,8 +496,9 @@ bool Sema::LookupTemplateName(LookupResult &Found, } } - if (Found.empty() && !IsDependent) { - // If we did not find any names, attempt to correct any typos. + if (Found.empty() && !IsDependent && !Disambiguation) { + // If we did not find any names, and this is not a disambiguation, attempt + // to correct any typos. DeclarationName Name = Found.getLookupName(); Found.clear(); // Simple filter callback that, for keywords, only accepts the C++ *_cast diff --git a/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp index 6af63fc28e230f..210a4ff199c637 100644 --- a/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp @@ -71,14 +71,6 @@ class StdLibraryFunctionsChecker : public Checker { /// to us. If he doesn't, he performs additional invalidations. enum InvalidationKind { NoEvalCall, EvalCallAsPure }; - /// A pair of ValueRangeKind and IntRangeVector would describe a range - /// imposed on a particular argument or return value symbol. - /// - /// Given a range, should the argument stay inside or outside this range? - /// The special `ComparesToArgument' value indicates that we should - /// impose a constraint that involves other argument or return value symbols. - enum ValueRangeKind { OutOfRange, WithinRange, ComparesToArgument }; - // The universal integral type to use in value range descriptions. // Unsigned to make sure overflows are well-defined. typedef uint64_t RangeInt; @@ -93,44 +85,42 @@ class StdLibraryFunctionsChecker : public Checker { /// ArgNo in CallExpr and CallEvent is defined as Unsigned, but /// obviously uint32_t should be enough for all practical purposes. typedef uint32_t ArgNo; - static const ArgNo Ret = std::numeric_limits::max(); - - /// Incapsulates a single range on a single symbol within a branch. - class ValueRange { - ArgNo ArgN; // Argument to which we apply the range. - ValueRangeKind Kind; // Kind of range definition. - IntRangeVector Args; // Polymorphic arguments. + static const ArgNo Ret; + /// Polymorphic base class that represents a constraint on a given argument + /// (or return value) of a function. Derived classes implement different kind + /// of constraints, e.g range constraints or correlation between two + /// arguments. + class ValueConstraint { public: - ValueRange(ArgNo ArgN, ValueRangeKind Kind, const IntRangeVector &Args) - : ArgN(ArgN), Kind(Kind), Args(Args) {} - + ValueConstraint(ArgNo ArgN) : ArgN(ArgN) {} + virtual ~ValueConstraint() {} + /// Apply the effects of the constraint on the given program state. If null + /// is returned then the constraint is not feasible. + virtual ProgramStateRef apply(ProgramStateRef State, const CallEvent &Call, + const Summary &Summary) const = 0; ArgNo getArgNo() const { return ArgN; } - ValueRangeKind getKind() const { return Kind; } - - BinaryOperator::Opcode getOpcode() const { - assert(Kind == ComparesToArgument); - assert(Args.size() == 1); - BinaryOperator::Opcode Op = - static_cast(Args[0].first); - assert(BinaryOperator::isComparisonOp(Op) && - "Only comparison ops are supported for ComparesToArgument"); - return Op; - } - ArgNo getOtherArgNo() const { - assert(Kind == ComparesToArgument); - assert(Args.size() == 1); - return static_cast(Args[0].second); - } + protected: + ArgNo ArgN; // Argument to which we apply the constraint. + }; + + /// Given a range, should the argument stay inside or outside this range? + enum RangeKind { OutOfRange, WithinRange }; + + /// Encapsulates a single range on a single symbol within a branch. + class RangeConstraint : public ValueConstraint { + RangeKind Kind; // Kind of range definition. + IntRangeVector Args; // Polymorphic arguments. + + public: + RangeConstraint(ArgNo ArgN, RangeKind Kind, const IntRangeVector &Args) + : ValueConstraint(ArgN), Kind(Kind), Args(Args) {} const IntRangeVector &getRanges() const { - assert(Kind != ComparesToArgument); return Args; } - // We avoid creating a virtual apply() method because - // it makes initializer lists harder to write. private: ProgramStateRef applyAsOutOfRange(ProgramStateRef State, const CallEvent &Call, @@ -138,30 +128,44 @@ class StdLibraryFunctionsChecker : public Checker { ProgramStateRef applyAsWithinRange(ProgramStateRef State, const CallEvent &Call, const Summary &Summary) const; - ProgramStateRef applyAsComparesToArgument(ProgramStateRef State, - const CallEvent &Call, - const Summary &Summary) const; - public: ProgramStateRef apply(ProgramStateRef State, const CallEvent &Call, - const Summary &Summary) const { + const Summary &Summary) const override { switch (Kind) { case OutOfRange: return applyAsOutOfRange(State, Call, Summary); case WithinRange: return applyAsWithinRange(State, Call, Summary); - case ComparesToArgument: - return applyAsComparesToArgument(State, Call, Summary); } - llvm_unreachable("Unknown ValueRange kind!"); + llvm_unreachable("Unknown range kind!"); } }; - /// The complete list of ranges that defines a single branch. - typedef std::vector ValueRangeSet; + class ComparisonConstraint : public ValueConstraint { + BinaryOperator::Opcode Opcode; + ArgNo OtherArgN; + + public: + ComparisonConstraint(ArgNo ArgN, BinaryOperator::Opcode Opcode, + ArgNo OtherArgN) + : ValueConstraint(ArgN), Opcode(Opcode), OtherArgN(OtherArgN) {} + ArgNo getOtherArgNo() const { return OtherArgN; } + BinaryOperator::Opcode getOpcode() const { return Opcode; } + ProgramStateRef apply(ProgramStateRef State, const CallEvent &Call, + const Summary &Summary) const override; + }; + + // Pointer to the ValueConstraint. We need a copyable, polymorphic and + // default initialize able type (vector needs that). A raw pointer was good, + // however, we cannot default initialize that. unique_ptr makes the Summary + // class non-copyable, therefore not an option. Releasing the copyability + // requirement would render the initialization of the Summary map infeasible. + using ValueConstraintPtr = std::shared_ptr; + /// The complete list of constraints that defines a single branch. + typedef std::vector ConstraintSet; using ArgTypes = std::vector; - using Ranges = std::vector; + using Cases = std::vector; /// Includes information about function prototype (which is necessary to /// ensure we're modeling the right function and casting values properly), @@ -171,14 +175,14 @@ class StdLibraryFunctionsChecker : public Checker { const ArgTypes ArgTys; const QualType RetTy; const InvalidationKind InvalidationKd; - Ranges Cases; - ValueRangeSet ArgConstraints; + Cases CaseConstraints; + ConstraintSet ArgConstraints; Summary(ArgTypes ArgTys, QualType RetTy, InvalidationKind InvalidationKd) : ArgTys(ArgTys), RetTy(RetTy), InvalidationKd(InvalidationKd) {} - Summary &Case(ValueRangeSet VRS) { - Cases.push_back(VRS); + Summary &Case(ConstraintSet&& CS) { + CaseConstraints.push_back(std::move(CS)); return *this; } @@ -244,9 +248,13 @@ class StdLibraryFunctionsChecker : public Checker { void initFunctionSummaries(CheckerContext &C) const; }; + +const StdLibraryFunctionsChecker::ArgNo StdLibraryFunctionsChecker::Ret = + std::numeric_limits::max(); + } // end of anonymous namespace -ProgramStateRef StdLibraryFunctionsChecker::ValueRange::applyAsOutOfRange( +ProgramStateRef StdLibraryFunctionsChecker::RangeConstraint::applyAsOutOfRange( ProgramStateRef State, const CallEvent &Call, const Summary &Summary) const { @@ -273,7 +281,7 @@ ProgramStateRef StdLibraryFunctionsChecker::ValueRange::applyAsOutOfRange( return State; } -ProgramStateRef StdLibraryFunctionsChecker::ValueRange::applyAsWithinRange( +ProgramStateRef StdLibraryFunctionsChecker::RangeConstraint::applyAsWithinRange( ProgramStateRef State, const CallEvent &Call, const Summary &Summary) const { @@ -330,8 +338,7 @@ ProgramStateRef StdLibraryFunctionsChecker::ValueRange::applyAsWithinRange( return State; } -ProgramStateRef -StdLibraryFunctionsChecker::ValueRange::applyAsComparesToArgument( +ProgramStateRef StdLibraryFunctionsChecker::ComparisonConstraint::apply( ProgramStateRef State, const CallEvent &Call, const Summary &Summary) const { @@ -367,15 +374,15 @@ void StdLibraryFunctionsChecker::checkPostCall(const CallEvent &Call, if (!FoundSummary) return; - // Now apply ranges. + // Now apply the constraints. const Summary &Summary = *FoundSummary; ProgramStateRef State = C.getState(); // Apply case/branch specifications. - for (const auto &VRS : Summary.Cases) { + for (const auto &VRS : Summary.CaseConstraints) { ProgramStateRef NewState = State; for (const auto &VR: VRS) { - NewState = VR.apply(NewState, Call, Summary); + NewState = VR->apply(NewState, Call, Summary); if (!NewState) break; } @@ -555,24 +562,26 @@ void StdLibraryFunctionsChecker::initFunctionSummaries( // Please update the list of functions in the header after editing! // - // Below are helper functions to create the summaries. - auto ArgumentCondition = [](ArgNo ArgN, ValueRangeKind Kind, - IntRangeVector Ranges) -> ValueRange { - ValueRange VR{ArgN, Kind, Ranges}; - return VR; - }; - auto ReturnValueCondition = [](ValueRangeKind Kind, - IntRangeVector Ranges) -> ValueRange { - ValueRange VR{Ret, Kind, Ranges}; - return VR; + // Below are helpers functions to create the summaries. + auto ArgumentCondition = [](ArgNo ArgN, RangeKind Kind, + IntRangeVector Ranges) { + return std::make_shared(ArgN, Kind, Ranges); }; + struct { + auto operator()(RangeKind Kind, IntRangeVector Ranges) { + return std::make_shared(Ret, Kind, Ranges); + } + auto operator()(BinaryOperator::Opcode Op, ArgNo OtherArgN) { + return std::make_shared(Ret, Op, OtherArgN); + } + } ReturnValueCondition; auto Range = [](RangeInt b, RangeInt e) { return IntRangeVector{std::pair{b, e}}; }; auto SingleValue = [](RangeInt v) { return IntRangeVector{std::pair{v, v}}; }; - auto IsLessThan = [](ArgNo ArgN) { return IntRangeVector{{BO_LE, ArgN}}; }; + auto LessThanOrEq = BO_LE; using RetType = QualType; @@ -585,14 +594,14 @@ void StdLibraryFunctionsChecker::initFunctionSummaries( auto Read = [&](RetType R, RangeInt Max) { return Summary(ArgTypes{Irrelevant, Irrelevant, SizeTy}, RetType{R}, NoEvalCall) - .Case({ReturnValueCondition(ComparesToArgument, IsLessThan(2)), + .Case({ReturnValueCondition(LessThanOrEq, ArgNo(2)), ReturnValueCondition(WithinRange, Range(-1, Max))}); }; auto Fread = [&]() { return Summary(ArgTypes{Irrelevant, Irrelevant, SizeTy, Irrelevant}, RetType{SizeTy}, NoEvalCall) .Case({ - ReturnValueCondition(ComparesToArgument, IsLessThan(2)), + ReturnValueCondition(LessThanOrEq, ArgNo(2)), }); }; auto Getline = [&](RetType R, RangeInt Max) { diff --git a/clang/lib/Tooling/Syntax/BuildTree.cpp b/clang/lib/Tooling/Syntax/BuildTree.cpp index 2430394134037f..9ebf7d29d8eda8 100644 --- a/clang/lib/Tooling/Syntax/BuildTree.cpp +++ b/clang/lib/Tooling/Syntax/BuildTree.cpp @@ -6,10 +6,15 @@ // //===----------------------------------------------------------------------===// #include "clang/Tooling/Syntax/BuildTree.h" +#include "clang/AST/ASTFwd.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" +#include "clang/AST/DeclCXX.h" +#include "clang/AST/DeclarationName.h" #include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/Stmt.h" +#include "clang/AST/TypeLoc.h" +#include "clang/AST/TypeLocVisitor.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" @@ -20,6 +25,7 @@ #include "clang/Tooling/Syntax/Tree.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/ScopeExit.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Casting.h" @@ -34,6 +40,110 @@ using namespace clang; LLVM_ATTRIBUTE_UNUSED static bool isImplicitExpr(clang::Expr *E) { return E->IgnoreImplicit() != E; } +static SourceLocation getQualifiedNameStart(DeclaratorDecl *D) { + auto DN = D->getDeclName(); + bool IsAnonymous = DN.isIdentifier() && !DN.getAsIdentifierInfo(); + if (IsAnonymous) + return SourceLocation(); + return D->getQualifierLoc() ? D->getQualifierLoc().getBeginLoc() + : D->getLocation(); +} + +namespace { +/// Get start location of the Declarator from the TypeLoc. +/// E.g.: +/// loc of `(` in `int (a)` +/// loc of `*` in `int *(a)` +/// loc of the first `(` in `int (*a)(int)` +/// loc of the `*` in `int *(a)(int)` +/// loc of the first `*` in `const int *const *volatile a;` +/// +/// It is non-trivial to get the start location because TypeLocs are stored +/// inside out. In the example above `*volatile` is the TypeLoc returned +/// by `Decl.getTypeSourceInfo()`, and `*const` is what `.getPointeeLoc()` +/// returns. +struct GetStartLoc : TypeLocVisitor { + SourceLocation VisitParenTypeLoc(ParenTypeLoc T) { + auto L = Visit(T.getInnerLoc()); + if (L.isValid()) + return L; + return T.getLParenLoc(); + } + + // Types spelled in the prefix part of the declarator. + SourceLocation VisitPointerTypeLoc(PointerTypeLoc T) { + return HandlePointer(T); + } + + SourceLocation VisitMemberPointerTypeLoc(MemberPointerTypeLoc T) { + return HandlePointer(T); + } + + SourceLocation VisitBlockPointerTypeLoc(BlockPointerTypeLoc T) { + return HandlePointer(T); + } + + SourceLocation VisitReferenceTypeLoc(ReferenceTypeLoc T) { + return HandlePointer(T); + } + + SourceLocation VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc T) { + return HandlePointer(T); + } + + // All other cases are not important, as they are either part of declaration + // specifiers (e.g. inheritors of TypeSpecTypeLoc) or introduce modifiers on + // existing declarators (e.g. QualifiedTypeLoc). They cannot start the + // declarator themselves, but their underlying type can. + SourceLocation VisitTypeLoc(TypeLoc T) { + auto N = T.getNextTypeLoc(); + if (!N) + return SourceLocation(); + return Visit(N); + } + + SourceLocation VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc T) { + if (T.getTypePtr()->hasTrailingReturn()) + return SourceLocation(); // avoid recursing into the suffix of declarator. + return VisitTypeLoc(T); + } + +private: + template SourceLocation HandlePointer(PtrLoc T) { + auto L = Visit(T.getPointeeLoc()); + if (L.isValid()) + return L; + return T.getLocalSourceRange().getBegin(); + } +}; +} // namespace + +/// Gets the range of declarator as defined by the C++ grammar. E.g. +/// `int a;` -> range of `a`, +/// `int *a;` -> range of `*a`, +/// `int a[10];` -> range of `a[10]`, +/// `int a[1][2][3];` -> range of `a[1][2][3]`, +/// `int *a = nullptr` -> range of `*a = nullptr`. +/// FIMXE: \p Name must be a source range, e.g. for `operator+`. +static SourceRange getDeclaratorRange(const SourceManager &SM, TypeLoc T, + SourceLocation Name, + SourceRange Initializer) { + SourceLocation Start = GetStartLoc().Visit(T); + SourceLocation End = T.getSourceRange().getEnd(); + assert(End.isValid()); + if (Name.isValid()) { + if (Start.isInvalid()) + Start = Name; + if (SM.isBeforeInTranslationUnit(End, Name)) + End = Name; + } + if (Initializer.isValid()) { + assert(SM.isBeforeInTranslationUnit(End, Initializer.getEnd())); + End = Initializer.getEnd(); + } + return SourceRange(Start, End); +} + /// A helper class for constructing the syntax tree while traversing a clang /// AST. /// @@ -57,6 +167,7 @@ class syntax::TreeBuilder { } llvm::BumpPtrAllocator &allocator() { return Arena.allocator(); } + const SourceManager &sourceManager() const { return Arena.sourceManager(); } /// Populate children for \p New node, assuming it covers tokens from \p /// Range. @@ -64,16 +175,16 @@ class syntax::TreeBuilder { /// Must be called with the range of each `DeclaratorDecl`. Ensures the /// corresponding declarator nodes are covered by `SimpleDeclaration`. - void noticeDeclaratorRange(llvm::ArrayRef Range); + void noticeDeclRange(llvm::ArrayRef Range); /// Notifies that we should not consume trailing semicolon when computing /// token range of \p D. - void noticeDeclaratorWithoutSemicolon(Decl *D); + void noticeDeclWithoutSemicolon(Decl *D); /// Mark the \p Child node with a corresponding \p Role. All marked children /// should be consumed by foldNode. - /// (!) when called on expressions (clang::Expr is derived from clang::Stmt), - /// wraps expressions into expression statement. + /// When called on expressions (clang::Expr is derived from clang::Stmt), + /// wraps expressions into expression statement. void markStmtChild(Stmt *Child, NodeRole Role); /// Should be called for expressions in non-statement position to avoid /// wrapping into expression statement. @@ -81,6 +192,13 @@ class syntax::TreeBuilder { /// Set role for a token starting at \p Loc. void markChildToken(SourceLocation Loc, NodeRole R); + /// Set role for \p T. + void markChildToken(const syntax::Token *T, NodeRole R); + + /// Set role for the node that spans exactly \p Range. + void markChild(llvm::ArrayRef Range, NodeRole R); + /// Set role for the delayed node that spans exactly \p Range. + void markDelayedChild(llvm::ArrayRef Range, NodeRole R); /// Finish building the tree and consume the root node. syntax::TranslationUnit *finalize() && { @@ -141,7 +259,7 @@ class syntax::TreeBuilder { withTrailingSemicolon(llvm::ArrayRef Tokens) const { assert(!Tokens.empty()); assert(Tokens.back().kind() != tok::eof); - // (!) we never consume 'eof', so looking at the next token is ok. + // We never consume 'eof', so looking at the next token is ok. if (Tokens.back().kind() != tok::semi && Tokens.end()->kind() == tok::semi) return llvm::makeArrayRef(Tokens.begin(), Tokens.end() + 1); return Tokens; @@ -172,6 +290,14 @@ class syntax::TreeBuilder { ~Forest() { assert(DelayedFolds.empty()); } + void assignRoleDelayed(llvm::ArrayRef Range, + syntax::NodeRole Role) { + auto It = DelayedFolds.find(Range.begin()); + assert(It != DelayedFolds.end()); + assert(It->second.End == Range.end()); + It->second.Role = Role; + } + void assignRole(llvm::ArrayRef Range, syntax::NodeRole Role) { assert(!Range.empty()); @@ -189,12 +315,19 @@ class syntax::TreeBuilder { llvm::ArrayRef Tokens, syntax::Tree *Node) { // Execute delayed folds inside `Tokens`. - auto BeginExecuted = DelayedFolds.lower_bound(Tokens.begin()); - auto It = BeginExecuted; - for (; It != DelayedFolds.end() && It->second.End <= Tokens.end(); ++It) + auto BeginFolds = DelayedFolds.lower_bound(Tokens.begin()); + auto EndFolds = BeginFolds; + for (; EndFolds != DelayedFolds.end() && + EndFolds->second.End <= Tokens.end(); + ++EndFolds) + ; + // We go in reverse order to ensure we fold deeper nodes first. + for (auto RevIt = EndFolds; RevIt != BeginFolds; --RevIt) { + auto It = std::prev(RevIt); foldChildrenEager(A, llvm::makeArrayRef(It->first, It->second.End), It->second.Node); - DelayedFolds.erase(BeginExecuted, It); + } + DelayedFolds.erase(BeginFolds, EndFolds); // Attach children to `Node`. foldChildrenEager(A, Tokens, Node); @@ -269,7 +402,7 @@ class syntax::TreeBuilder { (EndChildren == Trees.end() || EndChildren->first == Tokens.end()) && "fold crosses boundaries of existing subtrees"); - // (!) we need to go in reverse order, because we can only prepend. + // We need to go in reverse order, because we can only prepend. for (auto It = EndChildren; It != BeginChildren; --It) Node->prependChildLowLevel(std::prev(It)->second.Node, std::prev(It)->second.Role); @@ -301,6 +434,7 @@ class syntax::TreeBuilder { struct DelayedFold { const syntax::Token *End = nullptr; syntax::Tree *Node = nullptr; + NodeRole Role = NodeRole::Unknown; }; std::map DelayedFolds; }; @@ -324,16 +458,43 @@ class BuildTreeVisitor : public RecursiveASTVisitor { bool shouldTraversePostOrder() const { return true; } - bool WalkUpFromDeclaratorDecl(DeclaratorDecl *D) { + bool WalkUpFromDeclaratorDecl(DeclaratorDecl *DD) { // Ensure declarators are covered by SimpleDeclaration. - Builder.noticeDeclaratorRange(Builder.getRange(D)); - // FIXME: build nodes for the declarator too. + Builder.noticeDeclRange(Builder.getRange(DD)); + + // Build the declarator node. + SourceRange Initializer; + if (auto *V = llvm::dyn_cast(DD)) { + auto *I = V->getInit(); + // Initializers in range-based-for are not part of the declarator + if (I && !V->isCXXForRangeDecl()) + Initializer = I->getSourceRange(); + } + auto Declarator = getDeclaratorRange( + Builder.sourceManager(), DD->getTypeSourceInfo()->getTypeLoc(), + getQualifiedNameStart(DD), Initializer); + if (Declarator.isValid()) { + auto Tokens = + Builder.getRange(Declarator.getBegin(), Declarator.getEnd()); + Builder.foldNode(Tokens, new (allocator()) syntax::SimpleDeclarator); + Builder.markChild(Tokens, syntax::NodeRole::SimpleDeclaration_declarator); + } + return true; } + bool WalkUpFromTypedefNameDecl(TypedefNameDecl *D) { - // Also a declarator. - Builder.noticeDeclaratorRange(Builder.getRange(D)); - // FIXME: build nodes for the declarator too. + // Ensure declarators are covered by SimpleDeclaration. + Builder.noticeDeclRange(Builder.getRange(D)); + + auto R = getDeclaratorRange( + Builder.sourceManager(), D->getTypeSourceInfo()->getTypeLoc(), + /*Name=*/D->getLocation(), /*Initializer=*/SourceRange()); + if (R.isValid()) { + auto Tokens = Builder.getRange(R.getBegin(), R.getEnd()); + Builder.foldNode(Tokens, new (allocator()) syntax::SimpleDeclarator); + Builder.markChild(Tokens, syntax::NodeRole::SimpleDeclaration_declarator); + } return true; } @@ -356,7 +517,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor { } bool WalkUpFromTranslationUnitDecl(TranslationUnitDecl *TU) { - // (!) we do not want to call VisitDecl(), the declaration for translation + // We do not want to call VisitDecl(), the declaration for translation // unit is built by finalize(). return true; } @@ -401,10 +562,10 @@ class BuildTreeVisitor : public RecursiveASTVisitor { if (auto *DS = llvm::dyn_cast_or_null(S)) { // We want to consume the semicolon, make sure SimpleDeclaration does not. for (auto *D : DS->decls()) - Builder.noticeDeclaratorWithoutSemicolon(D); + Builder.noticeDeclWithoutSemicolon(D); } else if (auto *E = llvm::dyn_cast_or_null(S)) { - // (!) do not recurse into subexpressions. - // we do not have syntax trees for expressions yet, so we only want to see + // Do not recurse into subexpressions. + // We do not have syntax trees for expressions yet, so we only want to see // the first top-level expression. return WalkUpFromExpr(E->IgnoreImplicit()); } @@ -431,6 +592,62 @@ class BuildTreeVisitor : public RecursiveASTVisitor { return true; } + bool TraverseParenTypeLoc(ParenTypeLoc L) { + // We reverse order of traversal to get the proper syntax structure. + if (!WalkUpFromParenTypeLoc(L)) + return false; + return TraverseTypeLoc(L.getInnerLoc()); + } + + bool WalkUpFromParenTypeLoc(ParenTypeLoc L) { + Builder.markChildToken(L.getLParenLoc(), syntax::NodeRole::OpenParen); + Builder.markChildToken(L.getRParenLoc(), syntax::NodeRole::CloseParen); + Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getRParenLoc()), + new (allocator()) syntax::ParenDeclarator); + return true; + } + + // Declarator chunks, they are produced by type locs and some clang::Decls. + bool WalkUpFromArrayTypeLoc(ArrayTypeLoc L) { + Builder.markChildToken(L.getLBracketLoc(), syntax::NodeRole::OpenParen); + Builder.markExprChild(L.getSizeExpr(), + syntax::NodeRole::ArraySubscript_sizeExpression); + Builder.markChildToken(L.getRBracketLoc(), syntax::NodeRole::CloseParen); + Builder.foldNode(Builder.getRange(L.getLBracketLoc(), L.getRBracketLoc()), + new (allocator()) syntax::ArraySubscript); + return true; + } + + bool WalkUpFromFunctionTypeLoc(FunctionTypeLoc L) { + Builder.markChildToken(L.getLParenLoc(), syntax::NodeRole::OpenParen); + for (auto *P : L.getParams()) + Builder.markDelayedChild( + Builder.getRange(P), + syntax::NodeRole::ParametersAndQualifiers_parameter); + Builder.markChildToken(L.getRParenLoc(), syntax::NodeRole::CloseParen); + Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getEndLoc()), + new (allocator()) syntax::ParametersAndQualifiers); + return true; + } + + bool WalkUpFromFunctionProtoTypeLoc(FunctionProtoTypeLoc L) { + if (!L.getTypePtr()->hasTrailingReturn()) + return WalkUpFromFunctionTypeLoc(L); + + auto TrailingReturnTokens = BuildTrailingReturn(L); + // Finish building the node for parameters. + Builder.markChild(TrailingReturnTokens, + syntax::NodeRole::ParametersAndQualifiers_trailingReturn); + return WalkUpFromFunctionTypeLoc(L); + } + + bool WalkUpFromMemberPointerTypeLoc(MemberPointerTypeLoc L) { + auto SR = L.getLocalSourceRange(); + Builder.foldNode(Builder.getRange(SR.getBegin(), SR.getEnd()), + new (allocator()) syntax::MemberPointer); + return true; + } + // The code below is very regular, it could even be generated with some // preprocessor magic. We merely assign roles to the corresponding children // and fold resulting nodes. @@ -597,6 +814,37 @@ class BuildTreeVisitor : public RecursiveASTVisitor { } private: + /// Returns the range of the built node. + llvm::ArrayRef BuildTrailingReturn(FunctionProtoTypeLoc L) { + assert(L.getTypePtr()->hasTrailingReturn()); + + auto ReturnedType = L.getReturnLoc(); + // Build node for the declarator, if any. + auto ReturnDeclaratorRange = + getDeclaratorRange(this->Builder.sourceManager(), ReturnedType, + /*Name=*/SourceLocation(), + /*Initializer=*/SourceLocation()); + llvm::ArrayRef ReturnDeclaratorTokens; + if (ReturnDeclaratorRange.isValid()) { + ReturnDeclaratorTokens = Builder.getRange( + ReturnDeclaratorRange.getBegin(), ReturnDeclaratorRange.getEnd()); + Builder.foldNode(ReturnDeclaratorTokens, + new (allocator()) syntax::SimpleDeclarator); + } + + // Build node for trailing return type. + auto Return = + Builder.getRange(ReturnedType.getBeginLoc(), ReturnedType.getEndLoc()); + const auto *Arrow = Return.begin() - 1; + assert(Arrow->kind() == tok::arrow); + auto Tokens = llvm::makeArrayRef(Arrow, Return.end()); + Builder.markChildToken(Arrow, syntax::NodeRole::TrailingReturnType_arrow); + if (!ReturnDeclaratorTokens.empty()) + Builder.markChild(ReturnDeclaratorTokens, + syntax::NodeRole::TrailingReturnType_declarator); + Builder.foldNode(Tokens, new (allocator()) syntax::TrailingReturnType); + return Tokens; + } /// A small helper to save some typing. llvm::BumpPtrAllocator &allocator() { return Builder.allocator(); } @@ -610,15 +858,14 @@ void syntax::TreeBuilder::foldNode(llvm::ArrayRef Range, Pending.foldChildren(Arena, Range, New); } -void syntax::TreeBuilder::noticeDeclaratorRange( - llvm::ArrayRef Range) { +void syntax::TreeBuilder::noticeDeclRange(llvm::ArrayRef Range) { if (Pending.extendDelayedFold(Range)) return; Pending.foldChildrenDelayed(Range, new (allocator()) syntax::SimpleDeclaration); } -void syntax::TreeBuilder::noticeDeclaratorWithoutSemicolon(Decl *D) { +void syntax::TreeBuilder::noticeDeclWithoutSemicolon(Decl *D) { DeclsWithoutSemicolons.insert(D); } @@ -628,6 +875,22 @@ void syntax::TreeBuilder::markChildToken(SourceLocation Loc, NodeRole Role) { Pending.assignRole(*findToken(Loc), Role); } +void syntax::TreeBuilder::markChildToken(const syntax::Token *T, NodeRole R) { + if (!T) + return; + Pending.assignRole(*T, R); +} + +void syntax::TreeBuilder::markChild(llvm::ArrayRef Range, + NodeRole R) { + Pending.assignRole(Range, R); +} + +void syntax::TreeBuilder::markDelayedChild(llvm::ArrayRef Range, + NodeRole R) { + Pending.assignRoleDelayed(Range, R); +} + void syntax::TreeBuilder::markStmtChild(Stmt *Child, NodeRole Role) { if (!Child) return; @@ -638,7 +901,7 @@ void syntax::TreeBuilder::markStmtChild(Stmt *Child, NodeRole Role) { if (auto *E = dyn_cast(Child)) { Pending.assignRole(getExprRange(E), NodeRole::ExpressionStatement_expression); - // (!) 'getRange(Stmt)' ensures this already covers a trailing semicolon. + // 'getRange(Stmt)' ensures this already covers a trailing semicolon. Pending.foldChildren(Arena, Range, new (allocator()) syntax::ExpressionStatement); } diff --git a/clang/lib/Tooling/Syntax/Nodes.cpp b/clang/lib/Tooling/Syntax/Nodes.cpp index 5b0c5107c134cb..4f86007e39bb5c 100644 --- a/clang/lib/Tooling/Syntax/Nodes.cpp +++ b/clang/lib/Tooling/Syntax/Nodes.cpp @@ -68,6 +68,18 @@ llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) { return OS << "UsingDeclaration"; case NodeKind::TypeAliasDeclaration: return OS << "TypeAliasDeclaration"; + case NodeKind::SimpleDeclarator: + return OS << "SimpleDeclarator"; + case NodeKind::ParenDeclarator: + return OS << "ParenDeclarator"; + case NodeKind::ArraySubscript: + return OS << "ArraySubscript"; + case NodeKind::TrailingReturnType: + return OS << "TrailingReturnType"; + case NodeKind::ParametersAndQualifiers: + return OS << "ParametersAndQualifiers"; + case NodeKind::MemberPointer: + return OS << "MemberPointer"; } llvm_unreachable("unknown node kind"); } @@ -104,6 +116,18 @@ llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeRole R) { return OS << "StaticAssertDeclaration_condition"; case syntax::NodeRole::StaticAssertDeclaration_message: return OS << "StaticAssertDeclaration_message"; + case syntax::NodeRole::SimpleDeclaration_declarator: + return OS << "SimpleDeclaration_declarator"; + case syntax::NodeRole::ArraySubscript_sizeExpression: + return OS << "ArraySubscript_sizeExpression"; + case syntax::NodeRole::TrailingReturnType_arrow: + return OS << "TrailingReturnType_arrow"; + case syntax::NodeRole::TrailingReturnType_declarator: + return OS << "TrailingReturnType_declarator"; + case syntax::NodeRole::ParametersAndQualifiers_parameter: + return OS << "ParametersAndQualifiers_parameter"; + case syntax::NodeRole::ParametersAndQualifiers_trailingReturn: + return OS << "ParametersAndQualifiers_trailingReturn"; } llvm_unreachable("invalid role"); } @@ -246,3 +270,73 @@ syntax::Expression *syntax::StaticAssertDeclaration::message() { return llvm::cast_or_null( findChild(syntax::NodeRole::StaticAssertDeclaration_message)); } + +std::vector +syntax::SimpleDeclaration::declarators() { + std::vector Children; + for (auto *C = firstChild(); C; C = C->nextSibling()) { + if (C->role() == syntax::NodeRole::SimpleDeclaration_declarator) + Children.push_back(llvm::cast(C)); + } + return Children; +} + +syntax::Leaf *syntax::ParenDeclarator::lparen() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::OpenParen)); +} + +syntax::Leaf *syntax::ParenDeclarator::rparen() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::CloseParen)); +} + +syntax::Leaf *syntax::ArraySubscript::lbracket() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::OpenParen)); +} + +syntax::Expression *syntax::ArraySubscript::sizeExpression() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::ArraySubscript_sizeExpression)); +} + +syntax::Leaf *syntax::ArraySubscript::rbracket() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::CloseParen)); +} + +syntax::Leaf *syntax::TrailingReturnType::arrow() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::TrailingReturnType_arrow)); +} + +syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::TrailingReturnType_declarator)); +} + +syntax::Leaf *syntax::ParametersAndQualifiers::lparen() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::OpenParen)); +} + +std::vector +syntax::ParametersAndQualifiers::parameters() { + std::vector Children; + for (auto *C = firstChild(); C; C = C->nextSibling()) { + if (C->role() == syntax::NodeRole::ParametersAndQualifiers_parameter) + Children.push_back(llvm::cast(C)); + } + return Children; +} + +syntax::Leaf *syntax::ParametersAndQualifiers::rparen() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::CloseParen)); +} + +syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() { + return llvm::cast_or_null( + findChild(syntax::NodeRole::ParametersAndQualifiers_trailingReturn)); +} diff --git a/clang/test/CodeGen/aarch64-sve-inline-asm-crash.c b/clang/test/CodeGen/aarch64-sve-inline-asm-crash.c new file mode 100644 index 00000000000000..11ddb7f6d5800a --- /dev/null +++ b/clang/test/CodeGen/aarch64-sve-inline-asm-crash.c @@ -0,0 +1,24 @@ +// REQUIRES: aarch64-registered-target + +// RUN: not %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns \ +// RUN: -target-feature +neon -S -O1 -o - %s 2>&1 | FileCheck %s + +// Set a vector constraint for an sve predicate register +// As the wrong constraint is used for an SVBool, +// the compiler will try to extend the nxv16i1 to an nxv16i8 +// TODO: We don't have patterns for this yet but once they are added this test +// should be updated to check for an assembler error +__SVBool_t funcB1(__SVBool_t in) +{ + __SVBool_t ret ; + asm volatile ( + "mov %[ret].b, %[in].b \n" + : [ret] "=w" (ret) + : [in] "w" (in) + :); + + return ret ; +} + +// CHECK: funcB1 +// CHECK-ERROR: fatal error: error in backend: Cannot select diff --git a/clang/test/CodeGen/aarch64-sve-inline-asm-datatypes.c b/clang/test/CodeGen/aarch64-sve-inline-asm-datatypes.c new file mode 100644 index 00000000000000..c68bb25e36fa55 --- /dev/null +++ b/clang/test/CodeGen/aarch64-sve-inline-asm-datatypes.c @@ -0,0 +1,252 @@ +// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns \ +// RUN: -target-feature +neon -S -O1 -o - -emit-llvm %s | FileCheck %s + +// Tests to check that all sve datatypes can be passed in as input operands +// and passed out as output operands. + +#define SVINT_TEST(DT, KIND)\ +DT func_int_##DT##KIND(DT in)\ +{\ + DT out;\ + asm volatile (\ + "ptrue p0.b\n"\ + "mov %[out]." #KIND ", p0/m, %[in]." #KIND "\n"\ + : [out] "=w" (out)\ + : [in] "w" (in)\ + : "p0"\ + );\ + return out;\ +} + +SVINT_TEST(__SVUint8_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint8_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint8_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint8_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVUint16_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint16_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint16_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint16_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVUint32_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint32_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint32_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint32_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVUint64_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint64_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint64_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVUint64_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVInt8_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt8_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt8_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt8_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVInt16_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt16_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt16_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt16_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVInt32_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt32_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt32_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt32_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVInt64_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt64_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt64_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVInt64_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + + +//Test that floats can also be used as datatypes for integer instructions +//and check all the variants which would not be possible with a float +//instruction +SVINT_TEST(__SVFloat16_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat16_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat16_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat16_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVFloat32_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat32_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat32_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat32_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + +SVINT_TEST(__SVFloat64_t,b); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.b, p0/m, $1.b\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat64_t,h); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.h, p0/m, $1.h\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat64_t,s); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.s, p0/m, $1.s\0A", "=w,w,~{p0}"( %in) +SVINT_TEST(__SVFloat64_t,d); +// CHECK: call asm sideeffect "ptrue p0.b\0Amov $0.d, p0/m, $1.d\0A", "=w,w,~{p0}"( %in) + + +#define SVBOOL_TEST(KIND)\ +__SVBool_t func_bool_##KIND(__SVBool_t in1, __SVBool_t in2)\ +{\ + __SVBool_t out;\ + asm volatile (\ + "zip1 %[out]." #KIND ", %[in1]." #KIND ", %[in2]." #KIND "\n"\ + : [out] "=Upa" (out)\ + : [in1] "Upa" (in1),\ + [in2] "Upa" (in2)\ + :);\ + return out;\ +} + +SVBOOL_TEST(b) ; +// CHECK: call asm sideeffect "zip1 $0.b, $1.b, $2.b\0A", "=@3Upa,@3Upa,@3Upa"( %in1, %in2) +SVBOOL_TEST(h) ; +// CHECK: call asm sideeffect "zip1 $0.h, $1.h, $2.h\0A", "=@3Upa,@3Upa,@3Upa"( %in1, %in2) +SVBOOL_TEST(s) ; +// CHECK: call asm sideeffect "zip1 $0.s, $1.s, $2.s\0A", "=@3Upa,@3Upa,@3Upa"( %in1, %in2) +SVBOOL_TEST(d) ; +// CHECK: call asm sideeffect "zip1 $0.d, $1.d, $2.d\0A", "=@3Upa,@3Upa,@3Upa"( %in1, %in2) + + +#define SVBOOL_TEST_UPL(DT, KIND)\ +__SVBool_t func_bool_upl_##KIND(__SVBool_t in1, DT in2, DT in3)\ +{\ + __SVBool_t out;\ + asm volatile (\ + "fadd %[out]." #KIND ", %[in1]." #KIND ", %[in2]." #KIND ", %[in3]." #KIND "\n"\ + : [out] "=w" (out)\ + : [in1] "Upl" (in1),\ + [in2] "w" (in2),\ + [in3] "w" (in3)\ + :);\ + return out;\ +} + +SVBOOL_TEST_UPL(__SVInt8_t, b) ; +// CHECK: call asm sideeffect "fadd $0.b, $1.b, $2.b, $3.b\0A", "=w,@3Upl,w,w"( %in1, %in2, %in3) +SVBOOL_TEST_UPL(__SVInt16_t, h) ; +// CHECK: call asm sideeffect "fadd $0.h, $1.h, $2.h, $3.h\0A", "=w,@3Upl,w,w"( %in1, %in2, %in3) +SVBOOL_TEST_UPL(__SVInt32_t, s) ; +// CHECK: call asm sideeffect "fadd $0.s, $1.s, $2.s, $3.s\0A", "=w,@3Upl,w,w"( %in1, %in2, %in3) +SVBOOL_TEST_UPL(__SVInt64_t, d) ; +// CHECK: call asm sideeffect "fadd $0.d, $1.d, $2.d, $3.d\0A", "=w,@3Upl,w,w"( %in1, %in2, %in3) + +#define SVFLOAT_TEST(DT,KIND)\ +DT func_float_##DT##KIND(DT inout1, DT in2)\ +{\ + asm volatile (\ + "ptrue p0." #KIND ", #1 \n"\ + "fsub %[inout1]." #KIND ", p0/m, %[inout1]." #KIND ", %[in2]." #KIND "\n"\ + : [inout1] "=w" (inout1)\ + : "[inout1]" (inout1),\ + [in2] "w" (in2)\ + : "p0");\ + return inout1 ;\ +}\ + +SVFLOAT_TEST(__SVFloat16_t,s); +// CHECK: call asm sideeffect "ptrue p0.s, #1 \0Afsub $0.s, p0/m, $0.s, $2.s\0A", "=w,0,w,~{p0}"( %inout1, %in2) +SVFLOAT_TEST(__SVFloat16_t,d); +// CHECK: call asm sideeffect "ptrue p0.d, #1 \0Afsub $0.d, p0/m, $0.d, $2.d\0A", "=w,0,w,~{p0}"( %inout1, %in2) + +SVFLOAT_TEST(__SVFloat32_t,s); +// CHECK: call asm sideeffect "ptrue p0.s, #1 \0Afsub $0.s, p0/m, $0.s, $2.s\0A", "=w,0,w,~{p0}"( %inout1, %in2) +SVFLOAT_TEST(__SVFloat32_t,d); +// CHECK: call asm sideeffect "ptrue p0.d, #1 \0Afsub $0.d, p0/m, $0.d, $2.d\0A", "=w,0,w,~{p0}"( %inout1, %in2) + +SVFLOAT_TEST(__SVFloat64_t,s); +// CHECK: call asm sideeffect "ptrue p0.s, #1 \0Afsub $0.s, p0/m, $0.s, $2.s\0A", "=w,0,w,~{p0}"( %inout1, %in2) +SVFLOAT_TEST(__SVFloat64_t,d); +// CHECK: call asm sideeffect "ptrue p0.d, #1 \0Afsub $0.d, p0/m, $0.d, $2.d\0A", "=w,0,w,~{p0}"( %inout1, %in2) + +#define SVFLOAT_TEST_Y(DT, KIND)\ +__SVBool_t func_float_y_##KIND(DT in1, DT in2)\ +{\ + __SVBool_t out;\ + asm volatile (\ + "fmul %[out]." #KIND ", %[in1]." #KIND ", %[in2]." #KIND "\n"\ + : [out] "=w" (out)\ + : [in1] "w" (in1),\ + [in2] "y" (in2)\ + :);\ + return out;\ +} + +SVFLOAT_TEST_Y(__SVFloat16_t,h); +// CHECK: call asm sideeffect "fmul $0.h, $1.h, $2.h\0A", "=w,w,y"( %in1, %in2) +SVFLOAT_TEST_Y(__SVFloat32_t,s); +// CHECK: call asm sideeffect "fmul $0.s, $1.s, $2.s\0A", "=w,w,y"( %in1, %in2) +SVFLOAT_TEST_Y(__SVFloat64_t,d); +// CHECK: call asm sideeffect "fmul $0.d, $1.d, $2.d\0A", "=w,w,y"( %in1, %in2) + + +// Another test for floats to include h suffix + +#define SVFLOAT_CVT_TEST(DT1,KIND1,DT2,KIND2)\ +DT1 func_float_cvt_##DT1##KIND1##DT2##KIND2(DT2 in1)\ +{\ + DT1 out1 ;\ + asm volatile (\ + "ptrue p0." #KIND2 ", #1 \n"\ + "fcvt %[out1]." #KIND1 ", p0/m, %[in1]." #KIND2 "\n"\ + : [out1] "=w" (out1)\ + : [in1] "w" (in1)\ + : "p0");\ + return out1 ;\ +}\ + +SVFLOAT_CVT_TEST(__SVFloat64_t,d,__SVFloat32_t,s); +// CHECK: call asm sideeffect "ptrue p0.s, #1 \0Afcvt $0.d, p0/m, $1.s\0A", "=w,w,~{p0}"( %in1) +SVFLOAT_CVT_TEST(__SVFloat64_t,d,__SVFloat16_t,h); +// CHECK: call asm sideeffect "ptrue p0.h, #1 \0Afcvt $0.d, p0/m, $1.h\0A", "=w,w,~{p0}"( %in1) +SVFLOAT_CVT_TEST(__SVFloat32_t,s,__SVFloat16_t,h); +// CHECK: call asm sideeffect "ptrue p0.h, #1 \0Afcvt $0.s, p0/m, $1.h\0A", "=w,w,~{p0}"( %in1) +SVFLOAT_CVT_TEST(__SVFloat32_t,s,__SVFloat64_t,d); +// CHECK: call asm sideeffect "ptrue p0.d, #1 \0Afcvt $0.s, p0/m, $1.d\0A", "=w,w,~{p0}"( %in1) +SVFLOAT_CVT_TEST(__SVFloat16_t,h,__SVFloat64_t,d); +// CHECK: call asm sideeffect "ptrue p0.d, #1 \0Afcvt $0.h, p0/m, $1.d\0A", "=w,w,~{p0}"( %in1) +SVFLOAT_CVT_TEST(__SVFloat16_t,h,__SVFloat32_t,s); +// CHECK: call asm sideeffect "ptrue p0.s, #1 \0Afcvt $0.h, p0/m, $1.s\0A", "=w,w,~{p0}"( %in1) + +//Test a mix of float and ints +SVFLOAT_CVT_TEST(__SVInt16_t,h,__SVFloat32_t,s); +// CHECK: call asm sideeffect "ptrue p0.s, #1 \0Afcvt $0.h, p0/m, $1.s\0A", "=w,w,~{p0}"( %in1) +SVFLOAT_CVT_TEST(__SVFloat16_t,s,__SVUint32_t,d); +// CHECK: call asm sideeffect "ptrue p0.d, #1 \0Afcvt $0.s, p0/m, $1.d\0A", "=w,w,~{p0}"( %in1) diff --git a/clang/test/CodeGen/aarch64-sve-inline-asm-negative-test.c b/clang/test/CodeGen/aarch64-sve-inline-asm-negative-test.c new file mode 100644 index 00000000000000..ffe7a419469419 --- /dev/null +++ b/clang/test/CodeGen/aarch64-sve-inline-asm-negative-test.c @@ -0,0 +1,21 @@ +// REQUIRES: aarch64-registered-target + +// RUN: not %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns \ +// RUN: -target-feature +neon -S -O1 -o - %s | FileCheck %s + +// Assembler error +// Output constraint : Set a vector constraint on an integer +__SVFloat32_t funcB2() +{ + __SVFloat32_t ret ; + asm volatile ( + "fmov %[ret], wzr \n" + : [ret] "=w" (ret) + : + :); + + return ret ; +} + +// CHECK: funcB2 +// CHECK-ERROR: error: invalid operand for instruction diff --git a/clang/test/CodeGen/mdouble.c b/clang/test/CodeGen/mdouble.c new file mode 100644 index 00000000000000..8399919f702574 --- /dev/null +++ b/clang/test/CodeGen/mdouble.c @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - -triple=avr-unknown-unknown -mdouble=64 | \ +// RUN: FileCheck --check-prefix=AVR-FP64 %s +// RUN: %clang_cc1 %s -emit-llvm -o - -triple=avr-unknown-unknown -mdouble=32 | \ +// RUN: FileCheck --check-prefix=AVR-FP32 %s + +double x = 0; +int size = sizeof(x); + +// FIXME: the double should have an alignment of 1 on AVR, not 4 or 8. +// AVR-FP64: @x = global double {{.*}}, align 8 +// AVR-FP64: @size = global i16 8 +// AVR-FP32: @x = global float {{.*}}, align 4 +// AVR-FP32: @size = global i16 4 diff --git a/clang/test/Driver/mdouble.c b/clang/test/Driver/mdouble.c new file mode 100644 index 00000000000000..408d907053163c --- /dev/null +++ b/clang/test/Driver/mdouble.c @@ -0,0 +1,7 @@ +// RUN: %clang -target avr -c -### %s -mdouble=64 2>&1 | FileCheck %s + +// CHECK: "-mdouble=64" + +// RUN: %clang -target aarch64 -c -### %s -mdouble=64 2>&1 | FileCheck --check-prefix=ERR %s + +// ERR: error: unsupported option '-mdouble=64' for target 'aarch64' diff --git a/clang/test/Driver/memtag.c b/clang/test/Driver/memtag.c new file mode 100644 index 00000000000000..bfe453beef5629 --- /dev/null +++ b/clang/test/Driver/memtag.c @@ -0,0 +1,23 @@ +// REQUIRES: aarch64-registered-target + +// Old pass manager. +// RUN: %clang -fno-experimental-new-pass-manager -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-NO-SAFETY +// RUN: %clang -O1 -fno-experimental-new-pass-manager -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-SAFETY +// RUN: %clang -O2 -fno-experimental-new-pass-manager -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-SAFETY +// RUN: %clang -O3 -fno-experimental-new-pass-manager -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-SAFETY + +// New pass manager. +// RUN: %clang -fexperimental-new-pass-manager -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-NO-SAFETY +// RUN: %clang -O1 -fexperimental-new-pass-manager -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-SAFETY +// RUN: %clang -O2 -fexperimental-new-pass-manager -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-SAFETY +// RUN: %clang -O3 -fexperimental-new-pass-manager -target aarch64-unknown-linux -march=armv8+memtag -fsanitize=memtag %s -S -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-SAFETY + +int z; +__attribute__((noinline)) void use(int *p) { *p = z; } +int foo() { int x; use(&x); return x; } + +// CHECK-NO-SAFETY: define dso_local i32 @foo() +// CHECK-NO-SAFETY: %{{.*}} = alloca i32, align 4{{$}} + +// CHECK-SAFETY: define dso_local i32 @foo() +// CHECK-SAFETY: %{{.*}} = alloca i32, align 4, !stack-safe diff --git a/clang/test/Driver/ps4-runtime-flags.c b/clang/test/Driver/ps4-runtime-flags.c index 315976d4e228e1..3131690304dbf0 100644 --- a/clang/test/Driver/ps4-runtime-flags.c +++ b/clang/test/Driver/ps4-runtime-flags.c @@ -10,10 +10,15 @@ // RUN: %clang -target x86_64-scei-ps4 -fprofile-arcs -fno-profile-arcs %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-NO-PROFILE %s // RUN: %clang -target x86_64-scei-ps4 -fprofile-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-PROFILE %s // RUN: %clang -target x86_64-scei-ps4 -fno-profile-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-NO-PROFILE %s +// RUN: %clang -target x86_64-scei-ps4 -fprofile-generate -fno-profile-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-NO-PROFILE %s // RUN: %clang -target x86_64-scei-ps4 -fprofile-generate=dir %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-PROFILE %s // RUN: %clang -target x86_64-scei-ps4 -fprofile-instr-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-PROFILE %s // RUN: %clang -target x86_64-scei-ps4 -fno-profile-instr-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-NO-PROFILE %s +// RUN: %clang -target x86_64-scei-ps4 -fprofile-instr-generate -fno-profile-instr-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-NO-PROFILE %s +// RUN: %clang -target x86_64-scei-ps4 -fprofile-generate -fno-profile-instr-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-PROFILE %s // RUN: %clang -target x86_64-scei-ps4 -fprofile-instr-generate=somefile.profraw %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-PROFILE %s +// RUN: %clang -target x86_64-scei-ps4 -fcs-profile-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-PROFILE %s +// RUN: %clang -target x86_64-scei-ps4 -fcs-profile-generate -fno-profile-generate %s -### 2>&1 | FileCheck --check-prefix=CHECK-PS4-NO-PROFILE %s // // CHECK-PS4-PROFILE: "--dependent-lib=libclang_rt.profile-x86_64.a" // CHECK-PS4-NO-PROFILE-NOT: "--dependent-lib=libclang_rt.profile-x86_64.a" diff --git a/clang/test/Sema/sizeless-1.c b/clang/test/Sema/sizeless-1.c index 962595b7b1f869..c823823fa00c9d 100644 --- a/clang/test/Sema/sizeless-1.c +++ b/clang/test/Sema/sizeless-1.c @@ -137,11 +137,17 @@ void func(int sel) { dump(&volatile_int8); dump(&const_volatile_int8); + dump(&local_int8 + 1); // expected-error {{arithmetic on a pointer to sizeless type}} + *&local_int8 = local_int8; *&const_int8 = local_int8; // expected-error {{read-only variable is not assignable}} *&volatile_int8 = local_int8; *&const_volatile_int8 = local_int8; // expected-error {{read-only variable is not assignable}} + global_int8_ptr[0] = local_int8; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}} + global_int8_ptr[1] = local_int8; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}} + global_int8_ptr = &global_int8_ptr[2]; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}} + overf(local_int8); overf(local_int16); @@ -154,6 +160,16 @@ void func(int sel) { noproto(local_int8); varargs(1, local_int8, local_int16); + global_int8_ptr++; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr--; // expected-error {{arithmetic on a pointer to sizeless type}} + ++global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}} + --global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr + 1; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr - 1; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr += 1; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr -= 1; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr - global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}} + +init_int8; // expected-error {{invalid argument type 'svint8_t'}} ++init_int8; // expected-error {{cannot increment value of type 'svint8_t'}} init_int8++; // expected-error {{cannot increment value of type 'svint8_t'}} diff --git a/clang/test/SemaCXX/invalid-member-expr.cpp b/clang/test/SemaCXX/invalid-member-expr.cpp index 920d92380e69eb..e0b40794a0ce79 100644 --- a/clang/test/SemaCXX/invalid-member-expr.cpp +++ b/clang/test/SemaCXX/invalid-member-expr.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s class X {}; diff --git a/clang/test/SemaCXX/sizeless-1.cpp b/clang/test/SemaCXX/sizeless-1.cpp index 8b6c00f6e044c5..5cbf1923d7055d 100644 --- a/clang/test/SemaCXX/sizeless-1.cpp +++ b/clang/test/SemaCXX/sizeless-1.cpp @@ -158,11 +158,17 @@ void func(int sel) { dump(&volatile_int8); dump(&const_volatile_int8); + dump(&local_int8 + 1); // expected-error {{arithmetic on a pointer to sizeless type}} + *&local_int8 = local_int8; *&const_int8 = local_int8; // expected-error {{read-only variable is not assignable}} *&volatile_int8 = local_int8; *&const_volatile_int8 = local_int8; // expected-error {{read-only variable is not assignable}} + global_int8_ptr[0] = local_int8; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}} + global_int8_ptr[1] = local_int8; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}} + global_int8_ptr = &global_int8_ptr[2]; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}} + overf(local_int8); overf(local_int16); @@ -174,6 +180,16 @@ void func(int sel) { varargs(1, local_int8, local_int16); + global_int8_ptr++; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr--; // expected-error {{arithmetic on a pointer to sizeless type}} + ++global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}} + --global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr + 1; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr - 1; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr += 1; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr -= 1; // expected-error {{arithmetic on a pointer to sizeless type}} + global_int8_ptr - global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}} + +init_int8; // expected-error {{invalid argument type 'svint8_t'}} ++init_int8; // expected-error {{cannot increment value of type 'svint8_t'}} init_int8++; // expected-error {{cannot increment value of type 'svint8_t'}} @@ -329,6 +345,12 @@ void with_default(svint8_t = svint8_t()); constexpr int ce_taking_int8(svint8_t) { return 1; } // expected-error {{constexpr function's 1st parameter type 'svint8_t' (aka '__SVInt8_t') is not a literal type}} #endif +#if __cplusplus < 201703L +void throwing_func() throw(svint8_t); // expected-error {{sizeless type 'svint8_t' (aka '__SVInt8_t') is not allowed in exception specification}} +void throwing_pointer_func() throw(svint8_t *); +void throwing_reference_func() throw(svint8_t &); // expected-error {{reference to sizeless type 'svint8_t' (aka '__SVInt8_t') is not allowed in exception specification}} +#endif + template void template_fn_direct(T) {} template @@ -373,6 +395,34 @@ void cxx_only(int sel) { local_int16 = static_cast(local_int8); // expected-error {{static_cast from 'svint8_t' (aka '__SVInt8_t') to 'svint16_t' (aka '__SVInt16_t') is not allowed}} sel = static_cast(local_int8); // expected-error {{static_cast from 'svint8_t' (aka '__SVInt8_t') to 'int' is not allowed}} + throw local_int8; // expected-error {{cannot throw object of sizeless type 'svint8_t'}} + throw global_int8_ptr; + + try { + } catch (int) { + } + try { + } catch (svint8_t) { // expected-error {{cannot catch sizeless type 'svint8_t'}} + } + try { + } catch (svint8_t *) { + } + try { + } catch (svint8_t &) { // expected-error {{cannot catch reference to sizeless type 'svint8_t'}} + } + + new svint8_t; // expected-error {{allocation of sizeless type 'svint8_t'}} + new svint8_t(); // expected-error {{allocation of sizeless type 'svint8_t'}} + new svint8_t[10]; // expected-error {{allocation of sizeless type 'svint8_t'}} + new svint8_t *; + + new (global_int8_ptr) svint8_t; // expected-error {{allocation of sizeless type 'svint8_t'}} + new (global_int8_ptr) svint8_t(); // expected-error {{allocation of sizeless type 'svint8_t'}} + new (global_int8_ptr) svint8_t[10]; // expected-error {{allocation of sizeless type 'svint8_t'}} + + delete global_int8_ptr; // expected-error {{cannot delete expression of type 'svint8_t *'}} + delete[] global_int8_ptr; // expected-error {{cannot delete expression of type 'svint8_t *'}} + local_int8.~__SVInt8_t(); // expected-error {{object expression of non-scalar type 'svint8_t' (aka '__SVInt8_t') cannot be used in a pseudo-destructor expression}} (void)svint8_t(); diff --git a/clang/test/SemaCXX/typo-correction.cpp b/clang/test/SemaCXX/typo-correction.cpp index 33dea4d36b3e5f..92a145074e728c 100644 --- a/clang/test/SemaCXX/typo-correction.cpp +++ b/clang/test/SemaCXX/typo-correction.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -fspell-checking-limit 0 -verify -Wno-c++11-extensions %s +// RUN: %clang_cc1 -fspell-checking-limit 0 -verify -Wno-c++11-extensions -std=c++20 %s namespace PR21817{ int a(-rsing[2]); // expected-error {{undeclared identifier 'rsing'; did you mean 'using'?}} @@ -523,8 +524,8 @@ PR18685::BitVector Map; // expected-error-re {{no type named 'BitVector' in nam namespace shadowed_template { template class Fizbin {}; // expected-note {{'::shadowed_template::Fizbin' declared here}} class Baz { - int Fizbin(); - Fizbin qux; // expected-error {{no template named 'Fizbin'; did you mean '::shadowed_template::Fizbin'?}} + int Fizbin; + Fizbin qux; // expected-error {{no template named 'Fizbin'; did you mean '::shadowed_template::Fizbin'?}} }; } diff --git a/clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp b/clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp index a41248ee1b8ef4..cb497176ff0eeb 100644 --- a/clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp +++ b/clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++1y -fms-compatibility -fno-spell-checking -fsyntax-only -verify %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++20 -fms-compatibility -fno-spell-checking -fsyntax-only -verify %s template diff --git a/clang/unittests/Tooling/Syntax/TreeTest.cpp b/clang/unittests/Tooling/Syntax/TreeTest.cpp index 1749e6635a12a9..6e914b6378c863 100644 --- a/clang/unittests/Tooling/Syntax/TreeTest.cpp +++ b/clang/unittests/Tooling/Syntax/TreeTest.cpp @@ -174,17 +174,21 @@ void foo() {} *: TranslationUnit |-SimpleDeclaration | |-int -| |-main -| |-( -| |-) +| |-SimpleDeclarator +| | |-main +| | `-ParametersAndQualifiers +| | |-( +| | `-) | `-CompoundStatement | |-{ | `-} `-SimpleDeclaration |-void - |-foo - |-( - |-) + |-SimpleDeclarator + | |-foo + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ `-} @@ -201,9 +205,11 @@ int main() { *: TranslationUnit `-SimpleDeclaration |-int - |-main - |-( - |-) + |-SimpleDeclarator + | |-main + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-IfStatement @@ -246,9 +252,11 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-ForStatement @@ -268,18 +276,21 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-DeclarationStatement | |-SimpleDeclaration | | |-int - | | |-a - | | |-= - | | `-UnknownExpression - | | `-10 + | | `-SimpleDeclarator + | | |-a + | | |-= + | | `-UnknownExpression + | | `-10 | `-; `-} )txt"}, @@ -287,9 +298,11 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-EmptyStatement @@ -309,9 +322,11 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-SwitchStatement @@ -345,9 +360,11 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-WhileStatement @@ -375,9 +392,11 @@ int test() { return 1; } *: TranslationUnit `-SimpleDeclaration |-int - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-ReturnStatement @@ -398,26 +417,31 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-DeclarationStatement | |-SimpleDeclaration | | |-int - | | |-a - | | |-[ - | | |-UnknownExpression - | | | `-3 - | | `-] + | | `-SimpleDeclarator + | | |-a + | | `-ArraySubscript + | | |-[ + | | |-UnknownExpression + | | | `-3 + | | `-] | `-; |-RangeBasedForStatement | |-for | |-( | |-SimpleDeclaration | | |-int - | | |-x + | | |-SimpleDeclarator + | | | `-x | | `-: | |-UnknownExpression | | `-a @@ -433,9 +457,11 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-main - |-( - |-) + |-SimpleDeclarator + | |-main + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-UnknownStatement @@ -460,9 +486,11 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-ExpressionStatement @@ -500,10 +528,12 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-int - |-* - |-a + |-SimpleDeclarator + | |-* + | `-a |-, - |-b + |-SimpleDeclarator + | `-b `-; )txt"}, {R"cpp( @@ -514,10 +544,12 @@ void test() { `-SimpleDeclaration |-typedef |-int - |-* - |-a + |-SimpleDeclarator + | |-* + | `-a |-, - |-b + |-SimpleDeclarator + | `-b `-; )txt"}, // Multiple declarators inside a statement. @@ -531,27 +563,33 @@ void foo() { *: TranslationUnit `-SimpleDeclaration |-void - |-foo - |-( - |-) + |-SimpleDeclarator + | |-foo + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-DeclarationStatement | |-SimpleDeclaration | | |-int - | | |-* - | | |-a + | | |-SimpleDeclarator + | | | |-* + | | | `-a | | |-, - | | `-b + | | `-SimpleDeclarator + | | `-b | `-; |-DeclarationStatement | |-SimpleDeclaration | | |-typedef | | |-int - | | |-* - | | |-ta + | | |-SimpleDeclarator + | | | |-* + | | | `-ta | | |-, - | | `-tb + | | `-SimpleDeclarator + | | `-tb | `-; `-} )txt"}, @@ -617,23 +655,26 @@ struct {} *a1; |-SimpleDeclaration | |-struct | |-Y -| |-* -| |-y1 +| |-SimpleDeclarator +| | |-* +| | `-y1 | `-; |-SimpleDeclaration | |-struct | |-Y | |-{ | |-} -| |-* -| |-y2 +| |-SimpleDeclarator +| | |-* +| | `-y2 | `-; `-SimpleDeclaration |-struct |-{ |-} - |-* - |-a1 + |-SimpleDeclarator + | |-* + | `-a1 `-; )txt"}, {R"cpp( @@ -666,7 +707,8 @@ using ns::a; | |-{ | |-SimpleDeclaration | | |-int -| | |-a +| | |-SimpleDeclarator +| | | `-a | | `-; | `-} `-UsingDeclaration @@ -766,7 +808,8 @@ extern "C" { int b; int c; } | |-"C" | `-SimpleDeclaration | |-int -| |-a +| |-SimpleDeclarator +| | `-a | `-; `-LinkageSpecificationDeclaration |-extern @@ -774,11 +817,13 @@ extern "C" { int b; int c; } |-{ |-SimpleDeclaration | |-int - | |-b + | |-SimpleDeclarator + | | `-b | `-; |-SimpleDeclaration | |-int - | |-c + | |-SimpleDeclarator + | | `-c | `-; `-} )txt"}, @@ -793,9 +838,11 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-IfStatement @@ -834,9 +881,11 @@ void test() { *: TranslationUnit `-SimpleDeclaration |-void - |-test - |-( - |-) + |-SimpleDeclarator + | |-test + | `-ParametersAndQualifiers + | |-( + | `-) `-CompoundStatement |-{ |-CompoundStatement @@ -855,6 +904,533 @@ void test() { | `-} `-} )txt"}, + // Array subscripts in declarators. + {R"cpp( +int a[10]; +int b[1][2][3]; +int c[] = {1,2,3}; +void f(int xs[static 10]); + )cpp", + R"txt( +*: TranslationUnit +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-a +| | `-ArraySubscript +| | |-[ +| | |-UnknownExpression +| | | `-10 +| | `-] +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-b +| | |-ArraySubscript +| | | |-[ +| | | |-UnknownExpression +| | | | `-1 +| | | `-] +| | |-ArraySubscript +| | | |-[ +| | | |-UnknownExpression +| | | | `-2 +| | | `-] +| | `-ArraySubscript +| | |-[ +| | |-UnknownExpression +| | | `-3 +| | `-] +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-c +| | |-ArraySubscript +| | | |-[ +| | | `-] +| | |-= +| | `-UnknownExpression +| | |-{ +| | |-1 +| | |-, +| | |-2 +| | |-, +| | |-3 +| | `-} +| `-; +`-SimpleDeclaration + |-void + |-SimpleDeclarator + | |-f + | `-ParametersAndQualifiers + | |-( + | |-SimpleDeclaration + | | |-int + | | `-SimpleDeclarator + | | |-xs + | | `-ArraySubscript + | | |-[ + | | |-static + | | |-UnknownExpression + | | | `-10 + | | `-] + | `-) + `-; + )txt"}, + // Parameter lists in declarators. + {R"cpp( +int a() const; +int b() volatile; +int c() &; +int d() &&; +int foo(int a, int b); +int foo( + const int a, + volatile int b, + const volatile int c, + int* d, + int& e, + int&& f +); + )cpp", + R"txt( +*: TranslationUnit +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-a +| | `-ParametersAndQualifiers +| | |-( +| | |-) +| | `-const +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-b +| | `-ParametersAndQualifiers +| | |-( +| | |-) +| | `-volatile +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-c +| | `-ParametersAndQualifiers +| | |-( +| | |-) +| | `-& +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-d +| | `-ParametersAndQualifiers +| | |-( +| | |-) +| | `-&& +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-foo +| | `-ParametersAndQualifiers +| | |-( +| | |-SimpleDeclaration +| | | |-int +| | | `-SimpleDeclarator +| | | `-a +| | |-, +| | |-SimpleDeclaration +| | | |-int +| | | `-SimpleDeclarator +| | | `-b +| | `-) +| `-; +`-SimpleDeclaration + |-int + |-SimpleDeclarator + | |-foo + | `-ParametersAndQualifiers + | |-( + | |-SimpleDeclaration + | | |-const + | | |-int + | | `-SimpleDeclarator + | | `-a + | |-, + | |-SimpleDeclaration + | | |-volatile + | | |-int + | | `-SimpleDeclarator + | | `-b + | |-, + | |-SimpleDeclaration + | | |-const + | | |-volatile + | | |-int + | | `-SimpleDeclarator + | | `-c + | |-, + | |-SimpleDeclaration + | | |-int + | | `-SimpleDeclarator + | | |-* + | | `-d + | |-, + | |-SimpleDeclaration + | | |-int + | | `-SimpleDeclarator + | | |-& + | | `-e + | |-, + | |-SimpleDeclaration + | | |-int + | | `-SimpleDeclarator + | | |-&& + | | `-f + | `-) + `-; + )txt"}, + // Trailing const qualifier. + {R"cpp( +struct X { + int foo() const; +} + )cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-struct + |-X + |-{ + |-SimpleDeclaration + | |-int + | |-SimpleDeclarator + | | |-foo + | | `-ParametersAndQualifiers + | | |-( + | | |-) + | | `-const + | `-; + `-} + )txt"}, + // Trailing return type in parameter lists. + {R"cpp( +auto foo() -> int; + )cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-auto + |-SimpleDeclarator + | |-foo + | `-ParametersAndQualifiers + | |-( + | |-) + | `-TrailingReturnType + | |--> + | `-int + `-; + )txt"}, + // Exception specification in parameter lists. + {R"cpp( +int a() noexcept; +int b() noexcept(true); +int c() throw(); + )cpp", + R"txt( +*: TranslationUnit +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-a +| | `-ParametersAndQualifiers +| | |-( +| | |-) +| | `-noexcept +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-b +| | `-ParametersAndQualifiers +| | |-( +| | |-) +| | |-noexcept +| | |-( +| | |-UnknownExpression +| | | `-true +| | `-) +| `-; +`-SimpleDeclaration + |-int + |-SimpleDeclarator + | |-c + | `-ParametersAndQualifiers + | |-( + | |-) + | |-throw + | |-( + | `-) + `-; + )txt"}, + // Declarators in parentheses. + {R"cpp( +int (a); +int *(b); +int (*c)(int); +int *(d)(int); + )cpp", + R"txt( +*: TranslationUnit +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | `-ParenDeclarator +| | |-( +| | |-a +| | `-) +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-* +| | `-ParenDeclarator +| | |-( +| | |-b +| | `-) +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-ParenDeclarator +| | | |-( +| | | |-* +| | | |-c +| | | `-) +| | `-ParametersAndQualifiers +| | |-( +| | |-SimpleDeclaration +| | | `-int +| | `-) +| `-; +`-SimpleDeclaration + |-int + |-SimpleDeclarator + | |-* + | |-ParenDeclarator + | | |-( + | | |-d + | | `-) + | `-ParametersAndQualifiers + | |-( + | |-SimpleDeclaration + | | `-int + | `-) + `-; + )txt"}, + // CV qualifiers. + {R"cpp( +const int west = -1; +int const east = 1; +const int const universal = 0; +const int const *const *volatile b; + )cpp", + R"txt( +*: TranslationUnit +|-SimpleDeclaration +| |-const +| |-int +| |-SimpleDeclarator +| | |-west +| | |-= +| | `-UnknownExpression +| | |-- +| | `-1 +| `-; +|-SimpleDeclaration +| |-int +| |-const +| |-SimpleDeclarator +| | |-east +| | |-= +| | `-UnknownExpression +| | `-1 +| `-; +|-SimpleDeclaration +| |-const +| |-int +| |-const +| |-SimpleDeclarator +| | |-universal +| | |-= +| | `-UnknownExpression +| | `-0 +| `-; +`-SimpleDeclaration + |-const + |-int + |-const + |-SimpleDeclarator + | |-* + | |-const + | |-* + | |-volatile + | `-b + `-; + )txt"}, + // Ranges of declarators with trailing return types. + {R"cpp( +auto foo() -> auto(*)(int) -> double*; + )cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-auto + |-SimpleDeclarator + | |-foo + | `-ParametersAndQualifiers + | |-( + | |-) + | `-TrailingReturnType + | |--> + | |-auto + | `-SimpleDeclarator + | |-ParenDeclarator + | | |-( + | | |-* + | | `-) + | `-ParametersAndQualifiers + | |-( + | |-SimpleDeclaration + | | `-int + | |-) + | `-TrailingReturnType + | |--> + | |-double + | `-SimpleDeclarator + | `-* + `-; + )txt"}, + // Member pointers. + {R"cpp( +struct X {}; +int X::* a; +const int X::* b; + )cpp", + R"txt( +*: TranslationUnit +|-SimpleDeclaration +| |-struct +| |-X +| |-{ +| |-} +| `-; +|-SimpleDeclaration +| |-int +| |-SimpleDeclarator +| | |-MemberPointer +| | | |-X +| | | |-:: +| | | `-* +| | `-a +| `-; +`-SimpleDeclaration + |-const + |-int + |-SimpleDeclarator + | |-MemberPointer + | | |-X + | | |-:: + | | `-* + | `-b + `-; + )txt"}, + // All-in-one tests. + {R"cpp( +void x(char a, short (*b)(int)); + )cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-void + |-SimpleDeclarator + | |-x + | `-ParametersAndQualifiers + | |-( + | |-SimpleDeclaration + | | |-char + | | `-SimpleDeclarator + | | `-a + | |-, + | |-SimpleDeclaration + | | |-short + | | `-SimpleDeclarator + | | |-ParenDeclarator + | | | |-( + | | | |-* + | | | |-b + | | | `-) + | | `-ParametersAndQualifiers + | | |-( + | | |-SimpleDeclaration + | | | `-int + | | `-) + | `-) + `-; + )txt"}, + {R"cpp( +void x(char a, short (*b)(int), long (**c)(long long)); + )cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-void + |-SimpleDeclarator + | |-x + | `-ParametersAndQualifiers + | |-( + | |-SimpleDeclaration + | | |-char + | | `-SimpleDeclarator + | | `-a + | |-, + | |-SimpleDeclaration + | | |-short + | | `-SimpleDeclarator + | | |-ParenDeclarator + | | | |-( + | | | |-* + | | | |-b + | | | `-) + | | `-ParametersAndQualifiers + | | |-( + | | |-SimpleDeclaration + | | | `-int + | | `-) + | |-, + | |-SimpleDeclaration + | | |-long + | | `-SimpleDeclarator + | | |-ParenDeclarator + | | | |-( + | | | |-* + | | | |-* + | | | |-c + | | | `-) + | | `-ParametersAndQualifiers + | | |-( + | | |-SimpleDeclaration + | | | |-long + | | | `-long + | | `-) + | `-) + `-; + )txt"}, }; for (const auto &T : Cases) { diff --git a/clang/utils/TableGen/SveEmitter.cpp b/clang/utils/TableGen/SveEmitter.cpp index 1f342df74a914a..9eb4c01a935812 100644 --- a/clang/utils/TableGen/SveEmitter.cpp +++ b/clang/utils/TableGen/SveEmitter.cpp @@ -29,7 +29,6 @@ #include "llvm/ADT/StringExtras.h" #include "llvm/TableGen/Record.h" #include "llvm/TableGen/Error.h" -#include "clang/Basic/AArch64SVETypeFlags.h" #include #include #include @@ -37,535 +36,26 @@ using namespace llvm; -enum ClassKind { - ClassNone, - ClassS, // signed/unsigned, e.g., "_s8", "_u8" suffix - ClassG, // Overloaded name without type suffix -}; - -using TypeSpec = std::string; -using SVETypeFlags = clang::SVETypeFlags; +//===----------------------------------------------------------------------===// +// SVEEmitter +//===----------------------------------------------------------------------===// namespace { -class SVEType { - TypeSpec TS; - bool Float, Signed, Immediate, Void, Constant, Pointer; - bool DefaultType, IsScalable, Predicate, PredicatePattern, PrefetchOp; - unsigned Bitwidth, ElementBitwidth, NumVectors; - -public: - SVEType() : SVEType(TypeSpec(), 'v') {} - - SVEType(TypeSpec TS, char CharMod) - : TS(TS), Float(false), Signed(true), Immediate(false), Void(false), - Constant(false), Pointer(false), DefaultType(false), IsScalable(true), - Predicate(false), PredicatePattern(false), PrefetchOp(false), - Bitwidth(128), ElementBitwidth(~0U), NumVectors(1) { - if (!TS.empty()) - applyTypespec(); - applyModifier(CharMod); - } - - /// Return the value in SVETypeFlags for this type. - unsigned getTypeFlags() const; - - bool isPointer() const { return Pointer; } - bool isVoidPointer() const { return Pointer && Void; } - bool isSigned() const { return Signed; } - bool isImmediate() const { return Immediate; } - bool isScalar() const { return NumVectors == 0; } - bool isVector() const { return NumVectors > 0; } - bool isScalableVector() const { return isVector() && IsScalable; } - bool isChar() const { return ElementBitwidth == 8; } - bool isVoid() const { return Void & !Pointer; } - bool isDefault() const { return DefaultType; } - bool isFloat() const { return Float; } - bool isInteger() const { return !Float && !Predicate; } - bool isScalarPredicate() const { return !Float && ElementBitwidth == 1; } - bool isPredicateVector() const { return Predicate; } - bool isPredicatePattern() const { return PredicatePattern; } - bool isPrefetchOp() const { return PrefetchOp; } - bool isConstant() const { return Constant; } - unsigned getElementSizeInBits() const { return ElementBitwidth; } - unsigned getNumVectors() const { return NumVectors; } - - unsigned getNumElements() const { - assert(ElementBitwidth != ~0U); - return Bitwidth / ElementBitwidth; - } - unsigned getSizeInBits() const { - return Bitwidth; - } - - /// Return the string representation of a type, which is an encoded - /// string for passing to the BUILTIN() macro in Builtins.def. - std::string builtin_str() const; - -private: - /// Creates the type based on the typespec string in TS. - void applyTypespec(); - - /// Applies a prototype modifier to the type. - void applyModifier(char Mod); -}; - - -class SVEEmitter; - -/// The main grunt class. This represents an instantiation of an intrinsic with -/// a particular typespec and prototype. -class Intrinsic { - /// The unmangled name. - std::string Name; - - /// The name of the corresponding LLVM IR intrinsic. - std::string LLVMName; - - /// Intrinsic prototype. - std::string Proto; - - /// The base type spec for this intrinsic. - TypeSpec BaseTypeSpec; - - /// The base class kind. Most intrinsics use ClassS, which has full type - /// info for integers (_s32/_u32), or ClassG which is used for overloaded - /// intrinsics. - ClassKind Class; - - /// The architectural #ifdef guard. - std::string Guard; - - /// The types of return value [0] and parameters [1..]. - std::vector Types; - - /// The "base type", which is VarType('d', BaseTypeSpec). - SVEType BaseType; - - /// The type of the memory element - enum MemEltType { - MemEltTypeDefault, - MemEltTypeInt8, - MemEltTypeInt16, - MemEltTypeInt32, - MemEltTypeInt64, - MemEltTypeInvalid - } MemEltTy; - - SVETypeFlags Flags; - -public: - /// The type of predication. - enum MergeType { - MergeNone, - MergeAny, - MergeOp1, - MergeZero, - MergeAnyExp, - MergeZeroExp, - MergeInvalid - } Merge; - - Intrinsic(StringRef Name, StringRef Proto, int64_t MT, int64_t MET, - StringRef LLVMName, SVETypeFlags Flags, TypeSpec BT, ClassKind Class, - SVEEmitter &Emitter, StringRef Guard) - : Name(Name.str()), LLVMName(LLVMName), Proto(Proto.str()), - BaseTypeSpec(BT), Class(Class), Guard(Guard.str()), BaseType(BT, 'd'), - MemEltTy(MemEltType(MET)), Flags(Flags), Merge(MergeType(MT)) { - // Types[0] is the return value. - for (unsigned I = 0; I < Proto.size(); ++I) - Types.emplace_back(BaseTypeSpec, Proto[I]); - } - - ~Intrinsic()=default; - - std::string getName() const { return Name; } - std::string getLLVMName() const { return LLVMName; } - std::string getProto() const { return Proto; } - TypeSpec getBaseTypeSpec() const { return BaseTypeSpec; } - SVEType getBaseType() const { return BaseType; } - - StringRef getGuard() const { return Guard; } - ClassKind getClassKind() const { return Class; } - MergeType getMergeType() const { return Merge; } - - SVEType getReturnType() const { return Types[0]; } - ArrayRef getTypes() const { return Types; } - SVEType getParamType(unsigned I) const { return Types[I + 1]; } - unsigned getNumParams() const { return Proto.size() - 1; } - - SVETypeFlags getFlags() const { return Flags; } - bool isFlagSet(uint64_t Flag) const { return Flags.isFlagSet(Flag);} - - int64_t getMemEltTypeEnum() const { - int64_t METEnum = (MemEltTy << SVETypeFlags::MemEltTypeOffset); - assert((METEnum &~ SVETypeFlags::MemEltTypeMask) == 0 && "Bad MemEltTy"); - return METEnum; - } - - /// Return the type string for a BUILTIN() macro in Builtins.def. - std::string getBuiltinTypeStr(); - - /// Return the name, mangled with type information. The name is mangled for - /// ClassS, so will add type suffixes such as _u32/_s32. - std::string getMangledName() const { return mangleName(ClassS); } - - /// Returns true if the intrinsic is overloaded, in that it should also generate - /// a short form without the type-specifiers, e.g. 'svld1(..)' instead of - /// 'svld1_u32(..)'. - static bool isOverloadedIntrinsic(StringRef Name) { - auto BrOpen = Name.find("["); - auto BrClose = Name.find(']'); - return BrOpen != std::string::npos && BrClose != std::string::npos; - } - - /// Emits the intrinsic declaration to the ostream. - void emitIntrinsic(raw_ostream &OS) const; - -private: - std::string getMergeSuffix() const; - std::string mangleName(ClassKind LocalCK) const; - std::string replaceTemplatedArgs(std::string Name, TypeSpec TS, - std::string Proto) const; -}; - class SVEEmitter { -private: - RecordKeeper &Records; - public: - SVEEmitter(RecordKeeper &R) : Records(R) {} - - /// Emit arm_sve.h. - void createHeader(raw_ostream &o); - - /// Emit all the __builtin prototypes and code needed by Sema. - void createBuiltins(raw_ostream &o); - - /// Emit all the information needed to map builtin -> LLVM IR intrinsic. - void createCodeGenMap(raw_ostream &o); - - /// Create intrinsic and add it to \p Out - void createIntrinsic(Record *R, SmallVectorImpl> &Out); + // run - Emit arm_sve.h + void run(raw_ostream &o); }; } // end anonymous namespace -//===----------------------------------------------------------------------===// -// Type implementation -//===----------------------------------------------------------------------===// - -unsigned SVEType::getTypeFlags() const { - if (isFloat()) { - switch (ElementBitwidth) { - case 16: return SVETypeFlags::Float16; - case 32: return SVETypeFlags::Float32; - case 64: return SVETypeFlags::Float64; - default: llvm_unreachable("Unhandled float element bitwidth!"); - } - } - - if (isPredicateVector()) { - switch (ElementBitwidth) { - case 8: return SVETypeFlags::Bool8; - case 16: return SVETypeFlags::Bool16; - case 32: return SVETypeFlags::Bool32; - case 64: return SVETypeFlags::Bool64; - default: llvm_unreachable("Unhandled predicate element bitwidth!"); - } - } - - switch (ElementBitwidth) { - case 8: return SVETypeFlags::Int8; - case 16: return SVETypeFlags::Int16; - case 32: return SVETypeFlags::Int32; - case 64: return SVETypeFlags::Int64; - default: llvm_unreachable("Unhandled integer element bitwidth!"); - } -} - -std::string SVEType::builtin_str() const { - std::string S; - if (isVoid()) - return "v"; - - if (isVoidPointer()) - S += "v"; - else if (!Float) - switch (ElementBitwidth) { - case 1: S += "b"; break; - case 8: S += "c"; break; - case 16: S += "s"; break; - case 32: S += "i"; break; - case 64: S += "Wi"; break; - case 128: S += "LLLi"; break; - default: llvm_unreachable("Unhandled case!"); - } - else - switch (ElementBitwidth) { - case 16: S += "h"; break; - case 32: S += "f"; break; - case 64: S += "d"; break; - default: llvm_unreachable("Unhandled case!"); - } - - if (!isFloat()) { - if ((isChar() || isPointer()) && !isVoidPointer()) { - // Make chars and typed pointers explicitly signed. - if (Signed) - S = "S" + S; - else if (!Signed) - S = "U" + S; - } else if (!isVoidPointer() && !Signed) { - S = "U" + S; - } - } - - // Constant indices are "int", but have the "constant expression" modifier. - if (isImmediate()) { - assert(!isFloat() && "fp immediates are not supported"); - S = "I" + S; - } - - if (isScalar()) { - if (Constant) S += "C"; - if (Pointer) S += "*"; - return S; - } - - assert(isScalableVector() && "Unsupported type"); - return "q" + utostr(getNumElements() * NumVectors) + S; -} - -void SVEType::applyTypespec() { - for (char I : TS) { - switch (I) { - case 'P': - Predicate = true; - ElementBitwidth = 1; - break; - case 'U': - Signed = false; - break; - case 'c': - ElementBitwidth = 8; - break; - case 's': - ElementBitwidth = 16; - break; - case 'i': - ElementBitwidth = 32; - break; - case 'l': - ElementBitwidth = 64; - break; - case 'h': - Float = true; - ElementBitwidth = 16; - break; - case 'f': - Float = true; - ElementBitwidth = 32; - break; - case 'd': - Float = true; - ElementBitwidth = 64; - break; - default: - llvm_unreachable("Unhandled type code!"); - } - } - assert(ElementBitwidth != ~0U && "Bad element bitwidth!"); -} - -void SVEType::applyModifier(char Mod) { - switch (Mod) { - case 'v': - Void = true; - break; - case 'd': - DefaultType = true; - break; - case 'c': - Constant = true; - LLVM_FALLTHROUGH; - case 'p': - Pointer = true; - Bitwidth = ElementBitwidth; - NumVectors = 0; - break; - case 'P': - Signed = true; - Float = false; - Predicate = true; - Bitwidth = 16; - ElementBitwidth = 1; - break; - default: - llvm_unreachable("Unhandled character!"); - } -} - - -//===----------------------------------------------------------------------===// -// Intrinsic implementation -//===----------------------------------------------------------------------===// - -std::string Intrinsic::getBuiltinTypeStr() { - std::string S; - - SVEType RetT = getReturnType(); - // Since the return value must be one type, return a vector type of the - // appropriate width which we will bitcast. An exception is made for - // returning structs of 2, 3, or 4 vectors which are returned in a sret-like - // fashion, storing them to a pointer arg. - if (RetT.getNumVectors() > 1) { - S += "vv*"; // void result with void* first argument - } else - S += RetT.builtin_str(); - - for (unsigned I = 0; I < getNumParams(); ++I) - S += getParamType(I).builtin_str(); - - return S; -} - -std::string Intrinsic::replaceTemplatedArgs(std::string Name, TypeSpec TS, - std::string Proto) const { - std::string Ret = Name; - while (Ret.find('{') != std::string::npos) { - size_t Pos = Ret.find('{'); - size_t End = Ret.find('}'); - unsigned NumChars = End - Pos + 1; - assert(NumChars == 3 && "Unexpected template argument"); - - SVEType T; - char C = Ret[Pos+1]; - switch(C) { - default: - llvm_unreachable("Unknown predication specifier"); - case 'd': - T = SVEType(TS, 'd'); - break; - case '0': - case '1': - case '2': - case '3': - T = SVEType(TS, Proto[C - '0']); - break; - } - - // Replace templated arg with the right suffix (e.g. u32) - std::string TypeCode; - if (T.isInteger()) - TypeCode = T.isSigned() ? 's' : 'u'; - else if (T.isPredicateVector()) - TypeCode = 'b'; - else - TypeCode = 'f'; - Ret.replace(Pos, NumChars, TypeCode + utostr(T.getElementSizeInBits())); - } - - return Ret; -} - -// ACLE function names have a merge style postfix. -std::string Intrinsic::getMergeSuffix() const { - switch (getMergeType()) { - default: - llvm_unreachable("Unknown predication specifier"); - case MergeNone: return ""; - case MergeAny: - case MergeAnyExp: return "_x"; - case MergeOp1: return "_m"; - case MergeZero: - case MergeZeroExp: return "_z"; - } -} - -std::string Intrinsic::mangleName(ClassKind LocalCK) const { - std::string S = getName(); - - if (LocalCK == ClassG) { - // Remove the square brackets and everything in between. - while (S.find("[") != std::string::npos) { - auto Start = S.find("["); - auto End = S.find(']'); - S.erase(Start, (End-Start)+1); - } - } else { - // Remove the square brackets. - while (S.find("[") != std::string::npos) { - auto BrPos = S.find('['); - if (BrPos != std::string::npos) - S.erase(BrPos, 1); - BrPos = S.find(']'); - if (BrPos != std::string::npos) - S.erase(BrPos, 1); - } - } - - // Replace all {d} like expressions with e.g. 'u32' - return replaceTemplatedArgs(S, getBaseTypeSpec(), getProto()) + - getMergeSuffix(); -} - -void Intrinsic::emitIntrinsic(raw_ostream &OS) const { - // Use the preprocessor to enable the non-overloaded builtins. - if (getClassKind() != ClassG || getProto().size() <= 1) { - OS << "#define " << mangleName(getClassKind()) - << "(...) __builtin_sve_" << mangleName(ClassS) - << "(__VA_ARGS__)\n"; - } else { - llvm_unreachable("Not yet implemented. Overloaded intrinsics will follow " - "in a future patch"); - } -} - //===----------------------------------------------------------------------===// // SVEEmitter implementation //===----------------------------------------------------------------------===// -void SVEEmitter::createIntrinsic( - Record *R, SmallVectorImpl> &Out) { - StringRef Name = R->getValueAsString("Name"); - StringRef Proto = R->getValueAsString("Prototype"); - StringRef Types = R->getValueAsString("Types"); - StringRef Guard = R->getValueAsString("ArchGuard"); - StringRef LLVMName = R->getValueAsString("LLVMIntrinsic"); - int64_t Merge = R->getValueAsInt("Merge"); - std::vector FlagsList = R->getValueAsListOfDefs("Flags"); - int64_t MemEltType = R->getValueAsInt("MemEltType"); - - int64_t Flags = 0; - for (auto FlagRec : FlagsList) - Flags |= FlagRec->getValueAsInt("Value"); - - // Extract type specs from string - SmallVector TypeSpecs; - TypeSpec Acc; - for (char I : Types) { - Acc.push_back(I); - if (islower(I)) { - TypeSpecs.push_back(TypeSpec(Acc)); - Acc.clear(); - } - } - - // Remove duplicate type specs. - std::sort(TypeSpecs.begin(), TypeSpecs.end()); - TypeSpecs.erase(std::unique(TypeSpecs.begin(), TypeSpecs.end()), - TypeSpecs.end()); - // Create an Intrinsic for each type spec. - for (auto TS : TypeSpecs) { - Out.push_back(std::make_unique(Name, Proto, Merge, MemEltType, - LLVMName, Flags, TS, ClassS, - *this, Guard)); - } -} - -void SVEEmitter::createHeader(raw_ostream &OS) { +void SVEEmitter::run(raw_ostream &OS) { OS << "/*===---- arm_sve.h - ARM SVE intrinsics " "-----------------------------------===\n" " *\n" @@ -587,9 +77,7 @@ void SVEEmitter::createHeader(raw_ostream &OS) { OS << "#else\n\n"; OS << "#include \n\n"; - OS << "#ifdef __cplusplus\n"; - OS << "extern \"C\" {\n"; - OS << "#else\n"; + OS << "#ifndef __cplusplus\n"; OS << "#include \n"; OS << "#endif\n\n"; @@ -611,120 +99,25 @@ void SVEEmitter::createHeader(raw_ostream &OS) { OS << "typedef __SVFloat64_t svfloat64_t;\n"; OS << "typedef __SVBool_t svbool_t;\n\n"; - SmallVector, 128> Defs; - std::vector RV = Records.getAllDerivedDefinitions("Inst"); - for (auto *R : RV) - createIntrinsic(R, Defs); - - // Sort intrinsics in header file by following order/priority: - // - Architectural guard (i.e. does it require SVE2 or SVE2_AES) - // - Class (is intrinsic overloaded or not) - // - Intrinsic name - std::stable_sort( - Defs.begin(), Defs.end(), [](const std::unique_ptr &A, - const std::unique_ptr &B) { - return A->getGuard() < B->getGuard() || - (unsigned)A->getClassKind() < (unsigned)B->getClassKind() || - A->getName() < B->getName(); - }); - - StringRef InGuard = ""; - for (auto &I : Defs) { - // Emit #endif/#if pair if needed. - if (I->getGuard() != InGuard) { - if (!InGuard.empty()) - OS << "#endif //" << InGuard << "\n"; - InGuard = I->getGuard(); - if (!InGuard.empty()) - OS << "\n#if " << InGuard << "\n"; - } - - // Actually emit the intrinsic declaration. - I->emitIntrinsic(OS); - } - - if (!InGuard.empty()) - OS << "#endif //" << InGuard << "\n"; - - OS << "#ifdef __cplusplus\n"; - OS << "} // extern \"C\"\n"; - OS << "#endif\n\n"; - OS << "#endif /*__ARM_FEATURE_SVE */\n\n"; + OS << "#define svld1_u8(...) __builtin_sve_svld1_u8(__VA_ARGS__)\n"; + OS << "#define svld1_u16(...) __builtin_sve_svld1_u16(__VA_ARGS__)\n"; + OS << "#define svld1_u32(...) __builtin_sve_svld1_u32(__VA_ARGS__)\n"; + OS << "#define svld1_u64(...) __builtin_sve_svld1_u64(__VA_ARGS__)\n"; + OS << "#define svld1_s8(...) __builtin_sve_svld1_s8(__VA_ARGS__)\n"; + OS << "#define svld1_s16(...) __builtin_sve_svld1_s16(__VA_ARGS__)\n"; + OS << "#define svld1_s32(...) __builtin_sve_svld1_s32(__VA_ARGS__)\n"; + OS << "#define svld1_s64(...) __builtin_sve_svld1_s64(__VA_ARGS__)\n"; + OS << "#define svld1_f16(...) __builtin_sve_svld1_f16(__VA_ARGS__)\n"; + OS << "#define svld1_f32(...) __builtin_sve_svld1_f32(__VA_ARGS__)\n"; + OS << "#define svld1_f64(...) __builtin_sve_svld1_f64(__VA_ARGS__)\n"; + + OS << "#endif /*__ARM_FEATURE_SVE */\n"; OS << "#endif /* __ARM_SVE_H */\n"; } -void SVEEmitter::createBuiltins(raw_ostream &OS) { - std::vector RV = Records.getAllDerivedDefinitions("Inst"); - SmallVector, 128> Defs; - for (auto *R : RV) - createIntrinsic(R, Defs); - - // The mappings must be sorted based on BuiltinID. - llvm::sort(Defs, [](const std::unique_ptr &A, - const std::unique_ptr &B) { - return A->getMangledName() < B->getMangledName(); - }); - - OS << "#ifdef GET_SVE_BUILTINS\n"; - for (auto &Def : Defs) { - // Only create BUILTINs for non-overloaded intrinsics, as overloaded - // declarations only live in the header file. - if (Def->getClassKind() != ClassG) - OS << "BUILTIN(__builtin_sve_" << Def->getMangledName() << ", \"" - << Def->getBuiltinTypeStr() << "\", \"n\")\n"; - } - OS << "#endif\n\n"; -} - -void SVEEmitter::createCodeGenMap(raw_ostream &OS) { - std::vector RV = Records.getAllDerivedDefinitions("Inst"); - SmallVector, 128> Defs; - for (auto *R : RV) - createIntrinsic(R, Defs); - - // The mappings must be sorted based on BuiltinID. - llvm::sort(Defs, [](const std::unique_ptr &A, - const std::unique_ptr &B) { - return A->getMangledName() < B->getMangledName(); - }); - - OS << "#ifdef GET_SVE_LLVM_INTRINSIC_MAP\n"; - for (auto &Def : Defs) { - // Builtins only exist for non-overloaded intrinsics, overloaded - // declarations only live in the header file. - if (Def->getClassKind() == ClassG) - continue; - - assert(!Def->isFlagSet(SVETypeFlags::EltTypeMask) && - !Def->isFlagSet(SVETypeFlags::MemEltTypeMask) && - "Unexpected mask value"); - uint64_t Flags = Def->getFlags().getBits() | - Def->getBaseType().getTypeFlags() | - Def->getMemEltTypeEnum(); - auto FlagString = std::to_string(Flags); - - std::string LLVMName = Def->getLLVMName(); - std::string Builtin = Def->getMangledName(); - if (!LLVMName.empty()) - OS << "SVEMAP1(" << Builtin << ", " << LLVMName << ", " << FlagString - << "),\n"; - else - OS << "SVEMAP2(" << Builtin << ", " << FlagString << "),\n"; - } - OS << "#endif\n\n"; -} - namespace clang { void EmitSveHeader(RecordKeeper &Records, raw_ostream &OS) { - SVEEmitter(Records).createHeader(OS); -} - -void EmitSveBuiltins(RecordKeeper &Records, raw_ostream &OS) { - SVEEmitter(Records).createBuiltins(OS); -} - -void EmitSveCodeGenMap(RecordKeeper &Records, raw_ostream &OS) { - SVEEmitter(Records).createCodeGenMap(OS); + SVEEmitter().run(OS); } } // End namespace clang diff --git a/clang/utils/TableGen/TableGen.cpp b/clang/utils/TableGen/TableGen.cpp index 3d61a9bf8e6e45..b0f9120416bc29 100644 --- a/clang/utils/TableGen/TableGen.cpp +++ b/clang/utils/TableGen/TableGen.cpp @@ -71,8 +71,6 @@ enum ActionType { GenArmMveBuiltinCG, GenArmMveBuiltinAliases, GenArmSveHeader, - GenArmSveBuiltins, - GenArmSveCodeGenMap, GenArmCdeHeader, GenArmCdeBuiltinDef, GenArmCdeBuiltinSema, @@ -190,10 +188,6 @@ cl::opt Action( "Generate ARM NEON tests for clang"), clEnumValN(GenArmSveHeader, "gen-arm-sve-header", "Generate arm_sve.h for clang"), - clEnumValN(GenArmSveBuiltins, "gen-arm-sve-builtins", - "Generate arm_sve_builtins.inc for clang"), - clEnumValN(GenArmSveCodeGenMap, "gen-arm-sve-codegenmap", - "Generate arm_sve_codegenmap.inc for clang"), clEnumValN(GenArmMveHeader, "gen-arm-mve-header", "Generate arm_mve.h for clang"), clEnumValN(GenArmMveBuiltinDef, "gen-arm-mve-builtin-def", @@ -378,12 +372,6 @@ bool ClangTableGenMain(raw_ostream &OS, RecordKeeper &Records) { case GenArmSveHeader: EmitSveHeader(Records, OS); break; - case GenArmSveBuiltins: - EmitSveBuiltins(Records, OS); - break; - case GenArmSveCodeGenMap: - EmitSveCodeGenMap(Records, OS); - break; case GenArmCdeHeader: EmitCdeHeader(Records, OS); break; diff --git a/clang/utils/TableGen/TableGenBackends.h b/clang/utils/TableGen/TableGenBackends.h index fb19dcc7588d6b..3ff6b26c40526e 100644 --- a/clang/utils/TableGen/TableGenBackends.h +++ b/clang/utils/TableGen/TableGenBackends.h @@ -92,8 +92,6 @@ void EmitNeonSema2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitNeonTest2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitSveHeader(llvm::RecordKeeper &Records, llvm::raw_ostream &OS); -void EmitSveBuiltins(llvm::RecordKeeper &Records, llvm::raw_ostream &OS); -void EmitSveCodeGenMap(llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitMveHeader(llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitMveBuiltinDef(llvm::RecordKeeper &Records, llvm::raw_ostream &OS); diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h b/compiler-rt/lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h index f806ee1ea4f56c..5c8d3c27dc90c8 100644 --- a/compiler-rt/lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h +++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h @@ -35,9 +35,9 @@ struct PthreadHelperCreateThreadInfo { inline DWORD WINAPI PthreadHelperThreadProc(void *arg) { PthreadHelperCreateThreadInfo *start_data = reinterpret_cast(arg); - void *ret = (start_data->start_routine)(start_data->arg); + (start_data->start_routine)(start_data->arg); delete start_data; - return (DWORD)ret; + return 0; } inline void PTHREAD_CREATE(pthread_t *thread, void *attr, @@ -60,7 +60,7 @@ inline void PTHREAD_JOIN(pthread_t thread, void **value_ptr) { inline void pthread_exit(void *retval) { ASSERT_EQ(0, retval) << "Nonzero retval is not supported yet."; - ExitThread((DWORD)retval); + ExitThread(0); } #endif // _WIN32 diff --git a/compiler-rt/test/asan/TestCases/Posix/no-fd.cpp b/compiler-rt/test/asan/TestCases/Posix/no-fd.cpp index ee355b5dc10174..6f8b2f4e15b0ae 100644 --- a/compiler-rt/test/asan/TestCases/Posix/no-fd.cpp +++ b/compiler-rt/test/asan/TestCases/Posix/no-fd.cpp @@ -6,8 +6,9 @@ // This test closes the 0, 1, and 2 file descriptors before an exec() and relies // on them remaining closed across an execve(). This is not the case on newer -// versions of Android. -// UNSUPPORTED: android +// versions of Android. On PPC with ASLR turned on, this fails when linked with +// lld - see https://bugs.llvm.org/show_bug.cgi?id=45076. +// UNSUPPORTED: android, powerpc #include #include diff --git a/debuginfo-tests/dexter/dex/dextIR/DextIR.py b/debuginfo-tests/dexter/dex/dextIR/DextIR.py index 7638e8b4ab7870..b82c2bab56decf 100644 --- a/debuginfo-tests/dexter/dex/dextIR/DextIR.py +++ b/debuginfo-tests/dexter/dex/dextIR/DextIR.py @@ -102,6 +102,10 @@ def _get_new_step_kind(self, context, step): frame_step = self._get_prev_step_in_this_frame(step) prev_step = frame_step if frame_step is not None else prev_step + # If we're missing line numbers to compare then the step kind has to be UNKNOWN. + if prev_step.current_location.lineno is None or step.current_location.lineno is None: + return StepKind.UNKNOWN + # We're in the same func as prev step, check lineo. if prev_step.current_location.lineno > step.current_location.lineno: return StepKind.VERTICAL_BACKWARD diff --git a/libc/AOR_v20.02/Makefile b/libc/AOR_v20.02/Makefile new file mode 100644 index 00000000000000..53e0245f82c402 --- /dev/null +++ b/libc/AOR_v20.02/Makefile @@ -0,0 +1,90 @@ +# Makefile - requires GNU make +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +srcdir = . +prefix = /usr +bindir = $(prefix)/bin +libdir = $(prefix)/lib +includedir = $(prefix)/include + +# Configure these in config.mk, do not make changes in this file. +SUBS = math string networking +HOST_CC = cc +HOST_CFLAGS = -std=c99 -O2 +HOST_LDFLAGS = +HOST_LDLIBS = +EMULATOR = +CPPFLAGS = +CFLAGS = -std=c99 -O2 +CFLAGS_SHARED = -fPIC +CFLAGS_ALL = -Ibuild/include $(CPPFLAGS) $(CFLAGS) +LDFLAGS = +LDLIBS = +AR = $(CROSS_COMPILE)ar +RANLIB = $(CROSS_COMPILE)ranlib +INSTALL = install + +all: + +-include config.mk + +$(foreach sub,$(SUBS),$(eval include $(srcdir)/$(sub)/Dir.mk)) + +# Required targets of subproject foo: +# all-foo +# check-foo +# clean-foo +# install-foo +# Required make variables of subproject foo: +# foo-files: Built files (all in build/). +# Make variables used by subproject foo: +# foo-...: Variables defined in foo/Dir.mk or by config.mk. + +all: $(SUBS:%=all-%) + +ALL_FILES = $(foreach sub,$(SUBS),$($(sub)-files)) +DIRS = $(sort $(patsubst %/,%,$(dir $(ALL_FILES)))) +$(ALL_FILES): | $(DIRS) +$(DIRS): + mkdir -p $@ + +$(filter %.os,$(ALL_FILES)): CFLAGS_ALL += $(CFLAGS_SHARED) + +build/%.o: $(srcdir)/%.S + $(CC) $(CFLAGS_ALL) -c -o $@ $< + +build/%.o: $(srcdir)/%.c + $(CC) $(CFLAGS_ALL) -c -o $@ $< + +build/%.os: $(srcdir)/%.S + $(CC) $(CFLAGS_ALL) -c -o $@ $< + +build/%.os: $(srcdir)/%.c + $(CC) $(CFLAGS_ALL) -c -o $@ $< + +clean: $(SUBS:%=clean-%) + rm -rf build + +distclean: clean + rm -f config.mk + +$(DESTDIR)$(bindir)/%: build/bin/% + $(INSTALL) -D $< $@ + +$(DESTDIR)$(libdir)/%.so: build/lib/%.so + $(INSTALL) -D $< $@ + +$(DESTDIR)$(libdir)/%: build/lib/% + $(INSTALL) -m 644 -D $< $@ + +$(DESTDIR)$(includedir)/%: build/include/% + $(INSTALL) -m 644 -D $< $@ + +install: $(SUBS:%=install-%) + +check: $(SUBS:%=check-%) + +.PHONY: all clean distclean install check diff --git a/libc/AOR_v20.02/README.md b/libc/AOR_v20.02/README.md new file mode 100644 index 00000000000000..860f90ebe26dd0 --- /dev/null +++ b/libc/AOR_v20.02/README.md @@ -0,0 +1,6 @@ +This directory contains Arm's contribution of their optimized routines as +initially uploaded to https://reviews.llvm.org/D75355. Going forward, parts +of the implementations from this directory will be moved over to the +appropriate place in the LLVM-libc tree. This will be done over many patches, +all of which will go through the normal LLVM code review practice, and follow +the LLVM-libc implementation standards. diff --git a/libc/AOR_v20.02/config.mk b/libc/AOR_v20.02/config.mk new file mode 100644 index 00000000000000..6808df93519e00 --- /dev/null +++ b/libc/AOR_v20.02/config.mk @@ -0,0 +1,70 @@ +# Example config.mk +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +# Subprojects to build +# For now, LLVM-libc project will focus only "math" functions. +SUBS = math # string networking + +# Target architecture: aarch64, arm or x86_64 +# For now, LLVM-libc project will focus on x86_64 only. +ARCH = x86_64 + +# Compiler for the target +CC = $(CROSS_COMPILE)gcc +CFLAGS = -std=c99 -pipe -O3 +CFLAGS += -Wall -Wno-missing-braces +CFLAGS += -Werror=implicit-function-declaration + +# Used for test case generator that is executed on the host +HOST_CC = gcc +HOST_CFLAGS = -std=c99 -O2 +HOST_CFLAGS += -Wall -Wno-unused-function + +# Enable debug info. +HOST_CFLAGS += -g +CFLAGS += -g + +# Optimize the shared libraries on aarch64 assuming they fit in 1M. +#CFLAGS_SHARED = -fPIC -mcmodel=tiny + +# Use for cross compilation with gcc. +#CROSS_COMPILE = aarch64-none-linux-gnu- + +# Use with cross testing. +#EMULATOR = qemu-aarch64-static +#EMULATOR = sh -c 'scp $$1 user@host:/dir && ssh user@host /dir/"$$@"' -- + +# Additional flags for subprojects. +math-cflags = +math-ldlibs = +math-ulpflags = +math-testflags = +string-cflags = +networking-cflags = + +# Use if mpfr is available on the target for ulp error checking. +#math-ldlibs += -lmpfr -lgmp +#math-cflags += -DUSE_MPFR + +# Use with gcc. +math-cflags += -frounding-math -fexcess-precision=standard -fno-stack-protector +math-cflags += -ffp-contract=fast -fno-math-errno + +# Use with clang. +#math-cflags += -ffp-contract=fast + +# Disable vector math code +#math-cflags += -DWANT_VMATH=0 + +# Disable fenv checks +#math-ulpflags = -q -f +#math-testflags = -nostatus + +# Enable assertion checks. +#networking-cflags += -DWANT_ASSERT + +# Avoid auto-vectorization of scalar code and unroll loops +networking-cflags += -O2 -fno-tree-vectorize -funroll-loops diff --git a/libc/AOR_v20.02/config.mk.dist b/libc/AOR_v20.02/config.mk.dist new file mode 100644 index 00000000000000..240d4b6f4b4c26 --- /dev/null +++ b/libc/AOR_v20.02/config.mk.dist @@ -0,0 +1,68 @@ +# Example config.mk +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +# Subprojects to build +SUBS = math string networking + +# Target architecture: aarch64, arm or x86_64 +ARCH = aarch64 + +# Compiler for the target +CC = $(CROSS_COMPILE)gcc +CFLAGS = -std=c99 -pipe -O3 +CFLAGS += -Wall -Wno-missing-braces +CFLAGS += -Werror=implicit-function-declaration + +# Used for test case generator that is executed on the host +HOST_CC = gcc +HOST_CFLAGS = -std=c99 -O2 +HOST_CFLAGS += -Wall -Wno-unused-function + +# Enable debug info. +HOST_CFLAGS += -g +CFLAGS += -g + +# Optimize the shared libraries on aarch64 assuming they fit in 1M. +#CFLAGS_SHARED = -fPIC -mcmodel=tiny + +# Use for cross compilation with gcc. +#CROSS_COMPILE = aarch64-none-linux-gnu- + +# Use with cross testing. +#EMULATOR = qemu-aarch64-static +#EMULATOR = sh -c 'scp $$1 user@host:/dir && ssh user@host /dir/"$$@"' -- + +# Additional flags for subprojects. +math-cflags = +math-ldlibs = +math-ulpflags = +math-testflags = +string-cflags = +networking-cflags = + +# Use if mpfr is available on the target for ulp error checking. +#math-ldlibs += -lmpfr -lgmp +#math-cflags += -DUSE_MPFR + +# Use with gcc. +math-cflags += -frounding-math -fexcess-precision=standard -fno-stack-protector +math-cflags += -ffp-contract=fast -fno-math-errno + +# Use with clang. +#math-cflags += -ffp-contract=fast + +# Disable vector math code +#math-cflags += -DWANT_VMATH=0 + +# Disable fenv checks +#math-ulpflags = -q -f +#math-testflags = -nostatus + +# Enable assertion checks. +#networking-cflags += -DWANT_ASSERT + +# Avoid auto-vectorization of scalar code and unroll loops +networking-cflags += -O2 -fno-tree-vectorize -funroll-loops diff --git a/libc/AOR_v20.02/math/Dir.mk b/libc/AOR_v20.02/math/Dir.mk new file mode 100644 index 00000000000000..6be9115e86b085 --- /dev/null +++ b/libc/AOR_v20.02/math/Dir.mk @@ -0,0 +1,111 @@ +# Makefile fragment - requires GNU make +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +S := $(srcdir)/math +B := build/math + +math-lib-srcs := $(wildcard $(S)/*.[cS]) +math-test-srcs := \ + $(S)/test/mathtest.c \ + $(S)/test/mathbench.c \ + $(S)/test/ulp.c \ + +math-test-host-srcs := $(wildcard $(S)/test/rtest/*.[cS]) + +math-includes := $(patsubst $(S)/%,build/%,$(wildcard $(S)/include/*.h)) + +math-libs := \ + build/lib/libmathlib.so \ + build/lib/libmathlib.a \ + +math-tools := \ + build/bin/mathtest \ + build/bin/mathbench \ + build/bin/mathbench_libc \ + build/bin/runulp.sh \ + build/bin/ulp \ + +math-host-tools := \ + build/bin/rtest \ + +math-lib-objs := $(patsubst $(S)/%,$(B)/%.o,$(basename $(math-lib-srcs))) +math-test-objs := $(patsubst $(S)/%,$(B)/%.o,$(basename $(math-test-srcs))) +math-host-objs := $(patsubst $(S)/%,$(B)/%.o,$(basename $(math-test-host-srcs))) +math-target-objs := $(math-lib-objs) $(math-test-objs) +math-objs := $(math-target-objs) $(math-target-objs:%.o=%.os) $(math-host-objs) + +math-files := \ + $(math-objs) \ + $(math-libs) \ + $(math-tools) \ + $(math-host-tools) \ + $(math-includes) \ + +all-math: $(math-libs) $(math-tools) $(math-includes) + +$(math-objs): $(math-includes) +$(math-objs): CFLAGS_ALL += $(math-cflags) +$(B)/test/mathtest.o: CFLAGS_ALL += -fmath-errno +$(math-host-objs): CC = $(HOST_CC) +$(math-host-objs): CFLAGS_ALL = $(HOST_CFLAGS) + +$(B)/test/ulp.o: $(S)/test/ulp.h + +build/lib/libmathlib.so: $(math-lib-objs:%.o=%.os) + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -shared -o $@ $^ + +build/lib/libmathlib.a: $(math-lib-objs) + rm -f $@ + $(AR) rc $@ $^ + $(RANLIB) $@ + +$(math-host-tools): HOST_LDLIBS += -lm -lmpfr -lmpc +$(math-tools): LDLIBS += $(math-ldlibs) -lm + +build/bin/rtest: $(math-host-objs) + $(HOST_CC) $(HOST_CFLAGS) $(HOST_LDFLAGS) -o $@ $^ $(HOST_LDLIBS) + +build/bin/mathtest: $(B)/test/mathtest.o build/lib/libmathlib.a + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -static -o $@ $^ $(LDLIBS) + +build/bin/mathbench: $(B)/test/mathbench.o build/lib/libmathlib.a + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -static -o $@ $^ $(LDLIBS) + +# This is not ideal, but allows custom symbols in mathbench to get resolved. +build/bin/mathbench_libc: $(B)/test/mathbench.o build/lib/libmathlib.a + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -static -o $@ $< $(LDLIBS) -lc build/lib/libmathlib.a -lm + +build/bin/ulp: $(B)/test/ulp.o build/lib/libmathlib.a + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -static -o $@ $^ $(LDLIBS) + +build/include/%.h: $(S)/include/%.h + cp $< $@ + +build/bin/%.sh: $(S)/test/%.sh + cp $< $@ + +math-tests := $(wildcard $(S)/test/testcases/directed/*.tst) +math-rtests := $(wildcard $(S)/test/testcases/random/*.tst) + +check-math-test: $(math-tools) + cat $(math-tests) | $(EMULATOR) build/bin/mathtest $(math-testflags) + +check-math-rtest: $(math-host-tools) $(math-tools) + cat $(math-rtests) | build/bin/rtest | $(EMULATOR) build/bin/mathtest $(math-testflags) + +check-math-ulp: $(math-tools) + ULPFLAGS="$(math-ulpflags)" build/bin/runulp.sh $(EMULATOR) + +check-math: check-math-test check-math-rtest check-math-ulp + +install-math: \ + $(math-libs:build/lib/%=$(DESTDIR)$(libdir)/%) \ + $(math-includes:build/include/%=$(DESTDIR)$(includedir)/%) + +clean-math: + rm -f $(math-files) + +.PHONY: all-math check-math-test check-math-rtest check-math-ulp check-math install-math clean-math diff --git a/libc/AOR_v20.02/math/cosf.c b/libc/AOR_v20.02/math/cosf.c new file mode 100644 index 00000000000000..1ab98a1dd60fbc --- /dev/null +++ b/libc/AOR_v20.02/math/cosf.c @@ -0,0 +1,64 @@ +/* + * Single-precision cos function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" +#include "sincosf.h" + +/* Fast cosf implementation. Worst-case ULP is 0.5607, maximum relative + error is 0.5303 * 2^-23. A single-step range reduction is used for + small values. Large inputs have their range reduced using fast integer + arithmetic. */ +float +cosf (float y) +{ + double x = y; + double s; + int n; + const sincos_t *p = &__sincosf_table[0]; + + if (abstop12 (y) < abstop12 (pio4)) + { + double x2 = x * x; + + if (unlikely (abstop12 (y) < abstop12 (0x1p-12f))) + return 1.0f; + + return sinf_poly (x, x2, p, 1); + } + else if (likely (abstop12 (y) < abstop12 (120.0f))) + { + x = reduce_fast (x, p, &n); + + /* Setup the signs for sin and cos. */ + s = p->sign[n & 3]; + + if (n & 2) + p = &__sincosf_table[1]; + + return sinf_poly (x * s, x * x, p, n ^ 1); + } + else if (abstop12 (y) < abstop12 (INFINITY)) + { + uint32_t xi = asuint (y); + int sign = xi >> 31; + + x = reduce_large (xi, &n); + + /* Setup signs for sin and cos - include original sign. */ + s = p->sign[(n + sign) & 3]; + + if ((n + sign) & 2) + p = &__sincosf_table[1]; + + return sinf_poly (x * s, x * x, p, n ^ 1); + } + else + return __math_invalidf (y); +} diff --git a/libc/AOR_v20.02/math/exp.c b/libc/AOR_v20.02/math/exp.c new file mode 100644 index 00000000000000..d0996023188ca3 --- /dev/null +++ b/libc/AOR_v20.02/math/exp.c @@ -0,0 +1,177 @@ +/* + * Double-precision e^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include "math_config.h" + +#define N (1 << EXP_TABLE_BITS) +#define InvLn2N __exp_data.invln2N +#define NegLn2hiN __exp_data.negln2hiN +#define NegLn2loN __exp_data.negln2loN +#define Shift __exp_data.shift +#define T __exp_data.tab +#define C2 __exp_data.poly[5 - EXP_POLY_ORDER] +#define C3 __exp_data.poly[6 - EXP_POLY_ORDER] +#define C4 __exp_data.poly[7 - EXP_POLY_ORDER] +#define C5 __exp_data.poly[8 - EXP_POLY_ORDER] +#define C6 __exp_data.poly[9 - EXP_POLY_ORDER] + +/* Handle cases that may overflow or underflow when computing the result that + is scale*(1+TMP) without intermediate rounding. The bit representation of + scale is in SBITS, however it has a computed exponent that may have + overflown into the sign bit so that needs to be adjusted before using it as + a double. (int32_t)KI is the k used in the argument reduction and exponent + adjustment of scale, positive k here means the result may overflow and + negative k means the result may underflow. */ +static inline double +specialcase (double_t tmp, uint64_t sbits, uint64_t ki) +{ + double_t scale, y; + + if ((ki & 0x80000000) == 0) + { + /* k > 0, the exponent of scale might have overflowed by <= 460. */ + sbits -= 1009ull << 52; + scale = asdouble (sbits); + y = 0x1p1009 * (scale + scale * tmp); + return check_oflow (eval_as_double (y)); + } + /* k < 0, need special care in the subnormal range. */ + sbits += 1022ull << 52; + scale = asdouble (sbits); + y = scale + scale * tmp; + if (y < 1.0) + { + /* Round y to the right precision before scaling it into the subnormal + range to avoid double rounding that can cause 0.5+E/2 ulp error where + E is the worst-case ulp error outside the subnormal range. So this + is only useful if the goal is better than 1 ulp worst-case error. */ + double_t hi, lo; + lo = scale - y + scale * tmp; + hi = 1.0 + y; + lo = 1.0 - hi + y + lo; + y = eval_as_double (hi + lo) - 1.0; + /* Avoid -0.0 with downward rounding. */ + if (WANT_ROUNDING && y == 0.0) + y = 0.0; + /* The underflow exception needs to be signaled explicitly. */ + force_eval_double (opt_barrier_double (0x1p-1022) * 0x1p-1022); + } + y = 0x1p-1022 * y; + return check_uflow (eval_as_double (y)); +} + +/* Top 12 bits of a double (sign and exponent bits). */ +static inline uint32_t +top12 (double x) +{ + return asuint64 (x) >> 52; +} + +/* Computes exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|. + If hastail is 0 then xtail is assumed to be 0 too. */ +static inline double +exp_inline (double x, double xtail, int hastail) +{ + uint32_t abstop; + uint64_t ki, idx, top, sbits; + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t kd, z, r, r2, scale, tail, tmp; + + abstop = top12 (x) & 0x7ff; + if (unlikely (abstop - top12 (0x1p-54) >= top12 (512.0) - top12 (0x1p-54))) + { + if (abstop - top12 (0x1p-54) >= 0x80000000) + /* Avoid spurious underflow for tiny x. */ + /* Note: 0 is common input. */ + return WANT_ROUNDING ? 1.0 + x : 1.0; + if (abstop >= top12 (1024.0)) + { + if (asuint64 (x) == asuint64 (-INFINITY)) + return 0.0; + if (abstop >= top12 (INFINITY)) + return 1.0 + x; + if (asuint64 (x) >> 63) + return __math_uflow (0); + else + return __math_oflow (0); + } + /* Large x is special cased below. */ + abstop = 0; + } + + /* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]. */ + /* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]. */ + z = InvLn2N * x; +#if TOINT_INTRINSICS + kd = roundtoint (z); + ki = converttoint (z); +#elif EXP_USE_TOINT_NARROW + /* z - kd is in [-0.5-2^-16, 0.5] in all rounding modes. */ + kd = eval_as_double (z + Shift); + ki = asuint64 (kd) >> 16; + kd = (double_t) (int32_t) ki; +#else + /* z - kd is in [-1, 1] in non-nearest rounding modes. */ + kd = eval_as_double (z + Shift); + ki = asuint64 (kd); + kd -= Shift; +#endif + r = x + kd * NegLn2hiN + kd * NegLn2loN; + /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ + if (hastail) + r += xtail; + /* 2^(k/N) ~= scale * (1 + tail). */ + idx = 2 * (ki % N); + top = ki << (52 - EXP_TABLE_BITS); + tail = asdouble (T[idx]); + /* This is only a valid scale when -1023*N < k < 1024*N. */ + sbits = T[idx + 1] + top; + /* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1). */ + /* Evaluation is optimized assuming superscalar pipelined execution. */ + r2 = r * r; + /* Without fma the worst case error is 0.25/N ulp larger. */ + /* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp. */ +#if EXP_POLY_ORDER == 4 + tmp = tail + r + r2 * C2 + r * r2 * (C3 + r * C4); +#elif EXP_POLY_ORDER == 5 + tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5); +#elif EXP_POLY_ORDER == 6 + tmp = tail + r + r2 * (0.5 + r * C3) + r2 * r2 * (C4 + r * C5 + r2 * C6); +#endif + if (unlikely (abstop == 0)) + return specialcase (tmp, sbits, ki); + scale = asdouble (sbits); + /* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there + is no spurious underflow here even without fma. */ + return eval_as_double (scale + scale * tmp); +} + +double +exp (double x) +{ + return exp_inline (x, 0, 0); +} + +/* May be useful for implementing pow where more than double + precision input is needed. */ +double +__exp_dd (double x, double xtail) +{ + return exp_inline (x, xtail, 1); +} +#if USE_GLIBC_ABI +strong_alias (exp, __exp_finite) +hidden_alias (exp, __ieee754_exp) +hidden_alias (__exp_dd, __exp1) +# if LDBL_MANT_DIG == 53 +long double expl (long double x) { return exp (x); } +# endif +#endif diff --git a/libc/AOR_v20.02/math/exp2.c b/libc/AOR_v20.02/math/exp2.c new file mode 100644 index 00000000000000..53296ab7c5815a --- /dev/null +++ b/libc/AOR_v20.02/math/exp2.c @@ -0,0 +1,144 @@ +/* + * Double-precision 2^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include "math_config.h" + +#define N (1 << EXP_TABLE_BITS) +#define Shift __exp_data.exp2_shift +#define T __exp_data.tab +#define C1 __exp_data.exp2_poly[0] +#define C2 __exp_data.exp2_poly[1] +#define C3 __exp_data.exp2_poly[2] +#define C4 __exp_data.exp2_poly[3] +#define C5 __exp_data.exp2_poly[4] +#define C6 __exp_data.exp2_poly[5] + +/* Handle cases that may overflow or underflow when computing the result that + is scale*(1+TMP) without intermediate rounding. The bit representation of + scale is in SBITS, however it has a computed exponent that may have + overflown into the sign bit so that needs to be adjusted before using it as + a double. (int32_t)KI is the k used in the argument reduction and exponent + adjustment of scale, positive k here means the result may overflow and + negative k means the result may underflow. */ +static inline double +specialcase (double_t tmp, uint64_t sbits, uint64_t ki) +{ + double_t scale, y; + + if ((ki & 0x80000000) == 0) + { + /* k > 0, the exponent of scale might have overflowed by 1. */ + sbits -= 1ull << 52; + scale = asdouble (sbits); + y = 2 * (scale + scale * tmp); + return check_oflow (eval_as_double (y)); + } + /* k < 0, need special care in the subnormal range. */ + sbits += 1022ull << 52; + scale = asdouble (sbits); + y = scale + scale * tmp; + if (y < 1.0) + { + /* Round y to the right precision before scaling it into the subnormal + range to avoid double rounding that can cause 0.5+E/2 ulp error where + E is the worst-case ulp error outside the subnormal range. So this + is only useful if the goal is better than 1 ulp worst-case error. */ + double_t hi, lo; + lo = scale - y + scale * tmp; + hi = 1.0 + y; + lo = 1.0 - hi + y + lo; + y = eval_as_double (hi + lo) - 1.0; + /* Avoid -0.0 with downward rounding. */ + if (WANT_ROUNDING && y == 0.0) + y = 0.0; + /* The underflow exception needs to be signaled explicitly. */ + force_eval_double (opt_barrier_double (0x1p-1022) * 0x1p-1022); + } + y = 0x1p-1022 * y; + return check_uflow (eval_as_double (y)); +} + +/* Top 12 bits of a double (sign and exponent bits). */ +static inline uint32_t +top12 (double x) +{ + return asuint64 (x) >> 52; +} + +double +exp2 (double x) +{ + uint32_t abstop; + uint64_t ki, idx, top, sbits; + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t kd, r, r2, scale, tail, tmp; + + abstop = top12 (x) & 0x7ff; + if (unlikely (abstop - top12 (0x1p-54) >= top12 (512.0) - top12 (0x1p-54))) + { + if (abstop - top12 (0x1p-54) >= 0x80000000) + /* Avoid spurious underflow for tiny x. */ + /* Note: 0 is common input. */ + return WANT_ROUNDING ? 1.0 + x : 1.0; + if (abstop >= top12 (1024.0)) + { + if (asuint64 (x) == asuint64 (-INFINITY)) + return 0.0; + if (abstop >= top12 (INFINITY)) + return 1.0 + x; + if (!(asuint64 (x) >> 63)) + return __math_oflow (0); + else if (asuint64 (x) >= asuint64 (-1075.0)) + return __math_uflow (0); + } + if (2 * asuint64 (x) > 2 * asuint64 (928.0)) + /* Large x is special cased below. */ + abstop = 0; + } + + /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ + /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ + kd = eval_as_double (x + Shift); + ki = asuint64 (kd); /* k. */ + kd -= Shift; /* k/N for int k. */ + r = x - kd; + /* 2^(k/N) ~= scale * (1 + tail). */ + idx = 2 * (ki % N); + top = ki << (52 - EXP_TABLE_BITS); + tail = asdouble (T[idx]); + /* This is only a valid scale when -1023*N < k < 1024*N. */ + sbits = T[idx + 1] + top; + /* exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1). */ + /* Evaluation is optimized assuming superscalar pipelined execution. */ + r2 = r * r; + /* Without fma the worst case error is 0.5/N ulp larger. */ + /* Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp. */ +#if EXP2_POLY_ORDER == 4 + tmp = tail + r * C1 + r2 * C2 + r * r2 * (C3 + r * C4); +#elif EXP2_POLY_ORDER == 5 + tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5); +#elif EXP2_POLY_ORDER == 6 + tmp = tail + r * C1 + r2 * (0.5 + r * C3) + r2 * r2 * (C4 + r * C5 + r2 * C6); +#endif + if (unlikely (abstop == 0)) + return specialcase (tmp, sbits, ki); + scale = asdouble (sbits); + /* Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there + is no spurious underflow here even without fma. */ + return eval_as_double (scale + scale * tmp); +} +#if USE_GLIBC_ABI +strong_alias (exp2, __exp2_finite) +hidden_alias (exp2, __ieee754_exp2) +# if LDBL_MANT_DIG == 53 +long double exp2l (long double x) { return exp2 (x); } +# endif +#endif diff --git a/libc/AOR_v20.02/math/exp2f.c b/libc/AOR_v20.02/math/exp2f.c new file mode 100644 index 00000000000000..4259e29777e114 --- /dev/null +++ b/libc/AOR_v20.02/math/exp2f.c @@ -0,0 +1,81 @@ +/* + * Single-precision 2^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" + +/* +EXP2F_TABLE_BITS = 5 +EXP2F_POLY_ORDER = 3 + +ULP error: 0.502 (nearest rounding.) +Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.) +Wrong count: 168353 (all nearest rounding wrong results with fma.) +Non-nearest ULP error: 1 (rounded ULP error) +*/ + +#define N (1 << EXP2F_TABLE_BITS) +#define T __exp2f_data.tab +#define C __exp2f_data.poly +#define SHIFT __exp2f_data.shift_scaled + +static inline uint32_t +top12 (float x) +{ + return asuint (x) >> 20; +} + +float +exp2f (float x) +{ + uint32_t abstop; + uint64_t ki, t; + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t kd, xd, z, r, r2, y, s; + + xd = (double_t) x; + abstop = top12 (x) & 0x7ff; + if (unlikely (abstop >= top12 (128.0f))) + { + /* |x| >= 128 or x is nan. */ + if (asuint (x) == asuint (-INFINITY)) + return 0.0f; + if (abstop >= top12 (INFINITY)) + return x + x; + if (x > 0.0f) + return __math_oflowf (0); + if (x <= -150.0f) + return __math_uflowf (0); +#if WANT_ERRNO_UFLOW + if (x < -149.0f) + return __math_may_uflowf (0); +#endif + } + + /* x = k/N + r with r in [-1/(2N), 1/(2N)] and int k. */ + kd = eval_as_double (xd + SHIFT); + ki = asuint64 (kd); + kd -= SHIFT; /* k/N for int k. */ + r = xd - kd; + + /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ + t = T[ki % N]; + t += ki << (52 - EXP2F_TABLE_BITS); + s = asdouble (t); + z = C[0] * r + C[1]; + r2 = r * r; + y = C[2] * r + 1; + y = z * r2 + y; + y = y * s; + return eval_as_float (y); +} +#if USE_GLIBC_ABI +strong_alias (exp2f, __exp2f_finite) +hidden_alias (exp2f, __ieee754_exp2f) +#endif diff --git a/libc/AOR_v20.02/math/exp2f_data.c b/libc/AOR_v20.02/math/exp2f_data.c new file mode 100644 index 00000000000000..06307500632810 --- /dev/null +++ b/libc/AOR_v20.02/math/exp2f_data.c @@ -0,0 +1,79 @@ +/* + * Shared data between expf, exp2f and powf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +#define N (1 << EXP2F_TABLE_BITS) + +const struct exp2f_data __exp2f_data = { + /* tab[i] = uint(2^(i/N)) - (i << 52-BITS) + used for computing 2^(k/N) for an int |k| < 150 N as + double(tab[k%N] + (k << 52-BITS)) */ + .tab = { +#if N == 8 +0x3ff0000000000000, 0x3fef72b83c7d517b, 0x3fef06fe0a31b715, 0x3feebfdad5362a27, +0x3feea09e667f3bcd, 0x3feeace5422aa0db, 0x3feee89f995ad3ad, 0x3fef5818dcfba487, +#elif N == 16 +0x3ff0000000000000, 0x3fefb5586cf9890f, 0x3fef72b83c7d517b, 0x3fef387a6e756238, +0x3fef06fe0a31b715, 0x3feedea64c123422, 0x3feebfdad5362a27, 0x3feeab07dd485429, +0x3feea09e667f3bcd, 0x3feea11473eb0187, 0x3feeace5422aa0db, 0x3feec49182a3f090, +0x3feee89f995ad3ad, 0x3fef199bdd85529c, 0x3fef5818dcfba487, 0x3fefa4afa2a490da, +#elif N == 32 +0x3ff0000000000000, 0x3fefd9b0d3158574, 0x3fefb5586cf9890f, 0x3fef9301d0125b51, +0x3fef72b83c7d517b, 0x3fef54873168b9aa, 0x3fef387a6e756238, 0x3fef1e9df51fdee1, +0x3fef06fe0a31b715, 0x3feef1a7373aa9cb, 0x3feedea64c123422, 0x3feece086061892d, +0x3feebfdad5362a27, 0x3feeb42b569d4f82, 0x3feeab07dd485429, 0x3feea47eb03a5585, +0x3feea09e667f3bcd, 0x3fee9f75e8ec5f74, 0x3feea11473eb0187, 0x3feea589994cce13, +0x3feeace5422aa0db, 0x3feeb737b0cdc5e5, 0x3feec49182a3f090, 0x3feed503b23e255d, +0x3feee89f995ad3ad, 0x3feeff76f2fb5e47, 0x3fef199bdd85529c, 0x3fef3720dcef9069, +0x3fef5818dcfba487, 0x3fef7c97337b9b5f, 0x3fefa4afa2a490da, 0x3fefd0765b6e4540, +#elif N == 64 +0x3ff0000000000000, 0x3fefec9a3e778061, 0x3fefd9b0d3158574, 0x3fefc74518759bc8, +0x3fefb5586cf9890f, 0x3fefa3ec32d3d1a2, 0x3fef9301d0125b51, 0x3fef829aaea92de0, +0x3fef72b83c7d517b, 0x3fef635beb6fcb75, 0x3fef54873168b9aa, 0x3fef463b88628cd6, +0x3fef387a6e756238, 0x3fef2b4565e27cdd, 0x3fef1e9df51fdee1, 0x3fef1285a6e4030b, +0x3fef06fe0a31b715, 0x3feefc08b26416ff, 0x3feef1a7373aa9cb, 0x3feee7db34e59ff7, +0x3feedea64c123422, 0x3feed60a21f72e2a, 0x3feece086061892d, 0x3feec6a2b5c13cd0, +0x3feebfdad5362a27, 0x3feeb9b2769d2ca7, 0x3feeb42b569d4f82, 0x3feeaf4736b527da, +0x3feeab07dd485429, 0x3feea76f15ad2148, 0x3feea47eb03a5585, 0x3feea23882552225, +0x3feea09e667f3bcd, 0x3fee9fb23c651a2f, 0x3fee9f75e8ec5f74, 0x3fee9feb564267c9, +0x3feea11473eb0187, 0x3feea2f336cf4e62, 0x3feea589994cce13, 0x3feea8d99b4492ed, +0x3feeace5422aa0db, 0x3feeb1ae99157736, 0x3feeb737b0cdc5e5, 0x3feebd829fde4e50, +0x3feec49182a3f090, 0x3feecc667b5de565, 0x3feed503b23e255d, 0x3feede6b5579fdbf, +0x3feee89f995ad3ad, 0x3feef3a2b84f15fb, 0x3feeff76f2fb5e47, 0x3fef0c1e904bc1d2, +0x3fef199bdd85529c, 0x3fef27f12e57d14b, 0x3fef3720dcef9069, 0x3fef472d4a07897c, +0x3fef5818dcfba487, 0x3fef69e603db3285, 0x3fef7c97337b9b5f, 0x3fef902ee78b3ff6, +0x3fefa4afa2a490da, 0x3fefba1bee615a27, 0x3fefd0765b6e4540, 0x3fefe7c1819e90d8, +#endif + }, + .shift_scaled = 0x1.8p+52 / N, + .poly = { +#if N == 8 + 0x1.c6a00335106e2p-5, 0x1.ec0c313449f55p-3, 0x1.62e431111f69fp-1, +#elif N == 16 + 0x1.c6ac6aa313963p-5, 0x1.ebfff4532d9bap-3, 0x1.62e43001bc49fp-1, +#elif N == 32 + 0x1.c6af84b912394p-5, 0x1.ebfce50fac4f3p-3, 0x1.62e42ff0c52d6p-1, +#elif N == 64 + 0x1.c6b04b4221b2ap-5, 0x1.ebfc213e184d7p-3, 0x1.62e42fefb5b7fp-1, +#endif + }, + .shift = 0x1.8p+52, + .invln2_scaled = 0x1.71547652b82fep+0 * N, + .poly_scaled = { +#if N == 8 + 0x1.c6a00335106e2p-5/N/N/N, 0x1.ec0c313449f55p-3/N/N, 0x1.62e431111f69fp-1/N, +#elif N == 16 + 0x1.c6ac6aa313963p-5/N/N/N, 0x1.ebfff4532d9bap-3/N/N, 0x1.62e43001bc49fp-1/N, +#elif N == 32 + 0x1.c6af84b912394p-5/N/N/N, 0x1.ebfce50fac4f3p-3/N/N, 0x1.62e42ff0c52d6p-1/N, +#elif N == 64 + 0x1.c6b04b4221b2ap-5/N/N/N, 0x1.ebfc213e184d7p-3/N/N, 0x1.62e42fefb5b7fp-1/N, +#endif + }, +}; diff --git a/libc/AOR_v20.02/math/exp_data.c b/libc/AOR_v20.02/math/exp_data.c new file mode 100644 index 00000000000000..682eee860070b0 --- /dev/null +++ b/libc/AOR_v20.02/math/exp_data.c @@ -0,0 +1,1121 @@ +/* + * Shared data between exp, exp2 and pow. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +#define N (1 << EXP_TABLE_BITS) + +const struct exp_data __exp_data = { +// N/ln2 +.invln2N = 0x1.71547652b82fep0 * N, +// -ln2/N +#if N == 64 +.negln2hiN = -0x1.62e42fefa0000p-7, +.negln2loN = -0x1.cf79abc9e3b3ap-46, +#elif N == 128 +.negln2hiN = -0x1.62e42fefa0000p-8, +.negln2loN = -0x1.cf79abc9e3b3ap-47, +#elif N == 256 +.negln2hiN = -0x1.62e42fefc0000p-9, +.negln2loN = 0x1.c610ca86c3899p-45, +#elif N == 512 +.negln2hiN = -0x1.62e42fef80000p-10, +.negln2loN = -0x1.1cf79abc9e3b4p-45, +#endif +// Used for rounding when !TOINT_INTRINSICS +#if EXP_USE_TOINT_NARROW +.shift = 0x1800000000.8p0, +#else +.shift = 0x1.8p52, +#endif +// exp polynomial coefficients. +.poly = { +#if N == 64 && EXP_POLY_ORDER == 5 && !EXP_POLY_WIDE +// abs error: 1.5543*2^-60 +// ulp error: 0.529 (0.533 without fma) +// if |x| < ln2/128+eps +// abs error if |x| < ln2/64: 1.7157*2^-50 +0x1.fffffffffdbcdp-2, +0x1.555555555444cp-3, +0x1.555573c6a9f7dp-5, +0x1.1111266d28935p-7, +#elif N == 64 && EXP_POLY_ORDER == 6 && EXP_POLY_WIDE +// abs error: 1.6735*2^-64 +// ulp error: 0.518 (0.522 without fma) +// if |x| < ln2/64 +0x1.5555555548f9ap-3, +0x1.555555554bf5dp-5, +0x1.11115b75f0f4dp-7, +0x1.6c171a6b6303ep-10, +#elif N == 128 && EXP_POLY_ORDER == 5 && !EXP_POLY_WIDE +// abs error: 1.555*2^-66 +// ulp error: 0.509 (0.511 without fma) +// if |x| < ln2/256+eps +// abs error if |x| < ln2/256+0x1p-15: 1.09*2^-65 +// abs error if |x| < ln2/128: 1.7145*2^-56 +0x1.ffffffffffdbdp-2, +0x1.555555555543cp-3, +0x1.55555cf172b91p-5, +0x1.1111167a4d017p-7, +#elif N == 128 && EXP_POLY_ORDER == 5 && EXP_POLY_WIDE +// abs error: 1.5542*2^-60 +// ulp error: 0.521 (0.523 without fma) +// if |x| < ln2/128 +0x1.fffffffffdbcep-2, +0x1.55555555543c2p-3, +0x1.555573c64f2e3p-5, +0x1.111126b4eff73p-7, +#elif N == 128 && EXP_POLY_ORDER == 6 && EXP_POLY_WIDE +// abs error: 1.6861*2^-71 +// ulp error: 0.509 (0.511 without fma) +// if |x| < ln2/128 +0x1.55555555548fdp-3, +0x1.555555555658fp-5, +0x1.111123a859bb6p-7, +0x1.6c16ba6920cabp-10, +#elif N == 256 && EXP_POLY_ORDER == 4 && !EXP_POLY_WIDE +// abs error: 1.43*2^-58 +// ulp error: 0.549 (0.550 without fma) +// if |x| < ln2/512 +0x1p0, // unused +0x1.fffffffffffd4p-2, +0x1.5555571d6ef9p-3, +0x1.5555576a5adcep-5, +#elif N == 256 && EXP_POLY_ORDER == 5 && EXP_POLY_WIDE +// abs error: 1.5547*2^-66 +// ulp error: 0.505 (0.506 without fma) +// if |x| < ln2/256 +0x1.ffffffffffdbdp-2, +0x1.555555555543cp-3, +0x1.55555cf16e1edp-5, +0x1.1111167a4b553p-7, +#elif N == 512 && EXP_POLY_ORDER == 4 && !EXP_POLY_WIDE +// abs error: 1.4300*2^-63 +// ulp error: 0.504 +// if |x| < ln2/1024 +// abs error if |x| < ln2/512: 1.0689*2^-55 +0x1p0, // unused +0x1.ffffffffffffdp-2, +0x1.555555c75bb6p-3, +0x1.555555dec04a8p-5, +#endif +}, +.exp2_shift = 0x1.8p52 / N, +// exp2 polynomial coefficients. +.exp2_poly = { +#if N == 64 && EXP2_POLY_ORDER == 6 && EXP2_POLY_WIDE +// abs error: 1.3054*2^-63 +// ulp error: 0.515 +// if |x| < 1/64 +0x1.62e42fefa39efp-1, +0x1.ebfbdff82c58fp-3, +0x1.c6b08d7045cf1p-5, +0x1.3b2ab6fb8fd0ep-7, +0x1.5d884afec48d7p-10, +0x1.43097dc684ae1p-13, +#elif N == 128 && EXP2_POLY_ORDER == 5 && !EXP2_POLY_WIDE +// abs error: 1.2195*2^-65 +// ulp error: 0.507 (0.511 without fma) +// if |x| < 1/256 +// abs error if |x| < 1/128: 1.9941*2^-56 +0x1.62e42fefa39efp-1, +0x1.ebfbdff82c424p-3, +0x1.c6b08d70cf4b5p-5, +0x1.3b2abd24650ccp-7, +0x1.5d7e09b4e3a84p-10, +#elif N == 256 && EXP2_POLY_ORDER == 5 && EXP2_POLY_WIDE +// abs error: 1.2195*2^-65 +// ulp error: 0.504 (0.508 without fma) +// if |x| < 1/256 +0x1.62e42fefa39efp-1, +0x1.ebfbdff82c424p-3, +0x1.c6b08d70cf4b5p-5, +0x1.3b2abd24650ccp-7, +0x1.5d7e09b4e3a84p-10, +#elif N == 512 && EXP2_POLY_ORDER == 4 && !EXP2_POLY_WIDE +// abs error: 1.4411*2^-64 +// ulp error: 0.5024 (0.5063 without fma) +// if |x| < 1/1024 +// abs error if |x| < 1/512: 1.9430*2^-56 +0x1.62e42fefa39ecp-1, +0x1.ebfbdff82c58bp-3, +0x1.c6b08e46de41fp-5, +0x1.3b2ab786ee1dap-7, +#endif +}, +// 2^(k/N) ~= H[k]*(1 + T[k]) for int k in [0,N) +// tab[2*k] = asuint64(T[k]) +// tab[2*k+1] = asuint64(H[k]) - (k << 52)/N +.tab = { +#if N == 64 +0x0, 0x3ff0000000000000, +0xbc7160139cd8dc5d, 0x3fefec9a3e778061, +0x3c8cd2523567f613, 0x3fefd9b0d3158574, +0x3c60f74e61e6c861, 0x3fefc74518759bc8, +0x3c979aa65d837b6d, 0x3fefb5586cf9890f, +0x3c3ebe3d702f9cd1, 0x3fefa3ec32d3d1a2, +0xbc9556522a2fbd0e, 0x3fef9301d0125b51, +0xbc91c923b9d5f416, 0x3fef829aaea92de0, +0xbc801b15eaa59348, 0x3fef72b83c7d517b, +0x3c8b898c3f1353bf, 0x3fef635beb6fcb75, +0x3c9aecf73e3a2f60, 0x3fef54873168b9aa, +0x3c8a6f4144a6c38d, 0x3fef463b88628cd6, +0x3c968efde3a8a894, 0x3fef387a6e756238, +0x3c80472b981fe7f2, 0x3fef2b4565e27cdd, +0x3c82f7e16d09ab31, 0x3fef1e9df51fdee1, +0x3c8b3782720c0ab4, 0x3fef1285a6e4030b, +0x3c834d754db0abb6, 0x3fef06fe0a31b715, +0x3c8fdd395dd3f84a, 0x3feefc08b26416ff, +0xbc924aedcc4b5068, 0x3feef1a7373aa9cb, +0xbc71d1e83e9436d2, 0x3feee7db34e59ff7, +0x3c859f48a72a4c6d, 0x3feedea64c123422, +0xbc58a78f4817895b, 0x3feed60a21f72e2a, +0x3c4363ed60c2ac11, 0x3feece086061892d, +0x3c6ecce1daa10379, 0x3feec6a2b5c13cd0, +0x3c7690cebb7aafb0, 0x3feebfdad5362a27, +0xbc8f94340071a38e, 0x3feeb9b2769d2ca7, +0xbc78dec6bd0f385f, 0x3feeb42b569d4f82, +0x3c93350518fdd78e, 0x3feeaf4736b527da, +0x3c9063e1e21c5409, 0x3feeab07dd485429, +0x3c9432e62b64c035, 0x3feea76f15ad2148, +0xbc8c33c53bef4da8, 0x3feea47eb03a5585, +0xbc93cedd78565858, 0x3feea23882552225, +0xbc93b3efbf5e2228, 0x3feea09e667f3bcd, +0xbc6367efb86da9ee, 0x3fee9fb23c651a2f, +0xbc781f647e5a3ecf, 0x3fee9f75e8ec5f74, +0xbc8619321e55e68a, 0x3fee9feb564267c9, +0xbc7b32dcb94da51d, 0x3feea11473eb0187, +0x3c65ebe1abd66c55, 0x3feea2f336cf4e62, +0xbc9369b6f13b3734, 0x3feea589994cce13, +0xbc94d450d872576e, 0x3feea8d99b4492ed, +0x3c8db72fc1f0eab4, 0x3feeace5422aa0db, +0x3c7bf68359f35f44, 0x3feeb1ae99157736, +0xbc5da9b88b6c1e29, 0x3feeb737b0cdc5e5, +0xbc92434322f4f9aa, 0x3feebd829fde4e50, +0x3c71affc2b91ce27, 0x3feec49182a3f090, +0xbc87c50422622263, 0x3feecc667b5de565, +0xbc91bbd1d3bcbb15, 0x3feed503b23e255d, +0x3c8469846e735ab3, 0x3feede6b5579fdbf, +0x3c8c1a7792cb3387, 0x3feee89f995ad3ad, +0xbc55c3d956dcaeba, 0x3feef3a2b84f15fb, +0xbc68d6f438ad9334, 0x3feeff76f2fb5e47, +0x3c74ffd70a5fddcd, 0x3fef0c1e904bc1d2, +0x3c736eae30af0cb3, 0x3fef199bdd85529c, +0x3c84e08fd10959ac, 0x3fef27f12e57d14b, +0x3c676b2c6c921968, 0x3fef3720dcef9069, +0xbc8fad5d3ffffa6f, 0x3fef472d4a07897c, +0x3c74a385a63d07a7, 0x3fef5818dcfba487, +0x3c8e5a50d5c192ac, 0x3fef69e603db3285, +0xbc82d52107b43e1f, 0x3fef7c97337b9b5f, +0x3c74b604603a88d3, 0x3fef902ee78b3ff6, +0xbc8ff7128fd391f0, 0x3fefa4afa2a490da, +0x3c8ec3bc41aa2008, 0x3fefba1bee615a27, +0x3c8a64a931d185ee, 0x3fefd0765b6e4540, +0x3c77893b4d91cd9d, 0x3fefe7c1819e90d8, +#elif N == 128 +0x0, 0x3ff0000000000000, +0x3c9b3b4f1a88bf6e, 0x3feff63da9fb3335, +0xbc7160139cd8dc5d, 0x3fefec9a3e778061, +0xbc905e7a108766d1, 0x3fefe315e86e7f85, +0x3c8cd2523567f613, 0x3fefd9b0d3158574, +0xbc8bce8023f98efa, 0x3fefd06b29ddf6de, +0x3c60f74e61e6c861, 0x3fefc74518759bc8, +0x3c90a3e45b33d399, 0x3fefbe3ecac6f383, +0x3c979aa65d837b6d, 0x3fefb5586cf9890f, +0x3c8eb51a92fdeffc, 0x3fefac922b7247f7, +0x3c3ebe3d702f9cd1, 0x3fefa3ec32d3d1a2, +0xbc6a033489906e0b, 0x3fef9b66affed31b, +0xbc9556522a2fbd0e, 0x3fef9301d0125b51, +0xbc5080ef8c4eea55, 0x3fef8abdc06c31cc, +0xbc91c923b9d5f416, 0x3fef829aaea92de0, +0x3c80d3e3e95c55af, 0x3fef7a98c8a58e51, +0xbc801b15eaa59348, 0x3fef72b83c7d517b, +0xbc8f1ff055de323d, 0x3fef6af9388c8dea, +0x3c8b898c3f1353bf, 0x3fef635beb6fcb75, +0xbc96d99c7611eb26, 0x3fef5be084045cd4, +0x3c9aecf73e3a2f60, 0x3fef54873168b9aa, +0xbc8fe782cb86389d, 0x3fef4d5022fcd91d, +0x3c8a6f4144a6c38d, 0x3fef463b88628cd6, +0x3c807a05b0e4047d, 0x3fef3f49917ddc96, +0x3c968efde3a8a894, 0x3fef387a6e756238, +0x3c875e18f274487d, 0x3fef31ce4fb2a63f, +0x3c80472b981fe7f2, 0x3fef2b4565e27cdd, +0xbc96b87b3f71085e, 0x3fef24dfe1f56381, +0x3c82f7e16d09ab31, 0x3fef1e9df51fdee1, +0xbc3d219b1a6fbffa, 0x3fef187fd0dad990, +0x3c8b3782720c0ab4, 0x3fef1285a6e4030b, +0x3c6e149289cecb8f, 0x3fef0cafa93e2f56, +0x3c834d754db0abb6, 0x3fef06fe0a31b715, +0x3c864201e2ac744c, 0x3fef0170fc4cd831, +0x3c8fdd395dd3f84a, 0x3feefc08b26416ff, +0xbc86a3803b8e5b04, 0x3feef6c55f929ff1, +0xbc924aedcc4b5068, 0x3feef1a7373aa9cb, +0xbc9907f81b512d8e, 0x3feeecae6d05d866, +0xbc71d1e83e9436d2, 0x3feee7db34e59ff7, +0xbc991919b3ce1b15, 0x3feee32dc313a8e5, +0x3c859f48a72a4c6d, 0x3feedea64c123422, +0xbc9312607a28698a, 0x3feeda4504ac801c, +0xbc58a78f4817895b, 0x3feed60a21f72e2a, +0xbc7c2c9b67499a1b, 0x3feed1f5d950a897, +0x3c4363ed60c2ac11, 0x3feece086061892d, +0x3c9666093b0664ef, 0x3feeca41ed1d0057, +0x3c6ecce1daa10379, 0x3feec6a2b5c13cd0, +0x3c93ff8e3f0f1230, 0x3feec32af0d7d3de, +0x3c7690cebb7aafb0, 0x3feebfdad5362a27, +0x3c931dbdeb54e077, 0x3feebcb299fddd0d, +0xbc8f94340071a38e, 0x3feeb9b2769d2ca7, +0xbc87deccdc93a349, 0x3feeb6daa2cf6642, +0xbc78dec6bd0f385f, 0x3feeb42b569d4f82, +0xbc861246ec7b5cf6, 0x3feeb1a4ca5d920f, +0x3c93350518fdd78e, 0x3feeaf4736b527da, +0x3c7b98b72f8a9b05, 0x3feead12d497c7fd, +0x3c9063e1e21c5409, 0x3feeab07dd485429, +0x3c34c7855019c6ea, 0x3feea9268a5946b7, +0x3c9432e62b64c035, 0x3feea76f15ad2148, +0xbc8ce44a6199769f, 0x3feea5e1b976dc09, +0xbc8c33c53bef4da8, 0x3feea47eb03a5585, +0xbc845378892be9ae, 0x3feea34634ccc320, +0xbc93cedd78565858, 0x3feea23882552225, +0x3c5710aa807e1964, 0x3feea155d44ca973, +0xbc93b3efbf5e2228, 0x3feea09e667f3bcd, +0xbc6a12ad8734b982, 0x3feea012750bdabf, +0xbc6367efb86da9ee, 0x3fee9fb23c651a2f, +0xbc80dc3d54e08851, 0x3fee9f7df9519484, +0xbc781f647e5a3ecf, 0x3fee9f75e8ec5f74, +0xbc86ee4ac08b7db0, 0x3fee9f9a48a58174, +0xbc8619321e55e68a, 0x3fee9feb564267c9, +0x3c909ccb5e09d4d3, 0x3feea0694fde5d3f, +0xbc7b32dcb94da51d, 0x3feea11473eb0187, +0x3c94ecfd5467c06b, 0x3feea1ed0130c132, +0x3c65ebe1abd66c55, 0x3feea2f336cf4e62, +0xbc88a1c52fb3cf42, 0x3feea427543e1a12, +0xbc9369b6f13b3734, 0x3feea589994cce13, +0xbc805e843a19ff1e, 0x3feea71a4623c7ad, +0xbc94d450d872576e, 0x3feea8d99b4492ed, +0x3c90ad675b0e8a00, 0x3feeaac7d98a6699, +0x3c8db72fc1f0eab4, 0x3feeace5422aa0db, +0xbc65b6609cc5e7ff, 0x3feeaf3216b5448c, +0x3c7bf68359f35f44, 0x3feeb1ae99157736, +0xbc93091fa71e3d83, 0x3feeb45b0b91ffc6, +0xbc5da9b88b6c1e29, 0x3feeb737b0cdc5e5, +0xbc6c23f97c90b959, 0x3feeba44cbc8520f, +0xbc92434322f4f9aa, 0x3feebd829fde4e50, +0xbc85ca6cd7668e4b, 0x3feec0f170ca07ba, +0x3c71affc2b91ce27, 0x3feec49182a3f090, +0x3c6dd235e10a73bb, 0x3feec86319e32323, +0xbc87c50422622263, 0x3feecc667b5de565, +0x3c8b1c86e3e231d5, 0x3feed09bec4a2d33, +0xbc91bbd1d3bcbb15, 0x3feed503b23e255d, +0x3c90cc319cee31d2, 0x3feed99e1330b358, +0x3c8469846e735ab3, 0x3feede6b5579fdbf, +0xbc82dfcd978e9db4, 0x3feee36bbfd3f37a, +0x3c8c1a7792cb3387, 0x3feee89f995ad3ad, +0xbc907b8f4ad1d9fa, 0x3feeee07298db666, +0xbc55c3d956dcaeba, 0x3feef3a2b84f15fb, +0xbc90a40e3da6f640, 0x3feef9728de5593a, +0xbc68d6f438ad9334, 0x3feeff76f2fb5e47, +0xbc91eee26b588a35, 0x3fef05b030a1064a, +0x3c74ffd70a5fddcd, 0x3fef0c1e904bc1d2, +0xbc91bdfbfa9298ac, 0x3fef12c25bd71e09, +0x3c736eae30af0cb3, 0x3fef199bdd85529c, +0x3c8ee3325c9ffd94, 0x3fef20ab5fffd07a, +0x3c84e08fd10959ac, 0x3fef27f12e57d14b, +0x3c63cdaf384e1a67, 0x3fef2f6d9406e7b5, +0x3c676b2c6c921968, 0x3fef3720dcef9069, +0xbc808a1883ccb5d2, 0x3fef3f0b555dc3fa, +0xbc8fad5d3ffffa6f, 0x3fef472d4a07897c, +0xbc900dae3875a949, 0x3fef4f87080d89f2, +0x3c74a385a63d07a7, 0x3fef5818dcfba487, +0xbc82919e2040220f, 0x3fef60e316c98398, +0x3c8e5a50d5c192ac, 0x3fef69e603db3285, +0x3c843a59ac016b4b, 0x3fef7321f301b460, +0xbc82d52107b43e1f, 0x3fef7c97337b9b5f, +0xbc892ab93b470dc9, 0x3fef864614f5a129, +0x3c74b604603a88d3, 0x3fef902ee78b3ff6, +0x3c83c5ec519d7271, 0x3fef9a51fbc74c83, +0xbc8ff7128fd391f0, 0x3fefa4afa2a490da, +0xbc8dae98e223747d, 0x3fefaf482d8e67f1, +0x3c8ec3bc41aa2008, 0x3fefba1bee615a27, +0x3c842b94c3a9eb32, 0x3fefc52b376bba97, +0x3c8a64a931d185ee, 0x3fefd0765b6e4540, +0xbc8e37bae43be3ed, 0x3fefdbfdad9cbe14, +0x3c77893b4d91cd9d, 0x3fefe7c1819e90d8, +0x3c5305c14160cc89, 0x3feff3c22b8f71f1, +#elif N == 256 +0x0, 0x3ff0000000000000, +0xbc84e82fc61851ac, 0x3feffb1afa5abcbf, +0x3c9b3b4f1a88bf6e, 0x3feff63da9fb3335, +0xbc82985dd8521d32, 0x3feff168143b0281, +0xbc7160139cd8dc5d, 0x3fefec9a3e778061, +0x3c651e617061bfbd, 0x3fefe7d42e11bbcc, +0xbc905e7a108766d1, 0x3fefe315e86e7f85, +0x3c845fad437fa426, 0x3fefde5f72f654b1, +0x3c8cd2523567f613, 0x3fefd9b0d3158574, +0xbc954529642b232f, 0x3fefd50a0e3c1f89, +0xbc8bce8023f98efa, 0x3fefd06b29ddf6de, +0x3c8293708ef5c32e, 0x3fefcbd42b72a836, +0x3c60f74e61e6c861, 0x3fefc74518759bc8, +0xbc95b9280905b2a4, 0x3fefc2bdf66607e0, +0x3c90a3e45b33d399, 0x3fefbe3ecac6f383, +0x3c84f31f32c4b7e7, 0x3fefb9c79b1f3919, +0x3c979aa65d837b6d, 0x3fefb5586cf9890f, +0x3c9407fb30d06420, 0x3fefb0f145e46c85, +0x3c8eb51a92fdeffc, 0x3fefac922b7247f7, +0xbc9a5d04b3b9911b, 0x3fefa83b23395dec, +0x3c3ebe3d702f9cd1, 0x3fefa3ec32d3d1a2, +0xbc937a01f0739546, 0x3fef9fa55fdfa9c5, +0xbc6a033489906e0b, 0x3fef9b66affed31b, +0x3c8b8268b04ef0a5, 0x3fef973028d7233e, +0xbc9556522a2fbd0e, 0x3fef9301d0125b51, +0xbc9ac46e44a2ebcc, 0x3fef8edbab5e2ab6, +0xbc5080ef8c4eea55, 0x3fef8abdc06c31cc, +0xbc65704e90c9f860, 0x3fef86a814f204ab, +0xbc91c923b9d5f416, 0x3fef829aaea92de0, +0xbc897cea57e46280, 0x3fef7e95934f312e, +0x3c80d3e3e95c55af, 0x3fef7a98c8a58e51, +0x3c56f01429e2b9d2, 0x3fef76a45471c3c2, +0xbc801b15eaa59348, 0x3fef72b83c7d517b, +0x3c6e653b2459034b, 0x3fef6ed48695bbc0, +0xbc8f1ff055de323d, 0x3fef6af9388c8dea, +0x3c92cc7ea345b7dc, 0x3fef672658375d2f, +0x3c8b898c3f1353bf, 0x3fef635beb6fcb75, +0x3c957bfb2876ea9e, 0x3fef5f99f8138a1c, +0xbc96d99c7611eb26, 0x3fef5be084045cd4, +0x3c8cdc1873af2155, 0x3fef582f95281c6b, +0x3c9aecf73e3a2f60, 0x3fef54873168b9aa, +0xbc9493684653a131, 0x3fef50e75eb44027, +0xbc8fe782cb86389d, 0x3fef4d5022fcd91d, +0xbc98e2899077520a, 0x3fef49c18438ce4d, +0x3c8a6f4144a6c38d, 0x3fef463b88628cd6, +0x3c9120fcd4f59273, 0x3fef42be3578a819, +0x3c807a05b0e4047d, 0x3fef3f49917ddc96, +0x3c89b788c188c9b8, 0x3fef3bdda27912d1, +0x3c968efde3a8a894, 0x3fef387a6e756238, +0x3c877afbca90ef84, 0x3fef351ffb82140a, +0x3c875e18f274487d, 0x3fef31ce4fb2a63f, +0x3c91512f082876ee, 0x3fef2e85711ece75, +0x3c80472b981fe7f2, 0x3fef2b4565e27cdd, +0x3c9a02f0c7d75ec6, 0x3fef280e341ddf29, +0xbc96b87b3f71085e, 0x3fef24dfe1f56381, +0xbc803297e78260bf, 0x3fef21ba7591bb70, +0x3c82f7e16d09ab31, 0x3fef1e9df51fdee1, +0xbc95b77e5ccd9fbf, 0x3fef1b8a66d10f13, +0xbc3d219b1a6fbffa, 0x3fef187fd0dad990, +0xbc91e75c40b4251e, 0x3fef157e39771b2f, +0x3c8b3782720c0ab4, 0x3fef1285a6e4030b, +0x3c98a911f1f7785a, 0x3fef0f961f641589, +0x3c6e149289cecb8f, 0x3fef0cafa93e2f56, +0xbc61e7c998db7dbb, 0x3fef09d24abd886b, +0x3c834d754db0abb6, 0x3fef06fe0a31b715, +0x3c85425c11faadf4, 0x3fef0432edeeb2fd, +0x3c864201e2ac744c, 0x3fef0170fc4cd831, +0xbc979517a03e2847, 0x3feefeb83ba8ea32, +0x3c8fdd395dd3f84a, 0x3feefc08b26416ff, +0xbc800e2a46da4bee, 0x3feef96266e3fa2d, +0xbc86a3803b8e5b04, 0x3feef6c55f929ff1, +0xbc87430803972b34, 0x3feef431a2de883b, +0xbc924aedcc4b5068, 0x3feef1a7373aa9cb, +0xbc954de30ae02d94, 0x3feeef26231e754a, +0xbc9907f81b512d8e, 0x3feeecae6d05d866, +0xbc94f2487e1c03ec, 0x3feeea401b7140ef, +0xbc71d1e83e9436d2, 0x3feee7db34e59ff7, +0x3c914a5432fcb2f4, 0x3feee57fbfec6cf4, +0xbc991919b3ce1b15, 0x3feee32dc313a8e5, +0x3c79c3bba5562a2f, 0x3feee0e544ede173, +0x3c859f48a72a4c6d, 0x3feedea64c123422, +0xbc85a71612e21658, 0x3feedc70df1c5175, +0xbc9312607a28698a, 0x3feeda4504ac801c, +0x3c86421f6f1d24d6, 0x3feed822c367a024, +0xbc58a78f4817895b, 0x3feed60a21f72e2a, +0xbc9348a6815fce65, 0x3feed3fb2709468a, +0xbc7c2c9b67499a1b, 0x3feed1f5d950a897, +0x3c835c43984d9871, 0x3feecffa3f84b9d4, +0x3c4363ed60c2ac11, 0x3feece086061892d, +0xbc632afc8d9473a0, 0x3feecc2042a7d232, +0x3c9666093b0664ef, 0x3feeca41ed1d0057, +0xbc95fc5e44de020e, 0x3feec86d668b3237, +0x3c6ecce1daa10379, 0x3feec6a2b5c13cd0, +0xbc7ea0148327c42f, 0x3feec4e1e192aed2, +0x3c93ff8e3f0f1230, 0x3feec32af0d7d3de, +0xbc7a843ad1a88022, 0x3feec17dea6db7d7, +0x3c7690cebb7aafb0, 0x3feebfdad5362a27, +0x3c892ca3bf144e63, 0x3feebe41b817c114, +0x3c931dbdeb54e077, 0x3feebcb299fddd0d, +0xbc902c99b04aa8b0, 0x3feebb2d81d8abff, +0xbc8f94340071a38e, 0x3feeb9b2769d2ca7, +0x3c73e34f67e67118, 0x3feeb8417f4531ee, +0xbc87deccdc93a349, 0x3feeb6daa2cf6642, +0xbc75a3b1197ba0f0, 0x3feeb57de83f4eef, +0xbc78dec6bd0f385f, 0x3feeb42b569d4f82, +0x3c81bd2888075068, 0x3feeb2e2f4f6ad27, +0xbc861246ec7b5cf6, 0x3feeb1a4ca5d920f, +0xbc896be8ae89ef8f, 0x3feeb070dde910d2, +0x3c93350518fdd78e, 0x3feeaf4736b527da, +0xbc88e6ac90348602, 0x3feeae27dbe2c4cf, +0x3c7b98b72f8a9b05, 0x3feead12d497c7fd, +0xbc91af7f1365c3ac, 0x3feeac0827ff07cc, +0x3c9063e1e21c5409, 0x3feeab07dd485429, +0xbc943a3540d1898a, 0x3feeaa11fba87a03, +0x3c34c7855019c6ea, 0x3feea9268a5946b7, +0xbc951f58ddaa8090, 0x3feea84590998b93, +0x3c9432e62b64c035, 0x3feea76f15ad2148, +0xbc82e1648e50a17c, 0x3feea6a320dceb71, +0xbc8ce44a6199769f, 0x3feea5e1b976dc09, +0x3c95f30eda98a575, 0x3feea52ae6cdf6f4, +0xbc8c33c53bef4da8, 0x3feea47eb03a5585, +0x3c917ecda8a72159, 0x3feea3dd1d1929fd, +0xbc845378892be9ae, 0x3feea34634ccc320, +0xbc9345f3cee1ae6e, 0x3feea2b9febc8fb7, +0xbc93cedd78565858, 0x3feea23882552225, +0xbc85c33fdf910406, 0x3feea1c1c70833f6, +0x3c5710aa807e1964, 0x3feea155d44ca973, +0x3c81079ab5789604, 0x3feea0f4b19e9538, +0xbc93b3efbf5e2228, 0x3feea09e667f3bcd, +0x3c727df161cd7778, 0x3feea052fa75173e, +0xbc6a12ad8734b982, 0x3feea012750bdabf, +0x3c93f9924a05b767, 0x3fee9fdcddd47645, +0xbc6367efb86da9ee, 0x3fee9fb23c651a2f, +0xbc87557939a8b5ef, 0x3fee9f9298593ae5, +0xbc80dc3d54e08851, 0x3fee9f7df9519484, +0x3c51ed2f56fa9d1a, 0x3fee9f7466f42e87, +0xbc781f647e5a3ecf, 0x3fee9f75e8ec5f74, +0xbc88e67a9006c909, 0x3fee9f8286ead08a, +0xbc86ee4ac08b7db0, 0x3fee9f9a48a58174, +0x3c86597566977ac8, 0x3fee9fbd35d7cbfd, +0xbc8619321e55e68a, 0x3fee9feb564267c9, +0x3c92c0b7028a5c3a, 0x3feea024b1ab6e09, +0x3c909ccb5e09d4d3, 0x3feea0694fde5d3f, +0x3c8a30faf49cc78c, 0x3feea0b938ac1cf6, +0xbc7b32dcb94da51d, 0x3feea11473eb0187, +0xbc92dad3519d7b5b, 0x3feea17b0976cfdb, +0x3c94ecfd5467c06b, 0x3feea1ed0130c132, +0x3c87d51410fd15c2, 0x3feea26a62ff86f0, +0x3c65ebe1abd66c55, 0x3feea2f336cf4e62, +0xbc760a3629969871, 0x3feea3878491c491, +0xbc88a1c52fb3cf42, 0x3feea427543e1a12, +0x3c8b18c6e3fdef5d, 0x3feea4d2add106d9, +0xbc9369b6f13b3734, 0x3feea589994cce13, +0x3c90ec1ddcb1390a, 0x3feea64c1eb941f7, +0xbc805e843a19ff1e, 0x3feea71a4623c7ad, +0xbc522cea4f3afa1e, 0x3feea7f4179f5b21, +0xbc94d450d872576e, 0x3feea8d99b4492ed, +0x3c7c88549b958471, 0x3feea9cad931a436, +0x3c90ad675b0e8a00, 0x3feeaac7d98a6699, +0x3c931143962f7877, 0x3feeabd0a478580f, +0x3c8db72fc1f0eab4, 0x3feeace5422aa0db, +0x3c93e9e96f112479, 0x3feeae05bad61778, +0xbc65b6609cc5e7ff, 0x3feeaf3216b5448c, +0xbc8dac42a4a38df0, 0x3feeb06a5e0866d9, +0x3c7bf68359f35f44, 0x3feeb1ae99157736, +0x3c8b99dd98b1ed84, 0x3feeb2fed0282c8a, +0xbc93091fa71e3d83, 0x3feeb45b0b91ffc6, +0xbc7885ad50cbb750, 0x3feeb5c353aa2fe2, +0xbc5da9b88b6c1e29, 0x3feeb737b0cdc5e5, +0xbc82d5e85f3e0301, 0x3feeb8b82b5f98e5, +0xbc6c23f97c90b959, 0x3feeba44cbc8520f, +0xbc51669428996971, 0x3feebbdd9a7670b3, +0xbc92434322f4f9aa, 0x3feebd829fde4e50, +0x3c71f2b2c1c4c014, 0x3feebf33e47a22a2, +0xbc85ca6cd7668e4b, 0x3feec0f170ca07ba, +0xbc9294f304f166b6, 0x3feec2bb4d53fe0d, +0x3c71affc2b91ce27, 0x3feec49182a3f090, +0xbc8a1e58414c07d3, 0x3feec674194bb8d5, +0x3c6dd235e10a73bb, 0x3feec86319e32323, +0xbc79740b58a20091, 0x3feeca5e8d07f29e, +0xbc87c50422622263, 0x3feecc667b5de565, +0x3c9165830a2b96c2, 0x3feece7aed8eb8bb, +0x3c8b1c86e3e231d5, 0x3feed09bec4a2d33, +0xbc903d5cbe27874b, 0x3feed2c980460ad8, +0xbc91bbd1d3bcbb15, 0x3feed503b23e255d, +0x3c5986178980fce0, 0x3feed74a8af46052, +0x3c90cc319cee31d2, 0x3feed99e1330b358, +0xbc89472975b1f2a5, 0x3feedbfe53c12e59, +0x3c8469846e735ab3, 0x3feede6b5579fdbf, +0x3c7d8157a34b7e7f, 0x3feee0e521356eba, +0xbc82dfcd978e9db4, 0x3feee36bbfd3f37a, +0x3c8c8a4e231ebb7d, 0x3feee5ff3a3c2774, +0x3c8c1a7792cb3387, 0x3feee89f995ad3ad, +0xbc888c8d11a142e5, 0x3feeeb4ce622f2ff, +0xbc907b8f4ad1d9fa, 0x3feeee07298db666, +0x3c889c2ea41433c7, 0x3feef0ce6c9a8952, +0xbc55c3d956dcaeba, 0x3feef3a2b84f15fb, +0xbc7274aedac8ff80, 0x3feef68415b749b1, +0xbc90a40e3da6f640, 0x3feef9728de5593a, +0x3c85c620ce76df06, 0x3feefc6e29f1c52a, +0xbc68d6f438ad9334, 0x3feeff76f2fb5e47, +0xbc8fda52e1b51e41, 0x3fef028cf22749e4, +0xbc91eee26b588a35, 0x3fef05b030a1064a, +0xbc32141a7b3e2cd8, 0x3fef08e0b79a6f1f, +0x3c74ffd70a5fddcd, 0x3fef0c1e904bc1d2, +0xbc302899507554e5, 0x3fef0f69c3f3a207, +0xbc91bdfbfa9298ac, 0x3fef12c25bd71e09, +0xbc80dda2d4c0010c, 0x3fef16286141b33d, +0x3c736eae30af0cb3, 0x3fef199bdd85529c, +0xbc8a007daadf8d68, 0x3fef1d1cd9fa652c, +0x3c8ee3325c9ffd94, 0x3fef20ab5fffd07a, +0x3c836909391181d3, 0x3fef244778fafb22, +0x3c84e08fd10959ac, 0x3fef27f12e57d14b, +0xbc811cd7dbdf9547, 0x3fef2ba88988c933, +0x3c63cdaf384e1a67, 0x3fef2f6d9406e7b5, +0xbc7ac28b7bef6621, 0x3fef33405751c4db, +0x3c676b2c6c921968, 0x3fef3720dcef9069, +0xbc7030587207b9e1, 0x3fef3b0f2e6d1675, +0xbc808a1883ccb5d2, 0x3fef3f0b555dc3fa, +0xbc8cc734592af7fc, 0x3fef43155b5bab74, +0xbc8fad5d3ffffa6f, 0x3fef472d4a07897c, +0x3c87752a44f587e8, 0x3fef4b532b08c968, +0xbc900dae3875a949, 0x3fef4f87080d89f2, +0x3c85b66fefeef52e, 0x3fef53c8eacaa1d6, +0x3c74a385a63d07a7, 0x3fef5818dcfba487, +0x3c5159d9d908a96e, 0x3fef5c76e862e6d3, +0xbc82919e2040220f, 0x3fef60e316c98398, +0x3c8c254d16117a68, 0x3fef655d71ff6075, +0x3c8e5a50d5c192ac, 0x3fef69e603db3285, +0xbc8d8c329fbd0e03, 0x3fef6e7cd63a8315, +0x3c843a59ac016b4b, 0x3fef7321f301b460, +0xbc8ea6e6fbd5f2a6, 0x3fef77d5641c0658, +0xbc82d52107b43e1f, 0x3fef7c97337b9b5f, +0xbc63e8e3eab2cbb4, 0x3fef81676b197d17, +0xbc892ab93b470dc9, 0x3fef864614f5a129, +0xbc8b7966cd0d2cd9, 0x3fef8b333b16ee12, +0x3c74b604603a88d3, 0x3fef902ee78b3ff6, +0xbc776caa4c2ff1cf, 0x3fef953924676d76, +0x3c83c5ec519d7271, 0x3fef9a51fbc74c83, +0xbc81d5fc525d9940, 0x3fef9f7977cdb740, +0xbc8ff7128fd391f0, 0x3fefa4afa2a490da, +0x3c855cd8aaea3d21, 0x3fefa9f4867cca6e, +0xbc8dae98e223747d, 0x3fefaf482d8e67f1, +0x3c8269947c2bed4a, 0x3fefb4aaa2188510, +0x3c8ec3bc41aa2008, 0x3fefba1bee615a27, +0xbc83b6137e9afe9e, 0x3fefbf9c1cb6412a, +0x3c842b94c3a9eb32, 0x3fefc52b376bba97, +0xbc69fa74878ba7c7, 0x3fefcac948dd7274, +0x3c8a64a931d185ee, 0x3fefd0765b6e4540, +0x3c901f3a75ee0efe, 0x3fefd632798844f8, +0xbc8e37bae43be3ed, 0x3fefdbfdad9cbe14, +0xbc516a9ce6ed84fa, 0x3fefe1d802243c89, +0x3c77893b4d91cd9d, 0x3fefe7c1819e90d8, +0xbc699c7db2effc76, 0x3fefedba3692d514, +0x3c5305c14160cc89, 0x3feff3c22b8f71f1, +0x3c64b458677f9840, 0x3feff9d96b2a23d9, +#elif N == 512 +0x0, 0x3ff0000000000000, +0xbc75d87ade1f60d5, 0x3feffd8c86da1c0a, +0xbc84e82fc61851ac, 0x3feffb1afa5abcbf, +0x3c9bffdaa7ac4bac, 0x3feff8ab5b2cbd11, +0x3c9b3b4f1a88bf6e, 0x3feff63da9fb3335, +0x3c75c18e5ae0563a, 0x3feff3d1e77170b4, +0xbc82985dd8521d32, 0x3feff168143b0281, +0xbc705b1125cf49a5, 0x3fefef003103b10e, +0xbc7160139cd8dc5d, 0x3fefec9a3e778061, +0x3c9f879abbff3f87, 0x3fefea363d42b027, +0x3c651e617061bfbd, 0x3fefe7d42e11bbcc, +0x3c9b14003824712a, 0x3fefe57411915a8a, +0xbc905e7a108766d1, 0x3fefe315e86e7f85, +0x3c61cbf0f38af658, 0x3fefe0b9b35659d8, +0x3c845fad437fa426, 0x3fefde5f72f654b1, +0xbc9a3316383dcbc5, 0x3fefdc0727fc1762, +0x3c8cd2523567f613, 0x3fefd9b0d3158574, +0x3c9901c9e0e797fd, 0x3fefd75c74f0bec2, +0xbc954529642b232f, 0x3fefd50a0e3c1f89, +0xbc89b3236d111646, 0x3fefd2b99fa6407c, +0xbc8bce8023f98efa, 0x3fefd06b29ddf6de, +0xbc8cb191be99b1b0, 0x3fefce1ead925493, +0x3c8293708ef5c32e, 0x3fefcbd42b72a836, +0xbc9acb71e83765b7, 0x3fefc98ba42e7d30, +0x3c60f74e61e6c861, 0x3fefc74518759bc8, +0x3c5cd3e58b03697e, 0x3fefc50088f8093f, +0xbc95b9280905b2a4, 0x3fefc2bdf66607e0, +0xbc8bfb07d4755452, 0x3fefc07d61701716, +0x3c90a3e45b33d399, 0x3fefbe3ecac6f383, +0x3c8aedeb3e7b14cd, 0x3fefbc02331b9715, +0x3c84f31f32c4b7e7, 0x3fefb9c79b1f3919, +0x3c9a8eb1f3d914b4, 0x3fefb78f03834e52, +0x3c979aa65d837b6d, 0x3fefb5586cf9890f, +0xbc85b9eb0402507b, 0x3fefb323d833d93f, +0x3c9407fb30d06420, 0x3fefb0f145e46c85, +0xbc93f0f225bbf3ee, 0x3fefaec0b6bdae53, +0x3c8eb51a92fdeffc, 0x3fefac922b7247f7, +0xbc9c3fe7282d1784, 0x3fefaa65a4b520ba, +0xbc9a5d04b3b9911b, 0x3fefa83b23395dec, +0x3c9c8be44bf4cde8, 0x3fefa612a7b26300, +0x3c3ebe3d702f9cd1, 0x3fefa3ec32d3d1a2, +0x3c820c5444c93c44, 0x3fefa1c7c55189c6, +0xbc937a01f0739546, 0x3fef9fa55fdfa9c5, +0xbc84c6baeb580d7a, 0x3fef9d8503328e6d, +0xbc6a033489906e0b, 0x3fef9b66affed31b, +0x3c8657aa1b0d9f83, 0x3fef994a66f951ce, +0x3c8b8268b04ef0a5, 0x3fef973028d7233e, +0x3c62f2c7fd6ee145, 0x3fef9517f64d9ef1, +0xbc9556522a2fbd0e, 0x3fef9301d0125b51, +0xbc6b0b2789925e90, 0x3fef90edb6db2dc1, +0xbc9ac46e44a2ebcc, 0x3fef8edbab5e2ab6, +0xbc93aad17d197fae, 0x3fef8ccbae51a5c8, +0xbc5080ef8c4eea55, 0x3fef8abdc06c31cc, +0xbc989c464a07ad70, 0x3fef88b1e264a0e9, +0xbc65704e90c9f860, 0x3fef86a814f204ab, +0xbc72c338fce197f4, 0x3fef84a058cbae1e, +0xbc91c923b9d5f416, 0x3fef829aaea92de0, +0xbc6dca724cea0eb6, 0x3fef809717425438, +0xbc897cea57e46280, 0x3fef7e95934f312e, +0x3c464770b955d34d, 0x3fef7c962388149e, +0x3c80d3e3e95c55af, 0x3fef7a98c8a58e51, +0xbc962811c114424f, 0x3fef789d83606e12, +0x3c56f01429e2b9d2, 0x3fef76a45471c3c2, +0x3c8ec58e74904dd4, 0x3fef74ad3c92df73, +0xbc801b15eaa59348, 0x3fef72b83c7d517b, +0x3c8d63b0ab2d5bbf, 0x3fef70c554eaea89, +0x3c6e653b2459034b, 0x3fef6ed48695bbc0, +0xbc9ca9effbeeac92, 0x3fef6ce5d23816c9, +0xbc8f1ff055de323d, 0x3fef6af9388c8dea, +0x3c8bda920de0f6e2, 0x3fef690eba4df41f, +0x3c92cc7ea345b7dc, 0x3fef672658375d2f, +0xbc9a597f9a5ff71c, 0x3fef654013041dc2, +0x3c8b898c3f1353bf, 0x3fef635beb6fcb75, +0x3c50835b125aa573, 0x3fef6179e2363cf8, +0x3c957bfb2876ea9e, 0x3fef5f99f8138a1c, +0x3c8aaa13d61aec1f, 0x3fef5dbc2dc40bf0, +0xbc96d99c7611eb26, 0x3fef5be084045cd4, +0x3c8a4f81aa7110bd, 0x3fef5a06fb91588f, +0x3c8cdc1873af2155, 0x3fef582f95281c6b, +0xbc6817fd6a313e3e, 0x3fef565a51860746, +0x3c9aecf73e3a2f60, 0x3fef54873168b9aa, +0xbc96236af85fd26a, 0x3fef52b6358e15e8, +0xbc9493684653a131, 0x3fef50e75eb44027, +0x3c7795eb4523abe7, 0x3fef4f1aad999e82, +0xbc8fe782cb86389d, 0x3fef4d5022fcd91d, +0x3c8fe58b91b40095, 0x3fef4b87bf9cda38, +0xbc98e2899077520a, 0x3fef49c18438ce4d, +0x3c91ecaa860c614a, 0x3fef47fd7190241e, +0x3c8a6f4144a6c38d, 0x3fef463b88628cd6, +0xbc3e45c83ba0bbcb, 0x3fef447bc96ffc18, +0x3c9120fcd4f59273, 0x3fef42be3578a819, +0xbc29fd3bea07b4ee, 0x3fef4102cd3d09b9, +0x3c807a05b0e4047d, 0x3fef3f49917ddc96, +0x3c87f1c7350e256d, 0x3fef3d9282fc1f27, +0x3c89b788c188c9b8, 0x3fef3bdda27912d1, +0x3c420dac6c124f4f, 0x3fef3a2af0b63bff, +0x3c968efde3a8a894, 0x3fef387a6e756238, +0xbc99501d09bc09fd, 0x3fef36cc1c78903a, +0x3c877afbca90ef84, 0x3fef351ffb82140a, +0x3c73baf864dc8675, 0x3fef33760c547f15, +0x3c875e18f274487d, 0x3fef31ce4fb2a63f, +0x3c91b0575c1eaf54, 0x3fef3028c65fa1ff, +0x3c91512f082876ee, 0x3fef2e85711ece75, +0xbc90364bc9ce33ab, 0x3fef2ce450b3cb82, +0x3c80472b981fe7f2, 0x3fef2b4565e27cdd, +0xbc7548165d85ed32, 0x3fef29a8b16f0a30, +0x3c9a02f0c7d75ec6, 0x3fef280e341ddf29, +0x3c7c3b977a68e32c, 0x3fef2675eeb3ab98, +0xbc96b87b3f71085e, 0x3fef24dfe1f56381, +0xbc93a255f697ecfe, 0x3fef234c0ea83f36, +0xbc803297e78260bf, 0x3fef21ba7591bb70, +0x3c8d2d19edc1e550, 0x3fef202b17779965, +0x3c82f7e16d09ab31, 0x3fef1e9df51fdee1, +0xbc76b2173113dd8c, 0x3fef1d130f50d65c, +0xbc95b77e5ccd9fbf, 0x3fef1b8a66d10f13, +0x3c811aa5f853590b, 0x3fef1a03fc675d1f, +0xbc3d219b1a6fbffa, 0x3fef187fd0dad990, +0x3c61d61a34c8aa02, 0x3fef16fde4f2e280, +0xbc91e75c40b4251e, 0x3fef157e39771b2f, +0xbc91f892bf6b286d, 0x3fef1400cf2f6c18, +0x3c8b3782720c0ab4, 0x3fef1285a6e4030b, +0x3c7590c65c20e680, 0x3fef110cc15d5346, +0x3c98a911f1f7785a, 0x3fef0f961f641589, +0x3c86fe320b5c1e9d, 0x3fef0e21c1c14833, +0x3c6e149289cecb8f, 0x3fef0cafa93e2f56, +0xbc903cd8b2f25790, 0x3fef0b3fd6a454d2, +0xbc61e7c998db7dbb, 0x3fef09d24abd886b, +0x3c7b3bf786a54a87, 0x3fef08670653dfe4, +0x3c834d754db0abb6, 0x3fef06fe0a31b715, +0x3c74bb6c41732885, 0x3fef05975721b004, +0x3c85425c11faadf4, 0x3fef0432edeeb2fd, +0xbc99d7399abb9a8b, 0x3fef02d0cf63eeac, +0x3c864201e2ac744c, 0x3fef0170fc4cd831, +0xbc5451d60c6ac9eb, 0x3fef001375752b40, +0xbc979517a03e2847, 0x3feefeb83ba8ea32, +0x3c8787a210ceafd9, 0x3feefd5f4fb45e20, +0x3c8fdd395dd3f84a, 0x3feefc08b26416ff, +0xbc888d1e4629943d, 0x3feefab46484ebb4, +0xbc800e2a46da4bee, 0x3feef96266e3fa2d, +0xbc93369c544088b6, 0x3feef812ba4ea77d, +0xbc86a3803b8e5b04, 0x3feef6c55f929ff1, +0x3c85373ce4eb6dfb, 0x3feef57a577dd72b, +0xbc87430803972b34, 0x3feef431a2de883b, +0x3c83adec8265a67f, 0x3feef2eb428335b4, +0xbc924aedcc4b5068, 0x3feef1a7373aa9cb, +0xbc835388bcac6bc5, 0x3feef06581d3f669, +0xbc954de30ae02d94, 0x3feeef26231e754a, +0x3c727cdb4e4b6640, 0x3feeede91be9c811, +0xbc9907f81b512d8e, 0x3feeecae6d05d866, +0x3c86c2696a26af35, 0x3feeeb761742d808, +0xbc94f2487e1c03ec, 0x3feeea401b7140ef, +0x3c888f6ff06b979a, 0x3feee90c7a61d55b, +0xbc71d1e83e9436d2, 0x3feee7db34e59ff7, +0xbc89d5efaabc2030, 0x3feee6ac4bcdf3ea, +0x3c914a5432fcb2f4, 0x3feee57fbfec6cf4, +0xbc76b8867f91c9d6, 0x3feee4559212ef89, +0xbc991919b3ce1b15, 0x3feee32dc313a8e5, +0x3c94c9c0b5157fe6, 0x3feee20853c10f28, +0x3c79c3bba5562a2f, 0x3feee0e544ede173, +0xbc62455345b51c8e, 0x3feedfc4976d27fa, +0x3c859f48a72a4c6d, 0x3feedea64c123422, +0xbc93331de45477d0, 0x3feedd8a63b0a09b, +0xbc85a71612e21658, 0x3feedc70df1c5175, +0xbc95f84d39b39b16, 0x3feedb59bf29743f, +0xbc9312607a28698a, 0x3feeda4504ac801c, +0xbc72ba4dc7c4d562, 0x3feed932b07a35df, +0x3c86421f6f1d24d6, 0x3feed822c367a024, +0xbc844f25dc02691f, 0x3feed7153e4a136a, +0xbc58a78f4817895b, 0x3feed60a21f72e2a, +0xbc888d328eb9b501, 0x3feed5016f44d8f5, +0xbc9348a6815fce65, 0x3feed3fb2709468a, +0x3c7f0bec42ddb15a, 0x3feed2f74a1af3f1, +0xbc7c2c9b67499a1b, 0x3feed1f5d950a897, +0xbc615f0a2b9cd452, 0x3feed0f6d5817663, +0x3c835c43984d9871, 0x3feecffa3f84b9d4, +0xbc8c2e465a919e1d, 0x3feecf0018321a1a, +0x3c4363ed60c2ac11, 0x3feece086061892d, +0xbc865dfd02bd08f1, 0x3feecd1318eb43ec, +0xbc632afc8d9473a0, 0x3feecc2042a7d232, +0xbc8e68cec89b1762, 0x3feecb2fde7006f4, +0x3c9666093b0664ef, 0x3feeca41ed1d0057, +0xbc48ae858eb682ca, 0x3feec9566f8827d0, +0xbc95fc5e44de020e, 0x3feec86d668b3237, +0x3c5dd71277c0915f, 0x3feec786d3001fe5, +0x3c6ecce1daa10379, 0x3feec6a2b5c13cd0, +0x3c92001325ecd7fb, 0x3feec5c10fa920a1, +0xbc7ea0148327c42f, 0x3feec4e1e192aed2, +0x3c65ace6e2870332, 0x3feec4052c5916c4, +0x3c93ff8e3f0f1230, 0x3feec32af0d7d3de, +0xbc9595c55690ffaf, 0x3feec2532feaada6, +0xbc7a843ad1a88022, 0x3feec17dea6db7d7, +0xbc8b401ba9fb5199, 0x3feec0ab213d5283, +0x3c7690cebb7aafb0, 0x3feebfdad5362a27, +0x3c6df82bf324cc57, 0x3feebf0d073537ca, +0x3c892ca3bf144e63, 0x3feebe41b817c114, +0x3c97cae38641c7bb, 0x3feebd78e8bb586b, +0x3c931dbdeb54e077, 0x3feebcb299fddd0d, +0x3c62d80c5c4a2b67, 0x3feebbeeccbd7b2a, +0xbc902c99b04aa8b0, 0x3feebb2d81d8abff, +0x3c8f39c10d12eaf0, 0x3feeba6eba2e35f0, +0xbc8f94340071a38e, 0x3feeb9b2769d2ca7, +0xbc80b582d74a55d9, 0x3feeb8f8b804f127, +0x3c73e34f67e67118, 0x3feeb8417f4531ee, +0xbc6b4e327ff434ca, 0x3feeb78ccd3deb0d, +0xbc87deccdc93a349, 0x3feeb6daa2cf6642, +0xbc592dca38593e20, 0x3feeb62b00da3b14, +0xbc75a3b1197ba0f0, 0x3feeb57de83f4eef, +0xbc85daca9994833e, 0x3feeb4d359dfd53d, +0xbc78dec6bd0f385f, 0x3feeb42b569d4f82, +0xbc980b4321bc6dae, 0x3feeb385df598d78, +0x3c81bd2888075068, 0x3feeb2e2f4f6ad27, +0xbc8390afec5241c5, 0x3feeb24298571b06, +0xbc861246ec7b5cf6, 0x3feeb1a4ca5d920f, +0x3c8f15cdafe7d586, 0x3feeb1098bed1bdf, +0xbc896be8ae89ef8f, 0x3feeb070dde910d2, +0xbc910aa91ae9b67f, 0x3feeafdac1351819, +0x3c93350518fdd78e, 0x3feeaf4736b527da, +0x3c957e1b67462375, 0x3feeaeb63f4d854c, +0xbc88e6ac90348602, 0x3feeae27dbe2c4cf, +0x3c8124d5051552a7, 0x3feead9c0d59ca07, +0x3c7b98b72f8a9b05, 0x3feead12d497c7fd, +0xbc3ca103952ecf1f, 0x3feeac8c32824135, +0xbc91af7f1365c3ac, 0x3feeac0827ff07cc, +0x3c773345c02a4fd6, 0x3feeab86b5f43d92, +0x3c9063e1e21c5409, 0x3feeab07dd485429, +0xbc909d2a0fce20f2, 0x3feeaa8b9ee20d1e, +0xbc943a3540d1898a, 0x3feeaa11fba87a03, +0xbc924f2cb4f81746, 0x3feea99af482fc8f, +0x3c34c7855019c6ea, 0x3feea9268a5946b7, +0xbc943592a0a9846b, 0x3feea8b4be135acc, +0xbc951f58ddaa8090, 0x3feea84590998b93, +0xbc956bc85d444f4f, 0x3feea7d902d47c65, +0x3c9432e62b64c035, 0x3feea76f15ad2148, +0x3c914d1e4218319f, 0x3feea707ca0cbf0f, +0xbc82e1648e50a17c, 0x3feea6a320dceb71, +0x3c971c93709313f4, 0x3feea6411b078d26, +0xbc8ce44a6199769f, 0x3feea5e1b976dc09, +0x3c7f88303b60d222, 0x3feea584fd15612a, +0x3c95f30eda98a575, 0x3feea52ae6cdf6f4, +0x3c70125ca18d4b5b, 0x3feea4d3778bc944, +0xbc8c33c53bef4da8, 0x3feea47eb03a5585, +0x3c9592ea73798b11, 0x3feea42c91c56acd, +0x3c917ecda8a72159, 0x3feea3dd1d1929fd, +0xbc9371d6d7d75739, 0x3feea390532205d8, +0xbc845378892be9ae, 0x3feea34634ccc320, +0xbc8ac05fd996f807, 0x3feea2fec30678b7, +0xbc9345f3cee1ae6e, 0x3feea2b9febc8fb7, +0xbc91f5067d03653a, 0x3feea277e8dcc390, +0xbc93cedd78565858, 0x3feea23882552225, +0x3c917339c86ce3ad, 0x3feea1fbcc140be7, +0xbc85c33fdf910406, 0x3feea1c1c70833f6, +0xbc77e66065ba2500, 0x3feea18a7420a036, +0x3c5710aa807e1964, 0x3feea155d44ca973, +0x3c964c827ee6b49a, 0x3feea123e87bfb7a, +0x3c81079ab5789604, 0x3feea0f4b19e9538, +0xbc928311a3c73480, 0x3feea0c830a4c8d4, +0xbc93b3efbf5e2228, 0x3feea09e667f3bcd, +0x3c882c79e185e981, 0x3feea077541ee718, +0x3c727df161cd7778, 0x3feea052fa75173e, +0xbc8b48cea80b043b, 0x3feea0315a736c75, +0xbc6a12ad8734b982, 0x3feea012750bdabf, +0xbc4f4863bc8e5180, 0x3fee9ff64b30aa09, +0x3c93f9924a05b767, 0x3fee9fdcddd47645, +0x3c954835dd4b7548, 0x3fee9fc62dea2f8a, +0xbc6367efb86da9ee, 0x3fee9fb23c651a2f, +0xbc8bf41f59b59f8a, 0x3fee9fa10a38cee8, +0xbc87557939a8b5ef, 0x3fee9f9298593ae5, +0xbc8f652fde52775c, 0x3fee9f86e7ba9fef, +0xbc80dc3d54e08851, 0x3fee9f7df9519484, +0xbc7b0300defbcf98, 0x3fee9f77ce1303f6, +0x3c51ed2f56fa9d1a, 0x3fee9f7466f42e87, +0xbc89dab646035dc0, 0x3fee9f73c4eaa988, +0xbc781f647e5a3ecf, 0x3fee9f75e8ec5f74, +0xbc91f0c230588dde, 0x3fee9f7ad3ef9011, +0xbc88e67a9006c909, 0x3fee9f8286ead08a, +0x3c9106450507a28c, 0x3fee9f8d02d50b8f, +0xbc86ee4ac08b7db0, 0x3fee9f9a48a58174, +0xbc9129729a10f3a0, 0x3fee9faa5953c849, +0x3c86597566977ac8, 0x3fee9fbd35d7cbfd, +0x3c781a70a5124f67, 0x3fee9fd2df29ce7c, +0xbc8619321e55e68a, 0x3fee9feb564267c9, +0x3c941626ea62646d, 0x3feea0069c1a861d, +0x3c92c0b7028a5c3a, 0x3feea024b1ab6e09, +0xbc940b9f54365b7c, 0x3feea04597eeba8f, +0x3c909ccb5e09d4d3, 0x3feea0694fde5d3f, +0x3c873455e0e826c1, 0x3feea08fda749e5d, +0x3c8a30faf49cc78c, 0x3feea0b938ac1cf6, +0x3c94f006ad874e3e, 0x3feea0e56b7fcf03, +0xbc7b32dcb94da51d, 0x3feea11473eb0187, +0xbc8f6d693d0973bb, 0x3feea14652e958aa, +0xbc92dad3519d7b5b, 0x3feea17b0976cfdb, +0x3c58c5ee2b7e7848, 0x3feea1b2988fb9ec, +0x3c94ecfd5467c06b, 0x3feea1ed0130c132, +0xbc88b25e045d207b, 0x3feea22a4456e7a3, +0x3c87d51410fd15c2, 0x3feea26a62ff86f0, +0xbc69cb3314060ca7, 0x3feea2ad5e2850ac, +0x3c65ebe1abd66c55, 0x3feea2f336cf4e62, +0x3c87a0b15d19e0bb, 0x3feea33bedf2e1b9, +0xbc760a3629969871, 0x3feea3878491c491, +0x3c94aa7212bfa73c, 0x3feea3d5fbab091f, +0xbc88a1c52fb3cf42, 0x3feea427543e1a12, +0xbc81e688272a8a12, 0x3feea47b8f4abaa9, +0x3c8b18c6e3fdef5d, 0x3feea4d2add106d9, +0x3c4ab7b7112ec9d5, 0x3feea52cb0d1736a, +0xbc9369b6f13b3734, 0x3feea589994cce13, +0x3c8a1e274eed4476, 0x3feea5e968443d9a, +0x3c90ec1ddcb1390a, 0x3feea64c1eb941f7, +0x3c94a533a59324da, 0x3feea6b1bdadb46d, +0xbc805e843a19ff1e, 0x3feea71a4623c7ad, +0x3c7a56d2760d087d, 0x3feea785b91e07f1, +0xbc522cea4f3afa1e, 0x3feea7f4179f5b21, +0x3c91682c1c6e8b05, 0x3feea86562ab00ec, +0xbc94d450d872576e, 0x3feea8d99b4492ed, +0x3c89ea99cf7a9591, 0x3feea950c27004c2, +0x3c7c88549b958471, 0x3feea9cad931a436, +0xbc59e57d8f92ff8e, 0x3feeaa47e08e1957, +0x3c90ad675b0e8a00, 0x3feeaac7d98a6699, +0x3c909b176e05a9cd, 0x3feeab4ac52be8f7, +0x3c931143962f7877, 0x3feeabd0a478580f, +0x3c711607f1952c95, 0x3feeac597875c644, +0x3c8db72fc1f0eab4, 0x3feeace5422aa0db, +0x3c869608f0f86431, 0x3feead74029db01e, +0x3c93e9e96f112479, 0x3feeae05bad61778, +0xbc7f1ced15c5c5c0, 0x3feeae9a6bdb5598, +0xbc65b6609cc5e7ff, 0x3feeaf3216b5448c, +0x3c614b97be3f7b4e, 0x3feeafccbc6c19e6, +0xbc8dac42a4a38df0, 0x3feeb06a5e0866d9, +0x3c81c1701c359530, 0x3feeb10afc931857, +0x3c7bf68359f35f44, 0x3feeb1ae99157736, +0xbc8edb1bf6809287, 0x3feeb2553499284b, +0x3c8b99dd98b1ed84, 0x3feeb2fed0282c8a, +0xbc8ba58ce7a736d3, 0x3feeb3ab6ccce12c, +0xbc93091fa71e3d83, 0x3feeb45b0b91ffc6, +0xbc93fc025e1db9ce, 0x3feeb50dad829e70, +0xbc7885ad50cbb750, 0x3feeb5c353aa2fe2, +0xbc8d737c7d71382e, 0x3feeb67bff148396, +0xbc5da9b88b6c1e29, 0x3feeb737b0cdc5e5, +0x3c6ae88c43905293, 0x3feeb7f669e2802b, +0xbc82d5e85f3e0301, 0x3feeb8b82b5f98e5, +0xbc93d1f7661fe51b, 0x3feeb97cf65253d1, +0xbc6c23f97c90b959, 0x3feeba44cbc8520f, +0x3c651b68797ffc1c, 0x3feebb0faccf9243, +0xbc51669428996971, 0x3feebbdd9a7670b3, +0x3c54579c5ceed70b, 0x3feebcae95cba768, +0xbc92434322f4f9aa, 0x3feebd829fde4e50, +0x3c87298413381667, 0x3feebe59b9bddb5b, +0x3c71f2b2c1c4c014, 0x3feebf33e47a22a2, +0xbc905000be64e965, 0x3feec01121235681, +0xbc85ca6cd7668e4b, 0x3feec0f170ca07ba, +0xbc89fb12e3454b73, 0x3feec1d4d47f2598, +0xbc9294f304f166b6, 0x3feec2bb4d53fe0d, +0x3c7be2a03697693b, 0x3feec3a4dc5a3dd3, +0x3c71affc2b91ce27, 0x3feec49182a3f090, +0x3c90622b15810eea, 0x3feec581414380f2, +0xbc8a1e58414c07d3, 0x3feec674194bb8d5, +0x3be9a5ecc875d327, 0x3feec76a0bcfc15e, +0x3c6dd235e10a73bb, 0x3feec86319e32323, +0x3c88ea486a3350ef, 0x3feec95f4499c647, +0xbc79740b58a20091, 0x3feeca5e8d07f29e, +0xbc7a2ee551d4c40f, 0x3feecb60f4424fcb, +0xbc87c50422622263, 0x3feecc667b5de565, +0x3c89c31f7e38028b, 0x3feecd6f23701b15, +0x3c9165830a2b96c2, 0x3feece7aed8eb8bb, +0xbc5fac13f4e005a3, 0x3feecf89dacfe68c, +0x3c8b1c86e3e231d5, 0x3feed09bec4a2d33, +0x3c7d8aced7162e89, 0x3feed1b1231475f7, +0xbc903d5cbe27874b, 0x3feed2c980460ad8, +0xbc848f50cea7269f, 0x3feed3e504f696b1, +0xbc91bbd1d3bcbb15, 0x3feed503b23e255d, +0x3c821eb9a08a0542, 0x3feed625893523d4, +0x3c5986178980fce0, 0x3feed74a8af46052, +0xbc6133a953131cfd, 0x3feed872b8950a73, +0x3c90cc319cee31d2, 0x3feed99e1330b358, +0x3c89e95e6f4a0ae4, 0x3feedacc9be14dca, +0xbc89472975b1f2a5, 0x3feedbfe53c12e59, +0xbc90260cf07cb311, 0x3feedd333beb0b7e, +0x3c8469846e735ab3, 0x3feede6b5579fdbf, +0x3c1bca400a7b939d, 0x3feedfa6a1897fd2, +0x3c7d8157a34b7e7f, 0x3feee0e521356eba, +0x3c9140bc34dfc19f, 0x3feee226d59a09ee, +0xbc82dfcd978e9db4, 0x3feee36bbfd3f37a, +0xbc8c9b1da461ab87, 0x3feee4b3e100301e, +0x3c8c8a4e231ebb7d, 0x3feee5ff3a3c2774, +0x3c8c115f23ebea8e, 0x3feee74dcca5a413, +0x3c8c1a7792cb3387, 0x3feee89f995ad3ad, +0xbc6dcab99f23f84e, 0x3feee9f4a17a4735, +0xbc888c8d11a142e5, 0x3feeeb4ce622f2ff, +0x3c60a43e8b7e4bfe, 0x3feeeca868742ee4, +0xbc907b8f4ad1d9fa, 0x3feeee07298db666, +0x3c915b1397075f04, 0x3feeef692a8fa8cd, +0x3c889c2ea41433c7, 0x3feef0ce6c9a8952, +0xbc839f7a1f04d2b0, 0x3feef236f0cf3f3a, +0xbc55c3d956dcaeba, 0x3feef3a2b84f15fb, +0xbc86a510f31e13e6, 0x3feef511c43bbd62, +0xbc7274aedac8ff80, 0x3feef68415b749b1, +0xbc92887ea88e7340, 0x3feef7f9ade433c6, +0xbc90a40e3da6f640, 0x3feef9728de5593a, +0xbc6e57ac604759ba, 0x3feefaeeb6ddfc87, +0x3c85c620ce76df06, 0x3feefc6e29f1c52a, +0x3c8e6c6db4f83226, 0x3feefdf0e844bfc6, +0xbc68d6f438ad9334, 0x3feeff76f2fb5e47, +0xbc8d1bf10460dba0, 0x3fef01004b3a7804, +0xbc8fda52e1b51e41, 0x3fef028cf22749e4, +0x3c8e5d80813dddfc, 0x3fef041ce8e77680, +0xbc91eee26b588a35, 0x3fef05b030a1064a, +0x3c8caff9640f2dcb, 0x3fef0746ca7a67a7, +0xbc32141a7b3e2cd8, 0x3fef08e0b79a6f1f, +0x3c7a77557fd62db3, 0x3fef0a7df9285775, +0x3c74ffd70a5fddcd, 0x3fef0c1e904bc1d2, +0xbc651ba6128db749, 0x3fef0dc27e2cb5e5, +0xbc302899507554e5, 0x3fef0f69c3f3a207, +0xbc7c0ffefdc5e251, 0x3fef111462c95b60, +0xbc91bdfbfa9298ac, 0x3fef12c25bd71e09, +0xbc8b6cd058bfd6fa, 0x3fef1473b0468d30, +0xbc80dda2d4c0010c, 0x3fef16286141b33d, +0x3c923759b8aca76d, 0x3fef17e06ff301f4, +0x3c736eae30af0cb3, 0x3fef199bdd85529c, +0xbc895498a73dac7d, 0x3fef1b5aab23e61e, +0xbc8a007daadf8d68, 0x3fef1d1cd9fa652c, +0x3c851de924583108, 0x3fef1ee26b34e065, +0x3c8ee3325c9ffd94, 0x3fef20ab5fffd07a, +0xbc8c5fe4051ba06c, 0x3fef2277b9881650, +0x3c836909391181d3, 0x3fef244778fafb22, +0xbc6d1816c0a9ac07, 0x3fef261a9f8630ad, +0x3c84e08fd10959ac, 0x3fef27f12e57d14b, +0xbc7af5c67c4e8235, 0x3fef29cb269e601f, +0xbc811cd7dbdf9547, 0x3fef2ba88988c933, +0xbc8304ef0045d575, 0x3fef2d89584661a1, +0x3c63cdaf384e1a67, 0x3fef2f6d9406e7b5, +0x3c8725f94f910375, 0x3fef31553dfa8313, +0xbc7ac28b7bef6621, 0x3fef33405751c4db, +0x3c7b53e99f9191e8, 0x3fef352ee13da7cb, +0x3c676b2c6c921968, 0x3fef3720dcef9069, +0xbc810a79e6d7e2b8, 0x3fef39164b994d23, +0xbc7030587207b9e1, 0x3fef3b0f2e6d1675, +0x3c840635f6d2a9c0, 0x3fef3d0b869d8f0f, +0xbc808a1883ccb5d2, 0x3fef3f0b555dc3fa, +0x3c549eeef9ec910c, 0x3fef410e9be12cb9, +0xbc8cc734592af7fc, 0x3fef43155b5bab74, +0xbc8335827ffb9dce, 0x3fef451f95018d17, +0xbc8fad5d3ffffa6f, 0x3fef472d4a07897c, +0x3c645563980ef762, 0x3fef493e7ba2c38c, +0x3c87752a44f587e8, 0x3fef4b532b08c968, +0xbc8cd0205eb2aab2, 0x3fef4d6b596f948c, +0xbc900dae3875a949, 0x3fef4f87080d89f2, +0xbc8aab80ceab2b4a, 0x3fef51a638197a3c, +0x3c85b66fefeef52e, 0x3fef53c8eacaa1d6, +0xbc8f870f40a8ba1b, 0x3fef55ef2158a91f, +0x3c74a385a63d07a7, 0x3fef5818dcfba487, +0x3c83c119f18464c5, 0x3fef5a461eec14be, +0x3c5159d9d908a96e, 0x3fef5c76e862e6d3, +0xbc5a628c2be4e7c7, 0x3fef5eab3a99745b, +0xbc82919e2040220f, 0x3fef60e316c98398, +0xbc72550d76be719a, 0x3fef631e7e2d479d, +0x3c8c254d16117a68, 0x3fef655d71ff6075, +0xbc82090274667d12, 0x3fef679ff37adb4a, +0x3c8e5a50d5c192ac, 0x3fef69e603db3285, +0x3c75f7d28150cac4, 0x3fef6c2fa45c4dfd, +0xbc8d8c329fbd0e03, 0x3fef6e7cd63a8315, +0x3c890de9296f4cd1, 0x3fef70cd9ab294e4, +0x3c843a59ac016b4b, 0x3fef7321f301b460, +0x3c832ff9978b34bc, 0x3fef7579e065807d, +0xbc8ea6e6fbd5f2a6, 0x3fef77d5641c0658, +0xbc7303b63dda1980, 0x3fef7a347f63c159, +0xbc82d52107b43e1f, 0x3fef7c97337b9b5f, +0xbc81f2ba385f2f95, 0x3fef7efd81a2ece1, +0xbc63e8e3eab2cbb4, 0x3fef81676b197d17, +0x3c768d9144ae12fc, 0x3fef83d4f11f8220, +0xbc892ab93b470dc9, 0x3fef864614f5a129, +0x3c853687f542403b, 0x3fef88bad7dcee90, +0xbc8b7966cd0d2cd9, 0x3fef8b333b16ee12, +0xbc736ed2de40b407, 0x3fef8daf3fe592e8, +0x3c74b604603a88d3, 0x3fef902ee78b3ff6, +0xbc614ef56c770f3b, 0x3fef92b2334ac7ee, +0xbc776caa4c2ff1cf, 0x3fef953924676d76, +0x3c8df7d1353d8e88, 0x3fef97c3bc24e350, +0x3c83c5ec519d7271, 0x3fef9a51fbc74c83, +0xbc850bed64091b8a, 0x3fef9ce3e4933c7e, +0xbc81d5fc525d9940, 0x3fef9f7977cdb740, +0x3c89d852381c317f, 0x3fefa212b6bc3181, +0xbc8ff7128fd391f0, 0x3fefa4afa2a490da, +0x3c68a00e3cca04c4, 0x3fefa7503ccd2be5, +0x3c855cd8aaea3d21, 0x3fefa9f4867cca6e, +0xbc5a1f25ce94cae7, 0x3fefac9c80faa594, +0xbc8dae98e223747d, 0x3fefaf482d8e67f1, +0xbc6fb5f3ee307976, 0x3fefb1f78d802dc2, +0x3c8269947c2bed4a, 0x3fefb4aaa2188510, +0x3c737e8ae802b851, 0x3fefb7616ca06dd6, +0x3c8ec3bc41aa2008, 0x3fefba1bee615a27, +0x3c875119560e34af, 0x3fefbcda28a52e59, +0xbc83b6137e9afe9e, 0x3fefbf9c1cb6412a, +0xbc7431c3840929c6, 0x3fefc261cbdf5be7, +0x3c842b94c3a9eb32, 0x3fefc52b376bba97, +0xbc8cb472d2e86b99, 0x3fefc7f860a70c22, +0xbc69fa74878ba7c7, 0x3fefcac948dd7274, +0x3c83f5df2fde16a8, 0x3fefcd9df15b82ac, +0x3c8a64a931d185ee, 0x3fefd0765b6e4540, +0x3c8eef18336b62e3, 0x3fefd35288633625, +0x3c901f3a75ee0efe, 0x3fefd632798844f8, +0x3c80d23f87b50a2a, 0x3fefd916302bd526, +0xbc8e37bae43be3ed, 0x3fefdbfdad9cbe14, +0x3c8302dee657c8e6, 0x3fefdee8f32a4b45, +0xbc516a9ce6ed84fa, 0x3fefe1d802243c89, +0xbc7b0caa080df170, 0x3fefe4cadbdac61d, +0x3c77893b4d91cd9d, 0x3fefe7c1819e90d8, +0x3c7617a9f2fd24e5, 0x3fefeabbf4c0ba54, +0xbc699c7db2effc76, 0x3fefedba3692d514, +0x3c75f103b8fd5ca7, 0x3feff0bc4866e8ad, +0x3c5305c14160cc89, 0x3feff3c22b8f71f1, +0x3c8e70b094fa075a, 0x3feff6cbe15f6314, +0x3c64b458677f9840, 0x3feff9d96b2a23d9, +0xbc72ec9a3e5d680a, 0x3feffceaca4391b6, +#endif +}, +}; diff --git a/libc/AOR_v20.02/math/expf.c b/libc/AOR_v20.02/math/expf.c new file mode 100644 index 00000000000000..035cb45191630e --- /dev/null +++ b/libc/AOR_v20.02/math/expf.c @@ -0,0 +1,92 @@ +/* + * Single-precision e^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" + +/* +EXP2F_TABLE_BITS = 5 +EXP2F_POLY_ORDER = 3 + +ULP error: 0.502 (nearest rounding.) +Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.) +Wrong count: 170635 (all nearest rounding wrong results with fma.) +Non-nearest ULP error: 1 (rounded ULP error) +*/ + +#define N (1 << EXP2F_TABLE_BITS) +#define InvLn2N __exp2f_data.invln2_scaled +#define T __exp2f_data.tab +#define C __exp2f_data.poly_scaled + +static inline uint32_t +top12 (float x) +{ + return asuint (x) >> 20; +} + +float +expf (float x) +{ + uint32_t abstop; + uint64_t ki, t; + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t kd, xd, z, r, r2, y, s; + + xd = (double_t) x; + abstop = top12 (x) & 0x7ff; + if (unlikely (abstop >= top12 (88.0f))) + { + /* |x| >= 88 or x is nan. */ + if (asuint (x) == asuint (-INFINITY)) + return 0.0f; + if (abstop >= top12 (INFINITY)) + return x + x; + if (x > 0x1.62e42ep6f) /* x > log(0x1p128) ~= 88.72 */ + return __math_oflowf (0); + if (x < -0x1.9fe368p6f) /* x < log(0x1p-150) ~= -103.97 */ + return __math_uflowf (0); +#if WANT_ERRNO_UFLOW + if (x < -0x1.9d1d9ep6f) /* x < log(0x1p-149) ~= -103.28 */ + return __math_may_uflowf (0); +#endif + } + + /* x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k. */ + z = InvLn2N * xd; + + /* Round and convert z to int, the result is in [-150*N, 128*N] and + ideally nearest int is used, otherwise the magnitude of r can be + bigger which gives larger approximation error. */ +#if TOINT_INTRINSICS + kd = roundtoint (z); + ki = converttoint (z); +#else +# define SHIFT __exp2f_data.shift + kd = eval_as_double (z + SHIFT); + ki = asuint64 (kd); + kd -= SHIFT; +#endif + r = z - kd; + + /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ + t = T[ki % N]; + t += ki << (52 - EXP2F_TABLE_BITS); + s = asdouble (t); + z = C[0] * r + C[1]; + r2 = r * r; + y = C[2] * r + 1; + y = z * r2 + y; + y = y * s; + return eval_as_float (y); +} +#if USE_GLIBC_ABI +strong_alias (expf, __expf_finite) +hidden_alias (expf, __ieee754_expf) +#endif diff --git a/libc/AOR_v20.02/math/include/mathlib.h b/libc/AOR_v20.02/math/include/mathlib.h new file mode 100644 index 00000000000000..4765ff4106f204 --- /dev/null +++ b/libc/AOR_v20.02/math/include/mathlib.h @@ -0,0 +1,101 @@ +/* + * Public API. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef _MATHLIB_H +#define _MATHLIB_H + +float expf (float); +float exp2f (float); +float logf (float); +float log2f (float); +float powf (float, float); +float sinf (float); +float cosf (float); +void sincosf (float, float*, float*); + +double exp (double); +double exp2 (double); +double log (double); +double log2 (double); +double pow (double, double); + +/* Scalar functions using the vector algorithm with identical result. */ +float __s_sinf (float); +float __s_cosf (float); +float __s_expf (float); +float __s_expf_1u (float); +float __s_exp2f (float); +float __s_exp2f_1u (float); +float __s_logf (float); +float __s_powf (float, float); +double __s_sin (double); +double __s_cos (double); +double __s_exp (double); +double __s_log (double); +double __s_pow (double, double); + +#if __aarch64__ +#if __GNUC__ >= 5 +typedef __Float32x4_t __f32x4_t; +typedef __Float64x2_t __f64x2_t; +#elif __clang_major__*100+__clang_minor__ >= 305 +typedef __attribute__((__neon_vector_type__(4))) float __f32x4_t; +typedef __attribute__((__neon_vector_type__(2))) double __f64x2_t; +#else +#error Unsupported compiler +#endif + +/* Vector functions following the base PCS. */ +__f32x4_t __v_sinf (__f32x4_t); +__f32x4_t __v_cosf (__f32x4_t); +__f32x4_t __v_expf (__f32x4_t); +__f32x4_t __v_expf_1u (__f32x4_t); +__f32x4_t __v_exp2f (__f32x4_t); +__f32x4_t __v_exp2f_1u (__f32x4_t); +__f32x4_t __v_logf (__f32x4_t); +__f32x4_t __v_powf (__f32x4_t, __f32x4_t); +__f64x2_t __v_sin (__f64x2_t); +__f64x2_t __v_cos (__f64x2_t); +__f64x2_t __v_exp (__f64x2_t); +__f64x2_t __v_log (__f64x2_t); +__f64x2_t __v_pow (__f64x2_t, __f64x2_t); + +#if __GNUC__ >= 9 || __clang_major__ >= 8 +#define __vpcs __attribute__((__aarch64_vector_pcs__)) + +/* Vector functions following the vector PCS. */ +__vpcs __f32x4_t __vn_sinf (__f32x4_t); +__vpcs __f32x4_t __vn_cosf (__f32x4_t); +__vpcs __f32x4_t __vn_expf (__f32x4_t); +__vpcs __f32x4_t __vn_expf_1u (__f32x4_t); +__vpcs __f32x4_t __vn_exp2f (__f32x4_t); +__vpcs __f32x4_t __vn_exp2f_1u (__f32x4_t); +__vpcs __f32x4_t __vn_logf (__f32x4_t); +__vpcs __f32x4_t __vn_powf (__f32x4_t, __f32x4_t); +__vpcs __f64x2_t __vn_sin (__f64x2_t); +__vpcs __f64x2_t __vn_cos (__f64x2_t); +__vpcs __f64x2_t __vn_exp (__f64x2_t); +__vpcs __f64x2_t __vn_log (__f64x2_t); +__vpcs __f64x2_t __vn_pow (__f64x2_t, __f64x2_t); + +/* Vector functions following the vector PCS using ABI names. */ +__vpcs __f32x4_t _ZGVnN4v_sinf (__f32x4_t); +__vpcs __f32x4_t _ZGVnN4v_cosf (__f32x4_t); +__vpcs __f32x4_t _ZGVnN4v_expf (__f32x4_t); +__vpcs __f32x4_t _ZGVnN4v_exp2f (__f32x4_t); +__vpcs __f32x4_t _ZGVnN4v_logf (__f32x4_t); +__vpcs __f32x4_t _ZGVnN4vv_powf (__f32x4_t, __f32x4_t); +__vpcs __f64x2_t _ZGVnN2v_sin (__f64x2_t); +__vpcs __f64x2_t _ZGVnN2v_cos (__f64x2_t); +__vpcs __f64x2_t _ZGVnN2v_exp (__f64x2_t); +__vpcs __f64x2_t _ZGVnN2v_log (__f64x2_t); +__vpcs __f64x2_t _ZGVnN2vv_pow (__f64x2_t, __f64x2_t); +#endif +#endif + +#endif diff --git a/libc/AOR_v20.02/math/log.c b/libc/AOR_v20.02/math/log.c new file mode 100644 index 00000000000000..c546b694099ddc --- /dev/null +++ b/libc/AOR_v20.02/math/log.c @@ -0,0 +1,163 @@ +/* + * Double-precision log(x) function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include "math_config.h" + +#define T __log_data.tab +#define T2 __log_data.tab2 +#define B __log_data.poly1 +#define A __log_data.poly +#define Ln2hi __log_data.ln2hi +#define Ln2lo __log_data.ln2lo +#define N (1 << LOG_TABLE_BITS) +#define OFF 0x3fe6000000000000 + +/* Top 16 bits of a double. */ +static inline uint32_t +top16 (double x) +{ + return asuint64 (x) >> 48; +} + +double +log (double x) +{ + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t w, z, r, r2, r3, y, invc, logc, kd, hi, lo; + uint64_t ix, iz, tmp; + uint32_t top; + int k, i; + + ix = asuint64 (x); + top = top16 (x); + +#if LOG_POLY1_ORDER == 10 || LOG_POLY1_ORDER == 11 +# define LO asuint64 (1.0 - 0x1p-5) +# define HI asuint64 (1.0 + 0x1.1p-5) +#elif LOG_POLY1_ORDER == 12 +# define LO asuint64 (1.0 - 0x1p-4) +# define HI asuint64 (1.0 + 0x1.09p-4) +#endif + if (unlikely (ix - LO < HI - LO)) + { + /* Handle close to 1.0 inputs separately. */ + /* Fix sign of zero with downward rounding when x==1. */ + if (WANT_ROUNDING && unlikely (ix == asuint64 (1.0))) + return 0; + r = x - 1.0; + r2 = r * r; + r3 = r * r2; +#if LOG_POLY1_ORDER == 10 + /* Worst-case error is around 0.516 ULP. */ + y = r3 * (B[1] + r * B[2] + r2 * B[3] + + r3 * (B[4] + r * B[5] + r2 * B[6] + r3 * (B[7] + r * B[8]))); + w = B[0] * r2; /* B[0] == -0.5. */ + hi = r + w; + y += r - hi + w; + y += hi; +#elif LOG_POLY1_ORDER == 11 + /* Worst-case error is around 0.516 ULP. */ + y = r3 * (B[1] + r * B[2] + + r2 * (B[3] + r * B[4] + r2 * B[5] + + r3 * (B[6] + r * B[7] + r2 * B[8] + r3 * B[9]))); + w = B[0] * r2; /* B[0] == -0.5. */ + hi = r + w; + y += r - hi + w; + y += hi; +#elif LOG_POLY1_ORDER == 12 + y = r3 * (B[1] + r * B[2] + r2 * B[3] + + r3 * (B[4] + r * B[5] + r2 * B[6] + + r3 * (B[7] + r * B[8] + r2 * B[9] + r3 * B[10]))); +# if N <= 64 + /* Worst-case error is around 0.532 ULP. */ + w = B[0] * r2; /* B[0] == -0.5. */ + hi = r + w; + y += r - hi + w; + y += hi; +# else + /* Worst-case error is around 0.507 ULP. */ + w = r * 0x1p27; + double_t rhi = r + w - w; + double_t rlo = r - rhi; + w = rhi * rhi * B[0]; /* B[0] == -0.5. */ + hi = r + w; + lo = r - hi + w; + lo += B[0] * rlo * (rhi + r); + y += lo; + y += hi; +# endif +#endif + return eval_as_double (y); + } + if (unlikely (top - 0x0010 >= 0x7ff0 - 0x0010)) + { + /* x < 0x1p-1022 or inf or nan. */ + if (ix * 2 == 0) + return __math_divzero (1); + if (ix == asuint64 (INFINITY)) /* log(inf) == inf. */ + return x; + if ((top & 0x8000) || (top & 0x7ff0) == 0x7ff0) + return __math_invalid (x); + /* x is subnormal, normalize it. */ + ix = asuint64 (x * 0x1p52); + ix -= 52ULL << 52; + } + + /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (52 - LOG_TABLE_BITS)) % N; + k = (int64_t) tmp >> 52; /* arithmetic shift */ + iz = ix - (tmp & 0xfffULL << 52); + invc = T[i].invc; + logc = T[i].logc; + z = asdouble (iz); + + /* log(x) = log1p(z/c-1) + log(c) + k*Ln2. */ + /* r ~= z/c - 1, |r| < 1/(2*N). */ +#if HAVE_FAST_FMA + /* rounding error: 0x1p-55/N. */ + r = fma (z, invc, -1.0); +#else + /* rounding error: 0x1p-55/N + 0x1p-66. */ + r = (z - T2[i].chi - T2[i].clo) * invc; +#endif + kd = (double_t) k; + + /* hi + lo = r + log(c) + k*Ln2. */ + w = kd * Ln2hi + logc; + hi = w + r; + lo = w - hi + r + kd * Ln2lo; + + /* log(x) = lo + (log1p(r) - r) + hi. */ + r2 = r * r; /* rounding error: 0x1p-54/N^2. */ + /* Worst case error if |y| > 0x1p-5: + 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma) + Worst case error if |y| > 0x1p-4: + 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ +#if LOG_POLY_ORDER == 6 + y = lo + r2 * A[0] + r * r2 * (A[1] + r * A[2] + r2 * (A[3] + r * A[4])) + hi; +#elif LOG_POLY_ORDER == 7 + y = lo + + r2 * (A[0] + r * A[1] + r2 * (A[2] + r * A[3]) + + r2 * r2 * (A[4] + r * A[5])) + + hi; +#endif + return eval_as_double (y); +} +#if USE_GLIBC_ABI +strong_alias (log, __log_finite) +hidden_alias (log, __ieee754_log) +# if LDBL_MANT_DIG == 53 +long double logl (long double x) { return log (x); } +# endif +#endif diff --git a/libc/AOR_v20.02/math/log2.c b/libc/AOR_v20.02/math/log2.c new file mode 100644 index 00000000000000..a1e20b0118a597 --- /dev/null +++ b/libc/AOR_v20.02/math/log2.c @@ -0,0 +1,142 @@ +/* + * Double-precision log2(x) function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include "math_config.h" + +#define T __log2_data.tab +#define T2 __log2_data.tab2 +#define B __log2_data.poly1 +#define A __log2_data.poly +#define InvLn2hi __log2_data.invln2hi +#define InvLn2lo __log2_data.invln2lo +#define N (1 << LOG2_TABLE_BITS) +#define OFF 0x3fe6000000000000 + +/* Top 16 bits of a double. */ +static inline uint32_t +top16 (double x) +{ + return asuint64 (x) >> 48; +} + +double +log2 (double x) +{ + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t z, r, r2, r4, y, invc, logc, kd, hi, lo, t1, t2, t3, p; + uint64_t ix, iz, tmp; + uint32_t top; + int k, i; + + ix = asuint64 (x); + top = top16 (x); + +#if LOG2_POLY1_ORDER == 11 +# define LO asuint64 (1.0 - 0x1.5b51p-5) +# define HI asuint64 (1.0 + 0x1.6ab2p-5) +#endif + if (unlikely (ix - LO < HI - LO)) + { + /* Handle close to 1.0 inputs separately. */ + /* Fix sign of zero with downward rounding when x==1. */ + if (WANT_ROUNDING && unlikely (ix == asuint64 (1.0))) + return 0; + r = x - 1.0; +#if HAVE_FAST_FMA + hi = r * InvLn2hi; + lo = r * InvLn2lo + fma (r, InvLn2hi, -hi); +#else + double_t rhi, rlo; + rhi = asdouble (asuint64 (r) & -1ULL << 32); + rlo = r - rhi; + hi = rhi * InvLn2hi; + lo = rlo * InvLn2hi + r * InvLn2lo; +#endif + r2 = r * r; /* rounding error: 0x1p-62. */ + r4 = r2 * r2; +#if LOG2_POLY1_ORDER == 11 + /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ + p = r2 * (B[0] + r * B[1]); + y = hi + p; + lo += hi - y + p; + lo += r4 * (B[2] + r * B[3] + r2 * (B[4] + r * B[5]) + + r4 * (B[6] + r * B[7] + r2 * (B[8] + r * B[9]))); + y += lo; +#endif + return eval_as_double (y); + } + if (unlikely (top - 0x0010 >= 0x7ff0 - 0x0010)) + { + /* x < 0x1p-1022 or inf or nan. */ + if (ix * 2 == 0) + return __math_divzero (1); + if (ix == asuint64 (INFINITY)) /* log(inf) == inf. */ + return x; + if ((top & 0x8000) || (top & 0x7ff0) == 0x7ff0) + return __math_invalid (x); + /* x is subnormal, normalize it. */ + ix = asuint64 (x * 0x1p52); + ix -= 52ULL << 52; + } + + /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (52 - LOG2_TABLE_BITS)) % N; + k = (int64_t) tmp >> 52; /* arithmetic shift */ + iz = ix - (tmp & 0xfffULL << 52); + invc = T[i].invc; + logc = T[i].logc; + z = asdouble (iz); + kd = (double_t) k; + + /* log2(x) = log2(z/c) + log2(c) + k. */ + /* r ~= z/c - 1, |r| < 1/(2*N). */ +#if HAVE_FAST_FMA + /* rounding error: 0x1p-55/N. */ + r = fma (z, invc, -1.0); + t1 = r * InvLn2hi; + t2 = r * InvLn2lo + fma (r, InvLn2hi, -t1); +#else + double_t rhi, rlo; + /* rounding error: 0x1p-55/N + 0x1p-65. */ + r = (z - T2[i].chi - T2[i].clo) * invc; + rhi = asdouble (asuint64 (r) & -1ULL << 32); + rlo = r - rhi; + t1 = rhi * InvLn2hi; + t2 = rlo * InvLn2hi + r * InvLn2lo; +#endif + + /* hi + lo = r/ln2 + log2(c) + k. */ + t3 = kd + logc; + hi = t3 + t1; + lo = t3 - hi + t1 + t2; + + /* log2(r+1) = r/ln2 + r^2*poly(r). */ + /* Evaluation is optimized assuming superscalar pipelined execution. */ + r2 = r * r; /* rounding error: 0x1p-54/N^2. */ + r4 = r2 * r2; +#if LOG2_POLY_ORDER == 7 + /* Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma). + ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ + p = A[0] + r * A[1] + r2 * (A[2] + r * A[3]) + r4 * (A[4] + r * A[5]); + y = lo + r2 * p + hi; +#endif + return eval_as_double (y); +} +#if USE_GLIBC_ABI +strong_alias (log2, __log2_finite) +hidden_alias (log2, __ieee754_log2) +# if LDBL_MANT_DIG == 53 +long double log2l (long double x) { return log2 (x); } +# endif +#endif diff --git a/libc/AOR_v20.02/math/log2_data.c b/libc/AOR_v20.02/math/log2_data.c new file mode 100644 index 00000000000000..a487dbfb985602 --- /dev/null +++ b/libc/AOR_v20.02/math/log2_data.c @@ -0,0 +1,210 @@ +/* + * Data for log2. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +#define N (1 << LOG2_TABLE_BITS) + +const struct log2_data __log2_data = { +// First coefficient: 0x1.71547652b82fe1777d0ffda0d24p0 +.invln2hi = 0x1.7154765200000p+0, +.invln2lo = 0x1.705fc2eefa200p-33, +.poly1 = { +#if LOG2_POLY1_ORDER == 11 +// relative error: 0x1.2fad8188p-63 +// in -0x1.5b51p-5 0x1.6ab2p-5 +-0x1.71547652b82fep-1, +0x1.ec709dc3a03f7p-2, +-0x1.71547652b7c3fp-2, +0x1.2776c50f05be4p-2, +-0x1.ec709dd768fe5p-3, +0x1.a61761ec4e736p-3, +-0x1.7153fbc64a79bp-3, +0x1.484d154f01b4ap-3, +-0x1.289e4a72c383cp-3, +0x1.0b32f285aee66p-3, +#endif +}, +.poly = { +#if N == 64 && LOG2_POLY_ORDER == 7 +// relative error: 0x1.a72c2bf8p-58 +// abs error: 0x1.67a552c8p-66 +// in -0x1.f45p-8 0x1.f45p-8 +-0x1.71547652b8339p-1, +0x1.ec709dc3a04bep-2, +-0x1.7154764702ffbp-2, +0x1.2776c50034c48p-2, +-0x1.ec7b328ea92bcp-3, +0x1.a6225e117f92ep-3, +#endif +}, +/* Algorithm: + + x = 2^k z + log2(x) = k + log2(c) + log2(z/c) + log2(z/c) = poly(z/c - 1) + +where z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls +into the ith one, then table entries are computed as + + tab[i].invc = 1/c + tab[i].logc = (double)log2(c) + tab2[i].chi = (double)c + tab2[i].clo = (double)(c - (double)c) + +where c is near the center of the subinterval and is chosen by trying +-2^29 +floating point invc candidates around 1/center and selecting one for which + + 1) the rounding error in 0x1.8p10 + logc is 0, + 2) the rounding error in z - chi - clo is < 0x1p-64 and + 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68). + +Note: 1) ensures that k + logc can be computed without rounding error, 2) +ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a +single rounding error when there is no fast fma for z*invc - 1, 3) ensures +that logc + poly(z/c - 1) has small error, however near x == 1 when +|log2(x)| < 0x1p-4, this is not enough so that is special cased. */ +.tab = { +#if N == 64 +{0x1.724286bb1acf8p+0, -0x1.1095feecdb000p-1}, +{0x1.6e1f766d2cca1p+0, -0x1.08494bd76d000p-1}, +{0x1.6a13d0e30d48ap+0, -0x1.00143aee8f800p-1}, +{0x1.661ec32d06c85p+0, -0x1.efec5360b4000p-2}, +{0x1.623fa951198f8p+0, -0x1.dfdd91ab7e000p-2}, +{0x1.5e75ba4cf026cp+0, -0x1.cffae0cc79000p-2}, +{0x1.5ac055a214fb8p+0, -0x1.c043811fda000p-2}, +{0x1.571ed0f166e1ep+0, -0x1.b0b67323ae000p-2}, +{0x1.53909590bf835p+0, -0x1.a152f5a2db000p-2}, +{0x1.5014fed61adddp+0, -0x1.9217f5af86000p-2}, +{0x1.4cab88e487bd0p+0, -0x1.8304db0719000p-2}, +{0x1.49539b4334feep+0, -0x1.74189f9a9e000p-2}, +{0x1.460cbdfafd569p+0, -0x1.6552bb5199000p-2}, +{0x1.42d664ee4b953p+0, -0x1.56b23a29b1000p-2}, +{0x1.3fb01111dd8a6p+0, -0x1.483650f5fa000p-2}, +{0x1.3c995b70c5836p+0, -0x1.39de937f6a000p-2}, +{0x1.3991c4ab6fd4ap+0, -0x1.2baa1538d6000p-2}, +{0x1.3698e0ce099b5p+0, -0x1.1d98340ca4000p-2}, +{0x1.33ae48213e7b2p+0, -0x1.0fa853a40e000p-2}, +{0x1.30d191985bdb1p+0, -0x1.01d9c32e73000p-2}, +{0x1.2e025cab271d7p+0, -0x1.e857da2fa6000p-3}, +{0x1.2b404cf13cd82p+0, -0x1.cd3c8633d8000p-3}, +{0x1.288b02c7ccb50p+0, -0x1.b26034c14a000p-3}, +{0x1.25e2263944de5p+0, -0x1.97c1c2f4fe000p-3}, +{0x1.234563d8615b1p+0, -0x1.7d6023f800000p-3}, +{0x1.20b46e33eaf38p+0, -0x1.633a71a05e000p-3}, +{0x1.1e2eefdcda3ddp+0, -0x1.494f5e9570000p-3}, +{0x1.1bb4a580b3930p+0, -0x1.2f9e424e0a000p-3}, +{0x1.19453847f2200p+0, -0x1.162595afdc000p-3}, +{0x1.16e06c0d5d73cp+0, -0x1.f9c9a75bd8000p-4}, +{0x1.1485f47b7e4c2p+0, -0x1.c7b575bf9c000p-4}, +{0x1.12358ad0085d1p+0, -0x1.960c60ff48000p-4}, +{0x1.0fef00f532227p+0, -0x1.64ce247b60000p-4}, +{0x1.0db2077d03a8fp+0, -0x1.33f78b2014000p-4}, +{0x1.0b7e6d65980d9p+0, -0x1.0387d1a42c000p-4}, +{0x1.0953efe7b408dp+0, -0x1.a6f9208b50000p-5}, +{0x1.07325cac53b83p+0, -0x1.47a954f770000p-5}, +{0x1.05197e40d1b5cp+0, -0x1.d23a8c50c0000p-6}, +{0x1.03091c1208ea2p+0, -0x1.16a2629780000p-6}, +{0x1.0101025b37e21p+0, -0x1.720f8d8e80000p-8}, +{0x1.fc07ef9caa76bp-1, 0x1.6fe53b1500000p-7}, +{0x1.f4465d3f6f184p-1, 0x1.11ccce10f8000p-5}, +{0x1.ecc079f84107fp-1, 0x1.c4dfc8c8b8000p-5}, +{0x1.e573a99975ae8p-1, 0x1.3aa321e574000p-4}, +{0x1.de5d6f0bd3de6p-1, 0x1.918a0d08b8000p-4}, +{0x1.d77b681ff38b3p-1, 0x1.e72e9da044000p-4}, +{0x1.d0cb5724de943p-1, 0x1.1dcd2507f6000p-3}, +{0x1.ca4b2dc0e7563p-1, 0x1.476ab03dea000p-3}, +{0x1.c3f8ee8d6cb51p-1, 0x1.7074377e22000p-3}, +{0x1.bdd2b4f020c4cp-1, 0x1.98ede8ba94000p-3}, +{0x1.b7d6c006015cap-1, 0x1.c0db86ad2e000p-3}, +{0x1.b20366e2e338fp-1, 0x1.e840aafcee000p-3}, +{0x1.ac57026295039p-1, 0x1.0790ab4678000p-2}, +{0x1.a6d01bc2731ddp-1, 0x1.1ac056801c000p-2}, +{0x1.a16d3bc3ff18bp-1, 0x1.2db11d4fee000p-2}, +{0x1.9c2d14967feadp-1, 0x1.406464ec58000p-2}, +{0x1.970e4f47c9902p-1, 0x1.52dbe093af000p-2}, +{0x1.920fb3982bcf2p-1, 0x1.651902050d000p-2}, +{0x1.8d30187f759f1p-1, 0x1.771d2cdeaf000p-2}, +{0x1.886e5ebb9f66dp-1, 0x1.88e9c857d9000p-2}, +{0x1.83c97b658b994p-1, 0x1.9a80155e16000p-2}, +{0x1.7f405ffc61022p-1, 0x1.abe186ed3d000p-2}, +{0x1.7ad22181415cap-1, 0x1.bd0f2aea0e000p-2}, +{0x1.767dcf99eff8cp-1, 0x1.ce0a43dbf4000p-2}, +#endif +}, +#if !HAVE_FAST_FMA +.tab2 = { +# if N == 64 +{0x1.6200012b90a8ep-1, 0x1.904ab0644b605p-55}, +{0x1.66000045734a6p-1, 0x1.1ff9bea62f7a9p-57}, +{0x1.69fffc325f2c5p-1, 0x1.27ecfcb3c90bap-55}, +{0x1.6e00038b95a04p-1, 0x1.8ff8856739326p-55}, +{0x1.71fffe09994e3p-1, 0x1.afd40275f82b1p-55}, +{0x1.7600015590e1p-1, -0x1.2fd75b4238341p-56}, +{0x1.7a00012655bd5p-1, 0x1.808e67c242b76p-56}, +{0x1.7e0003259e9a6p-1, -0x1.208e426f622b7p-57}, +{0x1.81fffedb4b2d2p-1, -0x1.402461ea5c92fp-55}, +{0x1.860002dfafcc3p-1, 0x1.df7f4a2f29a1fp-57}, +{0x1.89ffff78c6b5p-1, -0x1.e0453094995fdp-55}, +{0x1.8e00039671566p-1, -0x1.a04f3bec77b45p-55}, +{0x1.91fffe2bf1745p-1, -0x1.7fa34400e203cp-56}, +{0x1.95fffcc5c9fd1p-1, -0x1.6ff8005a0695dp-56}, +{0x1.9a0003bba4767p-1, 0x1.0f8c4c4ec7e03p-56}, +{0x1.9dfffe7b92da5p-1, 0x1.e7fd9478c4602p-55}, +{0x1.a1fffd72efdafp-1, -0x1.a0c554dcdae7ep-57}, +{0x1.a5fffde04ff95p-1, 0x1.67da98ce9b26bp-55}, +{0x1.a9fffca5e8d2bp-1, -0x1.284c9b54c13dep-55}, +{0x1.adfffddad03eap-1, 0x1.812c8ea602e3cp-58}, +{0x1.b1ffff10d3d4dp-1, -0x1.efaddad27789cp-55}, +{0x1.b5fffce21165ap-1, 0x1.3cb1719c61237p-58}, +{0x1.b9fffd950e674p-1, 0x1.3f7d94194cep-56}, +{0x1.be000139ca8afp-1, 0x1.50ac4215d9bcp-56}, +{0x1.c20005b46df99p-1, 0x1.beea653e9c1c9p-57}, +{0x1.c600040b9f7aep-1, -0x1.c079f274a70d6p-56}, +{0x1.ca0006255fd8ap-1, -0x1.a0b4076e84c1fp-56}, +{0x1.cdfffd94c095dp-1, 0x1.8f933f99ab5d7p-55}, +{0x1.d1ffff975d6cfp-1, -0x1.82c08665fe1bep-58}, +{0x1.d5fffa2561c93p-1, -0x1.b04289bd295f3p-56}, +{0x1.d9fff9d228b0cp-1, 0x1.70251340fa236p-55}, +{0x1.de00065bc7e16p-1, -0x1.5011e16a4d80cp-56}, +{0x1.e200002f64791p-1, 0x1.9802f09ef62ep-55}, +{0x1.e600057d7a6d8p-1, -0x1.e0b75580cf7fap-56}, +{0x1.ea00027edc00cp-1, -0x1.c848309459811p-55}, +{0x1.ee0006cf5cb7cp-1, -0x1.f8027951576f4p-55}, +{0x1.f2000782b7dccp-1, -0x1.f81d97274538fp-55}, +{0x1.f6000260c450ap-1, -0x1.071002727ffdcp-59}, +{0x1.f9fffe88cd533p-1, -0x1.81bdce1fda8bp-58}, +{0x1.fdfffd50f8689p-1, 0x1.7f91acb918e6ep-55}, +{0x1.0200004292367p+0, 0x1.b7ff365324681p-54}, +{0x1.05fffe3e3d668p+0, 0x1.6fa08ddae957bp-55}, +{0x1.0a0000a85a757p+0, -0x1.7e2de80d3fb91p-58}, +{0x1.0e0001a5f3fccp+0, -0x1.1823305c5f014p-54}, +{0x1.11ffff8afbaf5p+0, -0x1.bfabb6680bac2p-55}, +{0x1.15fffe54d91adp+0, -0x1.d7f121737e7efp-54}, +{0x1.1a00011ac36e1p+0, 0x1.c000a0516f5ffp-54}, +{0x1.1e00019c84248p+0, -0x1.082fbe4da5dap-54}, +{0x1.220000ffe5e6ep+0, -0x1.8fdd04c9cfb43p-55}, +{0x1.26000269fd891p+0, 0x1.cfe2a7994d182p-55}, +{0x1.2a00029a6e6dap+0, -0x1.00273715e8bc5p-56}, +{0x1.2dfffe0293e39p+0, 0x1.b7c39dab2a6f9p-54}, +{0x1.31ffff7dcf082p+0, 0x1.df1336edc5254p-56}, +{0x1.35ffff05a8b6p+0, -0x1.e03564ccd31ebp-54}, +{0x1.3a0002e0eaeccp+0, 0x1.5f0e74bd3a477p-56}, +{0x1.3e000043bb236p+0, 0x1.c7dcb149d8833p-54}, +{0x1.4200002d187ffp+0, 0x1.e08afcf2d3d28p-56}, +{0x1.460000d387cb1p+0, 0x1.20837856599a6p-55}, +{0x1.4a00004569f89p+0, -0x1.9fa5c904fbcd2p-55}, +{0x1.4e000043543f3p+0, -0x1.81125ed175329p-56}, +{0x1.51fffcc027f0fp+0, 0x1.883d8847754dcp-54}, +{0x1.55ffffd87b36fp+0, -0x1.709e731d02807p-55}, +{0x1.59ffff21df7bap+0, 0x1.7f79f68727b02p-55}, +{0x1.5dfffebfc3481p+0, -0x1.180902e30e93ep-54}, +# endif +}, +#endif /* !HAVE_FAST_FMA */ +}; diff --git a/libc/AOR_v20.02/math/log2f.c b/libc/AOR_v20.02/math/log2f.c new file mode 100644 index 00000000000000..a43814f9827c0a --- /dev/null +++ b/libc/AOR_v20.02/math/log2f.c @@ -0,0 +1,81 @@ +/* + * Single-precision log2 function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" + +/* +LOG2F_TABLE_BITS = 4 +LOG2F_POLY_ORDER = 4 + +ULP error: 0.752 (nearest rounding.) +Relative error: 1.9 * 2^-26 (before rounding.) +*/ + +#define N (1 << LOG2F_TABLE_BITS) +#define T __log2f_data.tab +#define A __log2f_data.poly +#define OFF 0x3f330000 + +float +log2f (float x) +{ + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t z, r, r2, p, y, y0, invc, logc; + uint32_t ix, iz, top, tmp; + int k, i; + + ix = asuint (x); +#if WANT_ROUNDING + /* Fix sign of zero with downward rounding when x==1. */ + if (unlikely (ix == 0x3f800000)) + return 0; +#endif + if (unlikely (ix - 0x00800000 >= 0x7f800000 - 0x00800000)) + { + /* x < 0x1p-126 or inf or nan. */ + if (ix * 2 == 0) + return __math_divzerof (1); + if (ix == 0x7f800000) /* log2(inf) == inf. */ + return x; + if ((ix & 0x80000000) || ix * 2 >= 0xff000000) + return __math_invalidf (x); + /* x is subnormal, normalize it. */ + ix = asuint (x * 0x1p23f); + ix -= 23 << 23; + } + + /* x = 2^k z; where z is in range [OFF,2*OFF] and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (23 - LOG2F_TABLE_BITS)) % N; + top = tmp & 0xff800000; + iz = ix - top; + k = (int32_t) tmp >> 23; /* arithmetic shift */ + invc = T[i].invc; + logc = T[i].logc; + z = (double_t) asfloat (iz); + + /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ + r = z * invc - 1; + y0 = logc + (double_t) k; + + /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ + r2 = r * r; + y = A[1] * r + A[2]; + y = A[0] * r2 + y; + p = A[3] * r + y0; + y = y * r2 + p; + return eval_as_float (y); +} +#if USE_GLIBC_ABI +strong_alias (log2f, __log2f_finite) +hidden_alias (log2f, __ieee754_log2f) +#endif diff --git a/libc/AOR_v20.02/math/log2f_data.c b/libc/AOR_v20.02/math/log2f_data.c new file mode 100644 index 00000000000000..f8f270db40156a --- /dev/null +++ b/libc/AOR_v20.02/math/log2f_data.c @@ -0,0 +1,34 @@ +/* + * Data definition for log2f. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +const struct log2f_data __log2f_data = { + .tab = { + { 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2 }, + { 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2 }, + { 0x1.49539f0f010bp+0, -0x1.7418b0a1fb77bp-2 }, + { 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2 }, + { 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2 }, + { 0x1.25e227b0b8eap+0, -0x1.97c1d1b3b7afp-3 }, + { 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3 }, + { 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4 }, + { 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5 }, + { 0x1p+0, 0x0p+0 }, + { 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4 }, + { 0x1.ca4b31f026aap-1, 0x1.476a9543891bap-3 }, + { 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3 }, + { 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2 }, + { 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2 }, + { 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2 }, + }, + .poly = { + -0x1.712b6f70a7e4dp-2, 0x1.ecabf496832ep-2, -0x1.715479ffae3dep-1, + 0x1.715475f35c8b8p0, + } +}; diff --git a/libc/AOR_v20.02/math/log_data.c b/libc/AOR_v20.02/math/log_data.c new file mode 100644 index 00000000000000..26fc9dfca60c24 --- /dev/null +++ b/libc/AOR_v20.02/math/log_data.c @@ -0,0 +1,512 @@ +/* + * Data for log. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +#define N (1 << LOG_TABLE_BITS) + +const struct log_data __log_data = { +.ln2hi = 0x1.62e42fefa3800p-1, +.ln2lo = 0x1.ef35793c76730p-45, +.poly1 = { +#if LOG_POLY1_ORDER == 10 +// relative error: 0x1.32eccc6p-62 +// in -0x1p-5 0x1.1p-5 (|log(1+x)| > 0x1p-5 outside this interval) +-0x1p-1, +0x1.55555555554e5p-2, +-0x1.0000000000af2p-2, +0x1.9999999bbe436p-3, +-0x1.55555537f9cdep-3, +0x1.24922fc8127cfp-3, +-0x1.0000b7d6bb612p-3, +0x1.c806ee1ddbcafp-4, +-0x1.972335a9c2d6ep-4, +#elif LOG_POLY1_ORDER == 11 +// relative error: 0x1.52c8b708p-68 +// in -0x1p-5 0x1.1p-5 (|log(1+x)| > 0x1p-5 outside this interval) +-0x1p-1, +0x1.5555555555555p-2, +-0x1.ffffffffffea9p-3, +0x1.999999999c4d4p-3, +-0x1.55555557f5541p-3, +0x1.249248fbe33e4p-3, +-0x1.ffffc9a3c825bp-4, +0x1.c71e1f204435dp-4, +-0x1.9a7f26377d06ep-4, +0x1.71c30cf8f7364p-4, +#elif LOG_POLY1_ORDER == 12 +// relative error: 0x1.c04d76cp-63 +// in -0x1p-4 0x1.09p-4 (|log(1+x)| > 0x1p-4 outside the interval) +-0x1p-1, +0x1.5555555555577p-2, +-0x1.ffffffffffdcbp-3, +0x1.999999995dd0cp-3, +-0x1.55555556745a7p-3, +0x1.24924a344de3p-3, +-0x1.fffffa4423d65p-4, +0x1.c7184282ad6cap-4, +-0x1.999eb43b068ffp-4, +0x1.78182f7afd085p-4, +-0x1.5521375d145cdp-4, +#endif +}, +.poly = { +#if N == 64 && LOG_POLY_ORDER == 7 +// relative error: 0x1.906eb8ap-58 +// abs error: 0x1.d2cad5a8p-67 +// in -0x1.fp-8 0x1.fp-8 +-0x1.0000000000027p-1, +0x1.555555555556ap-2, +-0x1.fffffff0440bap-3, +0x1.99999991906c3p-3, +-0x1.555c8d7e8201ep-3, +0x1.24978c59151fap-3, +#elif N == 128 && LOG_POLY_ORDER == 6 +// relative error: 0x1.926199e8p-56 +// abs error: 0x1.882ff33p-65 +// in -0x1.fp-9 0x1.fp-9 +-0x1.0000000000001p-1, +0x1.555555551305bp-2, +-0x1.fffffffeb459p-3, +0x1.999b324f10111p-3, +-0x1.55575e506c89fp-3, +#elif N == 128 && LOG_POLY_ORDER == 7 +// relative error: 0x1.649fc4bp-64 +// abs error: 0x1.c3b5769p-74 +// in -0x1.fp-9 0x1.fp-9 +-0x1.0000000000001p-1, +0x1.5555555555556p-2, +-0x1.fffffffea1a8p-3, +0x1.99999998e9139p-3, +-0x1.555776801b968p-3, +0x1.2493c29331a5cp-3, +#endif +}, +/* Algorithm: + + x = 2^k z + log(x) = k ln2 + log(c) + log(z/c) + log(z/c) = poly(z/c - 1) + +where z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls +into the ith one, then table entries are computed as + + tab[i].invc = 1/c + tab[i].logc = (double)log(c) + tab2[i].chi = (double)c + tab2[i].clo = (double)(c - (double)c) + +where c is near the center of the subinterval and is chosen by trying +-2^29 +floating point invc candidates around 1/center and selecting one for which + + 1) the rounding error in 0x1.8p9 + logc is 0, + 2) the rounding error in z - chi - clo is < 0x1p-66 and + 3) the rounding error in (double)log(c) is minimized (< 0x1p-66). + +Note: 1) ensures that k*ln2hi + logc can be computed without rounding error, +2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to +a single rounding error when there is no fast fma for z*invc - 1, 3) ensures +that logc + poly(z/c - 1) has small error, however near x == 1 when +|log(x)| < 0x1p-4, this is not enough so that is special cased. */ +.tab = { +#if N == 64 +{0x1.7242886495cd8p+0, -0x1.79e267bdfe000p-2}, +{0x1.6e1f769340dc9p+0, -0x1.6e60ee0ecb000p-2}, +{0x1.6a13ccc8f195cp+0, -0x1.63002fdbf6000p-2}, +{0x1.661ec72e86f3ap+0, -0x1.57bf76c597000p-2}, +{0x1.623fa6c447b16p+0, -0x1.4c9e07f0d2000p-2}, +{0x1.5e75bbca31702p+0, -0x1.419b42f027000p-2}, +{0x1.5ac05655adb10p+0, -0x1.36b67660e6000p-2}, +{0x1.571ed3e940191p+0, -0x1.2bef0839e4800p-2}, +{0x1.539094ac0fbbfp+0, -0x1.21445727cb000p-2}, +{0x1.5015007e7fc42p+0, -0x1.16b5ca3c3d000p-2}, +{0x1.4cab877c31cf9p+0, -0x1.0c42d3805f800p-2}, +{0x1.49539e76a88d3p+0, -0x1.01eae61b60800p-2}, +{0x1.460cbc12211dap+0, -0x1.ef5adb9fb0000p-3}, +{0x1.42d6624debe3ap+0, -0x1.db13daab99000p-3}, +{0x1.3fb0144f0d462p+0, -0x1.c6ffbe896e000p-3}, +{0x1.3c995a1f9a9b4p+0, -0x1.b31d84722d000p-3}, +{0x1.3991c23952500p+0, -0x1.9f6c3cf6eb000p-3}, +{0x1.3698df35eaa14p+0, -0x1.8beafe7f13000p-3}, +{0x1.33ae463091760p+0, -0x1.7898db878d000p-3}, +{0x1.30d190aae3d72p+0, -0x1.6574efe4ec000p-3}, +{0x1.2e025c9203c89p+0, -0x1.527e620845000p-3}, +{0x1.2b404a7244988p+0, -0x1.3fb457d798000p-3}, +{0x1.288b01dc19544p+0, -0x1.2d1615a077000p-3}, +{0x1.25e2268085f69p+0, -0x1.1aa2b431e5000p-3}, +{0x1.23456812abb74p+0, -0x1.08598f1d2b000p-3}, +{0x1.20b4703174157p+0, -0x1.ec738fee40000p-4}, +{0x1.1e2ef308b4e9bp+0, -0x1.c885768862000p-4}, +{0x1.1bb4a36b70a3fp+0, -0x1.a4e75b6a46000p-4}, +{0x1.194538e960658p+0, -0x1.8197efba9a000p-4}, +{0x1.16e0692a10ac8p+0, -0x1.5e95ad734e000p-4}, +{0x1.1485f1ba1568bp+0, -0x1.3bdf67117c000p-4}, +{0x1.12358e123ed6fp+0, -0x1.1973b744f0000p-4}, +{0x1.0fef01de37c8dp+0, -0x1.eea33446bc000p-5}, +{0x1.0db20b82be414p+0, -0x1.aaef4ab304000p-5}, +{0x1.0b7e6f67f69b3p+0, -0x1.67c962fd2c000p-5}, +{0x1.0953f342fc108p+0, -0x1.252f29acf8000p-5}, +{0x1.0732604ec956bp+0, -0x1.c63d19e9c0000p-6}, +{0x1.051980117f9b0p+0, -0x1.432ab6a388000p-6}, +{0x1.03091aa6810f1p+0, -0x1.8244357f50000p-7}, +{0x1.01010152cf066p+0, -0x1.0080a711c0000p-8}, +{0x1.fc07ef6b6e30bp-1, 0x1.fe03018e80000p-8}, +{0x1.f4465aa1024afp-1, 0x1.7b91986450000p-6}, +{0x1.ecc07a8fd3f5ep-1, 0x1.39e88608c8000p-5}, +{0x1.e573ad856b537p-1, 0x1.b42dc6e624000p-5}, +{0x1.de5d6dc7b8057p-1, 0x1.165372ec20000p-4}, +{0x1.d77b6498bddf7p-1, 0x1.51b07a0170000p-4}, +{0x1.d0cb580315c0fp-1, 0x1.8c3465c7ea000p-4}, +{0x1.ca4b30d1cf449p-1, 0x1.c5e544a290000p-4}, +{0x1.c3f8ef4810d8ep-1, 0x1.fec91aa0a6000p-4}, +{0x1.bdd2b8b311f44p-1, 0x1.1b72acdc5c000p-3}, +{0x1.b7d6c2eeac054p-1, 0x1.371fc65a98000p-3}, +{0x1.b20363474c8f5p-1, 0x1.526e61c1aa000p-3}, +{0x1.ac570165eeab1p-1, 0x1.6d60ffc240000p-3}, +{0x1.a6d019f331df4p-1, 0x1.87fa08a013000p-3}, +{0x1.a16d3ebc9e3c3p-1, 0x1.a23bc630c3000p-3}, +{0x1.9c2d14567ef45p-1, 0x1.bc286a3512000p-3}, +{0x1.970e4efae9169p-1, 0x1.d5c2195697000p-3}, +{0x1.920fb3bd0b802p-1, 0x1.ef0ae132d3000p-3}, +{0x1.8d3018b58699ap-1, 0x1.040259974e000p-2}, +{0x1.886e5ff170ee6p-1, 0x1.1058bd40e2000p-2}, +{0x1.83c977ad35d27p-1, 0x1.1c898c1137800p-2}, +{0x1.7f405ed16c520p-1, 0x1.2895a3e65b000p-2}, +{0x1.7ad220d0335c4p-1, 0x1.347dd8f6bd000p-2}, +{0x1.767dce53474fdp-1, 0x1.4043083cb3800p-2}, +#elif N == 128 +{0x1.734f0c3e0de9fp+0, -0x1.7cc7f79e69000p-2}, +{0x1.713786a2ce91fp+0, -0x1.76feec20d0000p-2}, +{0x1.6f26008fab5a0p+0, -0x1.713e31351e000p-2}, +{0x1.6d1a61f138c7dp+0, -0x1.6b85b38287800p-2}, +{0x1.6b1490bc5b4d1p+0, -0x1.65d5590807800p-2}, +{0x1.69147332f0cbap+0, -0x1.602d076180000p-2}, +{0x1.6719f18224223p+0, -0x1.5a8ca86909000p-2}, +{0x1.6524f99a51ed9p+0, -0x1.54f4356035000p-2}, +{0x1.63356aa8f24c4p+0, -0x1.4f637c36b4000p-2}, +{0x1.614b36b9ddc14p+0, -0x1.49da7fda85000p-2}, +{0x1.5f66452c65c4cp+0, -0x1.445923989a800p-2}, +{0x1.5d867b5912c4fp+0, -0x1.3edf439b0b800p-2}, +{0x1.5babccb5b90dep+0, -0x1.396ce448f7000p-2}, +{0x1.59d61f2d91a78p+0, -0x1.3401e17bda000p-2}, +{0x1.5805612465687p+0, -0x1.2e9e2ef468000p-2}, +{0x1.56397cee76bd3p+0, -0x1.2941b3830e000p-2}, +{0x1.54725e2a77f93p+0, -0x1.23ec58cda8800p-2}, +{0x1.52aff42064583p+0, -0x1.1e9e129279000p-2}, +{0x1.50f22dbb2bddfp+0, -0x1.1956d2b48f800p-2}, +{0x1.4f38f4734ded7p+0, -0x1.141679ab9f800p-2}, +{0x1.4d843cfde2840p+0, -0x1.0edd094ef9800p-2}, +{0x1.4bd3ec078a3c8p+0, -0x1.09aa518db1000p-2}, +{0x1.4a27fc3e0258ap+0, -0x1.047e65263b800p-2}, +{0x1.4880524d48434p+0, -0x1.feb224586f000p-3}, +{0x1.46dce1b192d0bp+0, -0x1.f474a7517b000p-3}, +{0x1.453d9d3391854p+0, -0x1.ea4443d103000p-3}, +{0x1.43a2744b4845ap+0, -0x1.e020d44e9b000p-3}, +{0x1.420b54115f8fbp+0, -0x1.d60a22977f000p-3}, +{0x1.40782da3ef4b1p+0, -0x1.cc00104959000p-3}, +{0x1.3ee8f5d57fe8fp+0, -0x1.c202956891000p-3}, +{0x1.3d5d9a00b4ce9p+0, -0x1.b81178d811000p-3}, +{0x1.3bd60c010c12bp+0, -0x1.ae2c9ccd3d000p-3}, +{0x1.3a5242b75dab8p+0, -0x1.a45402e129000p-3}, +{0x1.38d22cd9fd002p+0, -0x1.9a877681df000p-3}, +{0x1.3755bc5847a1cp+0, -0x1.90c6d69483000p-3}, +{0x1.35dce49ad36e2p+0, -0x1.87120a645c000p-3}, +{0x1.34679984dd440p+0, -0x1.7d68fb4143000p-3}, +{0x1.32f5cceffcb24p+0, -0x1.73cb83c627000p-3}, +{0x1.3187775a10d49p+0, -0x1.6a39a9b376000p-3}, +{0x1.301c8373e3990p+0, -0x1.60b3154b7a000p-3}, +{0x1.2eb4ebb95f841p+0, -0x1.5737d76243000p-3}, +{0x1.2d50a0219a9d1p+0, -0x1.4dc7b8fc23000p-3}, +{0x1.2bef9a8b7fd2ap+0, -0x1.4462c51d20000p-3}, +{0x1.2a91c7a0c1babp+0, -0x1.3b08abc830000p-3}, +{0x1.293726014b530p+0, -0x1.31b996b490000p-3}, +{0x1.27dfa5757a1f5p+0, -0x1.2875490a44000p-3}, +{0x1.268b39b1d3bbfp+0, -0x1.1f3b9f879a000p-3}, +{0x1.2539d838ff5bdp+0, -0x1.160c8252ca000p-3}, +{0x1.23eb7aac9083bp+0, -0x1.0ce7f57f72000p-3}, +{0x1.22a012ba940b6p+0, -0x1.03cdc49fea000p-3}, +{0x1.2157996cc4132p+0, -0x1.f57bdbc4b8000p-4}, +{0x1.201201dd2fc9bp+0, -0x1.e370896404000p-4}, +{0x1.1ecf4494d480bp+0, -0x1.d17983ef94000p-4}, +{0x1.1d8f5528f6569p+0, -0x1.bf9674ed8a000p-4}, +{0x1.1c52311577e7cp+0, -0x1.adc79202f6000p-4}, +{0x1.1b17c74cb26e9p+0, -0x1.9c0c3e7288000p-4}, +{0x1.19e010c2c1ab6p+0, -0x1.8a646b372c000p-4}, +{0x1.18ab07bb670bdp+0, -0x1.78d01b3ac0000p-4}, +{0x1.1778a25efbcb6p+0, -0x1.674f145380000p-4}, +{0x1.1648d354c31dap+0, -0x1.55e0e6d878000p-4}, +{0x1.151b990275fddp+0, -0x1.4485cdea1e000p-4}, +{0x1.13f0ea432d24cp+0, -0x1.333d94d6aa000p-4}, +{0x1.12c8b7210f9dap+0, -0x1.22079f8c56000p-4}, +{0x1.11a3028ecb531p+0, -0x1.10e4698622000p-4}, +{0x1.107fbda8434afp+0, -0x1.ffa6c6ad20000p-5}, +{0x1.0f5ee0f4e6bb3p+0, -0x1.dda8d4a774000p-5}, +{0x1.0e4065d2a9fcep+0, -0x1.bbcece4850000p-5}, +{0x1.0d244632ca521p+0, -0x1.9a1894012c000p-5}, +{0x1.0c0a77ce2981ap+0, -0x1.788583302c000p-5}, +{0x1.0af2f83c636d1p+0, -0x1.5715e67d68000p-5}, +{0x1.09ddb98a01339p+0, -0x1.35c8a49658000p-5}, +{0x1.08cabaf52e7dfp+0, -0x1.149e364154000p-5}, +{0x1.07b9f2f4e28fbp+0, -0x1.e72c082eb8000p-6}, +{0x1.06ab58c358f19p+0, -0x1.a55f152528000p-6}, +{0x1.059eea5ecf92cp+0, -0x1.63d62cf818000p-6}, +{0x1.04949cdd12c90p+0, -0x1.228fb8caa0000p-6}, +{0x1.038c6c6f0ada9p+0, -0x1.c317b20f90000p-7}, +{0x1.02865137932a9p+0, -0x1.419355daa0000p-7}, +{0x1.0182427ea7348p+0, -0x1.81203c2ec0000p-8}, +{0x1.008040614b195p+0, -0x1.0040979240000p-9}, +{0x1.fe01ff726fa1ap-1, 0x1.feff384900000p-9}, +{0x1.fa11cc261ea74p-1, 0x1.7dc41353d0000p-7}, +{0x1.f6310b081992ep-1, 0x1.3cea3c4c28000p-6}, +{0x1.f25f63ceeadcdp-1, 0x1.b9fc114890000p-6}, +{0x1.ee9c8039113e7p-1, 0x1.1b0d8ce110000p-5}, +{0x1.eae8078cbb1abp-1, 0x1.58a5bd001c000p-5}, +{0x1.e741aa29d0c9bp-1, 0x1.95c8340d88000p-5}, +{0x1.e3a91830a99b5p-1, 0x1.d276aef578000p-5}, +{0x1.e01e009609a56p-1, 0x1.07598e598c000p-4}, +{0x1.dca01e577bb98p-1, 0x1.253f5e30d2000p-4}, +{0x1.d92f20b7c9103p-1, 0x1.42edd8b380000p-4}, +{0x1.d5cac66fb5ccep-1, 0x1.606598757c000p-4}, +{0x1.d272caa5ede9dp-1, 0x1.7da76356a0000p-4}, +{0x1.cf26e3e6b2ccdp-1, 0x1.9ab434e1c6000p-4}, +{0x1.cbe6da2a77902p-1, 0x1.b78c7bb0d6000p-4}, +{0x1.c8b266d37086dp-1, 0x1.d431332e72000p-4}, +{0x1.c5894bd5d5804p-1, 0x1.f0a3171de6000p-4}, +{0x1.c26b533bb9f8cp-1, 0x1.067152b914000p-3}, +{0x1.bf583eeece73fp-1, 0x1.147858292b000p-3}, +{0x1.bc4fd75db96c1p-1, 0x1.2266ecdca3000p-3}, +{0x1.b951e0c864a28p-1, 0x1.303d7a6c55000p-3}, +{0x1.b65e2c5ef3e2cp-1, 0x1.3dfc33c331000p-3}, +{0x1.b374867c9888bp-1, 0x1.4ba366b7a8000p-3}, +{0x1.b094b211d304ap-1, 0x1.5933928d1f000p-3}, +{0x1.adbe885f2ef7ep-1, 0x1.66acd2418f000p-3}, +{0x1.aaf1d31603da2p-1, 0x1.740f8ec669000p-3}, +{0x1.a82e63fd358a7p-1, 0x1.815c0f51af000p-3}, +{0x1.a5740ef09738bp-1, 0x1.8e92954f68000p-3}, +{0x1.a2c2a90ab4b27p-1, 0x1.9bb3602f84000p-3}, +{0x1.a01a01393f2d1p-1, 0x1.a8bed1c2c0000p-3}, +{0x1.9d79f24db3c1bp-1, 0x1.b5b515c01d000p-3}, +{0x1.9ae2505c7b190p-1, 0x1.c2967ccbcc000p-3}, +{0x1.9852ef297ce2fp-1, 0x1.cf635d5486000p-3}, +{0x1.95cbaeea44b75p-1, 0x1.dc1bd3446c000p-3}, +{0x1.934c69de74838p-1, 0x1.e8c01b8cfe000p-3}, +{0x1.90d4f2f6752e6p-1, 0x1.f5509c0179000p-3}, +{0x1.8e6528effd79dp-1, 0x1.00e6c121fb800p-2}, +{0x1.8bfce9fcc007cp-1, 0x1.071b80e93d000p-2}, +{0x1.899c0dabec30ep-1, 0x1.0d46b9e867000p-2}, +{0x1.87427aa2317fbp-1, 0x1.13687334bd000p-2}, +{0x1.84f00acb39a08p-1, 0x1.1980d67234800p-2}, +{0x1.82a49e8653e55p-1, 0x1.1f8ffe0cc8000p-2}, +{0x1.8060195f40260p-1, 0x1.2595fd7636800p-2}, +{0x1.7e22563e0a329p-1, 0x1.2b9300914a800p-2}, +{0x1.7beb377dcb5adp-1, 0x1.3187210436000p-2}, +{0x1.79baa679725c2p-1, 0x1.377266dec1800p-2}, +{0x1.77907f2170657p-1, 0x1.3d54ffbaf3000p-2}, +{0x1.756cadbd6130cp-1, 0x1.432eee32fe000p-2}, +#endif +}, +#if !HAVE_FAST_FMA +.tab2 = { +# if N == 64 +{0x1.61ffff94c4fecp-1, -0x1.9fe4fc998f325p-56}, +{0x1.66000020377ddp-1, 0x1.e804c7a9519f2p-55}, +{0x1.6a00004c41678p-1, 0x1.902c675d9ecfep-55}, +{0x1.6dffff7384f87p-1, -0x1.2fd6b95e55043p-56}, +{0x1.720000b37216ep-1, 0x1.802bc8d437043p-55}, +{0x1.75ffffbeb3c9dp-1, 0x1.6047ad0a0d4e4p-57}, +{0x1.7a0000628daep-1, -0x1.e00434b49313dp-56}, +{0x1.7dffffd7abd1ap-1, -0x1.6015f8a083576p-56}, +{0x1.81ffffdf40c54p-1, 0x1.7f54bf76a42c9p-57}, +{0x1.860000f334e11p-1, 0x1.60054cb5344d7p-56}, +{0x1.8a0001238aca7p-1, 0x1.c03c9bd132f55p-57}, +{0x1.8dffffb81d212p-1, -0x1.001e519f2764fp-55}, +{0x1.92000086adc7cp-1, 0x1.1fe40f88f49c6p-55}, +{0x1.960000135d8eap-1, -0x1.f832268dc3095p-55}, +{0x1.99ffff9435acp-1, 0x1.7031d8b835edcp-56}, +{0x1.9e00003478565p-1, -0x1.0030b221ce3eep-58}, +{0x1.a20000b592948p-1, 0x1.8fd2f1dbd4639p-55}, +{0x1.a600000ad0bcfp-1, 0x1.901d6a974e6bep-55}, +{0x1.a9ffff55953a5p-1, 0x1.a07556192db98p-57}, +{0x1.adffff29ce03dp-1, -0x1.fff0717ec71c2p-56}, +{0x1.b1ffff34f3ac8p-1, 0x1.8005573de89d1p-57}, +{0x1.b60000894c55bp-1, -0x1.ff2fb51b044c7p-57}, +{0x1.b9fffef45ec7dp-1, -0x1.9ff7c4e8730fp-56}, +{0x1.be0000cda7b2ap-1, 0x1.57d058dbf3c1dp-55}, +{0x1.c1ffff2c57917p-1, 0x1.7e66d7e48dbc9p-58}, +{0x1.c60000ea5b82ap-1, -0x1.47f5e132ed4bep-55}, +{0x1.ca0001121ae98p-1, -0x1.40958c8d5e00ap-58}, +{0x1.ce0000f9241cbp-1, -0x1.7da063caa81c8p-59}, +{0x1.d1fffe8be95a4p-1, -0x1.82e3a411afcd9p-59}, +{0x1.d5ffff035932bp-1, -0x1.00f901b3fe87dp-58}, +{0x1.d9fffe8b54ba7p-1, 0x1.ffef55d6e3a4p-55}, +{0x1.de0000ad95d19p-1, 0x1.5feb2efd4c7c7p-55}, +{0x1.e1fffe925ce47p-1, 0x1.c8085484eaf08p-55}, +{0x1.e5fffe3ddf853p-1, -0x1.fd5ed02c5cadp-60}, +{0x1.e9fffed0a0e5fp-1, -0x1.a80aaef411586p-55}, +{0x1.ee00008f82eep-1, -0x1.b000aeaf97276p-55}, +{0x1.f20000a22d2f4p-1, -0x1.8f8906e13eba3p-56}, +{0x1.f5fffee35b57dp-1, 0x1.1fdd33b2d3714p-57}, +{0x1.fa00014eec3a6p-1, -0x1.3ee0b7a18c1a5p-58}, +{0x1.fdffff5daa89fp-1, -0x1.c1e24c8e3b503p-58}, +{0x1.0200005b93349p+0, -0x1.50197fe6bedcap-54}, +{0x1.05ffff9d597acp+0, 0x1.20160d062d0dcp-55}, +{0x1.0a00005687a63p+0, -0x1.27f3f9307696ep-54}, +{0x1.0dffff779164ep+0, 0x1.b7eb40bb9c4f4p-54}, +{0x1.12000044a0aa8p+0, 0x1.efbc914d512c4p-55}, +{0x1.16000069685bcp+0, -0x1.c0bea3eb2d82cp-57}, +{0x1.1a000093f0d78p+0, 0x1.1fecbf1e8c52p-54}, +{0x1.1dffffb2b1457p+0, -0x1.3fc91365637d6p-55}, +{0x1.2200008824a1p+0, -0x1.dff7e9feb578ap-54}, +{0x1.25ffffeef953p+0, -0x1.b00a61ec912f7p-55}, +{0x1.2a0000a1e7783p+0, 0x1.60048318b0483p-56}, +{0x1.2e0000853d4c7p+0, -0x1.77fbedf2c8cf3p-54}, +{0x1.320000324c55bp+0, 0x1.f81983997354fp-54}, +{0x1.360000594f796p+0, -0x1.cfe4beff900a9p-54}, +{0x1.3a0000a4c1c0fp+0, 0x1.07dbb2e268d0ep-54}, +{0x1.3e0000751c61bp+0, 0x1.80583ed1c566ep-56}, +{0x1.42000069e8a9fp+0, 0x1.f01f1edf82045p-54}, +{0x1.460000b5a1e34p+0, -0x1.dfdf0cf45c14ap-55}, +{0x1.4a0000187e513p+0, 0x1.401306b83a98dp-55}, +{0x1.4dffff3ba420bp+0, 0x1.9fc6539a6454ep-56}, +{0x1.51fffffe391c9p+0, -0x1.601ef3353ac83p-54}, +{0x1.560000e342455p+0, 0x1.3fb7fac8ac151p-55}, +{0x1.59ffffc39676fp+0, 0x1.4fe7dd6659cc2p-55}, +{0x1.5dfffff10ef42p+0, -0x1.48154cb592bcbp-54}, +# elif N == 128 +{0x1.61000014fb66bp-1, 0x1.e026c91425b3cp-56}, +{0x1.63000034db495p-1, 0x1.dbfea48005d41p-55}, +{0x1.650000d94d478p-1, 0x1.e7fa786d6a5b7p-55}, +{0x1.67000074e6fadp-1, 0x1.1fcea6b54254cp-57}, +{0x1.68ffffedf0faep-1, -0x1.c7e274c590efdp-56}, +{0x1.6b0000763c5bcp-1, -0x1.ac16848dcda01p-55}, +{0x1.6d0001e5cc1f6p-1, 0x1.33f1c9d499311p-55}, +{0x1.6efffeb05f63ep-1, -0x1.e80041ae22d53p-56}, +{0x1.710000e86978p-1, 0x1.bff6671097952p-56}, +{0x1.72ffffc67e912p-1, 0x1.c00e226bd8724p-55}, +{0x1.74fffdf81116ap-1, -0x1.e02916ef101d2p-57}, +{0x1.770000f679c9p-1, -0x1.7fc71cd549c74p-57}, +{0x1.78ffffa7ec835p-1, 0x1.1bec19ef50483p-55}, +{0x1.7affffe20c2e6p-1, -0x1.07e1729cc6465p-56}, +{0x1.7cfffed3fc9p-1, -0x1.08072087b8b1cp-55}, +{0x1.7efffe9261a76p-1, 0x1.dc0286d9df9aep-55}, +{0x1.81000049ca3e8p-1, 0x1.97fd251e54c33p-55}, +{0x1.8300017932c8fp-1, -0x1.afee9b630f381p-55}, +{0x1.850000633739cp-1, 0x1.9bfbf6b6535bcp-55}, +{0x1.87000204289c6p-1, -0x1.bbf65f3117b75p-55}, +{0x1.88fffebf57904p-1, -0x1.9006ea23dcb57p-55}, +{0x1.8b00022bc04dfp-1, -0x1.d00df38e04b0ap-56}, +{0x1.8cfffe50c1b8ap-1, -0x1.8007146ff9f05p-55}, +{0x1.8effffc918e43p-1, 0x1.3817bd07a7038p-55}, +{0x1.910001efa5fc7p-1, 0x1.93e9176dfb403p-55}, +{0x1.9300013467bb9p-1, 0x1.f804e4b980276p-56}, +{0x1.94fffe6ee076fp-1, -0x1.f7ef0d9ff622ep-55}, +{0x1.96fffde3c12d1p-1, -0x1.082aa962638bap-56}, +{0x1.98ffff4458a0dp-1, -0x1.7801b9164a8efp-55}, +{0x1.9afffdd982e3ep-1, -0x1.740e08a5a9337p-55}, +{0x1.9cfffed49fb66p-1, 0x1.fce08c19bep-60}, +{0x1.9f00020f19c51p-1, -0x1.a3faa27885b0ap-55}, +{0x1.a10001145b006p-1, 0x1.4ff489958da56p-56}, +{0x1.a300007bbf6fap-1, 0x1.cbeab8a2b6d18p-55}, +{0x1.a500010971d79p-1, 0x1.8fecadd78793p-55}, +{0x1.a70001df52e48p-1, -0x1.f41763dd8abdbp-55}, +{0x1.a90001c593352p-1, -0x1.ebf0284c27612p-55}, +{0x1.ab0002a4f3e4bp-1, -0x1.9fd043cff3f5fp-57}, +{0x1.acfffd7ae1ed1p-1, -0x1.23ee7129070b4p-55}, +{0x1.aefffee510478p-1, 0x1.a063ee00edea3p-57}, +{0x1.b0fffdb650d5bp-1, 0x1.a06c8381f0ab9p-58}, +{0x1.b2ffffeaaca57p-1, -0x1.9011e74233c1dp-56}, +{0x1.b4fffd995badcp-1, -0x1.9ff1068862a9fp-56}, +{0x1.b7000249e659cp-1, 0x1.aff45d0864f3ep-55}, +{0x1.b8ffff987164p-1, 0x1.cfe7796c2c3f9p-56}, +{0x1.bafffd204cb4fp-1, -0x1.3ff27eef22bc4p-57}, +{0x1.bcfffd2415c45p-1, -0x1.cffb7ee3bea21p-57}, +{0x1.beffff86309dfp-1, -0x1.14103972e0b5cp-55}, +{0x1.c0fffe1b57653p-1, 0x1.bc16494b76a19p-55}, +{0x1.c2ffff1fa57e3p-1, -0x1.4feef8d30c6edp-57}, +{0x1.c4fffdcbfe424p-1, -0x1.43f68bcec4775p-55}, +{0x1.c6fffed54b9f7p-1, 0x1.47ea3f053e0ecp-55}, +{0x1.c8fffeb998fd5p-1, 0x1.383068df992f1p-56}, +{0x1.cb0002125219ap-1, -0x1.8fd8e64180e04p-57}, +{0x1.ccfffdd94469cp-1, 0x1.e7ebe1cc7ea72p-55}, +{0x1.cefffeafdc476p-1, 0x1.ebe39ad9f88fep-55}, +{0x1.d1000169af82bp-1, 0x1.57d91a8b95a71p-56}, +{0x1.d30000d0ff71dp-1, 0x1.9c1906970c7dap-55}, +{0x1.d4fffea790fc4p-1, -0x1.80e37c558fe0cp-58}, +{0x1.d70002edc87e5p-1, -0x1.f80d64dc10f44p-56}, +{0x1.d900021dc82aap-1, -0x1.47c8f94fd5c5cp-56}, +{0x1.dafffd86b0283p-1, 0x1.c7f1dc521617ep-55}, +{0x1.dd000296c4739p-1, 0x1.8019eb2ffb153p-55}, +{0x1.defffe54490f5p-1, 0x1.e00d2c652cc89p-57}, +{0x1.e0fffcdabf694p-1, -0x1.f8340202d69d2p-56}, +{0x1.e2fffdb52c8ddp-1, 0x1.b00c1ca1b0864p-56}, +{0x1.e4ffff24216efp-1, 0x1.2ffa8b094ab51p-56}, +{0x1.e6fffe88a5e11p-1, -0x1.7f673b1efbe59p-58}, +{0x1.e9000119eff0dp-1, -0x1.4808d5e0bc801p-55}, +{0x1.eafffdfa51744p-1, 0x1.80006d54320b5p-56}, +{0x1.ed0001a127fa1p-1, -0x1.002f860565c92p-58}, +{0x1.ef00007babcc4p-1, -0x1.540445d35e611p-55}, +{0x1.f0ffff57a8d02p-1, -0x1.ffb3139ef9105p-59}, +{0x1.f30001ee58ac7p-1, 0x1.a81acf2731155p-55}, +{0x1.f4ffff5823494p-1, 0x1.a3f41d4d7c743p-55}, +{0x1.f6ffffca94c6bp-1, -0x1.202f41c987875p-57}, +{0x1.f8fffe1f9c441p-1, 0x1.77dd1f477e74bp-56}, +{0x1.fafffd2e0e37ep-1, -0x1.f01199a7ca331p-57}, +{0x1.fd0001c77e49ep-1, 0x1.181ee4bceacb1p-56}, +{0x1.feffff7e0c331p-1, -0x1.e05370170875ap-57}, +{0x1.00ffff465606ep+0, -0x1.a7ead491c0adap-55}, +{0x1.02ffff3867a58p+0, -0x1.77f69c3fcb2ep-54}, +{0x1.04ffffdfc0d17p+0, 0x1.7bffe34cb945bp-54}, +{0x1.0700003cd4d82p+0, 0x1.20083c0e456cbp-55}, +{0x1.08ffff9f2cbe8p+0, -0x1.dffdfbe37751ap-57}, +{0x1.0b000010cda65p+0, -0x1.13f7faee626ebp-54}, +{0x1.0d00001a4d338p+0, 0x1.07dfa79489ff7p-55}, +{0x1.0effffadafdfdp+0, -0x1.7040570d66bcp-56}, +{0x1.110000bbafd96p+0, 0x1.e80d4846d0b62p-55}, +{0x1.12ffffae5f45dp+0, 0x1.dbffa64fd36efp-54}, +{0x1.150000dd59ad9p+0, 0x1.a0077701250aep-54}, +{0x1.170000f21559ap+0, 0x1.dfdf9e2e3deeep-55}, +{0x1.18ffffc275426p+0, 0x1.10030dc3b7273p-54}, +{0x1.1b000123d3c59p+0, 0x1.97f7980030188p-54}, +{0x1.1cffff8299eb7p+0, -0x1.5f932ab9f8c67p-57}, +{0x1.1effff48ad4p+0, 0x1.37fbf9da75bebp-54}, +{0x1.210000c8b86a4p+0, 0x1.f806b91fd5b22p-54}, +{0x1.2300003854303p+0, 0x1.3ffc2eb9fbf33p-54}, +{0x1.24fffffbcf684p+0, 0x1.601e77e2e2e72p-56}, +{0x1.26ffff52921d9p+0, 0x1.ffcbb767f0c61p-56}, +{0x1.2900014933a3cp+0, -0x1.202ca3c02412bp-56}, +{0x1.2b00014556313p+0, -0x1.2808233f21f02p-54}, +{0x1.2cfffebfe523bp+0, -0x1.8ff7e384fdcf2p-55}, +{0x1.2f0000bb8ad96p+0, -0x1.5ff51503041c5p-55}, +{0x1.30ffffb7ae2afp+0, -0x1.10071885e289dp-55}, +{0x1.32ffffeac5f7fp+0, -0x1.1ff5d3fb7b715p-54}, +{0x1.350000ca66756p+0, 0x1.57f82228b82bdp-54}, +{0x1.3700011fbf721p+0, 0x1.000bac40dd5ccp-55}, +{0x1.38ffff9592fb9p+0, -0x1.43f9d2db2a751p-54}, +{0x1.3b00004ddd242p+0, 0x1.57f6b707638e1p-55}, +{0x1.3cffff5b2c957p+0, 0x1.a023a10bf1231p-56}, +{0x1.3efffeab0b418p+0, 0x1.87f6d66b152bp-54}, +{0x1.410001532aff4p+0, 0x1.7f8375f198524p-57}, +{0x1.4300017478b29p+0, 0x1.301e672dc5143p-55}, +{0x1.44fffe795b463p+0, 0x1.9ff69b8b2895ap-55}, +{0x1.46fffe80475ep+0, -0x1.5c0b19bc2f254p-54}, +{0x1.48fffef6fc1e7p+0, 0x1.b4009f23a2a72p-54}, +{0x1.4afffe5bea704p+0, -0x1.4ffb7bf0d7d45p-54}, +{0x1.4d000171027dep+0, -0x1.9c06471dc6a3dp-54}, +{0x1.4f0000ff03ee2p+0, 0x1.77f890b85531cp-54}, +{0x1.5100012dc4bd1p+0, 0x1.004657166a436p-57}, +{0x1.530001605277ap+0, -0x1.6bfcece233209p-54}, +{0x1.54fffecdb704cp+0, -0x1.902720505a1d7p-55}, +{0x1.56fffef5f54a9p+0, 0x1.bbfe60ec96412p-54}, +{0x1.5900017e61012p+0, 0x1.87ec581afef9p-55}, +{0x1.5b00003c93e92p+0, -0x1.f41080abf0ccp-54}, +{0x1.5d0001d4919bcp+0, -0x1.8812afb254729p-54}, +{0x1.5efffe7b87a89p+0, -0x1.47eb780ed6904p-54}, +#endif +}, +#endif /* !HAVE_FAST_FMA */ +}; diff --git a/libc/AOR_v20.02/math/logf.c b/libc/AOR_v20.02/math/logf.c new file mode 100644 index 00000000000000..5afe629d68e78a --- /dev/null +++ b/libc/AOR_v20.02/math/logf.c @@ -0,0 +1,80 @@ +/* + * Single-precision log function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" + +/* +LOGF_TABLE_BITS = 4 +LOGF_POLY_ORDER = 4 + +ULP error: 0.818 (nearest rounding.) +Relative error: 1.957 * 2^-26 (before rounding.) +*/ + +#define T __logf_data.tab +#define A __logf_data.poly +#define Ln2 __logf_data.ln2 +#define N (1 << LOGF_TABLE_BITS) +#define OFF 0x3f330000 + +float +logf (float x) +{ + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t z, r, r2, y, y0, invc, logc; + uint32_t ix, iz, tmp; + int k, i; + + ix = asuint (x); +#if WANT_ROUNDING + /* Fix sign of zero with downward rounding when x==1. */ + if (unlikely (ix == 0x3f800000)) + return 0; +#endif + if (unlikely (ix - 0x00800000 >= 0x7f800000 - 0x00800000)) + { + /* x < 0x1p-126 or inf or nan. */ + if (ix * 2 == 0) + return __math_divzerof (1); + if (ix == 0x7f800000) /* log(inf) == inf. */ + return x; + if ((ix & 0x80000000) || ix * 2 >= 0xff000000) + return __math_invalidf (x); + /* x is subnormal, normalize it. */ + ix = asuint (x * 0x1p23f); + ix -= 23 << 23; + } + + /* x = 2^k z; where z is in range [OFF,2*OFF] and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (23 - LOGF_TABLE_BITS)) % N; + k = (int32_t) tmp >> 23; /* arithmetic shift */ + iz = ix - (tmp & 0x1ff << 23); + invc = T[i].invc; + logc = T[i].logc; + z = (double_t) asfloat (iz); + + /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ + r = z * invc - 1; + y0 = logc + (double_t) k * Ln2; + + /* Pipelined polynomial evaluation to approximate log1p(r). */ + r2 = r * r; + y = A[1] * r + A[2]; + y = A[0] * r2 + y; + y = y * r2 + (y0 + r); + return eval_as_float (y); +} +#if USE_GLIBC_ABI +strong_alias (logf, __logf_finite) +hidden_alias (logf, __ieee754_logf) +#endif diff --git a/libc/AOR_v20.02/math/logf_data.c b/libc/AOR_v20.02/math/logf_data.c new file mode 100644 index 00000000000000..e4de10f58e67a6 --- /dev/null +++ b/libc/AOR_v20.02/math/logf_data.c @@ -0,0 +1,34 @@ +/* + * Data definition for logf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +const struct logf_data __logf_data = { + .tab = { + { 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2 }, + { 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2 }, + { 0x1.49539f0f010bp+0, -0x1.01eae7f513a67p-2 }, + { 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3 }, + { 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3 }, + { 0x1.25e227b0b8eap+0, -0x1.1aa2bc79c81p-3 }, + { 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4 }, + { 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4 }, + { 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5 }, + { 0x1p+0, 0x0p+0 }, + { 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5 }, + { 0x1.ca4b31f026aap-1, 0x1.c5e53aa362eb4p-4 }, + { 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3 }, + { 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 }, + { 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2 }, + { 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2 }, + }, + .ln2 = 0x1.62e42fefa39efp-1, + .poly = { + -0x1.00ea348b88334p-2, 0x1.5575b0be00b6ap-2, -0x1.ffffef20a4123p-2, + } +}; diff --git a/libc/AOR_v20.02/math/math_config.h b/libc/AOR_v20.02/math/math_config.h new file mode 100644 index 00000000000000..ea2d59e94ff0dd --- /dev/null +++ b/libc/AOR_v20.02/math/math_config.h @@ -0,0 +1,420 @@ +/* + * Configuration for math routines. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef _MATH_CONFIG_H +#define _MATH_CONFIG_H + +#include +#include + +#ifndef WANT_ROUNDING +/* If defined to 1, return correct results for special cases in non-nearest + rounding modes (logf (1.0f) returns 0.0f with FE_DOWNWARD rather than -0.0f). + This may be set to 0 if there is no fenv support or if math functions only + get called in round to nearest mode. */ +# define WANT_ROUNDING 1 +#endif +#ifndef WANT_ERRNO +/* If defined to 1, set errno in math functions according to ISO C. Many math + libraries do not set errno, so this is 0 by default. It may need to be + set to 1 if math.h has (math_errhandling & MATH_ERRNO) != 0. */ +# define WANT_ERRNO 0 +#endif +#ifndef WANT_ERRNO_UFLOW +/* Set errno to ERANGE if result underflows to 0 (in all rounding modes). */ +# define WANT_ERRNO_UFLOW (WANT_ROUNDING && WANT_ERRNO) +#endif + +/* Compiler can inline round as a single instruction. */ +#ifndef HAVE_FAST_ROUND +# if __aarch64__ +# define HAVE_FAST_ROUND 1 +# else +# define HAVE_FAST_ROUND 0 +# endif +#endif + +/* Compiler can inline lround, but not (long)round(x). */ +#ifndef HAVE_FAST_LROUND +# if __aarch64__ && (100*__GNUC__ + __GNUC_MINOR__) >= 408 && __NO_MATH_ERRNO__ +# define HAVE_FAST_LROUND 1 +# else +# define HAVE_FAST_LROUND 0 +# endif +#endif + +/* Compiler can inline fma as a single instruction. */ +#ifndef HAVE_FAST_FMA +# if defined FP_FAST_FMA || __aarch64__ +# define HAVE_FAST_FMA 1 +# else +# define HAVE_FAST_FMA 0 +# endif +#endif + +/* Provide *_finite symbols and some of the glibc hidden symbols + so libmathlib can be used with binaries compiled against glibc + to interpose math functions with both static and dynamic linking. */ +#ifndef USE_GLIBC_ABI +# if __GNUC__ +# define USE_GLIBC_ABI 1 +# else +# define USE_GLIBC_ABI 0 +# endif +#endif + +/* Optionally used extensions. */ +#ifdef __GNUC__ +# define HIDDEN __attribute__ ((__visibility__ ("hidden"))) +# define NOINLINE __attribute__ ((noinline)) +# define UNUSED __attribute__ ((unused)) +# define likely(x) __builtin_expect (!!(x), 1) +# define unlikely(x) __builtin_expect (x, 0) +# if __GNUC__ >= 9 +# define attribute_copy(f) __attribute__ ((copy (f))) +# else +# define attribute_copy(f) +# endif +# define strong_alias(f, a) \ + extern __typeof (f) a __attribute__ ((alias (#f))) attribute_copy (f); +# define hidden_alias(f, a) \ + extern __typeof (f) a __attribute__ ((alias (#f), visibility ("hidden"))) \ + attribute_copy (f); +#else +# define HIDDEN +# define NOINLINE +# define UNUSED +# define likely(x) (x) +# define unlikely(x) (x) +#endif + +#if HAVE_FAST_ROUND +/* When set, the roundtoint and converttoint functions are provided with + the semantics documented below. */ +# define TOINT_INTRINSICS 1 + +/* Round x to nearest int in all rounding modes, ties have to be rounded + consistently with converttoint so the results match. If the result + would be outside of [-2^31, 2^31-1] then the semantics is unspecified. */ +static inline double_t +roundtoint (double_t x) +{ + return round (x); +} + +/* Convert x to nearest int in all rounding modes, ties have to be rounded + consistently with roundtoint. If the result is not representible in an + int32_t then the semantics is unspecified. */ +static inline int32_t +converttoint (double_t x) +{ +# if HAVE_FAST_LROUND + return lround (x); +# else + return (long) round (x); +# endif +} +#endif + +static inline uint32_t +asuint (float f) +{ + union + { + float f; + uint32_t i; + } u = {f}; + return u.i; +} + +static inline float +asfloat (uint32_t i) +{ + union + { + uint32_t i; + float f; + } u = {i}; + return u.f; +} + +static inline uint64_t +asuint64 (double f) +{ + union + { + double f; + uint64_t i; + } u = {f}; + return u.i; +} + +static inline double +asdouble (uint64_t i) +{ + union + { + uint64_t i; + double f; + } u = {i}; + return u.f; +} + +#ifndef IEEE_754_2008_SNAN +# define IEEE_754_2008_SNAN 1 +#endif +static inline int +issignalingf_inline (float x) +{ + uint32_t ix = asuint (x); + if (!IEEE_754_2008_SNAN) + return (ix & 0x7fc00000) == 0x7fc00000; + return 2 * (ix ^ 0x00400000) > 2u * 0x7fc00000; +} + +static inline int +issignaling_inline (double x) +{ + uint64_t ix = asuint64 (x); + if (!IEEE_754_2008_SNAN) + return (ix & 0x7ff8000000000000) == 0x7ff8000000000000; + return 2 * (ix ^ 0x0008000000000000) > 2 * 0x7ff8000000000000ULL; +} + +#if __aarch64__ && __GNUC__ +/* Prevent the optimization of a floating-point expression. */ +static inline float +opt_barrier_float (float x) +{ + __asm__ __volatile__ ("" : "+w" (x)); + return x; +} +static inline double +opt_barrier_double (double x) +{ + __asm__ __volatile__ ("" : "+w" (x)); + return x; +} +/* Force the evaluation of a floating-point expression for its side-effect. */ +static inline void +force_eval_float (float x) +{ + __asm__ __volatile__ ("" : "+w" (x)); +} +static inline void +force_eval_double (double x) +{ + __asm__ __volatile__ ("" : "+w" (x)); +} +#else +static inline float +opt_barrier_float (float x) +{ + volatile float y = x; + return y; +} +static inline double +opt_barrier_double (double x) +{ + volatile double y = x; + return y; +} +static inline void +force_eval_float (float x) +{ + volatile float y UNUSED = x; +} +static inline void +force_eval_double (double x) +{ + volatile double y UNUSED = x; +} +#endif + +/* Evaluate an expression as the specified type, normally a type + cast should be enough, but compilers implement non-standard + excess-precision handling, so when FLT_EVAL_METHOD != 0 then + these functions may need to be customized. */ +static inline float +eval_as_float (float x) +{ + return x; +} +static inline double +eval_as_double (double x) +{ + return x; +} + +/* Error handling tail calls for special cases, with a sign argument. + The sign of the return value is set if the argument is non-zero. */ + +/* The result overflows. */ +HIDDEN float __math_oflowf (uint32_t); +/* The result underflows to 0 in nearest rounding mode. */ +HIDDEN float __math_uflowf (uint32_t); +/* The result underflows to 0 in some directed rounding mode only. */ +HIDDEN float __math_may_uflowf (uint32_t); +/* Division by zero. */ +HIDDEN float __math_divzerof (uint32_t); +/* The result overflows. */ +HIDDEN double __math_oflow (uint32_t); +/* The result underflows to 0 in nearest rounding mode. */ +HIDDEN double __math_uflow (uint32_t); +/* The result underflows to 0 in some directed rounding mode only. */ +HIDDEN double __math_may_uflow (uint32_t); +/* Division by zero. */ +HIDDEN double __math_divzero (uint32_t); + +/* Error handling using input checking. */ + +/* Invalid input unless it is a quiet NaN. */ +HIDDEN float __math_invalidf (float); +/* Invalid input unless it is a quiet NaN. */ +HIDDEN double __math_invalid (double); + +/* Error handling using output checking, only for errno setting. */ + +/* Check if the result overflowed to infinity. */ +HIDDEN double __math_check_oflow (double); +/* Check if the result underflowed to 0. */ +HIDDEN double __math_check_uflow (double); + +/* Check if the result overflowed to infinity. */ +static inline double +check_oflow (double x) +{ + return WANT_ERRNO ? __math_check_oflow (x) : x; +} + +/* Check if the result underflowed to 0. */ +static inline double +check_uflow (double x) +{ + return WANT_ERRNO ? __math_check_uflow (x) : x; +} + + +/* Shared between expf, exp2f and powf. */ +#define EXP2F_TABLE_BITS 5 +#define EXP2F_POLY_ORDER 3 +extern const struct exp2f_data +{ + uint64_t tab[1 << EXP2F_TABLE_BITS]; + double shift_scaled; + double poly[EXP2F_POLY_ORDER]; + double shift; + double invln2_scaled; + double poly_scaled[EXP2F_POLY_ORDER]; +} __exp2f_data HIDDEN; + +#define LOGF_TABLE_BITS 4 +#define LOGF_POLY_ORDER 4 +extern const struct logf_data +{ + struct + { + double invc, logc; + } tab[1 << LOGF_TABLE_BITS]; + double ln2; + double poly[LOGF_POLY_ORDER - 1]; /* First order coefficient is 1. */ +} __logf_data HIDDEN; + +#define LOG2F_TABLE_BITS 4 +#define LOG2F_POLY_ORDER 4 +extern const struct log2f_data +{ + struct + { + double invc, logc; + } tab[1 << LOG2F_TABLE_BITS]; + double poly[LOG2F_POLY_ORDER]; +} __log2f_data HIDDEN; + +#define POWF_LOG2_TABLE_BITS 4 +#define POWF_LOG2_POLY_ORDER 5 +#if TOINT_INTRINSICS +# define POWF_SCALE_BITS EXP2F_TABLE_BITS +#else +# define POWF_SCALE_BITS 0 +#endif +#define POWF_SCALE ((double) (1 << POWF_SCALE_BITS)) +extern const struct powf_log2_data +{ + struct + { + double invc, logc; + } tab[1 << POWF_LOG2_TABLE_BITS]; + double poly[POWF_LOG2_POLY_ORDER]; +} __powf_log2_data HIDDEN; + + +#define EXP_TABLE_BITS 7 +#define EXP_POLY_ORDER 5 +/* Use polynomial that is optimized for a wider input range. This may be + needed for good precision in non-nearest rounding and !TOINT_INTRINSICS. */ +#define EXP_POLY_WIDE 0 +/* Use close to nearest rounding toint when !TOINT_INTRINSICS. This may be + needed for good precision in non-nearest rouning and !EXP_POLY_WIDE. */ +#define EXP_USE_TOINT_NARROW 0 +#define EXP2_POLY_ORDER 5 +#define EXP2_POLY_WIDE 0 +extern const struct exp_data +{ + double invln2N; + double shift; + double negln2hiN; + double negln2loN; + double poly[4]; /* Last four coefficients. */ + double exp2_shift; + double exp2_poly[EXP2_POLY_ORDER]; + uint64_t tab[2*(1 << EXP_TABLE_BITS)]; +} __exp_data HIDDEN; + +#define LOG_TABLE_BITS 7 +#define LOG_POLY_ORDER 6 +#define LOG_POLY1_ORDER 12 +extern const struct log_data +{ + double ln2hi; + double ln2lo; + double poly[LOG_POLY_ORDER - 1]; /* First coefficient is 1. */ + double poly1[LOG_POLY1_ORDER - 1]; + struct {double invc, logc;} tab[1 << LOG_TABLE_BITS]; +#if !HAVE_FAST_FMA + struct {double chi, clo;} tab2[1 << LOG_TABLE_BITS]; +#endif +} __log_data HIDDEN; + +#define LOG2_TABLE_BITS 6 +#define LOG2_POLY_ORDER 7 +#define LOG2_POLY1_ORDER 11 +extern const struct log2_data +{ + double invln2hi; + double invln2lo; + double poly[LOG2_POLY_ORDER - 1]; + double poly1[LOG2_POLY1_ORDER - 1]; + struct {double invc, logc;} tab[1 << LOG2_TABLE_BITS]; +#if !HAVE_FAST_FMA + struct {double chi, clo;} tab2[1 << LOG2_TABLE_BITS]; +#endif +} __log2_data HIDDEN; + +#define POW_LOG_TABLE_BITS 7 +#define POW_LOG_POLY_ORDER 8 +extern const struct pow_log_data +{ + double ln2hi; + double ln2lo; + double poly[POW_LOG_POLY_ORDER - 1]; /* First coefficient is 1. */ + /* Note: the pad field is unused, but allows slightly faster indexing. */ + struct {double invc, pad, logc, logctail;} tab[1 << POW_LOG_TABLE_BITS]; +} __pow_log_data HIDDEN; + +#endif diff --git a/libc/AOR_v20.02/math/math_err.c b/libc/AOR_v20.02/math/math_err.c new file mode 100644 index 00000000000000..77d8a940efee25 --- /dev/null +++ b/libc/AOR_v20.02/math/math_err.c @@ -0,0 +1,81 @@ +/* + * Double-precision math error handling. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +#if WANT_ERRNO +#include +/* NOINLINE reduces code size and avoids making math functions non-leaf + when the error handling is inlined. */ +NOINLINE static double +with_errno (double y, int e) +{ + errno = e; + return y; +} +#else +#define with_errno(x, e) (x) +#endif + +/* NOINLINE reduces code size. */ +NOINLINE static double +xflow (uint32_t sign, double y) +{ + y = eval_as_double (opt_barrier_double (sign ? -y : y) * y); + return with_errno (y, ERANGE); +} + +HIDDEN double +__math_uflow (uint32_t sign) +{ + return xflow (sign, 0x1p-767); +} + +#if WANT_ERRNO_UFLOW +/* Underflows to zero in some non-nearest rounding mode, setting errno + is valid even if the result is non-zero, but in the subnormal range. */ +HIDDEN double +__math_may_uflow (uint32_t sign) +{ + return xflow (sign, 0x1.8p-538); +} +#endif + +HIDDEN double +__math_oflow (uint32_t sign) +{ + return xflow (sign, 0x1p769); +} + +HIDDEN double +__math_divzero (uint32_t sign) +{ + double y = opt_barrier_double (sign ? -1.0 : 1.0) / 0.0; + return with_errno (y, ERANGE); +} + +HIDDEN double +__math_invalid (double x) +{ + double y = (x - x) / (x - x); + return isnan (x) ? y : with_errno (y, EDOM); +} + +/* Check result and set errno if necessary. */ + +HIDDEN double +__math_check_uflow (double y) +{ + return y == 0.0 ? with_errno (y, ERANGE) : y; +} + +HIDDEN double +__math_check_oflow (double y) +{ + return isinf (y) ? with_errno (y, ERANGE) : y; +} diff --git a/libc/AOR_v20.02/math/math_errf.c b/libc/AOR_v20.02/math/math_errf.c new file mode 100644 index 00000000000000..0837463af4fdc2 --- /dev/null +++ b/libc/AOR_v20.02/math/math_errf.c @@ -0,0 +1,67 @@ +/* + * Single-precision math error handling. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +#if WANT_ERRNO +#include +/* NOINLINE reduces code size and avoids making math functions non-leaf + when the error handling is inlined. */ +NOINLINE static float +with_errnof (float y, int e) +{ + errno = e; + return y; +} +#else +#define with_errnof(x, e) (x) +#endif + +/* NOINLINE reduces code size. */ +NOINLINE static float +xflowf (uint32_t sign, float y) +{ + y = eval_as_float (opt_barrier_float (sign ? -y : y) * y); + return with_errnof (y, ERANGE); +} + +HIDDEN float +__math_uflowf (uint32_t sign) +{ + return xflowf (sign, 0x1p-95f); +} + +#if WANT_ERRNO_UFLOW +/* Underflows to zero in some non-nearest rounding mode, setting errno + is valid even if the result is non-zero, but in the subnormal range. */ +HIDDEN float +__math_may_uflowf (uint32_t sign) +{ + return xflowf (sign, 0x1.4p-75f); +} +#endif + +HIDDEN float +__math_oflowf (uint32_t sign) +{ + return xflowf (sign, 0x1p97f); +} + +HIDDEN float +__math_divzerof (uint32_t sign) +{ + float y = opt_barrier_float (sign ? -1.0f : 1.0f) / 0.0f; + return with_errnof (y, ERANGE); +} + +HIDDEN float +__math_invalidf (float x) +{ + float y = (x - x) / (x - x); + return isnan (x) ? y : with_errnof (y, EDOM); +} diff --git a/libc/AOR_v20.02/math/pow.c b/libc/AOR_v20.02/math/pow.c new file mode 100644 index 00000000000000..acdb23da138e7b --- /dev/null +++ b/libc/AOR_v20.02/math/pow.c @@ -0,0 +1,381 @@ +/* + * Double-precision x^y function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include "math_config.h" + +/* +Worst-case error: 0.54 ULP (~= ulperr_exp + 1024*Ln2*relerr_log*2^53) +relerr_log: 1.3 * 2^-68 (Relative error of log, 1.5 * 2^-68 without fma) +ulperr_exp: 0.509 ULP (ULP error of exp, 0.511 ULP without fma) +*/ + +#define T __pow_log_data.tab +#define A __pow_log_data.poly +#define Ln2hi __pow_log_data.ln2hi +#define Ln2lo __pow_log_data.ln2lo +#define N (1 << POW_LOG_TABLE_BITS) +#define OFF 0x3fe6955500000000 + +/* Top 12 bits of a double (sign and exponent bits). */ +static inline uint32_t +top12 (double x) +{ + return asuint64 (x) >> 52; +} + +/* Compute y+TAIL = log(x) where the rounded result is y and TAIL has about + additional 15 bits precision. IX is the bit representation of x, but + normalized in the subnormal range using the sign bit for the exponent. */ +static inline double_t +log_inline (uint64_t ix, double_t *tail) +{ + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t z, r, y, invc, logc, logctail, kd, hi, t1, t2, lo, lo1, lo2, p; + uint64_t iz, tmp; + int k, i; + + /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (52 - POW_LOG_TABLE_BITS)) % N; + k = (int64_t) tmp >> 52; /* arithmetic shift */ + iz = ix - (tmp & 0xfffULL << 52); + z = asdouble (iz); + kd = (double_t) k; + + /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ + invc = T[i].invc; + logc = T[i].logc; + logctail = T[i].logctail; + + /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and + |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ +#if HAVE_FAST_FMA + r = fma (z, invc, -1.0); +#else + /* Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|. */ + double_t zhi = asdouble ((iz + (1ULL << 31)) & (-1ULL << 32)); + double_t zlo = z - zhi; + double_t rhi = zhi * invc - 1.0; + double_t rlo = zlo * invc; + r = rhi + rlo; +#endif + + /* k*Ln2 + log(c) + r. */ + t1 = kd * Ln2hi + logc; + t2 = t1 + r; + lo1 = kd * Ln2lo + logctail; + lo2 = t1 - t2 + r; + + /* Evaluation is optimized assuming superscalar pipelined execution. */ + double_t ar, ar2, ar3, lo3, lo4; + ar = A[0] * r; /* A[0] = -0.5. */ + ar2 = r * ar; + ar3 = r * ar2; + /* k*Ln2 + log(c) + r + A[0]*r*r. */ +#if HAVE_FAST_FMA + hi = t2 + ar2; + lo3 = fma (ar, r, -ar2); + lo4 = t2 - hi + ar2; +#else + double_t arhi = A[0] * rhi; + double_t arhi2 = rhi * arhi; + hi = t2 + arhi2; + lo3 = rlo * (ar + arhi); + lo4 = t2 - hi + arhi2; +#endif + /* p = log1p(r) - r - A[0]*r*r. */ +#if POW_LOG_POLY_ORDER == 8 + p = (ar3 + * (A[1] + r * A[2] + ar2 * (A[3] + r * A[4] + ar2 * (A[5] + r * A[6])))); +#endif + lo = lo1 + lo2 + lo3 + lo4 + p; + y = hi + lo; + *tail = hi - y + lo; + return y; +} + +#undef N +#undef T +#define N (1 << EXP_TABLE_BITS) +#define InvLn2N __exp_data.invln2N +#define NegLn2hiN __exp_data.negln2hiN +#define NegLn2loN __exp_data.negln2loN +#define Shift __exp_data.shift +#define T __exp_data.tab +#define C2 __exp_data.poly[5 - EXP_POLY_ORDER] +#define C3 __exp_data.poly[6 - EXP_POLY_ORDER] +#define C4 __exp_data.poly[7 - EXP_POLY_ORDER] +#define C5 __exp_data.poly[8 - EXP_POLY_ORDER] +#define C6 __exp_data.poly[9 - EXP_POLY_ORDER] + +/* Handle cases that may overflow or underflow when computing the result that + is scale*(1+TMP) without intermediate rounding. The bit representation of + scale is in SBITS, however it has a computed exponent that may have + overflown into the sign bit so that needs to be adjusted before using it as + a double. (int32_t)KI is the k used in the argument reduction and exponent + adjustment of scale, positive k here means the result may overflow and + negative k means the result may underflow. */ +static inline double +specialcase (double_t tmp, uint64_t sbits, uint64_t ki) +{ + double_t scale, y; + + if ((ki & 0x80000000) == 0) + { + /* k > 0, the exponent of scale might have overflowed by <= 460. */ + sbits -= 1009ull << 52; + scale = asdouble (sbits); + y = 0x1p1009 * (scale + scale * tmp); + return check_oflow (eval_as_double (y)); + } + /* k < 0, need special care in the subnormal range. */ + sbits += 1022ull << 52; + /* Note: sbits is signed scale. */ + scale = asdouble (sbits); + y = scale + scale * tmp; + if (fabs (y) < 1.0) + { + /* Round y to the right precision before scaling it into the subnormal + range to avoid double rounding that can cause 0.5+E/2 ulp error where + E is the worst-case ulp error outside the subnormal range. So this + is only useful if the goal is better than 1 ulp worst-case error. */ + double_t hi, lo, one = 1.0; + if (y < 0.0) + one = -1.0; + lo = scale - y + scale * tmp; + hi = one + y; + lo = one - hi + y + lo; + y = eval_as_double (hi + lo) - one; + /* Fix the sign of 0. */ + if (y == 0.0) + y = asdouble (sbits & 0x8000000000000000); + /* The underflow exception needs to be signaled explicitly. */ + force_eval_double (opt_barrier_double (0x1p-1022) * 0x1p-1022); + } + y = 0x1p-1022 * y; + return check_uflow (eval_as_double (y)); +} + +#define SIGN_BIAS (0x800 << EXP_TABLE_BITS) + +/* Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|. + The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1. */ +static inline double +exp_inline (double_t x, double_t xtail, uint32_t sign_bias) +{ + uint32_t abstop; + uint64_t ki, idx, top, sbits; + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t kd, z, r, r2, scale, tail, tmp; + + abstop = top12 (x) & 0x7ff; + if (unlikely (abstop - top12 (0x1p-54) >= top12 (512.0) - top12 (0x1p-54))) + { + if (abstop - top12 (0x1p-54) >= 0x80000000) + { + /* Avoid spurious underflow for tiny x. */ + /* Note: 0 is common input. */ + double_t one = WANT_ROUNDING ? 1.0 + x : 1.0; + return sign_bias ? -one : one; + } + if (abstop >= top12 (1024.0)) + { + /* Note: inf and nan are already handled. */ + if (asuint64 (x) >> 63) + return __math_uflow (sign_bias); + else + return __math_oflow (sign_bias); + } + /* Large x is special cased below. */ + abstop = 0; + } + + /* exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]. */ + /* x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]. */ + z = InvLn2N * x; +#if TOINT_INTRINSICS + kd = roundtoint (z); + ki = converttoint (z); +#elif EXP_USE_TOINT_NARROW + /* z - kd is in [-0.5-2^-16, 0.5] in all rounding modes. */ + kd = eval_as_double (z + Shift); + ki = asuint64 (kd) >> 16; + kd = (double_t) (int32_t) ki; +#else + /* z - kd is in [-1, 1] in non-nearest rounding modes. */ + kd = eval_as_double (z + Shift); + ki = asuint64 (kd); + kd -= Shift; +#endif + r = x + kd * NegLn2hiN + kd * NegLn2loN; + /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ + r += xtail; + /* 2^(k/N) ~= scale * (1 + tail). */ + idx = 2 * (ki % N); + top = (ki + sign_bias) << (52 - EXP_TABLE_BITS); + tail = asdouble (T[idx]); + /* This is only a valid scale when -1023*N < k < 1024*N. */ + sbits = T[idx + 1] + top; + /* exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1). */ + /* Evaluation is optimized assuming superscalar pipelined execution. */ + r2 = r * r; + /* Without fma the worst case error is 0.25/N ulp larger. */ + /* Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp. */ +#if EXP_POLY_ORDER == 4 + tmp = tail + r + r2 * C2 + r * r2 * (C3 + r * C4); +#elif EXP_POLY_ORDER == 5 + tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5); +#elif EXP_POLY_ORDER == 6 + tmp = tail + r + r2 * (0.5 + r * C3) + r2 * r2 * (C4 + r * C5 + r2 * C6); +#endif + if (unlikely (abstop == 0)) + return specialcase (tmp, sbits, ki); + scale = asdouble (sbits); + /* Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there + is no spurious underflow here even without fma. */ + return eval_as_double (scale + scale * tmp); +} + +/* Returns 0 if not int, 1 if odd int, 2 if even int. The argument is + the bit representation of a non-zero finite floating-point value. */ +static inline int +checkint (uint64_t iy) +{ + int e = iy >> 52 & 0x7ff; + if (e < 0x3ff) + return 0; + if (e > 0x3ff + 52) + return 2; + if (iy & ((1ULL << (0x3ff + 52 - e)) - 1)) + return 0; + if (iy & (1ULL << (0x3ff + 52 - e))) + return 1; + return 2; +} + +/* Returns 1 if input is the bit representation of 0, infinity or nan. */ +static inline int +zeroinfnan (uint64_t i) +{ + return 2 * i - 1 >= 2 * asuint64 (INFINITY) - 1; +} + +double +pow (double x, double y) +{ + uint32_t sign_bias = 0; + uint64_t ix, iy; + uint32_t topx, topy; + + ix = asuint64 (x); + iy = asuint64 (y); + topx = top12 (x); + topy = top12 (y); + if (unlikely (topx - 0x001 >= 0x7ff - 0x001 + || (topy & 0x7ff) - 0x3be >= 0x43e - 0x3be)) + { + /* Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0 + and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1. */ + /* Special cases: (x < 0x1p-126 or inf or nan) or + (|y| < 0x1p-65 or |y| >= 0x1p63 or nan). */ + if (unlikely (zeroinfnan (iy))) + { + if (2 * iy == 0) + return issignaling_inline (x) ? x + y : 1.0; + if (ix == asuint64 (1.0)) + return issignaling_inline (y) ? x + y : 1.0; + if (2 * ix > 2 * asuint64 (INFINITY) + || 2 * iy > 2 * asuint64 (INFINITY)) + return x + y; + if (2 * ix == 2 * asuint64 (1.0)) + return 1.0; + if ((2 * ix < 2 * asuint64 (1.0)) == !(iy >> 63)) + return 0.0; /* |x|<1 && y==inf or |x|>1 && y==-inf. */ + return y * y; + } + if (unlikely (zeroinfnan (ix))) + { + double_t x2 = x * x; + if (ix >> 63 && checkint (iy) == 1) + { + x2 = -x2; + sign_bias = 1; + } + if (WANT_ERRNO && 2 * ix == 0 && iy >> 63) + return __math_divzero (sign_bias); + /* Without the barrier some versions of clang hoist the 1/x2 and + thus division by zero exception can be signaled spuriously. */ + return iy >> 63 ? opt_barrier_double (1 / x2) : x2; + } + /* Here x and y are non-zero finite. */ + if (ix >> 63) + { + /* Finite x < 0. */ + int yint = checkint (iy); + if (yint == 0) + return __math_invalid (x); + if (yint == 1) + sign_bias = SIGN_BIAS; + ix &= 0x7fffffffffffffff; + topx &= 0x7ff; + } + if ((topy & 0x7ff) - 0x3be >= 0x43e - 0x3be) + { + /* Note: sign_bias == 0 here because y is not odd. */ + if (ix == asuint64 (1.0)) + return 1.0; + if ((topy & 0x7ff) < 0x3be) + { + /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ + if (WANT_ROUNDING) + return ix > asuint64 (1.0) ? 1.0 + y : 1.0 - y; + else + return 1.0; + } + return (ix > asuint64 (1.0)) == (topy < 0x800) ? __math_oflow (0) + : __math_uflow (0); + } + if (topx == 0) + { + /* Normalize subnormal x so exponent becomes negative. */ + /* Without the barrier some versions of clang evalutate the mul + unconditionally causing spurious overflow exceptions. */ + ix = asuint64 (opt_barrier_double (x) * 0x1p52); + ix &= 0x7fffffffffffffff; + ix -= 52ULL << 52; + } + } + + double_t lo; + double_t hi = log_inline (ix, &lo); + double_t ehi, elo; +#if HAVE_FAST_FMA + ehi = y * hi; + elo = y * lo + fma (y, hi, -ehi); +#else + double_t yhi = asdouble (iy & -1ULL << 27); + double_t ylo = y - yhi; + double_t lhi = asdouble (asuint64 (hi) & -1ULL << 27); + double_t llo = hi - lhi + lo; + ehi = yhi * lhi; + elo = ylo * lhi + y * llo; /* |elo| < |ehi| * 2^-25. */ +#endif + return exp_inline (ehi, elo, sign_bias); +} +#if USE_GLIBC_ABI +strong_alias (pow, __pow_finite) +hidden_alias (pow, __ieee754_pow) +# if LDBL_MANT_DIG == 53 +long double powl (long double x, long double y) { return pow (x, y); } +# endif +#endif diff --git a/libc/AOR_v20.02/math/pow_log_data.c b/libc/AOR_v20.02/math/pow_log_data.c new file mode 100644 index 00000000000000..445d605228f8e0 --- /dev/null +++ b/libc/AOR_v20.02/math/pow_log_data.c @@ -0,0 +1,185 @@ +/* + * Data for the log part of pow. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +#define N (1 << POW_LOG_TABLE_BITS) + +const struct pow_log_data __pow_log_data = { +.ln2hi = 0x1.62e42fefa3800p-1, +.ln2lo = 0x1.ef35793c76730p-45, +.poly = { +#if N == 128 && POW_LOG_POLY_ORDER == 8 +// relative error: 0x1.11922ap-70 +// in -0x1.6bp-8 0x1.6bp-8 +// Coefficients are scaled to match the scaling during evaluation. +-0x1p-1, +0x1.555555555556p-2 * -2, +-0x1.0000000000006p-2 * -2, +0x1.999999959554ep-3 * 4, +-0x1.555555529a47ap-3 * 4, +0x1.2495b9b4845e9p-3 * -8, +-0x1.0002b8b263fc3p-3 * -8, +#endif +}, +/* Algorithm: + + x = 2^k z + log(x) = k ln2 + log(c) + log(z/c) + log(z/c) = poly(z/c - 1) + +where z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals +and z falls into the ith one, then table entries are computed as + + tab[i].invc = 1/c + tab[i].logc = round(0x1p43*log(c))/0x1p43 + tab[i].logctail = (double)(log(c) - logc) + +where c is chosen near the center of the subinterval such that 1/c has only a +few precision bits so z/c - 1 is exactly representible as double: + + 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2 + +Note: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97, +the last few bits of logc are rounded away so k*ln2hi + logc has no rounding +error and the interval for z is selected such that near x == 1, where log(x) +is tiny, large cancellation error is avoided in logc + poly(z/c - 1). */ +.tab = { +#if N == 128 +#define A(a, b, c) {a, 0, b, c}, +A(0x1.6a00000000000p+0, -0x1.62c82f2b9c800p-2, 0x1.ab42428375680p-48) +A(0x1.6800000000000p+0, -0x1.5d1bdbf580800p-2, -0x1.ca508d8e0f720p-46) +A(0x1.6600000000000p+0, -0x1.5767717455800p-2, -0x1.362a4d5b6506dp-45) +A(0x1.6400000000000p+0, -0x1.51aad872df800p-2, -0x1.684e49eb067d5p-49) +A(0x1.6200000000000p+0, -0x1.4be5f95777800p-2, -0x1.41b6993293ee0p-47) +A(0x1.6000000000000p+0, -0x1.4618bc21c6000p-2, 0x1.3d82f484c84ccp-46) +A(0x1.5e00000000000p+0, -0x1.404308686a800p-2, 0x1.c42f3ed820b3ap-50) +A(0x1.5c00000000000p+0, -0x1.3a64c55694800p-2, 0x1.0b1c686519460p-45) +A(0x1.5a00000000000p+0, -0x1.347dd9a988000p-2, 0x1.5594dd4c58092p-45) +A(0x1.5800000000000p+0, -0x1.2e8e2bae12000p-2, 0x1.67b1e99b72bd8p-45) +A(0x1.5600000000000p+0, -0x1.2895a13de8800p-2, 0x1.5ca14b6cfb03fp-46) +A(0x1.5600000000000p+0, -0x1.2895a13de8800p-2, 0x1.5ca14b6cfb03fp-46) +A(0x1.5400000000000p+0, -0x1.22941fbcf7800p-2, -0x1.65a242853da76p-46) +A(0x1.5200000000000p+0, -0x1.1c898c1699800p-2, -0x1.fafbc68e75404p-46) +A(0x1.5000000000000p+0, -0x1.1675cababa800p-2, 0x1.f1fc63382a8f0p-46) +A(0x1.4e00000000000p+0, -0x1.1058bf9ae4800p-2, -0x1.6a8c4fd055a66p-45) +A(0x1.4c00000000000p+0, -0x1.0a324e2739000p-2, -0x1.c6bee7ef4030ep-47) +A(0x1.4a00000000000p+0, -0x1.0402594b4d000p-2, -0x1.036b89ef42d7fp-48) +A(0x1.4a00000000000p+0, -0x1.0402594b4d000p-2, -0x1.036b89ef42d7fp-48) +A(0x1.4800000000000p+0, -0x1.fb9186d5e4000p-3, 0x1.d572aab993c87p-47) +A(0x1.4600000000000p+0, -0x1.ef0adcbdc6000p-3, 0x1.b26b79c86af24p-45) +A(0x1.4400000000000p+0, -0x1.e27076e2af000p-3, -0x1.72f4f543fff10p-46) +A(0x1.4200000000000p+0, -0x1.d5c216b4fc000p-3, 0x1.1ba91bbca681bp-45) +A(0x1.4000000000000p+0, -0x1.c8ff7c79aa000p-3, 0x1.7794f689f8434p-45) +A(0x1.4000000000000p+0, -0x1.c8ff7c79aa000p-3, 0x1.7794f689f8434p-45) +A(0x1.3e00000000000p+0, -0x1.bc286742d9000p-3, 0x1.94eb0318bb78fp-46) +A(0x1.3c00000000000p+0, -0x1.af3c94e80c000p-3, 0x1.a4e633fcd9066p-52) +A(0x1.3a00000000000p+0, -0x1.a23bc1fe2b000p-3, -0x1.58c64dc46c1eap-45) +A(0x1.3a00000000000p+0, -0x1.a23bc1fe2b000p-3, -0x1.58c64dc46c1eap-45) +A(0x1.3800000000000p+0, -0x1.9525a9cf45000p-3, -0x1.ad1d904c1d4e3p-45) +A(0x1.3600000000000p+0, -0x1.87fa06520d000p-3, 0x1.bbdbf7fdbfa09p-45) +A(0x1.3400000000000p+0, -0x1.7ab890210e000p-3, 0x1.bdb9072534a58p-45) +A(0x1.3400000000000p+0, -0x1.7ab890210e000p-3, 0x1.bdb9072534a58p-45) +A(0x1.3200000000000p+0, -0x1.6d60fe719d000p-3, -0x1.0e46aa3b2e266p-46) +A(0x1.3000000000000p+0, -0x1.5ff3070a79000p-3, -0x1.e9e439f105039p-46) +A(0x1.3000000000000p+0, -0x1.5ff3070a79000p-3, -0x1.e9e439f105039p-46) +A(0x1.2e00000000000p+0, -0x1.526e5e3a1b000p-3, -0x1.0de8b90075b8fp-45) +A(0x1.2c00000000000p+0, -0x1.44d2b6ccb8000p-3, 0x1.70cc16135783cp-46) +A(0x1.2c00000000000p+0, -0x1.44d2b6ccb8000p-3, 0x1.70cc16135783cp-46) +A(0x1.2a00000000000p+0, -0x1.371fc201e9000p-3, 0x1.178864d27543ap-48) +A(0x1.2800000000000p+0, -0x1.29552f81ff000p-3, -0x1.48d301771c408p-45) +A(0x1.2600000000000p+0, -0x1.1b72ad52f6000p-3, -0x1.e80a41811a396p-45) +A(0x1.2600000000000p+0, -0x1.1b72ad52f6000p-3, -0x1.e80a41811a396p-45) +A(0x1.2400000000000p+0, -0x1.0d77e7cd09000p-3, 0x1.a699688e85bf4p-47) +A(0x1.2400000000000p+0, -0x1.0d77e7cd09000p-3, 0x1.a699688e85bf4p-47) +A(0x1.2200000000000p+0, -0x1.fec9131dbe000p-4, -0x1.575545ca333f2p-45) +A(0x1.2000000000000p+0, -0x1.e27076e2b0000p-4, 0x1.a342c2af0003cp-45) +A(0x1.2000000000000p+0, -0x1.e27076e2b0000p-4, 0x1.a342c2af0003cp-45) +A(0x1.1e00000000000p+0, -0x1.c5e548f5bc000p-4, -0x1.d0c57585fbe06p-46) +A(0x1.1c00000000000p+0, -0x1.a926d3a4ae000p-4, 0x1.53935e85baac8p-45) +A(0x1.1c00000000000p+0, -0x1.a926d3a4ae000p-4, 0x1.53935e85baac8p-45) +A(0x1.1a00000000000p+0, -0x1.8c345d631a000p-4, 0x1.37c294d2f5668p-46) +A(0x1.1a00000000000p+0, -0x1.8c345d631a000p-4, 0x1.37c294d2f5668p-46) +A(0x1.1800000000000p+0, -0x1.6f0d28ae56000p-4, -0x1.69737c93373dap-45) +A(0x1.1600000000000p+0, -0x1.51b073f062000p-4, 0x1.f025b61c65e57p-46) +A(0x1.1600000000000p+0, -0x1.51b073f062000p-4, 0x1.f025b61c65e57p-46) +A(0x1.1400000000000p+0, -0x1.341d7961be000p-4, 0x1.c5edaccf913dfp-45) +A(0x1.1400000000000p+0, -0x1.341d7961be000p-4, 0x1.c5edaccf913dfp-45) +A(0x1.1200000000000p+0, -0x1.16536eea38000p-4, 0x1.47c5e768fa309p-46) +A(0x1.1000000000000p+0, -0x1.f0a30c0118000p-5, 0x1.d599e83368e91p-45) +A(0x1.1000000000000p+0, -0x1.f0a30c0118000p-5, 0x1.d599e83368e91p-45) +A(0x1.0e00000000000p+0, -0x1.b42dd71198000p-5, 0x1.c827ae5d6704cp-46) +A(0x1.0e00000000000p+0, -0x1.b42dd71198000p-5, 0x1.c827ae5d6704cp-46) +A(0x1.0c00000000000p+0, -0x1.77458f632c000p-5, -0x1.cfc4634f2a1eep-45) +A(0x1.0c00000000000p+0, -0x1.77458f632c000p-5, -0x1.cfc4634f2a1eep-45) +A(0x1.0a00000000000p+0, -0x1.39e87b9fec000p-5, 0x1.502b7f526feaap-48) +A(0x1.0a00000000000p+0, -0x1.39e87b9fec000p-5, 0x1.502b7f526feaap-48) +A(0x1.0800000000000p+0, -0x1.f829b0e780000p-6, -0x1.980267c7e09e4p-45) +A(0x1.0800000000000p+0, -0x1.f829b0e780000p-6, -0x1.980267c7e09e4p-45) +A(0x1.0600000000000p+0, -0x1.7b91b07d58000p-6, -0x1.88d5493faa639p-45) +A(0x1.0400000000000p+0, -0x1.fc0a8b0fc0000p-7, -0x1.f1e7cf6d3a69cp-50) +A(0x1.0400000000000p+0, -0x1.fc0a8b0fc0000p-7, -0x1.f1e7cf6d3a69cp-50) +A(0x1.0200000000000p+0, -0x1.fe02a6b100000p-8, -0x1.9e23f0dda40e4p-46) +A(0x1.0200000000000p+0, -0x1.fe02a6b100000p-8, -0x1.9e23f0dda40e4p-46) +A(0x1.0000000000000p+0, 0x0.0000000000000p+0, 0x0.0000000000000p+0) +A(0x1.0000000000000p+0, 0x0.0000000000000p+0, 0x0.0000000000000p+0) +A(0x1.fc00000000000p-1, 0x1.0101575890000p-7, -0x1.0c76b999d2be8p-46) +A(0x1.f800000000000p-1, 0x1.0205658938000p-6, -0x1.3dc5b06e2f7d2p-45) +A(0x1.f400000000000p-1, 0x1.8492528c90000p-6, -0x1.aa0ba325a0c34p-45) +A(0x1.f000000000000p-1, 0x1.0415d89e74000p-5, 0x1.111c05cf1d753p-47) +A(0x1.ec00000000000p-1, 0x1.466aed42e0000p-5, -0x1.c167375bdfd28p-45) +A(0x1.e800000000000p-1, 0x1.894aa149fc000p-5, -0x1.97995d05a267dp-46) +A(0x1.e400000000000p-1, 0x1.ccb73cdddc000p-5, -0x1.a68f247d82807p-46) +A(0x1.e200000000000p-1, 0x1.eea31c006c000p-5, -0x1.e113e4fc93b7bp-47) +A(0x1.de00000000000p-1, 0x1.1973bd1466000p-4, -0x1.5325d560d9e9bp-45) +A(0x1.da00000000000p-1, 0x1.3bdf5a7d1e000p-4, 0x1.cc85ea5db4ed7p-45) +A(0x1.d600000000000p-1, 0x1.5e95a4d97a000p-4, -0x1.c69063c5d1d1ep-45) +A(0x1.d400000000000p-1, 0x1.700d30aeac000p-4, 0x1.c1e8da99ded32p-49) +A(0x1.d000000000000p-1, 0x1.9335e5d594000p-4, 0x1.3115c3abd47dap-45) +A(0x1.cc00000000000p-1, 0x1.b6ac88dad6000p-4, -0x1.390802bf768e5p-46) +A(0x1.ca00000000000p-1, 0x1.c885801bc4000p-4, 0x1.646d1c65aacd3p-45) +A(0x1.c600000000000p-1, 0x1.ec739830a2000p-4, -0x1.dc068afe645e0p-45) +A(0x1.c400000000000p-1, 0x1.fe89139dbe000p-4, -0x1.534d64fa10afdp-45) +A(0x1.c000000000000p-1, 0x1.1178e8227e000p-3, 0x1.1ef78ce2d07f2p-45) +A(0x1.be00000000000p-1, 0x1.1aa2b7e23f000p-3, 0x1.ca78e44389934p-45) +A(0x1.ba00000000000p-1, 0x1.2d1610c868000p-3, 0x1.39d6ccb81b4a1p-47) +A(0x1.b800000000000p-1, 0x1.365fcb0159000p-3, 0x1.62fa8234b7289p-51) +A(0x1.b400000000000p-1, 0x1.4913d8333b000p-3, 0x1.5837954fdb678p-45) +A(0x1.b200000000000p-1, 0x1.527e5e4a1b000p-3, 0x1.633e8e5697dc7p-45) +A(0x1.ae00000000000p-1, 0x1.6574ebe8c1000p-3, 0x1.9cf8b2c3c2e78p-46) +A(0x1.ac00000000000p-1, 0x1.6f0128b757000p-3, -0x1.5118de59c21e1p-45) +A(0x1.aa00000000000p-1, 0x1.7898d85445000p-3, -0x1.c661070914305p-46) +A(0x1.a600000000000p-1, 0x1.8beafeb390000p-3, -0x1.73d54aae92cd1p-47) +A(0x1.a400000000000p-1, 0x1.95a5adcf70000p-3, 0x1.7f22858a0ff6fp-47) +A(0x1.a000000000000p-1, 0x1.a93ed3c8ae000p-3, -0x1.8724350562169p-45) +A(0x1.9e00000000000p-1, 0x1.b31d8575bd000p-3, -0x1.c358d4eace1aap-47) +A(0x1.9c00000000000p-1, 0x1.bd087383be000p-3, -0x1.d4bc4595412b6p-45) +A(0x1.9a00000000000p-1, 0x1.c6ffbc6f01000p-3, -0x1.1ec72c5962bd2p-48) +A(0x1.9600000000000p-1, 0x1.db13db0d49000p-3, -0x1.aff2af715b035p-45) +A(0x1.9400000000000p-1, 0x1.e530effe71000p-3, 0x1.212276041f430p-51) +A(0x1.9200000000000p-1, 0x1.ef5ade4dd0000p-3, -0x1.a211565bb8e11p-51) +A(0x1.9000000000000p-1, 0x1.f991c6cb3b000p-3, 0x1.bcbecca0cdf30p-46) +A(0x1.8c00000000000p-1, 0x1.07138604d5800p-2, 0x1.89cdb16ed4e91p-48) +A(0x1.8a00000000000p-1, 0x1.0c42d67616000p-2, 0x1.7188b163ceae9p-45) +A(0x1.8800000000000p-1, 0x1.1178e8227e800p-2, -0x1.c210e63a5f01cp-45) +A(0x1.8600000000000p-1, 0x1.16b5ccbacf800p-2, 0x1.b9acdf7a51681p-45) +A(0x1.8400000000000p-1, 0x1.1bf99635a6800p-2, 0x1.ca6ed5147bdb7p-45) +A(0x1.8200000000000p-1, 0x1.214456d0eb800p-2, 0x1.a87deba46baeap-47) +A(0x1.7e00000000000p-1, 0x1.2bef07cdc9000p-2, 0x1.a9cfa4a5004f4p-45) +A(0x1.7c00000000000p-1, 0x1.314f1e1d36000p-2, -0x1.8e27ad3213cb8p-45) +A(0x1.7a00000000000p-1, 0x1.36b6776be1000p-2, 0x1.16ecdb0f177c8p-46) +A(0x1.7800000000000p-1, 0x1.3c25277333000p-2, 0x1.83b54b606bd5cp-46) +A(0x1.7600000000000p-1, 0x1.419b423d5e800p-2, 0x1.8e436ec90e09dp-47) +A(0x1.7400000000000p-1, 0x1.4718dc271c800p-2, -0x1.f27ce0967d675p-45) +A(0x1.7200000000000p-1, 0x1.4c9e09e173000p-2, -0x1.e20891b0ad8a4p-45) +A(0x1.7000000000000p-1, 0x1.522ae0738a000p-2, 0x1.ebe708164c759p-45) +A(0x1.6e00000000000p-1, 0x1.57bf753c8d000p-2, 0x1.fadedee5d40efp-46) +A(0x1.6c00000000000p-1, 0x1.5d5bddf596000p-2, -0x1.a0b2a08a465dcp-47) +#endif +}, +}; diff --git a/libc/AOR_v20.02/math/powf.c b/libc/AOR_v20.02/math/powf.c new file mode 100644 index 00000000000000..3cb70c0b628828 --- /dev/null +++ b/libc/AOR_v20.02/math/powf.c @@ -0,0 +1,222 @@ +/* + * Single-precision pow function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" + +/* +POWF_LOG2_POLY_ORDER = 5 +EXP2F_TABLE_BITS = 5 + +ULP error: 0.82 (~ 0.5 + relerr*2^24) +relerr: 1.27 * 2^-26 (Relative error ~= 128*Ln2*relerr_log2 + relerr_exp2) +relerr_log2: 1.83 * 2^-33 (Relative error of logx.) +relerr_exp2: 1.69 * 2^-34 (Relative error of exp2(ylogx).) +*/ + +#define N (1 << POWF_LOG2_TABLE_BITS) +#define T __powf_log2_data.tab +#define A __powf_log2_data.poly +#define OFF 0x3f330000 + +/* Subnormal input is normalized so ix has negative biased exponent. + Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set. */ +static inline double_t +log2_inline (uint32_t ix) +{ + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t z, r, r2, r4, p, q, y, y0, invc, logc; + uint32_t iz, top, tmp; + int k, i; + + /* x = 2^k z; where z is in range [OFF,2*OFF] and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (23 - POWF_LOG2_TABLE_BITS)) % N; + top = tmp & 0xff800000; + iz = ix - top; + k = (int32_t) top >> (23 - POWF_SCALE_BITS); /* arithmetic shift */ + invc = T[i].invc; + logc = T[i].logc; + z = (double_t) asfloat (iz); + + /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ + r = z * invc - 1; + y0 = logc + (double_t) k; + + /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ + r2 = r * r; + y = A[0] * r + A[1]; + p = A[2] * r + A[3]; + r4 = r2 * r2; + q = A[4] * r + y0; + q = p * r2 + q; + y = y * r4 + q; + return y; +} + +#undef N +#undef T +#define N (1 << EXP2F_TABLE_BITS) +#define T __exp2f_data.tab +#define SIGN_BIAS (1 << (EXP2F_TABLE_BITS + 11)) + +/* The output of log2 and thus the input of exp2 is either scaled by N + (in case of fast toint intrinsics) or not. The unscaled xd must be + in [-1021,1023], sign_bias sets the sign of the result. */ +static inline float +exp2_inline (double_t xd, uint32_t sign_bias) +{ + uint64_t ki, ski, t; + /* double_t for better performance on targets with FLT_EVAL_METHOD==2. */ + double_t kd, z, r, r2, y, s; + +#if TOINT_INTRINSICS +# define C __exp2f_data.poly_scaled + /* N*x = k + r with r in [-1/2, 1/2] */ + kd = roundtoint (xd); /* k */ + ki = converttoint (xd); +#else +# define C __exp2f_data.poly +# define SHIFT __exp2f_data.shift_scaled + /* x = k/N + r with r in [-1/(2N), 1/(2N)] */ + kd = eval_as_double (xd + SHIFT); + ki = asuint64 (kd); + kd -= SHIFT; /* k/N */ +#endif + r = xd - kd; + + /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ + t = T[ki % N]; + ski = ki + sign_bias; + t += ski << (52 - EXP2F_TABLE_BITS); + s = asdouble (t); + z = C[0] * r + C[1]; + r2 = r * r; + y = C[2] * r + 1; + y = z * r2 + y; + y = y * s; + return eval_as_float (y); +} + +/* Returns 0 if not int, 1 if odd int, 2 if even int. The argument is + the bit representation of a non-zero finite floating-point value. */ +static inline int +checkint (uint32_t iy) +{ + int e = iy >> 23 & 0xff; + if (e < 0x7f) + return 0; + if (e > 0x7f + 23) + return 2; + if (iy & ((1 << (0x7f + 23 - e)) - 1)) + return 0; + if (iy & (1 << (0x7f + 23 - e))) + return 1; + return 2; +} + +static inline int +zeroinfnan (uint32_t ix) +{ + return 2 * ix - 1 >= 2u * 0x7f800000 - 1; +} + +float +powf (float x, float y) +{ + uint32_t sign_bias = 0; + uint32_t ix, iy; + + ix = asuint (x); + iy = asuint (y); + if (unlikely (ix - 0x00800000 >= 0x7f800000 - 0x00800000 || zeroinfnan (iy))) + { + /* Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan). */ + if (unlikely (zeroinfnan (iy))) + { + if (2 * iy == 0) + return issignalingf_inline (x) ? x + y : 1.0f; + if (ix == 0x3f800000) + return issignalingf_inline (y) ? x + y : 1.0f; + if (2 * ix > 2u * 0x7f800000 || 2 * iy > 2u * 0x7f800000) + return x + y; + if (2 * ix == 2 * 0x3f800000) + return 1.0f; + if ((2 * ix < 2 * 0x3f800000) == !(iy & 0x80000000)) + return 0.0f; /* |x|<1 && y==inf or |x|>1 && y==-inf. */ + return y * y; + } + if (unlikely (zeroinfnan (ix))) + { + float_t x2 = x * x; + if (ix & 0x80000000 && checkint (iy) == 1) + { + x2 = -x2; + sign_bias = 1; + } +#if WANT_ERRNO + if (2 * ix == 0 && iy & 0x80000000) + return __math_divzerof (sign_bias); +#endif + /* Without the barrier some versions of clang hoist the 1/x2 and + thus division by zero exception can be signaled spuriously. */ + return iy & 0x80000000 ? opt_barrier_float (1 / x2) : x2; + } + /* x and y are non-zero finite. */ + if (ix & 0x80000000) + { + /* Finite x < 0. */ + int yint = checkint (iy); + if (yint == 0) + return __math_invalidf (x); + if (yint == 1) + sign_bias = SIGN_BIAS; + ix &= 0x7fffffff; + } + if (ix < 0x00800000) + { + /* Normalize subnormal x so exponent becomes negative. */ + ix = asuint (x * 0x1p23f); + ix &= 0x7fffffff; + ix -= 23 << 23; + } + } + double_t logx = log2_inline (ix); + double_t ylogx = y * logx; /* Note: cannot overflow, y is single prec. */ + if (unlikely ((asuint64 (ylogx) >> 47 & 0xffff) + >= asuint64 (126.0 * POWF_SCALE) >> 47)) + { + /* |y*log(x)| >= 126. */ + if (ylogx > 0x1.fffffffd1d571p+6 * POWF_SCALE) + /* |x^y| > 0x1.ffffffp127. */ + return __math_oflowf (sign_bias); + if (WANT_ROUNDING && WANT_ERRNO + && ylogx > 0x1.fffffffa3aae2p+6 * POWF_SCALE) + /* |x^y| > 0x1.fffffep127, check if we round away from 0. */ + if ((!sign_bias + && eval_as_float (1.0f + opt_barrier_float (0x1p-25f)) != 1.0f) + || (sign_bias + && eval_as_float (-1.0f - opt_barrier_float (0x1p-25f)) + != -1.0f)) + return __math_oflowf (sign_bias); + if (ylogx <= -150.0 * POWF_SCALE) + return __math_uflowf (sign_bias); +#if WANT_ERRNO_UFLOW + if (ylogx < -149.0 * POWF_SCALE) + return __math_may_uflowf (sign_bias); +#endif + } + return exp2_inline (ylogx, sign_bias); +} +#if USE_GLIBC_ABI +strong_alias (powf, __powf_finite) +hidden_alias (powf, __ieee754_powf) +#endif diff --git a/libc/AOR_v20.02/math/powf_log2_data.c b/libc/AOR_v20.02/math/powf_log2_data.c new file mode 100644 index 00000000000000..d7c74b3d19e8e7 --- /dev/null +++ b/libc/AOR_v20.02/math/powf_log2_data.c @@ -0,0 +1,35 @@ +/* + * Data definition for powf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "math_config.h" + +const struct powf_log2_data __powf_log2_data = { + .tab = { + { 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2 * POWF_SCALE }, + { 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2 * POWF_SCALE }, + { 0x1.49539f0f010bp+0, -0x1.7418b0a1fb77bp-2 * POWF_SCALE }, + { 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2 * POWF_SCALE }, + { 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2 * POWF_SCALE }, + { 0x1.25e227b0b8eap+0, -0x1.97c1d1b3b7afp-3 * POWF_SCALE }, + { 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3 * POWF_SCALE }, + { 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4 * POWF_SCALE }, + { 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5 * POWF_SCALE }, + { 0x1p+0, 0x0p+0 * POWF_SCALE }, + { 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4 * POWF_SCALE }, + { 0x1.ca4b31f026aap-1, 0x1.476a9543891bap-3 * POWF_SCALE }, + { 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3 * POWF_SCALE }, + { 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2 * POWF_SCALE }, + { 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2 * POWF_SCALE }, + { 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2 * POWF_SCALE }, + }, + .poly = { + 0x1.27616c9496e0bp-2 * POWF_SCALE, -0x1.71969a075c67ap-2 * POWF_SCALE, + 0x1.ec70a6ca7baddp-2 * POWF_SCALE, -0x1.7154748bef6c8p-1 * POWF_SCALE, + 0x1.71547652ab82bp0 * POWF_SCALE, + } +}; diff --git a/libc/AOR_v20.02/math/s_cos.c b/libc/AOR_v20.02/math/s_cos.c new file mode 100644 index 00000000000000..c0176c70e3d307 --- /dev/null +++ b/libc/AOR_v20.02/math/s_cos.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_cos.c" diff --git a/libc/AOR_v20.02/math/s_cosf.c b/libc/AOR_v20.02/math/s_cosf.c new file mode 100644 index 00000000000000..8bea8ec96b601a --- /dev/null +++ b/libc/AOR_v20.02/math/s_cosf.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_cosf.c" diff --git a/libc/AOR_v20.02/math/s_exp.c b/libc/AOR_v20.02/math/s_exp.c new file mode 100644 index 00000000000000..2c9dbe7dde9be0 --- /dev/null +++ b/libc/AOR_v20.02/math/s_exp.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_exp.c" diff --git a/libc/AOR_v20.02/math/s_exp2f.c b/libc/AOR_v20.02/math/s_exp2f.c new file mode 100644 index 00000000000000..de566753922d35 --- /dev/null +++ b/libc/AOR_v20.02/math/s_exp2f.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_exp2f.c" diff --git a/libc/AOR_v20.02/math/s_exp2f_1u.c b/libc/AOR_v20.02/math/s_exp2f_1u.c new file mode 100644 index 00000000000000..53d557fb4aea6e --- /dev/null +++ b/libc/AOR_v20.02/math/s_exp2f_1u.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_exp2f_1u.c" diff --git a/libc/AOR_v20.02/math/s_expf.c b/libc/AOR_v20.02/math/s_expf.c new file mode 100644 index 00000000000000..6340895920fe69 --- /dev/null +++ b/libc/AOR_v20.02/math/s_expf.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_expf.c" diff --git a/libc/AOR_v20.02/math/s_expf_1u.c b/libc/AOR_v20.02/math/s_expf_1u.c new file mode 100644 index 00000000000000..127ae3bdd47b45 --- /dev/null +++ b/libc/AOR_v20.02/math/s_expf_1u.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_expf_1u.c" diff --git a/libc/AOR_v20.02/math/s_log.c b/libc/AOR_v20.02/math/s_log.c new file mode 100644 index 00000000000000..22fd46c4881985 --- /dev/null +++ b/libc/AOR_v20.02/math/s_log.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_log.c" diff --git a/libc/AOR_v20.02/math/s_logf.c b/libc/AOR_v20.02/math/s_logf.c new file mode 100644 index 00000000000000..3066f381482f46 --- /dev/null +++ b/libc/AOR_v20.02/math/s_logf.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_logf.c" diff --git a/libc/AOR_v20.02/math/s_pow.c b/libc/AOR_v20.02/math/s_pow.c new file mode 100644 index 00000000000000..bf0910bfef029c --- /dev/null +++ b/libc/AOR_v20.02/math/s_pow.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_pow.c" diff --git a/libc/AOR_v20.02/math/s_powf.c b/libc/AOR_v20.02/math/s_powf.c new file mode 100644 index 00000000000000..48319a22db52f5 --- /dev/null +++ b/libc/AOR_v20.02/math/s_powf.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_powf.c" diff --git a/libc/AOR_v20.02/math/s_sin.c b/libc/AOR_v20.02/math/s_sin.c new file mode 100644 index 00000000000000..969714f996e3f7 --- /dev/null +++ b/libc/AOR_v20.02/math/s_sin.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_sin.c" diff --git a/libc/AOR_v20.02/math/s_sinf.c b/libc/AOR_v20.02/math/s_sinf.c new file mode 100644 index 00000000000000..55d45677c642d7 --- /dev/null +++ b/libc/AOR_v20.02/math/s_sinf.c @@ -0,0 +1,7 @@ +/* + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#define SCALAR 1 +#include "v_sinf.c" diff --git a/libc/AOR_v20.02/math/sincosf.c b/libc/AOR_v20.02/math/sincosf.c new file mode 100644 index 00000000000000..819b05b2108065 --- /dev/null +++ b/libc/AOR_v20.02/math/sincosf.c @@ -0,0 +1,80 @@ +/* + * Single-precision sin/cos function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" +#include "sincosf.h" + +/* Fast sincosf implementation. Worst-case ULP is 0.5607, maximum relative + error is 0.5303 * 2^-23. A single-step range reduction is used for + small values. Large inputs have their range reduced using fast integer + arithmetic. */ +void +sincosf (float y, float *sinp, float *cosp) +{ + double x = y; + double s; + int n; + const sincos_t *p = &__sincosf_table[0]; + + if (abstop12 (y) < abstop12 (pio4)) + { + double x2 = x * x; + + if (unlikely (abstop12 (y) < abstop12 (0x1p-12f))) + { + if (unlikely (abstop12 (y) < abstop12 (0x1p-126f))) + /* Force underflow for tiny y. */ + force_eval_float (x2); + *sinp = y; + *cosp = 1.0f; + return; + } + + sincosf_poly (x, x2, p, 0, sinp, cosp); + } + else if (abstop12 (y) < abstop12 (120.0f)) + { + x = reduce_fast (x, p, &n); + + /* Setup the signs for sin and cos. */ + s = p->sign[n & 3]; + + if (n & 2) + p = &__sincosf_table[1]; + + sincosf_poly (x * s, x * x, p, n, sinp, cosp); + } + else if (likely (abstop12 (y) < abstop12 (INFINITY))) + { + uint32_t xi = asuint (y); + int sign = xi >> 31; + + x = reduce_large (xi, &n); + + /* Setup signs for sin and cos - include original sign. */ + s = p->sign[(n + sign) & 3]; + + if ((n + sign) & 2) + p = &__sincosf_table[1]; + + sincosf_poly (x * s, x * x, p, n, sinp, cosp); + } + else + { + /* Return NaN if Inf or NaN for both sin and cos. */ + *sinp = *cosp = y - y; +#if WANT_ERRNO + /* Needed to set errno for +-Inf, the add is a hack to work + around a gcc register allocation issue: just passing y + affects code generation in the fast path. */ + __math_invalidf (y + y); +#endif + } +} diff --git a/libc/AOR_v20.02/math/sincosf.h b/libc/AOR_v20.02/math/sincosf.h new file mode 100644 index 00000000000000..ef40d708acdeeb --- /dev/null +++ b/libc/AOR_v20.02/math/sincosf.h @@ -0,0 +1,154 @@ +/* + * Header for sinf, cosf and sincosf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" + +/* 2PI * 2^-64. */ +static const double pi63 = 0x1.921FB54442D18p-62; +/* PI / 4. */ +static const double pio4 = 0x1.921FB54442D18p-1; + +/* The constants and polynomials for sine and cosine. */ +typedef struct +{ + double sign[4]; /* Sign of sine in quadrants 0..3. */ + double hpi_inv; /* 2 / PI ( * 2^24 if !TOINT_INTRINSICS). */ + double hpi; /* PI / 2. */ + double c0, c1, c2, c3, c4; /* Cosine polynomial. */ + double s1, s2, s3; /* Sine polynomial. */ +} sincos_t; + +/* Polynomial data (the cosine polynomial is negated in the 2nd entry). */ +extern const sincos_t __sincosf_table[2] HIDDEN; + +/* Table with 4/PI to 192 bit precision. */ +extern const uint32_t __inv_pio4[] HIDDEN; + +/* Top 12 bits of the float representation with the sign bit cleared. */ +static inline uint32_t +abstop12 (float x) +{ + return (asuint (x) >> 20) & 0x7ff; +} + +/* Compute the sine and cosine of inputs X and X2 (X squared), using the + polynomial P and store the results in SINP and COSP. N is the quadrant, + if odd the cosine and sine polynomials are swapped. */ +static inline void +sincosf_poly (double x, double x2, const sincos_t *p, int n, float *sinp, + float *cosp) +{ + double x3, x4, x5, x6, s, c, c1, c2, s1; + + x4 = x2 * x2; + x3 = x2 * x; + c2 = p->c3 + x2 * p->c4; + s1 = p->s2 + x2 * p->s3; + + /* Swap sin/cos result based on quadrant. */ + float *tmp = (n & 1 ? cosp : sinp); + cosp = (n & 1 ? sinp : cosp); + sinp = tmp; + + c1 = p->c0 + x2 * p->c1; + x5 = x3 * x2; + x6 = x4 * x2; + + s = x + x3 * p->s1; + c = c1 + x4 * p->c2; + + *sinp = s + x5 * s1; + *cosp = c + x6 * c2; +} + +/* Return the sine of inputs X and X2 (X squared) using the polynomial P. + N is the quadrant, and if odd the cosine polynomial is used. */ +static inline float +sinf_poly (double x, double x2, const sincos_t *p, int n) +{ + double x3, x4, x6, x7, s, c, c1, c2, s1; + + if ((n & 1) == 0) + { + x3 = x * x2; + s1 = p->s2 + x2 * p->s3; + + x7 = x3 * x2; + s = x + x3 * p->s1; + + return s + x7 * s1; + } + else + { + x4 = x2 * x2; + c2 = p->c3 + x2 * p->c4; + c1 = p->c0 + x2 * p->c1; + + x6 = x4 * x2; + c = c1 + x4 * p->c2; + + return c + x6 * c2; + } +} + +/* Fast range reduction using single multiply-subtract. Return the modulo of + X as a value between -PI/4 and PI/4 and store the quadrant in NP. + The values for PI/2 and 2/PI are accessed via P. Since PI/2 as a double + is accurate to 55 bits and the worst-case cancellation happens at 6 * PI/4, + the result is accurate for |X| <= 120.0. */ +static inline double +reduce_fast (double x, const sincos_t *p, int *np) +{ + double r; +#if TOINT_INTRINSICS + /* Use fast round and lround instructions when available. */ + r = x * p->hpi_inv; + *np = converttoint (r); + return x - roundtoint (r) * p->hpi; +#else + /* Use scaled float to int conversion with explicit rounding. + hpi_inv is prescaled by 2^24 so the quadrant ends up in bits 24..31. + This avoids inaccuracies introduced by truncating negative values. */ + r = x * p->hpi_inv; + int n = ((int32_t)r + 0x800000) >> 24; + *np = n; + return x - n * p->hpi; +#endif +} + +/* Reduce the range of XI to a multiple of PI/2 using fast integer arithmetic. + XI is a reinterpreted float and must be >= 2.0f (the sign bit is ignored). + Return the modulo between -PI/4 and PI/4 and store the quadrant in NP. + Reduction uses a table of 4/PI with 192 bits of precision. A 32x96->128 bit + multiply computes the exact 2.62-bit fixed-point modulo. Since the result + can have at most 29 leading zeros after the binary point, the double + precision result is accurate to 33 bits. */ +static inline double +reduce_large (uint32_t xi, int *np) +{ + const uint32_t *arr = &__inv_pio4[(xi >> 26) & 15]; + int shift = (xi >> 23) & 7; + uint64_t n, res0, res1, res2; + + xi = (xi & 0xffffff) | 0x800000; + xi <<= shift; + + res0 = xi * arr[0]; + res1 = (uint64_t)xi * arr[4]; + res2 = (uint64_t)xi * arr[8]; + res0 = (res2 >> 32) | (res0 << 32); + res0 += res1; + + n = (res0 + (1ULL << 61)) >> 62; + res0 -= n << 62; + double x = (int64_t)res0; + *np = n; + return x * pi63; +} diff --git a/libc/AOR_v20.02/math/sincosf_data.c b/libc/AOR_v20.02/math/sincosf_data.c new file mode 100644 index 00000000000000..a3d5efda6f4cea --- /dev/null +++ b/libc/AOR_v20.02/math/sincosf_data.c @@ -0,0 +1,64 @@ +/* + * Data definition for sinf, cosf and sincosf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include "math_config.h" +#include "sincosf.h" + +/* The constants and polynomials for sine and cosine. The 2nd entry + computes -cos (x) rather than cos (x) to get negation for free. */ +const sincos_t __sincosf_table[2] = +{ + { + { 1.0, -1.0, -1.0, 1.0 }, +#if TOINT_INTRINSICS + 0x1.45F306DC9C883p-1, +#else + 0x1.45F306DC9C883p+23, +#endif + 0x1.921FB54442D18p0, + 0x1p0, + -0x1.ffffffd0c621cp-2, + 0x1.55553e1068f19p-5, + -0x1.6c087e89a359dp-10, + 0x1.99343027bf8c3p-16, + -0x1.555545995a603p-3, + 0x1.1107605230bc4p-7, + -0x1.994eb3774cf24p-13 + }, + { + { 1.0, -1.0, -1.0, 1.0 }, +#if TOINT_INTRINSICS + 0x1.45F306DC9C883p-1, +#else + 0x1.45F306DC9C883p+23, +#endif + 0x1.921FB54442D18p0, + -0x1p0, + 0x1.ffffffd0c621cp-2, + -0x1.55553e1068f19p-5, + 0x1.6c087e89a359dp-10, + -0x1.99343027bf8c3p-16, + -0x1.555545995a603p-3, + 0x1.1107605230bc4p-7, + -0x1.994eb3774cf24p-13 + } +}; + +/* Table with 4/PI to 192 bit precision. To avoid unaligned accesses + only 8 new bits are added per entry, making the table 4 times larger. */ +const uint32_t __inv_pio4[24] = +{ + 0xa2, 0xa2f9, 0xa2f983, 0xa2f9836e, + 0xf9836e4e, 0x836e4e44, 0x6e4e4415, 0x4e441529, + 0x441529fc, 0x1529fc27, 0x29fc2757, 0xfc2757d1, + 0x2757d1f5, 0x57d1f534, 0xd1f534dd, 0xf534ddc0, + 0x34ddc0db, 0xddc0db62, 0xc0db6295, 0xdb629599, + 0x6295993c, 0x95993c43, 0x993c4390, 0x3c439041 +}; diff --git a/libc/AOR_v20.02/math/sinf.c b/libc/AOR_v20.02/math/sinf.c new file mode 100644 index 00000000000000..644b82dd94da2c --- /dev/null +++ b/libc/AOR_v20.02/math/sinf.c @@ -0,0 +1,68 @@ +/* + * Single-precision sin function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include "math_config.h" +#include "sincosf.h" + +/* Fast sinf implementation. Worst-case ULP is 0.5607, maximum relative + error is 0.5303 * 2^-23. A single-step range reduction is used for + small values. Large inputs have their range reduced using fast integer + arithmetic. */ +float +sinf (float y) +{ + double x = y; + double s; + int n; + const sincos_t *p = &__sincosf_table[0]; + + if (abstop12 (y) < abstop12 (pio4)) + { + s = x * x; + + if (unlikely (abstop12 (y) < abstop12 (0x1p-12f))) + { + if (unlikely (abstop12 (y) < abstop12 (0x1p-126f))) + /* Force underflow for tiny y. */ + force_eval_float (s); + return y; + } + + return sinf_poly (x, s, p, 0); + } + else if (likely (abstop12 (y) < abstop12 (120.0f))) + { + x = reduce_fast (x, p, &n); + + /* Setup the signs for sin and cos. */ + s = p->sign[n & 3]; + + if (n & 2) + p = &__sincosf_table[1]; + + return sinf_poly (x * s, x * x, p, n); + } + else if (abstop12 (y) < abstop12 (INFINITY)) + { + uint32_t xi = asuint (y); + int sign = xi >> 31; + + x = reduce_large (xi, &n); + + /* Setup signs for sin and cos - include original sign. */ + s = p->sign[(n + sign) & 3]; + + if ((n + sign) & 2) + p = &__sincosf_table[1]; + + return sinf_poly (x * s, x * x, p, n); + } + else + return __math_invalidf (y); +} diff --git a/libc/AOR_v20.02/math/test/mathbench.c b/libc/AOR_v20.02/math/test/mathbench.c new file mode 100644 index 00000000000000..a57eddb2b48129 --- /dev/null +++ b/libc/AOR_v20.02/math/test/mathbench.c @@ -0,0 +1,772 @@ +/* + * Microbenchmark for math functions. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#undef _GNU_SOURCE +#define _GNU_SOURCE 1 +#include +#include +#include +#include +#include +#include +#include "mathlib.h" + +#ifndef WANT_VMATH +/* Enable the build of vector math code. */ +# define WANT_VMATH 1 +#endif + +/* Number of measurements, best result is reported. */ +#define MEASURE 60 +/* Array size. */ +#define N 8000 +/* Iterations over the array. */ +#define ITER 125 + +static double *Trace; +static size_t trace_size; +static double A[N]; +static float Af[N]; +static long measurecount = MEASURE; +static long itercount = ITER; + +#if __aarch64__ && WANT_VMATH +typedef __f64x2_t v_double; + +#define v_double_len() 2 + +static inline v_double +v_double_load (const double *p) +{ + return (v_double){p[0], p[1]}; +} + +static inline v_double +v_double_dup (double x) +{ + return (v_double){x, x}; +} + +typedef __f32x4_t v_float; + +#define v_float_len() 4 + +static inline v_float +v_float_load (const float *p) +{ + return (v_float){p[0], p[1], p[2], p[3]}; +} + +static inline v_float +v_float_dup (float x) +{ + return (v_float){x, x, x, x}; +} +#else +/* dummy definitions to make things compile. */ +typedef double v_double; +typedef float v_float; +#define v_double_len(x) 1 +#define v_double_load(x) (x)[0] +#define v_double_dup(x) (x) +#define v_float_len(x) 1 +#define v_float_load(x) (x)[0] +#define v_float_dup(x) (x) +#endif + +static double +dummy (double x) +{ + return x; +} + +static float +dummyf (float x) +{ + return x; +} + +#if WANT_VMATH +#if __aarch64__ +static v_double +__v_dummy (v_double x) +{ + return x; +} + +static v_float +__v_dummyf (v_float x) +{ + return x; +} + +#ifdef __vpcs +__vpcs static v_double +__vn_dummy (v_double x) +{ + return x; +} + +__vpcs static v_float +__vn_dummyf (v_float x) +{ + return x; +} + +__vpcs static v_float +xy__vn_powf (v_float x) +{ + return __vn_powf (x, x); +} + +__vpcs static v_float +xy_Z_powf (v_float x) +{ + return _ZGVnN4vv_powf (x, x); +} + +__vpcs static v_double +xy__vn_pow (v_double x) +{ + return __vn_pow (x, x); +} + +__vpcs static v_double +xy_Z_pow (v_double x) +{ + return _ZGVnN2vv_pow (x, x); +} +#endif + +static v_float +xy__v_powf (v_float x) +{ + return __v_powf (x, x); +} + +static v_double +xy__v_pow (v_double x) +{ + return __v_pow (x, x); +} +#endif + +static float +xy__s_powf (float x) +{ + return __s_powf (x, x); +} + +static double +xy__s_pow (double x) +{ + return __s_pow (x, x); +} +#endif + +static double +xypow (double x) +{ + return pow (x, x); +} + +static float +xypowf (float x) +{ + return powf (x, x); +} + +static double +xpow (double x) +{ + return pow (x, 23.4); +} + +static float +xpowf (float x) +{ + return powf (x, 23.4f); +} + +static double +ypow (double x) +{ + return pow (2.34, x); +} + +static float +ypowf (float x) +{ + return powf (2.34f, x); +} + +static float +sincosf_wrap (float x) +{ + float s, c; + sincosf (x, &s, &c); + return s + c; +} + +static const struct fun +{ + const char *name; + int prec; + int vec; + double lo; + double hi; + union + { + double (*d) (double); + float (*f) (float); + v_double (*vd) (v_double); + v_float (*vf) (v_float); +#ifdef __vpcs + __vpcs v_double (*vnd) (v_double); + __vpcs v_float (*vnf) (v_float); +#endif + } fun; +} funtab[] = { +#define D(func, lo, hi) {#func, 'd', 0, lo, hi, {.d = func}}, +#define F(func, lo, hi) {#func, 'f', 0, lo, hi, {.f = func}}, +#define VD(func, lo, hi) {#func, 'd', 'v', lo, hi, {.vd = func}}, +#define VF(func, lo, hi) {#func, 'f', 'v', lo, hi, {.vf = func}}, +#define VND(func, lo, hi) {#func, 'd', 'n', lo, hi, {.vnd = func}}, +#define VNF(func, lo, hi) {#func, 'f', 'n', lo, hi, {.vnf = func}}, +D (dummy, 1.0, 2.0) +D (exp, -9.9, 9.9) +D (exp, 0.5, 1.0) +D (exp2, -9.9, 9.9) +D (log, 0.01, 11.1) +D (log, 0.999, 1.001) +D (log2, 0.01, 11.1) +D (log2, 0.999, 1.001) +{"pow", 'd', 0, 0.01, 11.1, {.d = xypow}}, +D (xpow, 0.01, 11.1) +D (ypow, -9.9, 9.9) + +F (dummyf, 1.0, 2.0) +F (expf, -9.9, 9.9) +F (exp2f, -9.9, 9.9) +F (logf, 0.01, 11.1) +F (log2f, 0.01, 11.1) +{"powf", 'f', 0, 0.01, 11.1, {.f = xypowf}}, +F (xpowf, 0.01, 11.1) +F (ypowf, -9.9, 9.9) +{"sincosf", 'f', 0, 0.1, 0.7, {.f = sincosf_wrap}}, +{"sincosf", 'f', 0, 0.8, 3.1, {.f = sincosf_wrap}}, +{"sincosf", 'f', 0, -3.1, 3.1, {.f = sincosf_wrap}}, +{"sincosf", 'f', 0, 3.3, 33.3, {.f = sincosf_wrap}}, +{"sincosf", 'f', 0, 100, 1000, {.f = sincosf_wrap}}, +{"sincosf", 'f', 0, 1e6, 1e32, {.f = sincosf_wrap}}, +F (sinf, 0.1, 0.7) +F (sinf, 0.8, 3.1) +F (sinf, -3.1, 3.1) +F (sinf, 3.3, 33.3) +F (sinf, 100, 1000) +F (sinf, 1e6, 1e32) +F (cosf, 0.1, 0.7) +F (cosf, 0.8, 3.1) +F (cosf, -3.1, 3.1) +F (cosf, 3.3, 33.3) +F (cosf, 100, 1000) +F (cosf, 1e6, 1e32) +#if WANT_VMATH +D (__s_sin, -3.1, 3.1) +D (__s_cos, -3.1, 3.1) +D (__s_exp, -9.9, 9.9) +D (__s_log, 0.01, 11.1) +{"__s_pow", 'd', 0, 0.01, 11.1, {.d = xy__s_pow}}, +F (__s_expf, -9.9, 9.9) +F (__s_expf_1u, -9.9, 9.9) +F (__s_exp2f, -9.9, 9.9) +F (__s_exp2f_1u, -9.9, 9.9) +F (__s_logf, 0.01, 11.1) +{"__s_powf", 'f', 0, 0.01, 11.1, {.f = xy__s_powf}}, +F (__s_sinf, -3.1, 3.1) +F (__s_cosf, -3.1, 3.1) +#if __aarch64__ +VD (__v_dummy, 1.0, 2.0) +VD (__v_sin, -3.1, 3.1) +VD (__v_cos, -3.1, 3.1) +VD (__v_exp, -9.9, 9.9) +VD (__v_log, 0.01, 11.1) +{"__v_pow", 'd', 'v', 0.01, 11.1, {.vd = xy__v_pow}}, +VF (__v_dummyf, 1.0, 2.0) +VF (__v_expf, -9.9, 9.9) +VF (__v_expf_1u, -9.9, 9.9) +VF (__v_exp2f, -9.9, 9.9) +VF (__v_exp2f_1u, -9.9, 9.9) +VF (__v_logf, 0.01, 11.1) +{"__v_powf", 'f', 'v', 0.01, 11.1, {.vf = xy__v_powf}}, +VF (__v_sinf, -3.1, 3.1) +VF (__v_cosf, -3.1, 3.1) +#ifdef __vpcs +VND (__vn_dummy, 1.0, 2.0) +VND (__vn_exp, -9.9, 9.9) +VND (_ZGVnN2v_exp, -9.9, 9.9) +VND (__vn_log, 0.01, 11.1) +VND (_ZGVnN2v_log, 0.01, 11.1) +{"__vn_pow", 'd', 'n', 0.01, 11.1, {.vnd = xy__vn_pow}}, +{"_ZGVnN2vv_pow", 'd', 'n', 0.01, 11.1, {.vnd = xy_Z_pow}}, +VND (__vn_sin, -3.1, 3.1) +VND (_ZGVnN2v_sin, -3.1, 3.1) +VND (__vn_cos, -3.1, 3.1) +VND (_ZGVnN2v_cos, -3.1, 3.1) +VNF (__vn_dummyf, 1.0, 2.0) +VNF (__vn_expf, -9.9, 9.9) +VNF (_ZGVnN4v_expf, -9.9, 9.9) +VNF (__vn_expf_1u, -9.9, 9.9) +VNF (__vn_exp2f, -9.9, 9.9) +VNF (_ZGVnN4v_exp2f, -9.9, 9.9) +VNF (__vn_exp2f_1u, -9.9, 9.9) +VNF (__vn_logf, 0.01, 11.1) +VNF (_ZGVnN4v_logf, 0.01, 11.1) +{"__vn_powf", 'f', 'n', 0.01, 11.1, {.vnf = xy__vn_powf}}, +{"_ZGVnN4vv_powf", 'f', 'n', 0.01, 11.1, {.vnf = xy_Z_powf}}, +VNF (__vn_sinf, -3.1, 3.1) +VNF (_ZGVnN4v_sinf, -3.1, 3.1) +VNF (__vn_cosf, -3.1, 3.1) +VNF (_ZGVnN4v_cosf, -3.1, 3.1) +#endif +#endif +#endif +{0}, +#undef F +#undef D +#undef VF +#undef VD +#undef VNF +#undef VND +}; + +static void +gen_linear (double lo, double hi) +{ + for (int i = 0; i < N; i++) + A[i] = (lo * (N - i) + hi * i) / N; +} + +static void +genf_linear (double lo, double hi) +{ + for (int i = 0; i < N; i++) + Af[i] = (float)(lo * (N - i) + hi * i) / N; +} + +static inline double +asdouble (uint64_t i) +{ + union + { + uint64_t i; + double f; + } u = {i}; + return u.f; +} + +static uint64_t seed = 0x0123456789abcdef; + +static double +frand (double lo, double hi) +{ + seed = 6364136223846793005ULL * seed + 1; + return lo + (hi - lo) * (asdouble (seed >> 12 | 0x3ffULL << 52) - 1.0); +} + +static void +gen_rand (double lo, double hi) +{ + for (int i = 0; i < N; i++) + A[i] = frand (lo, hi); +} + +static void +genf_rand (double lo, double hi) +{ + for (int i = 0; i < N; i++) + Af[i] = (float)frand (lo, hi); +} + +static void +gen_trace (int index) +{ + for (int i = 0; i < N; i++) + A[i] = Trace[index + i]; +} + +static void +genf_trace (int index) +{ + for (int i = 0; i < N; i++) + Af[i] = (float)Trace[index + i]; +} + +static void +run_thruput (double f (double)) +{ + for (int i = 0; i < N; i++) + f (A[i]); +} + +static void +runf_thruput (float f (float)) +{ + for (int i = 0; i < N; i++) + f (Af[i]); +} + +volatile double zero = 0; + +static void +run_latency (double f (double)) +{ + double z = zero; + double prev = z; + for (int i = 0; i < N; i++) + prev = f (A[i] + prev * z); +} + +static void +runf_latency (float f (float)) +{ + float z = (float)zero; + float prev = z; + for (int i = 0; i < N; i++) + prev = f (Af[i] + prev * z); +} + +static void +run_v_thruput (v_double f (v_double)) +{ + for (int i = 0; i < N; i += v_double_len ()) + f (v_double_load (A+i)); +} + +static void +runf_v_thruput (v_float f (v_float)) +{ + for (int i = 0; i < N; i += v_float_len ()) + f (v_float_load (Af+i)); +} + +static void +run_v_latency (v_double f (v_double)) +{ + v_double z = v_double_dup (zero); + v_double prev = z; + for (int i = 0; i < N; i += v_double_len ()) + prev = f (v_double_load (A+i) + prev * z); +} + +static void +runf_v_latency (v_float f (v_float)) +{ + v_float z = v_float_dup (zero); + v_float prev = z; + for (int i = 0; i < N; i += v_float_len ()) + prev = f (v_float_load (Af+i) + prev * z); +} + +#ifdef __vpcs +static void +run_vn_thruput (__vpcs v_double f (v_double)) +{ + for (int i = 0; i < N; i += v_double_len ()) + f (v_double_load (A+i)); +} + +static void +runf_vn_thruput (__vpcs v_float f (v_float)) +{ + for (int i = 0; i < N; i += v_float_len ()) + f (v_float_load (Af+i)); +} + +static void +run_vn_latency (__vpcs v_double f (v_double)) +{ + v_double z = v_double_dup (zero); + v_double prev = z; + for (int i = 0; i < N; i += v_double_len ()) + prev = f (v_double_load (A+i) + prev * z); +} + +static void +runf_vn_latency (__vpcs v_float f (v_float)) +{ + v_float z = v_float_dup (zero); + v_float prev = z; + for (int i = 0; i < N; i += v_float_len ()) + prev = f (v_float_load (Af+i) + prev * z); +} +#endif + +static uint64_t +tic (void) +{ + struct timespec ts; + if (clock_gettime (CLOCK_REALTIME, &ts)) + abort (); + return ts.tv_sec * 1000000000ULL + ts.tv_nsec; +} + +#define TIMEIT(run, f) do { \ + dt = -1; \ + run (f); /* Warm up. */ \ + for (int j = 0; j < measurecount; j++) \ + { \ + uint64_t t0 = tic (); \ + for (int i = 0; i < itercount; i++) \ + run (f); \ + uint64_t t1 = tic (); \ + if (t1 - t0 < dt) \ + dt = t1 - t0; \ + } \ +} while (0) + +static void +bench1 (const struct fun *f, int type, double lo, double hi) +{ + uint64_t dt = 0; + uint64_t ns100; + const char *s = type == 't' ? "rthruput" : "latency"; + int vlen = 1; + + if (f->vec && f->prec == 'd') + vlen = v_double_len(); + else if (f->vec && f->prec == 'f') + vlen = v_float_len(); + + if (f->prec == 'd' && type == 't' && f->vec == 0) + TIMEIT (run_thruput, f->fun.d); + else if (f->prec == 'd' && type == 'l' && f->vec == 0) + TIMEIT (run_latency, f->fun.d); + else if (f->prec == 'f' && type == 't' && f->vec == 0) + TIMEIT (runf_thruput, f->fun.f); + else if (f->prec == 'f' && type == 'l' && f->vec == 0) + TIMEIT (runf_latency, f->fun.f); + else if (f->prec == 'd' && type == 't' && f->vec == 'v') + TIMEIT (run_v_thruput, f->fun.vd); + else if (f->prec == 'd' && type == 'l' && f->vec == 'v') + TIMEIT (run_v_latency, f->fun.vd); + else if (f->prec == 'f' && type == 't' && f->vec == 'v') + TIMEIT (runf_v_thruput, f->fun.vf); + else if (f->prec == 'f' && type == 'l' && f->vec == 'v') + TIMEIT (runf_v_latency, f->fun.vf); +#ifdef __vpcs + else if (f->prec == 'd' && type == 't' && f->vec == 'n') + TIMEIT (run_vn_thruput, f->fun.vnd); + else if (f->prec == 'd' && type == 'l' && f->vec == 'n') + TIMEIT (run_vn_latency, f->fun.vnd); + else if (f->prec == 'f' && type == 't' && f->vec == 'n') + TIMEIT (runf_vn_thruput, f->fun.vnf); + else if (f->prec == 'f' && type == 'l' && f->vec == 'n') + TIMEIT (runf_vn_latency, f->fun.vnf); +#endif + + if (type == 't') + { + ns100 = (100 * dt + itercount * N / 2) / (itercount * N); + printf ("%9s %8s: %4u.%02u ns/elem %10llu ns in [%g %g]\n", f->name, s, + (unsigned) (ns100 / 100), (unsigned) (ns100 % 100), + (unsigned long long) dt, lo, hi); + } + else if (type == 'l') + { + ns100 = (100 * dt + itercount * N / vlen / 2) / (itercount * N / vlen); + printf ("%9s %8s: %4u.%02u ns/call %10llu ns in [%g %g]\n", f->name, s, + (unsigned) (ns100 / 100), (unsigned) (ns100 % 100), + (unsigned long long) dt, lo, hi); + } + fflush (stdout); +} + +static void +bench (const struct fun *f, double lo, double hi, int type, int gen) +{ + if (f->prec == 'd' && gen == 'r') + gen_rand (lo, hi); + else if (f->prec == 'd' && gen == 'l') + gen_linear (lo, hi); + else if (f->prec == 'd' && gen == 't') + gen_trace (0); + else if (f->prec == 'f' && gen == 'r') + genf_rand (lo, hi); + else if (f->prec == 'f' && gen == 'l') + genf_linear (lo, hi); + else if (f->prec == 'f' && gen == 't') + genf_trace (0); + + if (gen == 't') + hi = trace_size / N; + + if (type == 'b' || type == 't') + bench1 (f, 't', lo, hi); + + if (type == 'b' || type == 'l') + bench1 (f, 'l', lo, hi); + + for (int i = N; i < trace_size; i += N) + { + if (f->prec == 'd') + gen_trace (i); + else + genf_trace (i); + + lo = i / N; + if (type == 'b' || type == 't') + bench1 (f, 't', lo, hi); + + if (type == 'b' || type == 'l') + bench1 (f, 'l', lo, hi); + } +} + +static void +readtrace (const char *name) +{ + int n = 0; + FILE *f = strcmp (name, "-") == 0 ? stdin : fopen (name, "r"); + if (!f) + { + printf ("openning \"%s\" failed: %m\n", name); + exit (1); + } + for (;;) + { + if (n >= trace_size) + { + trace_size += N; + Trace = realloc (Trace, trace_size * sizeof (Trace[0])); + if (Trace == NULL) + { + printf ("out of memory\n"); + exit (1); + } + } + if (fscanf (f, "%lf", Trace + n) != 1) + break; + n++; + } + if (ferror (f) || n == 0) + { + printf ("reading \"%s\" failed: %m\n", name); + exit (1); + } + fclose (f); + if (n % N == 0) + trace_size = n; + for (int i = 0; n < trace_size; n++, i++) + Trace[n] = Trace[i]; +} + +static void +usage (void) +{ + printf ("usage: ./mathbench [-g rand|linear|trace] [-t latency|thruput|both] " + "[-i low high] [-f tracefile] [-m measurements] [-c iterations] func " + "[func2 ..]\n"); + printf ("func:\n"); + printf ("%7s [run all benchmarks]\n", "all"); + for (const struct fun *f = funtab; f->name; f++) + printf ("%7s [low: %g high: %g]\n", f->name, f->lo, f->hi); + exit (1); +} + +int +main (int argc, char *argv[]) +{ + int usergen = 0, gen = 'r', type = 'b', all = 0; + double lo = 0, hi = 0; + const char *tracefile = "-"; + + argv++; + argc--; + for (;;) + { + if (argc <= 0) + usage (); + if (argv[0][0] != '-') + break; + else if (argc >= 3 && strcmp (argv[0], "-i") == 0) + { + usergen = 1; + lo = strtod (argv[1], 0); + hi = strtod (argv[2], 0); + argv += 3; + argc -= 3; + } + else if (argc >= 2 && strcmp (argv[0], "-m") == 0) + { + measurecount = strtol (argv[1], 0, 0); + argv += 2; + argc -= 2; + } + else if (argc >= 2 && strcmp (argv[0], "-c") == 0) + { + itercount = strtol (argv[1], 0, 0); + argv += 2; + argc -= 2; + } + else if (argc >= 2 && strcmp (argv[0], "-g") == 0) + { + gen = argv[1][0]; + if (strchr ("rlt", gen) == 0) + usage (); + argv += 2; + argc -= 2; + } + else if (argc >= 2 && strcmp (argv[0], "-f") == 0) + { + gen = 't'; /* -f implies -g trace. */ + tracefile = argv[1]; + argv += 2; + argc -= 2; + } + else if (argc >= 2 && strcmp (argv[0], "-t") == 0) + { + type = argv[1][0]; + if (strchr ("ltb", type) == 0) + usage (); + argv += 2; + argc -= 2; + } + else + usage (); + } + if (gen == 't') + { + readtrace (tracefile); + lo = hi = 0; + usergen = 1; + } + while (argc > 0) + { + int found = 0; + all = strcmp (argv[0], "all") == 0; + for (const struct fun *f = funtab; f->name; f++) + if (all || strcmp (argv[0], f->name) == 0) + { + found = 1; + if (!usergen) + { + lo = f->lo; + hi = f->hi; + } + bench (f, lo, hi, type, gen); + if (usergen && !all) + break; + } + if (!found) + printf ("unknown function: %s\n", argv[0]); + argv++; + argc--; + } + return 0; +} diff --git a/libc/AOR_v20.02/math/test/mathtest.c b/libc/AOR_v20.02/math/test/mathtest.c new file mode 100644 index 00000000000000..efe0a8a744bc5c --- /dev/null +++ b/libc/AOR_v20.02/math/test/mathtest.c @@ -0,0 +1,1702 @@ +/* + * mathtest.c - test rig for mathlib + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "mathlib.h" + +#ifndef math_errhandling +# define math_errhandling 0 +#endif + +#ifdef __cplusplus + #define EXTERN_C extern "C" +#else + #define EXTERN_C extern +#endif + +#ifndef TRUE +#define TRUE 1 +#endif +#ifndef FALSE +#define FALSE 0 +#endif + +#ifdef IMPORT_SYMBOL +#define STR2(x) #x +#define STR(x) STR2(x) +_Pragma(STR(import IMPORT_SYMBOL)) +#endif + +int dmsd, dlsd; +int quiet = 0; +int doround = 0; +unsigned statusmask = FE_ALL_EXCEPT; + +#define EXTRABITS (12) +#define ULPUNIT (1<name, ((test_func*)b)->name); +} + +int is_double_argtype(int argtype) { + switch(argtype) { + case at_d: + case at_d2: + case at_dc: + case at_dc2: + return 1; + default: + return 0; + } +} + +int is_single_argtype(int argtype) { + switch(argtype) { + case at_s: + case at_s2: + case at_sc: + case at_sc2: + return 1; + default: + return 0; + } +} + +int is_double_rettype(int rettype) { + switch(rettype) { + case rt_d: + case rt_dc: + case rt_d2: + return 1; + default: + return 0; + } +} + +int is_single_rettype(int rettype) { + switch(rettype) { + case rt_s: + case rt_sc: + case rt_s2: + return 1; + default: + return 0; + } +} + +int is_complex_argtype(int argtype) { + switch(argtype) { + case at_dc: + case at_sc: + case at_dc2: + case at_sc2: + return 1; + default: + return 0; + } +} + +int is_complex_rettype(int rettype) { + switch(rettype) { + case rt_dc: + case rt_sc: + return 1; + default: + return 0; + } +} + +/* + * Special-case flags indicating that some functions' error + * tolerance handling is more complicated than a fixed relative + * error bound. + */ +#define ABSLOWERBOUND 0x4000000000000000LL +#define PLUSMINUSPIO2 0x1000000000000000LL + +#define ARM_PREFIX(x) x + +#define TFUNC(arg,ret,name,tolerance) { t_func, arg, ret, (void*)&name, m_none, tolerance, #name } +#define TFUNCARM(arg,ret,name,tolerance) { t_func, arg, ret, (void*)& ARM_PREFIX(name), m_none, tolerance, #name } +#define MFUNC(arg,ret,name,tolerance) { t_macro, arg, ret, NULL, m_##name, tolerance, #name } + +/* sincosf wrappers for easier testing. */ +static float sincosf_sinf(float x) { float s,c; sincosf(x, &s, &c); return s; } +static float sincosf_cosf(float x) { float s,c; sincosf(x, &s, &c); return c; } + +test_func tfuncs[] = { + /* trigonometric */ + TFUNC(at_d,rt_d, acos, 4*ULPUNIT), + TFUNC(at_d,rt_d, asin, 4*ULPUNIT), + TFUNC(at_d,rt_d, atan, 4*ULPUNIT), + TFUNC(at_d2,rt_d, atan2, 4*ULPUNIT), + + TFUNC(at_d,rt_d, tan, 2*ULPUNIT), + TFUNC(at_d,rt_d, sin, 2*ULPUNIT), + TFUNC(at_d,rt_d, cos, 2*ULPUNIT), + + TFUNC(at_s,rt_s, acosf, 4*ULPUNIT), + TFUNC(at_s,rt_s, asinf, 4*ULPUNIT), + TFUNC(at_s,rt_s, atanf, 4*ULPUNIT), + TFUNC(at_s2,rt_s, atan2f, 4*ULPUNIT), + TFUNCARM(at_s,rt_s, tanf, 4*ULPUNIT), + TFUNCARM(at_s,rt_s, sinf, 3*ULPUNIT/4), + TFUNCARM(at_s,rt_s, cosf, 3*ULPUNIT/4), + TFUNCARM(at_s,rt_s, sincosf_sinf, 3*ULPUNIT/4), + TFUNCARM(at_s,rt_s, sincosf_cosf, 3*ULPUNIT/4), + + /* hyperbolic */ + TFUNC(at_d, rt_d, atanh, 4*ULPUNIT), + TFUNC(at_d, rt_d, asinh, 4*ULPUNIT), + TFUNC(at_d, rt_d, acosh, 4*ULPUNIT), + TFUNC(at_d,rt_d, tanh, 4*ULPUNIT), + TFUNC(at_d,rt_d, sinh, 4*ULPUNIT), + TFUNC(at_d,rt_d, cosh, 4*ULPUNIT), + + TFUNC(at_s, rt_s, atanhf, 4*ULPUNIT), + TFUNC(at_s, rt_s, asinhf, 4*ULPUNIT), + TFUNC(at_s, rt_s, acoshf, 4*ULPUNIT), + TFUNC(at_s,rt_s, tanhf, 4*ULPUNIT), + TFUNC(at_s,rt_s, sinhf, 4*ULPUNIT), + TFUNC(at_s,rt_s, coshf, 4*ULPUNIT), + + /* exponential and logarithmic */ + TFUNC(at_d,rt_d, log, 3*ULPUNIT/4), + TFUNC(at_d,rt_d, log10, 3*ULPUNIT), + TFUNC(at_d,rt_d, log2, 3*ULPUNIT/4), + TFUNC(at_d,rt_d, log1p, 2*ULPUNIT), + TFUNC(at_d,rt_d, exp, 3*ULPUNIT/4), + TFUNC(at_d,rt_d, exp2, 3*ULPUNIT/4), + TFUNC(at_d,rt_d, expm1, ULPUNIT), + TFUNCARM(at_s,rt_s, logf, ULPUNIT), + TFUNC(at_s,rt_s, log10f, 3*ULPUNIT), + TFUNCARM(at_s,rt_s, log2f, ULPUNIT), + TFUNC(at_s,rt_s, log1pf, 2*ULPUNIT), + TFUNCARM(at_s,rt_s, expf, 3*ULPUNIT/4), + TFUNCARM(at_s,rt_s, exp2f, 3*ULPUNIT/4), + TFUNC(at_s,rt_s, expm1f, ULPUNIT), + + /* power */ + TFUNC(at_d2,rt_d, pow, 3*ULPUNIT/4), + TFUNC(at_d,rt_d, sqrt, ULPUNIT/2), + TFUNC(at_d,rt_d, cbrt, 2*ULPUNIT), + TFUNC(at_d2, rt_d, hypot, 4*ULPUNIT), + + TFUNCARM(at_s2,rt_s, powf, ULPUNIT), + TFUNC(at_s,rt_s, sqrtf, ULPUNIT/2), + TFUNC(at_s,rt_s, cbrtf, 2*ULPUNIT), + TFUNC(at_s2, rt_s, hypotf, 4*ULPUNIT), + + /* error function */ + TFUNC(at_d,rt_d, erf, 16*ULPUNIT), + TFUNC(at_s,rt_s, erff, 16*ULPUNIT), + TFUNC(at_d,rt_d, erfc, 16*ULPUNIT), + TFUNC(at_s,rt_s, erfcf, 16*ULPUNIT), + + /* gamma functions */ + TFUNC(at_d,rt_d, tgamma, 16*ULPUNIT), + TFUNC(at_s,rt_s, tgammaf, 16*ULPUNIT), + TFUNC(at_d,rt_d, lgamma, 16*ULPUNIT | ABSLOWERBOUND), + TFUNC(at_s,rt_s, lgammaf, 16*ULPUNIT | ABSLOWERBOUND), + + TFUNC(at_d,rt_d, ceil, 0), + TFUNC(at_s,rt_s, ceilf, 0), + TFUNC(at_d2,rt_d, copysign, 0), + TFUNC(at_s2,rt_s, copysignf, 0), + TFUNC(at_d,rt_d, floor, 0), + TFUNC(at_s,rt_s, floorf, 0), + TFUNC(at_d2,rt_d, fmax, 0), + TFUNC(at_s2,rt_s, fmaxf, 0), + TFUNC(at_d2,rt_d, fmin, 0), + TFUNC(at_s2,rt_s, fminf, 0), + TFUNC(at_d2,rt_d, fmod, 0), + TFUNC(at_s2,rt_s, fmodf, 0), + MFUNC(at_d, rt_i, fpclassify, 0), + MFUNC(at_s, rt_i, fpclassifyf, 0), + TFUNC(at_dip,rt_d, frexp, 0), + TFUNC(at_sip,rt_s, frexpf, 0), + MFUNC(at_d, rt_i, isfinite, 0), + MFUNC(at_s, rt_i, isfinitef, 0), + MFUNC(at_d, rt_i, isgreater, 0), + MFUNC(at_d, rt_i, isgreaterequal, 0), + MFUNC(at_s, rt_i, isgreaterequalf, 0), + MFUNC(at_s, rt_i, isgreaterf, 0), + MFUNC(at_d, rt_i, isinf, 0), + MFUNC(at_s, rt_i, isinff, 0), + MFUNC(at_d, rt_i, isless, 0), + MFUNC(at_d, rt_i, islessequal, 0), + MFUNC(at_s, rt_i, islessequalf, 0), + MFUNC(at_s, rt_i, islessf, 0), + MFUNC(at_d, rt_i, islessgreater, 0), + MFUNC(at_s, rt_i, islessgreaterf, 0), + MFUNC(at_d, rt_i, isnan, 0), + MFUNC(at_s, rt_i, isnanf, 0), + MFUNC(at_d, rt_i, isnormal, 0), + MFUNC(at_s, rt_i, isnormalf, 0), + MFUNC(at_d, rt_i, isunordered, 0), + MFUNC(at_s, rt_i, isunorderedf, 0), + TFUNC(at_di,rt_d, ldexp, 0), + TFUNC(at_si,rt_s, ldexpf, 0), + TFUNC(at_ddp,rt_d2, modf, 0), + TFUNC(at_ssp,rt_s2, modff, 0), +#ifndef BIGRANGERED + MFUNC(at_d, rt_d, rred, 2*ULPUNIT), +#else + MFUNC(at_d, rt_d, m_rred, ULPUNIT), +#endif + MFUNC(at_d, rt_i, signbit, 0), + MFUNC(at_s, rt_i, signbitf, 0), +}; + +/* + * keywords are: func size op1 op2 result res2 errno op1r op1i op2r op2i resultr resulti + * also we ignore: wrongresult wrongres2 wrongerrno + * op1 equivalent to op1r, same with op2 and result + */ + +typedef struct { + test_func *func; + unsigned op1r[2]; /* real part, also used for non-complex numbers */ + unsigned op1i[2]; /* imaginary part */ + unsigned op2r[2]; + unsigned op2i[2]; + unsigned resultr[3]; + unsigned resulti[3]; + enum { + rc_none, rc_zero, rc_infinity, rc_nan, rc_finite + } resultc; /* special complex results, rc_none means use resultr and resulti as normal */ + unsigned res2[2]; + unsigned status; /* IEEE status return, if any */ + unsigned maybestatus; /* for optional status, or allowance for spurious */ + int nresult; /* number of result words */ + int in_err, in_err_limit; + int err; + int maybeerr; + int valid; + int comment; + int random; +} testdetail; + +enum { /* keywords */ + k_errno, k_errno_in, k_error, k_func, k_maybeerror, k_maybestatus, k_op1, k_op1i, k_op1r, k_op2, k_op2i, k_op2r, + k_random, k_res2, k_result, k_resultc, k_resulti, k_resultr, k_status, + k_wrongres2, k_wrongresult, k_wrongstatus, k_wrongerrno +}; +char *keywords[] = { + "errno", "errno_in", "error", "func", "maybeerror", "maybestatus", "op1", "op1i", "op1r", "op2", "op2i", "op2r", + "random", "res2", "result", "resultc", "resulti", "resultr", "status", + "wrongres2", "wrongresult", "wrongstatus", "wrongerrno" +}; + +enum { + e_0, e_EDOM, e_ERANGE, + + /* + * This enum makes sure that we have the right number of errnos in the + * errno[] array + */ + e_number_of_errnos +}; +char *errnos[] = { + "0", "EDOM", "ERANGE" +}; + +enum { + e_none, e_divbyzero, e_domain, e_overflow, e_underflow +}; +char *errors[] = { + "0", "divbyzero", "domain", "overflow", "underflow" +}; + +static int verbose, fo, strict; + +/* state toggled by random=on / random=off */ +static int randomstate; + +/* Canonify a double NaN: SNaNs all become 7FF00000.00000001 and QNaNs + * all become 7FF80000.00000001 */ +void canon_dNaN(unsigned a[2]) { + if ((a[0] & 0x7FF00000) != 0x7FF00000) + return; /* not Inf or NaN */ + if (!(a[0] & 0xFFFFF) && !a[1]) + return; /* Inf */ + a[0] &= 0x7FF80000; /* canonify top word */ + a[1] = 0x00000001; /* canonify bottom word */ +} + +/* Canonify a single NaN: SNaNs all become 7F800001 and QNaNs + * all become 7FC00001. Returns classification of the NaN. */ +void canon_sNaN(unsigned a[1]) { + if ((a[0] & 0x7F800000) != 0x7F800000) + return; /* not Inf or NaN */ + if (!(a[0] & 0x7FFFFF)) + return; /* Inf */ + a[0] &= 0x7FC00000; /* canonify most bits */ + a[0] |= 0x00000001; /* canonify bottom bit */ +} + +/* + * Detect difficult operands for FO mode. + */ +int is_dhard(unsigned a[2]) +{ + if ((a[0] & 0x7FF00000) == 0x7FF00000) + return TRUE; /* inf or NaN */ + if ((a[0] & 0x7FF00000) == 0 && + ((a[0] & 0x7FFFFFFF) | a[1]) != 0) + return TRUE; /* denormal */ + return FALSE; +} +int is_shard(unsigned a[1]) +{ + if ((a[0] & 0x7F800000) == 0x7F800000) + return TRUE; /* inf or NaN */ + if ((a[0] & 0x7F800000) == 0 && + (a[0] & 0x7FFFFFFF) != 0) + return TRUE; /* denormal */ + return FALSE; +} + +/* + * Normalise all zeroes into +0, for FO mode. + */ +void dnormzero(unsigned a[2]) +{ + if (a[0] == 0x80000000 && a[1] == 0) + a[0] = 0; +} +void snormzero(unsigned a[1]) +{ + if (a[0] == 0x80000000) + a[0] = 0; +} + +static int find(char *word, char **array, int asize) { + int i, j; + + asize /= sizeof(char *); + + i = -1; j = asize; /* strictly between i and j */ + while (j-i > 1) { + int k = (i+j) / 2; + int c = strcmp(word, array[k]); + if (c > 0) + i = k; + else if (c < 0) + j = k; + else /* found it! */ + return k; + } + return -1; /* not found */ +} + +static test_func* find_testfunc(char *word) { + int i, j, asize; + + asize = sizeof(tfuncs)/sizeof(test_func); + + i = -1; j = asize; /* strictly between i and j */ + while (j-i > 1) { + int k = (i+j) / 2; + int c = strcmp(word, tfuncs[k].name); + if (c > 0) + i = k; + else if (c < 0) + j = k; + else /* found it! */ + return tfuncs + k; + } + return NULL; /* not found */ +} + +static long long calc_error(unsigned a[2], unsigned b[3], int shift, int rettype) { + unsigned r0, r1, r2; + int sign, carry; + long long result; + + /* + * If either number is infinite, require exact equality. If + * either number is NaN, require that both are NaN. If either + * of these requirements is broken, return INT_MAX. + */ + if (is_double_rettype(rettype)) { + if ((a[0] & 0x7FF00000) == 0x7FF00000 || + (b[0] & 0x7FF00000) == 0x7FF00000) { + if (((a[0] & 0x800FFFFF) || a[1]) && + ((b[0] & 0x800FFFFF) || b[1]) && + (a[0] & 0x7FF00000) == 0x7FF00000 && + (b[0] & 0x7FF00000) == 0x7FF00000) + return 0; /* both NaN - OK */ + if (!((a[0] & 0xFFFFF) || a[1]) && + !((b[0] & 0xFFFFF) || b[1]) && + a[0] == b[0]) + return 0; /* both same sign of Inf - OK */ + return LLONG_MAX; + } + } else { + if ((a[0] & 0x7F800000) == 0x7F800000 || + (b[0] & 0x7F800000) == 0x7F800000) { + if ((a[0] & 0x807FFFFF) && + (b[0] & 0x807FFFFF) && + (a[0] & 0x7F800000) == 0x7F800000 && + (b[0] & 0x7F800000) == 0x7F800000) + return 0; /* both NaN - OK */ + if (!(a[0] & 0x7FFFFF) && + !(b[0] & 0x7FFFFF) && + a[0] == b[0]) + return 0; /* both same sign of Inf - OK */ + return LLONG_MAX; + } + } + + /* + * Both finite. Return INT_MAX if the signs differ. + */ + if ((a[0] ^ b[0]) & 0x80000000) + return LLONG_MAX; + + /* + * Now it's just straight multiple-word subtraction. + */ + if (is_double_rettype(rettype)) { + r2 = -b[2]; carry = (r2 == 0); + r1 = a[1] + ~b[1] + carry; carry = (r1 < a[1] || (carry && r1 == a[1])); + r0 = a[0] + ~b[0] + carry; + } else { + r2 = -b[1]; carry = (r2 == 0); + r1 = a[0] + ~b[0] + carry; carry = (r1 < a[0] || (carry && r1 == a[0])); + r0 = ~0 + carry; + } + + /* + * Forgive larger errors in specialised cases. + */ + if (shift > 0) { + if (shift > 32*3) + return 0; /* all errors are forgiven! */ + while (shift >= 32) { + r2 = r1; + r1 = r0; + r0 = -(r0 >> 31); + shift -= 32; + } + + if (shift > 0) { + r2 = (r2 >> shift) | (r1 << (32-shift)); + r1 = (r1 >> shift) | (r0 << (32-shift)); + r0 = (r0 >> shift) | ((-(r0 >> 31)) << (32-shift)); + } + } + + if (r0 & 0x80000000) { + sign = 1; + r2 = ~r2; carry = (r2 == 0); + r1 = 0 + ~r1 + carry; carry = (carry && (r2 == 0)); + r0 = 0 + ~r0 + carry; + } else { + sign = 0; + } + + if (r0 >= (1LL<<(31-EXTRABITS))) + return LLONG_MAX; /* many ulps out */ + + result = (r2 >> (32-EXTRABITS)) & (ULPUNIT-1); + result |= r1 << EXTRABITS; + result |= (long long)r0 << (32+EXTRABITS); + if (sign) + result = -result; + return result; +} + +/* special named operands */ + +typedef struct { + unsigned op1, op2; + char* name; +} special_op; + +static special_op special_ops_double[] = { + {0x00000000,0x00000000,"0"}, + {0x3FF00000,0x00000000,"1"}, + {0x7FF00000,0x00000000,"inf"}, + {0x7FF80000,0x00000001,"qnan"}, + {0x7FF00000,0x00000001,"snan"}, + {0x3ff921fb,0x54442d18,"pi2"}, + {0x400921fb,0x54442d18,"pi"}, + {0x3fe921fb,0x54442d18,"pi4"}, + {0x4002d97c,0x7f3321d2,"3pi4"}, +}; + +static special_op special_ops_float[] = { + {0x00000000,0,"0"}, + {0x3f800000,0,"1"}, + {0x7f800000,0,"inf"}, + {0x7fc00000,0,"qnan"}, + {0x7f800001,0,"snan"}, + {0x3fc90fdb,0,"pi2"}, + {0x40490fdb,0,"pi"}, + {0x3f490fdb,0,"pi4"}, + {0x4016cbe4,0,"3pi4"}, +}; + +/* + This is what is returned by the below functions. + We need it to handle the sign of the number +*/ +static special_op tmp_op = {0,0,0}; + +special_op* find_special_op_from_op(unsigned op1, unsigned op2, int is_double) { + int i; + special_op* sop; + if(is_double) { + sop = special_ops_double; + } else { + sop = special_ops_float; + } + for(i = 0; i < sizeof(special_ops_double)/sizeof(special_op); i++) { + if(sop->op1 == (op1&0x7fffffff) && sop->op2 == op2) { + if(tmp_op.name) free(tmp_op.name); + tmp_op.name = malloc(strlen(sop->name)+2); + if(op1>>31) { + sprintf(tmp_op.name,"-%s",sop->name); + } else { + strcpy(tmp_op.name,sop->name); + } + return &tmp_op; + } + sop++; + } + return NULL; +} + +special_op* find_special_op_from_name(const char* name, int is_double) { + int i, neg=0; + special_op* sop; + if(is_double) { + sop = special_ops_double; + } else { + sop = special_ops_float; + } + if(*name=='-') { + neg=1; + name++; + } else if(*name=='+') { + name++; + } + for(i = 0; i < sizeof(special_ops_double)/sizeof(special_op); i++) { + if(0 == strcmp(name,sop->name)) { + tmp_op.op1 = sop->op1; + if(neg) { + tmp_op.op1 |= 0x80000000; + } + tmp_op.op2 = sop->op2; + return &tmp_op; + } + sop++; + } + return NULL; +} + +/* + helper function for the below + type=0 for single, 1 for double, 2 for no sop +*/ +int do_op(char* q, unsigned* op, const char* name, int num, int sop_type) { + int i; + int n=num; + special_op* sop = NULL; + for(i = 0; i < num; i++) { + op[i] = 0; + } + if(sop_type<2) { + sop = find_special_op_from_name(q,sop_type); + } + if(sop != NULL) { + op[0] = sop->op1; + op[1] = sop->op2; + } else { + switch(num) { + case 1: n = sscanf(q, "%x", &op[0]); break; + case 2: n = sscanf(q, "%x.%x", &op[0], &op[1]); break; + case 3: n = sscanf(q, "%x.%x.%x", &op[0], &op[1], &op[2]); break; + default: return -1; + } + } + if (verbose) { + printf("%s=",name); + for (i = 0; (i < n); ++i) printf("%x.", op[i]); + printf(" (n=%d)\n", n); + } + return n; +} + +testdetail parsetest(char *testbuf, testdetail oldtest) { + char *p; /* Current part of line: Option name */ + char *q; /* Current part of line: Option value */ + testdetail ret; /* What we return */ + int k; /* Function enum from k_* */ + int n; /* Used as returns for scanfs */ + int argtype=2, rettype=2; /* for do_op */ + + /* clear ret */ + memset(&ret, 0, sizeof(ret)); + + if (verbose) printf("Parsing line: %s\n", testbuf); + while (*testbuf && isspace(*testbuf)) testbuf++; + if (testbuf[0] == ';' || testbuf[0] == '#' || testbuf[0] == '!' || + testbuf[0] == '>' || testbuf[0] == '\0') { + ret.comment = 1; + if (verbose) printf("Line is a comment\n"); + return ret; + } + ret.comment = 0; + + if (*testbuf == '+') { + if (oldtest.valid) { + ret = oldtest; /* structure copy */ + } else { + fprintf(stderr, "copy from invalid: ignored\n"); + } + testbuf++; + } + + ret.random = randomstate; + + ret.in_err = 0; + ret.in_err_limit = e_number_of_errnos; + + p = strtok(testbuf, " \t"); + while (p != NULL) { + q = strchr(p, '='); + if (!q) + goto balderdash; + *q++ = '\0'; + k = find(p, keywords, sizeof(keywords)); + switch (k) { + case k_random: + randomstate = (!strcmp(q, "on")); + ret.comment = 1; + return ret; /* otherwise ignore this line */ + case k_func: + if (verbose) printf("func=%s ", q); + //ret.func = find(q, funcs, sizeof(funcs)); + ret.func = find_testfunc(q); + if (ret.func == NULL) + { + if (verbose) printf("(id=unknown)\n"); + goto balderdash; + } + if(is_single_argtype(ret.func->argtype)) + argtype = 0; + else if(is_double_argtype(ret.func->argtype)) + argtype = 1; + if(is_single_rettype(ret.func->rettype)) + rettype = 0; + else if(is_double_rettype(ret.func->rettype)) + rettype = 1; + //ret.size = sizes[ret.func]; + if (verbose) printf("(name=%s) (size=%d)\n", ret.func->name, ret.func->argtype); + break; + case k_op1: + case k_op1r: + n = do_op(q,ret.op1r,"op1r",2,argtype); + if (n < 1) + goto balderdash; + break; + case k_op1i: + n = do_op(q,ret.op1i,"op1i",2,argtype); + if (n < 1) + goto balderdash; + break; + case k_op2: + case k_op2r: + n = do_op(q,ret.op2r,"op2r",2,argtype); + if (n < 1) + goto balderdash; + break; + case k_op2i: + n = do_op(q,ret.op2i,"op2i",2,argtype); + if (n < 1) + goto balderdash; + break; + case k_resultc: + puts(q); + if(strncmp(q,"inf",3)==0) { + ret.resultc = rc_infinity; + } else if(strcmp(q,"zero")==0) { + ret.resultc = rc_zero; + } else if(strcmp(q,"nan")==0) { + ret.resultc = rc_nan; + } else if(strcmp(q,"finite")==0) { + ret.resultc = rc_finite; + } else { + goto balderdash; + } + break; + case k_result: + case k_resultr: + n = (do_op)(q,ret.resultr,"resultr",3,rettype); + if (n < 1) + goto balderdash; + ret.nresult = n; /* assume real and imaginary have same no. words */ + break; + case k_resulti: + n = do_op(q,ret.resulti,"resulti",3,rettype); + if (n < 1) + goto balderdash; + break; + case k_res2: + n = do_op(q,ret.res2,"res2",2,rettype); + if (n < 1) + goto balderdash; + break; + case k_status: + while (*q) { + if (*q == 'i') ret.status |= FE_INVALID; + if (*q == 'z') ret.status |= FE_DIVBYZERO; + if (*q == 'o') ret.status |= FE_OVERFLOW; + if (*q == 'u') ret.status |= FE_UNDERFLOW; + q++; + } + break; + case k_maybeerror: + n = find(q, errors, sizeof(errors)); + if (n < 0) + goto balderdash; + if(math_errhandling&MATH_ERREXCEPT) { + switch(n) { + case e_domain: ret.maybestatus |= FE_INVALID; break; + case e_divbyzero: ret.maybestatus |= FE_DIVBYZERO; break; + case e_overflow: ret.maybestatus |= FE_OVERFLOW; break; + case e_underflow: ret.maybestatus |= FE_UNDERFLOW; break; + } + } + { + switch(n) { + case e_domain: + ret.maybeerr = e_EDOM; break; + case e_divbyzero: + case e_overflow: + case e_underflow: + ret.maybeerr = e_ERANGE; break; + } + } + case k_maybestatus: + while (*q) { + if (*q == 'i') ret.maybestatus |= FE_INVALID; + if (*q == 'z') ret.maybestatus |= FE_DIVBYZERO; + if (*q == 'o') ret.maybestatus |= FE_OVERFLOW; + if (*q == 'u') ret.maybestatus |= FE_UNDERFLOW; + q++; + } + break; + case k_error: + n = find(q, errors, sizeof(errors)); + if (n < 0) + goto balderdash; + if(math_errhandling&MATH_ERREXCEPT) { + switch(n) { + case e_domain: ret.status |= FE_INVALID; break; + case e_divbyzero: ret.status |= FE_DIVBYZERO; break; + case e_overflow: ret.status |= FE_OVERFLOW; break; + case e_underflow: ret.status |= FE_UNDERFLOW; break; + } + } + if(math_errhandling&MATH_ERRNO) { + switch(n) { + case e_domain: + ret.err = e_EDOM; break; + case e_divbyzero: + case e_overflow: + case e_underflow: + ret.err = e_ERANGE; break; + } + } + if(!(math_errhandling&MATH_ERRNO)) { + switch(n) { + case e_domain: + ret.maybeerr = e_EDOM; break; + case e_divbyzero: + case e_overflow: + case e_underflow: + ret.maybeerr = e_ERANGE; break; + } + } + break; + case k_errno: + ret.err = find(q, errnos, sizeof(errnos)); + if (ret.err < 0) + goto balderdash; + break; + case k_errno_in: + ret.in_err = find(q, errnos, sizeof(errnos)); + if (ret.err < 0) + goto balderdash; + ret.in_err_limit = ret.in_err + 1; + break; + case k_wrongresult: + case k_wrongstatus: + case k_wrongres2: + case k_wrongerrno: + /* quietly ignore these keys */ + break; + default: + goto balderdash; + } + p = strtok(NULL, " \t"); + } + ret.valid = 1; + return ret; + + /* come here from almost any error */ + balderdash: + ret.valid = 0; + return ret; +} + +typedef enum { + test_comment, /* deliberately not a test */ + test_invalid, /* accidentally not a test */ + test_decline, /* was a test, and wasn't run */ + test_fail, /* was a test, and failed */ + test_pass /* was a test, and passed */ +} testresult; + +char failtext[512]; + +typedef union { + unsigned i[2]; + double f; + double da[2]; +} dbl; + +typedef union { + unsigned i; + float f; + float da[2]; +} sgl; + +/* helper function for runtest */ +void print_error(int rettype, unsigned *result, char* text, char** failp) { + special_op *sop; + char *str; + + if(result) { + *failp += sprintf(*failp," %s=",text); + sop = find_special_op_from_op(result[0],result[1],is_double_rettype(rettype)); + if(sop) { + *failp += sprintf(*failp,"%s",sop->name); + } else { + if(is_double_rettype(rettype)) { + str="%08x.%08x"; + } else { + str="%08x"; + } + *failp += sprintf(*failp,str,result[0],result[1]); + } + } +} + + +void print_ulps_helper(const char *name, long long ulps, char** failp) { + if(ulps == LLONG_MAX) { + *failp += sprintf(*failp, " %s=HUGE", name); + } else { + *failp += sprintf(*failp, " %s=%.3f", name, (double)ulps / ULPUNIT); + } +} + +/* for complex args make ulpsr or ulpsri = 0 to not print */ +void print_ulps(int rettype, long long ulpsr, long long ulpsi, char** failp) { + if(is_complex_rettype(rettype)) { + if (ulpsr) print_ulps_helper("ulpsr",ulpsr,failp); + if (ulpsi) print_ulps_helper("ulpsi",ulpsi,failp); + } else { + if (ulpsr) print_ulps_helper("ulps",ulpsr,failp); + } +} + +int runtest(testdetail t) { + int err, status; + + dbl d_arg1, d_arg2, d_res, d_res2; + sgl s_arg1, s_arg2, s_res, s_res2; + + int deferred_decline = FALSE; + char *failp = failtext; + + unsigned int intres=0; + + int res2_adjust = 0; + + if (t.comment) + return test_comment; + if (!t.valid) + return test_invalid; + + /* Set IEEE status to mathlib-normal */ + feclearexcept(FE_ALL_EXCEPT); + + /* Deal with operands */ +#define DO_DOP(arg,op) arg.i[dmsd] = t.op[0]; arg.i[dlsd] = t.op[1] + DO_DOP(d_arg1,op1r); + DO_DOP(d_arg2,op2r); + s_arg1.i = t.op1r[0]; s_arg2.i = t.op2r[0]; + + /* + * Detect NaNs, infinities and denormals on input, and set a + * deferred decline flag if we're in FO mode. + * + * (We defer the decline rather than doing it immediately + * because even in FO mode the operation is not permitted to + * crash or tight-loop; so we _run_ the test, and then ignore + * all the results.) + */ + if (fo) { + if (is_double_argtype(t.func->argtype) && is_dhard(t.op1r)) + deferred_decline = TRUE; + if (t.func->argtype==at_d2 && is_dhard(t.op2r)) + deferred_decline = TRUE; + if (is_single_argtype(t.func->argtype) && is_shard(t.op1r)) + deferred_decline = TRUE; + if (t.func->argtype==at_s2 && is_shard(t.op2r)) + deferred_decline = TRUE; + if (is_double_rettype(t.func->rettype) && is_dhard(t.resultr)) + deferred_decline = TRUE; + if (t.func->rettype==rt_d2 && is_dhard(t.res2)) + deferred_decline = TRUE; + if (is_single_argtype(t.func->rettype) && is_shard(t.resultr)) + deferred_decline = TRUE; + if (t.func->rettype==rt_s2 && is_shard(t.res2)) + deferred_decline = TRUE; + if (t.err == e_ERANGE) + deferred_decline = TRUE; + } + + /* + * Perform the operation + */ + + errno = t.in_err == e_EDOM ? EDOM : t.in_err == e_ERANGE ? ERANGE : 0; + if (t.err == e_0) + t.err = t.in_err; + if (t.maybeerr == e_0) + t.maybeerr = t.in_err; + + if(t.func->type == t_func) { + switch(t.func->argtype) { + case at_d: d_res.f = t.func->func.d_d_ptr(d_arg1.f); break; + case at_s: s_res.f = t.func->func.s_s_ptr(s_arg1.f); break; + case at_d2: d_res.f = t.func->func.d2_d_ptr(d_arg1.f, d_arg2.f); break; + case at_s2: s_res.f = t.func->func.s2_s_ptr(s_arg1.f, s_arg2.f); break; + case at_di: d_res.f = t.func->func.di_d_ptr(d_arg1.f, d_arg2.i[dmsd]); break; + case at_si: s_res.f = t.func->func.si_s_ptr(s_arg1.f, s_arg2.i); break; + case at_dip: d_res.f = t.func->func.dip_d_ptr(d_arg1.f, (int*)&intres); break; + case at_sip: s_res.f = t.func->func.sip_s_ptr(s_arg1.f, (int*)&intres); break; + case at_ddp: d_res.f = t.func->func.ddp_d_ptr(d_arg1.f, &d_res2.f); break; + case at_ssp: s_res.f = t.func->func.ssp_s_ptr(s_arg1.f, &s_res2.f); break; + default: + printf("unhandled function: %s\n",t.func->name); + return test_fail; + } + } else { + /* printf("macro: name=%s, num=%i, s1.i=0x%08x s1.f=%f\n",t.func->name, t.func->macro_name, s_arg1.i, (double)s_arg1.f); */ + switch(t.func->macro_name) { + case m_isfinite: intres = isfinite(d_arg1.f); break; + case m_isinf: intres = isinf(d_arg1.f); break; + case m_isnan: intres = isnan(d_arg1.f); break; + case m_isnormal: intres = isnormal(d_arg1.f); break; + case m_signbit: intres = signbit(d_arg1.f); break; + case m_fpclassify: intres = fpclassify(d_arg1.f); break; + case m_isgreater: intres = isgreater(d_arg1.f, d_arg2.f); break; + case m_isgreaterequal: intres = isgreaterequal(d_arg1.f, d_arg2.f); break; + case m_isless: intres = isless(d_arg1.f, d_arg2.f); break; + case m_islessequal: intres = islessequal(d_arg1.f, d_arg2.f); break; + case m_islessgreater: intres = islessgreater(d_arg1.f, d_arg2.f); break; + case m_isunordered: intres = isunordered(d_arg1.f, d_arg2.f); break; + + case m_isfinitef: intres = isfinite(s_arg1.f); break; + case m_isinff: intres = isinf(s_arg1.f); break; + case m_isnanf: intres = isnan(s_arg1.f); break; + case m_isnormalf: intres = isnormal(s_arg1.f); break; + case m_signbitf: intres = signbit(s_arg1.f); break; + case m_fpclassifyf: intres = fpclassify(s_arg1.f); break; + case m_isgreaterf: intres = isgreater(s_arg1.f, s_arg2.f); break; + case m_isgreaterequalf: intres = isgreaterequal(s_arg1.f, s_arg2.f); break; + case m_islessf: intres = isless(s_arg1.f, s_arg2.f); break; + case m_islessequalf: intres = islessequal(s_arg1.f, s_arg2.f); break; + case m_islessgreaterf: intres = islessgreater(s_arg1.f, s_arg2.f); break; + case m_isunorderedf: intres = isunordered(s_arg1.f, s_arg2.f); break; + + default: + printf("unhandled macro: %s\n",t.func->name); + return test_fail; + } + } + + /* + * Decline the test if the deferred decline flag was set above. + */ + if (deferred_decline) + return test_decline; + + /* printf("intres=%i\n",intres); */ + + /* Clear the fail text (indicating a pass unless we change it) */ + failp[0] = '\0'; + + /* Check the IEEE status bits (except INX, which we disregard). + * We don't bother with this for complex numbers, because the + * complex functions are hard to get exactly right and we don't + * have to anyway (C99 annex G is only informative). */ + if (!(is_complex_argtype(t.func->argtype) || is_complex_rettype(t.func->rettype))) { + status = fetestexcept(FE_INVALID|FE_DIVBYZERO|FE_OVERFLOW|FE_UNDERFLOW); + if ((status|t.maybestatus|~statusmask) != (t.status|t.maybestatus|~statusmask)) { + if (quiet) failtext[0]='x'; + else { + failp += sprintf(failp, + " wrongstatus=%s%s%s%s%s", + (status & FE_INVALID ? "i" : ""), + (status & FE_DIVBYZERO ? "z" : ""), + (status & FE_OVERFLOW ? "o" : ""), + (status & FE_UNDERFLOW ? "u" : ""), + (status ? "" : "OK")); + } + } + } + + /* Check the result */ + { + unsigned resultr[2], resulti[2]; + unsigned tresultr[3], tresulti[3], wres; + + switch(t.func->rettype) { + case rt_d: + case rt_d2: + tresultr[0] = t.resultr[0]; + tresultr[1] = t.resultr[1]; + resultr[0] = d_res.i[dmsd]; resultr[1] = d_res.i[dlsd]; + wres = 2; + break; + case rt_i: + tresultr[0] = t.resultr[0]; + resultr[0] = intres; + wres = 1; + break; + case rt_s: + case rt_s2: + tresultr[0] = t.resultr[0]; + resultr[0] = s_res.i; + wres = 1; + break; + default: + puts("unhandled rettype in runtest"); + wres = 0; + } + if(t.resultc != rc_none) { + int err = 0; + switch(t.resultc) { + case rc_zero: + if(resultr[0] != 0 || resulti[0] != 0 || + (wres==2 && (resultr[1] != 0 || resulti[1] != 0))) { + err = 1; + } + break; + case rc_infinity: + if(wres==1) { + if(!((resultr[0]&0x7fffffff)==0x7f800000 || + (resulti[0]&0x7fffffff)==0x7f800000)) { + err = 1; + } + } else { + if(!(((resultr[0]&0x7fffffff)==0x7ff00000 && resultr[1]==0) || + ((resulti[0]&0x7fffffff)==0x7ff00000 && resulti[1]==0))) { + err = 1; + } + } + break; + case rc_nan: + if(wres==1) { + if(!((resultr[0]&0x7fffffff)>0x7f800000 || + (resulti[0]&0x7fffffff)>0x7f800000)) { + err = 1; + } + } else { + canon_dNaN(resultr); + canon_dNaN(resulti); + if(!(((resultr[0]&0x7fffffff)>0x7ff00000 && resultr[1]==1) || + ((resulti[0]&0x7fffffff)>0x7ff00000 && resulti[1]==1))) { + err = 1; + } + } + break; + case rc_finite: + if(wres==1) { + if(!((resultr[0]&0x7fffffff)<0x7f800000 || + (resulti[0]&0x7fffffff)<0x7f800000)) { + err = 1; + } + } else { + if(!((resultr[0]&0x7fffffff)<0x7ff00000 || + (resulti[0]&0x7fffffff)<0x7ff00000)) { + err = 1; + } + } + break; + default: + break; + } + if(err) { + print_error(t.func->rettype,resultr,"wrongresultr",&failp); + print_error(t.func->rettype,resulti,"wrongresulti",&failp); + } + } else if (t.nresult > wres) { + /* + * The test case data has provided the result to more + * than double precision. Instead of testing exact + * equality, we test against our maximum error + * tolerance. + */ + int rshift, ishift; + long long ulpsr, ulpsi, ulptolerance; + + tresultr[wres] = t.resultr[wres] << (32-EXTRABITS); + tresulti[wres] = t.resulti[wres] << (32-EXTRABITS); + if(strict) { + ulptolerance = 4096; /* one ulp */ + } else { + ulptolerance = t.func->tolerance; + } + rshift = ishift = 0; + if (ulptolerance & ABSLOWERBOUND) { + /* + * Hack for the lgamma functions, which have an + * error behaviour that can't conveniently be + * characterised in pure ULPs. Really, we want to + * say that the error in lgamma is "at most N ULPs, + * or at most an absolute error of X, whichever is + * larger", for appropriately chosen N,X. But since + * these two functions are the only cases where it + * arises, I haven't bothered to do it in a nice way + * in the function table above. + * + * (The difficult cases arise with negative input + * values such that |gamma(x)| is very near to 1; in + * this situation implementations tend to separately + * compute lgamma(|x|) and the log of the correction + * term from the Euler reflection formula, and + * subtract - which catastrophically loses + * significance.) + * + * As far as I can tell, nobody cares about this: + * GNU libm doesn't get those cases right either, + * and OpenCL explicitly doesn't state a ULP error + * limit for lgamma. So my guess is that this is + * simply considered acceptable error behaviour for + * this particular function, and hence I feel free + * to allow for it here. + */ + ulptolerance &= ~ABSLOWERBOUND; + if (t.op1r[0] & 0x80000000) { + if (t.func->rettype == rt_d) + rshift = 0x400 - ((tresultr[0] >> 20) & 0x7ff); + else if (t.func->rettype == rt_s) + rshift = 0x80 - ((tresultr[0] >> 23) & 0xff); + if (rshift < 0) + rshift = 0; + } + } + if (ulptolerance & PLUSMINUSPIO2) { + ulptolerance &= ~PLUSMINUSPIO2; + /* + * Hack for range reduction, which can reduce + * borderline cases in the wrong direction, i.e. + * return a value just outside one end of the interval + * [-pi/4,+pi/4] when it could have returned a value + * just inside the other end by subtracting an + * adjacent multiple of pi/2. + * + * We tolerate this, up to a point, because the + * trigonometric functions making use of the output of + * rred can cope and because making the range reducer + * do the exactly right thing in every case would be + * more expensive. + */ + if (wres == 1) { + /* Upper bound of overshoot derived in rredf.h */ + if ((resultr[0]&0x7FFFFFFF) <= 0x3f494b02 && + (resultr[0]&0x7FFFFFFF) > 0x3f490fda && + (resultr[0]&0x80000000) != (tresultr[0]&0x80000000)) { + unsigned long long val; + val = tresultr[0]; + val = (val << 32) | tresultr[1]; + /* + * Compute the alternative permitted result by + * subtracting from the sum of the extended + * single-precision bit patterns of +pi/4 and + * -pi/4. This is a horrible hack which only + * works because we can be confident that + * numbers in this range all have the same + * exponent! + */ + val = 0xfe921fb54442d184ULL - val; + tresultr[0] = val >> 32; + tresultr[1] = (val >> (32-EXTRABITS)) << (32-EXTRABITS); + /* + * Also, expect a correspondingly different + * value of res2 as a result of this change. + * The adjustment depends on whether we just + * flipped the result from + to - or vice + * versa. + */ + if (resultr[0] & 0x80000000) { + res2_adjust = +1; + } else { + res2_adjust = -1; + } + } + } + } + ulpsr = calc_error(resultr, tresultr, rshift, t.func->rettype); + if(is_complex_rettype(t.func->rettype)) { + ulpsi = calc_error(resulti, tresulti, ishift, t.func->rettype); + } else { + ulpsi = 0; + } + unsigned *rr = (ulpsr > ulptolerance || ulpsr < -ulptolerance) ? resultr : NULL; + unsigned *ri = (ulpsi > ulptolerance || ulpsi < -ulptolerance) ? resulti : NULL; +/* printf("tolerance=%i, ulpsr=%i, ulpsi=%i, rr=%p, ri=%p\n",ulptolerance,ulpsr,ulpsi,rr,ri); */ + if (rr || ri) { + if (quiet) failtext[0]='x'; + else { + print_error(t.func->rettype,rr,"wrongresultr",&failp); + print_error(t.func->rettype,ri,"wrongresulti",&failp); + print_ulps(t.func->rettype,rr ? ulpsr : 0, ri ? ulpsi : 0,&failp); + } + } + } else { + if(is_complex_rettype(t.func->rettype)) + /* + * Complex functions are not fully supported, + * this is unreachable, but prevents warnings. + */ + abort(); + /* + * The test case data has provided the result in + * exactly the output precision. Therefore we must + * complain about _any_ violation. + */ + switch(t.func->rettype) { + case rt_dc: + canon_dNaN(tresulti); + canon_dNaN(resulti); + if (fo) { + dnormzero(tresulti); + dnormzero(resulti); + } + /* deliberate fall-through */ + case rt_d: + canon_dNaN(tresultr); + canon_dNaN(resultr); + if (fo) { + dnormzero(tresultr); + dnormzero(resultr); + } + break; + case rt_sc: + canon_sNaN(tresulti); + canon_sNaN(resulti); + if (fo) { + snormzero(tresulti); + snormzero(resulti); + } + /* deliberate fall-through */ + case rt_s: + canon_sNaN(tresultr); + canon_sNaN(resultr); + if (fo) { + snormzero(tresultr); + snormzero(resultr); + } + break; + default: + break; + } + if(is_complex_rettype(t.func->rettype)) { + unsigned *rr, *ri; + if(resultr[0] != tresultr[0] || + (wres > 1 && resultr[1] != tresultr[1])) { + rr = resultr; + } else { + rr = NULL; + } + if(resulti[0] != tresulti[0] || + (wres > 1 && resulti[1] != tresulti[1])) { + ri = resulti; + } else { + ri = NULL; + } + if(rr || ri) { + if (quiet) failtext[0]='x'; + print_error(t.func->rettype,rr,"wrongresultr",&failp); + print_error(t.func->rettype,ri,"wrongresulti",&failp); + } + } else if (resultr[0] != tresultr[0] || + (wres > 1 && resultr[1] != tresultr[1])) { + if (quiet) failtext[0]='x'; + print_error(t.func->rettype,resultr,"wrongresult",&failp); + } + } + /* + * Now test res2, for those functions (frexp, modf, rred) + * which use it. + */ + if (t.func->func.ptr == &frexp || t.func->func.ptr == &frexpf || + t.func->macro_name == m_rred || t.func->macro_name == m_rredf) { + unsigned tres2 = t.res2[0]; + if (res2_adjust) { + /* Fix for range reduction, propagated from further up */ + tres2 = (tres2 + res2_adjust) & 3; + } + if (tres2 != intres) { + if (quiet) failtext[0]='x'; + else { + failp += sprintf(failp, + " wrongres2=%08x", intres); + } + } + } else if (t.func->func.ptr == &modf || t.func->func.ptr == &modff) { + tresultr[0] = t.res2[0]; + tresultr[1] = t.res2[1]; + if (is_double_rettype(t.func->rettype)) { + canon_dNaN(tresultr); + resultr[0] = d_res2.i[dmsd]; + resultr[1] = d_res2.i[dlsd]; + canon_dNaN(resultr); + if (fo) { + dnormzero(tresultr); + dnormzero(resultr); + } + } else { + canon_sNaN(tresultr); + resultr[0] = s_res2.i; + resultr[1] = s_res2.i; + canon_sNaN(resultr); + if (fo) { + snormzero(tresultr); + snormzero(resultr); + } + } + if (resultr[0] != tresultr[0] || + (wres > 1 && resultr[1] != tresultr[1])) { + if (quiet) failtext[0]='x'; + else { + if (is_double_rettype(t.func->rettype)) + failp += sprintf(failp, " wrongres2=%08x.%08x", + resultr[0], resultr[1]); + else + failp += sprintf(failp, " wrongres2=%08x", + resultr[0]); + } + } + } + } + + /* Check errno */ + err = (errno == EDOM ? e_EDOM : errno == ERANGE ? e_ERANGE : e_0); + if (err != t.err && err != t.maybeerr) { + if (quiet) failtext[0]='x'; + else { + failp += sprintf(failp, " wrongerrno=%s expecterrno=%s ", errnos[err], errnos[t.err]); + } + } + + return *failtext ? test_fail : test_pass; +} + +int passed, failed, declined; + +void runtests(char *name, FILE *fp) { + char testbuf[512], linebuf[512]; + int lineno = 1; + testdetail test; + + test.valid = 0; + + if (verbose) printf("runtests: %s\n", name); + while (fgets(testbuf, sizeof(testbuf), fp)) { + int res, print_errno; + testbuf[strcspn(testbuf, "\r\n")] = '\0'; + strcpy(linebuf, testbuf); + test = parsetest(testbuf, test); + print_errno = 0; + while (test.in_err < test.in_err_limit) { + res = runtest(test); + if (res == test_pass) { + if (verbose) + printf("%s:%d: pass\n", name, lineno); + ++passed; + } else if (res == test_decline) { + if (verbose) + printf("%s:%d: declined\n", name, lineno); + ++declined; + } else if (res == test_fail) { + if (!quiet) + printf("%s:%d: FAIL%s: %s%s%s%s\n", name, lineno, + test.random ? " (random)" : "", + linebuf, + print_errno ? " errno_in=" : "", + print_errno ? errnos[test.in_err] : "", + failtext); + ++failed; + } else if (res == test_invalid) { + printf("%s:%d: malformed: %s\n", name, lineno, linebuf); + ++failed; + } + test.in_err++; + print_errno = 1; + } + lineno++; + } +} + +int main(int ac, char **av) { + char **files; + int i, nfiles = 0; + dbl d; + +#ifdef MICROLIB + /* + * Invent argc and argv ourselves. + */ + char *argv[256]; + char args[256]; + { + int sargs[2]; + char *p; + + ac = 0; + + sargs[0]=(int)args; + sargs[1]=(int)sizeof(args); + if (!__semihost(0x15, sargs)) { + args[sizeof(args)-1] = '\0'; /* just in case */ + p = args; + while (1) { + while (*p == ' ' || *p == '\t') p++; + if (!*p) break; + argv[ac++] = p; + while (*p && *p != ' ' && *p != '\t') p++; + if (*p) *p++ = '\0'; + } + } + + av = argv; + } +#endif + + /* Sort tfuncs */ + qsort(tfuncs, sizeof(tfuncs)/sizeof(test_func), sizeof(test_func), &compare_tfuncs); + + /* + * Autodetect the `double' endianness. + */ + dmsd = 0; + d.f = 1.0; /* 0x3ff00000 / 0x00000000 */ + if (d.i[dmsd] == 0) { + dmsd = 1; + } + /* + * Now dmsd denotes what the compiler thinks we're at. Let's + * check that it agrees with what the runtime thinks. + */ + d.i[0] = d.i[1] = 0x11111111;/* a random +ve number */ + d.f /= d.f; /* must now be one */ + if (d.i[dmsd] == 0) { + fprintf(stderr, "YIKES! Compiler and runtime disagree on endianness" + " of `double'. Bailing out\n"); + return 1; + } + dlsd = !dmsd; + + /* default is terse */ + verbose = 0; + fo = 0; + strict = 0; + + files = (char **)malloc((ac+1) * sizeof(char *)); + if (!files) { + fprintf(stderr, "initial malloc failed!\n"); + return 1; + } +#ifdef NOCMDLINE + files[nfiles++] = "testfile"; +#endif + + while (--ac) { + char *p = *++av; + if (*p == '-') { + static char *options[] = { + "-fo", +#if 0 + "-noinexact", + "-noround", +#endif + "-nostatus", + "-quiet", + "-strict", + "-v", + "-verbose", + }; + enum { + op_fo, +#if 0 + op_noinexact, + op_noround, +#endif + op_nostatus, + op_quiet, + op_strict, + op_v, + op_verbose, + }; + switch (find(p, options, sizeof(options))) { + case op_quiet: + quiet = 1; + break; +#if 0 + case op_noinexact: + statusmask &= 0x0F; /* remove bit 4 */ + break; + case op_noround: + doround = 0; + break; +#endif + case op_nostatus: /* no status word => noinx,noround */ + statusmask = 0; + doround = 0; + break; + case op_v: + case op_verbose: + verbose = 1; + break; + case op_fo: + fo = 1; + break; + case op_strict: /* tolerance is 1 ulp */ + strict = 1; + break; + default: + fprintf(stderr, "unrecognised option: %s\n", p); + break; + } + } else { + files[nfiles++] = p; + } + } + + passed = failed = declined = 0; + + if (nfiles) { + for (i = 0; i < nfiles; i++) { + FILE *fp = fopen(files[i], "r"); + if (!fp) { + fprintf(stderr, "Couldn't open %s\n", files[i]); + } else + runtests(files[i], fp); + } + } else + runtests("(stdin)", stdin); + + printf("Completed. Passed %d, failed %d (total %d", + passed, failed, passed+failed); + if (declined) + printf(" plus %d declined", declined); + printf(")\n"); + if (failed || passed == 0) + return 1; + printf("** TEST PASSED OK **\n"); + return 0; +} + +void undef_func() { + failed++; + puts("ERROR: undefined function called"); +} diff --git a/libc/AOR_v20.02/math/test/rtest/dotest.c b/libc/AOR_v20.02/math/test/rtest/dotest.c new file mode 100644 index 00000000000000..43278626e75e8d --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/dotest.c @@ -0,0 +1,2168 @@ +/* + * dotest.c - actually generate mathlib test cases + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include +#include + +#include "semi.h" +#include "intern.h" +#include "random.h" + +#define MPFR_PREC 96 /* good enough for float or double + a few extra bits */ + +extern int lib_fo, lib_no_arith, ntests; + +/* + * Prototypes. + */ +static void cases_biased(uint32 *, uint32, uint32); +static void cases_biased_positive(uint32 *, uint32, uint32); +static void cases_biased_float(uint32 *, uint32, uint32); +static void cases_uniform(uint32 *, uint32, uint32); +static void cases_uniform_positive(uint32 *, uint32, uint32); +static void cases_uniform_float(uint32 *, uint32, uint32); +static void cases_uniform_float_positive(uint32 *, uint32, uint32); +static void log_cases(uint32 *, uint32, uint32); +static void log_cases_float(uint32 *, uint32, uint32); +static void log1p_cases(uint32 *, uint32, uint32); +static void log1p_cases_float(uint32 *, uint32, uint32); +static void minmax_cases(uint32 *, uint32, uint32); +static void minmax_cases_float(uint32 *, uint32, uint32); +static void atan2_cases(uint32 *, uint32, uint32); +static void atan2_cases_float(uint32 *, uint32, uint32); +static void pow_cases(uint32 *, uint32, uint32); +static void pow_cases_float(uint32 *, uint32, uint32); +static void rred_cases(uint32 *, uint32, uint32); +static void rred_cases_float(uint32 *, uint32, uint32); +static void cases_semi1(uint32 *, uint32, uint32); +static void cases_semi1_float(uint32 *, uint32, uint32); +static void cases_semi2(uint32 *, uint32, uint32); +static void cases_semi2_float(uint32 *, uint32, uint32); +static void cases_ldexp(uint32 *, uint32, uint32); +static void cases_ldexp_float(uint32 *, uint32, uint32); + +static void complex_cases_uniform(uint32 *, uint32, uint32); +static void complex_cases_uniform_float(uint32 *, uint32, uint32); +static void complex_cases_biased(uint32 *, uint32, uint32); +static void complex_cases_biased_float(uint32 *, uint32, uint32); +static void complex_log_cases(uint32 *, uint32, uint32); +static void complex_log_cases_float(uint32 *, uint32, uint32); +static void complex_pow_cases(uint32 *, uint32, uint32); +static void complex_pow_cases_float(uint32 *, uint32, uint32); +static void complex_arithmetic_cases(uint32 *, uint32, uint32); +static void complex_arithmetic_cases_float(uint32 *, uint32, uint32); + +static uint32 doubletop(int x, int scale); +static uint32 floatval(int x, int scale); + +/* + * Convert back and forth between IEEE bit patterns and the + * mpfr_t/mpc_t types. + */ +static void set_mpfr_d(mpfr_t x, uint32 h, uint32 l) +{ + uint64_t hl = ((uint64_t)h << 32) | l; + uint32 exp = (hl >> 52) & 0x7ff; + int64_t mantissa = hl & (((uint64_t)1 << 52) - 1); + int sign = (hl >> 63) ? -1 : +1; + if (exp == 0x7ff) { + if (mantissa == 0) + mpfr_set_inf(x, sign); + else + mpfr_set_nan(x); + } else if (exp == 0 && mantissa == 0) { + mpfr_set_ui(x, 0, GMP_RNDN); + mpfr_setsign(x, x, sign < 0, GMP_RNDN); + } else { + if (exp != 0) + mantissa |= ((uint64_t)1 << 52); + else + exp++; + mpfr_set_sj_2exp(x, mantissa * sign, (int)exp - 0x3ff - 52, GMP_RNDN); + } +} +static void set_mpfr_f(mpfr_t x, uint32 f) +{ + uint32 exp = (f >> 23) & 0xff; + int32 mantissa = f & ((1 << 23) - 1); + int sign = (f >> 31) ? -1 : +1; + if (exp == 0xff) { + if (mantissa == 0) + mpfr_set_inf(x, sign); + else + mpfr_set_nan(x); + } else if (exp == 0 && mantissa == 0) { + mpfr_set_ui(x, 0, GMP_RNDN); + mpfr_setsign(x, x, sign < 0, GMP_RNDN); + } else { + if (exp != 0) + mantissa |= (1 << 23); + else + exp++; + mpfr_set_sj_2exp(x, mantissa * sign, (int)exp - 0x7f - 23, GMP_RNDN); + } +} +static void set_mpc_d(mpc_t z, uint32 rh, uint32 rl, uint32 ih, uint32 il) +{ + mpfr_t x, y; + mpfr_init2(x, MPFR_PREC); + mpfr_init2(y, MPFR_PREC); + set_mpfr_d(x, rh, rl); + set_mpfr_d(y, ih, il); + mpc_set_fr_fr(z, x, y, MPC_RNDNN); + mpfr_clear(x); + mpfr_clear(y); +} +static void set_mpc_f(mpc_t z, uint32 r, uint32 i) +{ + mpfr_t x, y; + mpfr_init2(x, MPFR_PREC); + mpfr_init2(y, MPFR_PREC); + set_mpfr_f(x, r); + set_mpfr_f(y, i); + mpc_set_fr_fr(z, x, y, MPC_RNDNN); + mpfr_clear(x); + mpfr_clear(y); +} +static void get_mpfr_d(const mpfr_t x, uint32 *h, uint32 *l, uint32 *extra) +{ + uint32_t sign, expfield, mantfield; + mpfr_t significand; + int exp; + + if (mpfr_nan_p(x)) { + *h = 0x7ff80000; + *l = 0; + *extra = 0; + return; + } + + sign = mpfr_signbit(x) ? 0x80000000U : 0; + + if (mpfr_inf_p(x)) { + *h = 0x7ff00000 | sign; + *l = 0; + *extra = 0; + return; + } + + if (mpfr_zero_p(x)) { + *h = 0x00000000 | sign; + *l = 0; + *extra = 0; + return; + } + + mpfr_init2(significand, MPFR_PREC); + mpfr_set(significand, x, GMP_RNDN); + exp = mpfr_get_exp(significand); + mpfr_set_exp(significand, 0); + + /* Now significand is in [1/2,1), and significand * 2^exp == x. + * So the IEEE exponent corresponding to exp==0 is 0x3fe. */ + if (exp > 0x400) { + /* overflow to infinity anyway */ + *h = 0x7ff00000 | sign; + *l = 0; + *extra = 0; + mpfr_clear(significand); + return; + } + + if (exp <= -0x3fe || mpfr_zero_p(x)) + exp = -0x3fd; /* denormalise */ + expfield = exp + 0x3fd; /* offset to cancel leading mantissa bit */ + + mpfr_div_2si(significand, x, exp - 21, GMP_RNDN); + mpfr_abs(significand, significand, GMP_RNDN); + mantfield = mpfr_get_ui(significand, GMP_RNDZ); + *h = sign + ((uint64_t)expfield << 20) + mantfield; + mpfr_sub_ui(significand, significand, mantfield, GMP_RNDN); + mpfr_mul_2ui(significand, significand, 32, GMP_RNDN); + mantfield = mpfr_get_ui(significand, GMP_RNDZ); + *l = mantfield; + mpfr_sub_ui(significand, significand, mantfield, GMP_RNDN); + mpfr_mul_2ui(significand, significand, 32, GMP_RNDN); + mantfield = mpfr_get_ui(significand, GMP_RNDZ); + *extra = mantfield; + + mpfr_clear(significand); +} +static void get_mpfr_f(const mpfr_t x, uint32 *f, uint32 *extra) +{ + uint32_t sign, expfield, mantfield; + mpfr_t significand; + int exp; + + if (mpfr_nan_p(x)) { + *f = 0x7fc00000; + *extra = 0; + return; + } + + sign = mpfr_signbit(x) ? 0x80000000U : 0; + + if (mpfr_inf_p(x)) { + *f = 0x7f800000 | sign; + *extra = 0; + return; + } + + if (mpfr_zero_p(x)) { + *f = 0x00000000 | sign; + *extra = 0; + return; + } + + mpfr_init2(significand, MPFR_PREC); + mpfr_set(significand, x, GMP_RNDN); + exp = mpfr_get_exp(significand); + mpfr_set_exp(significand, 0); + + /* Now significand is in [1/2,1), and significand * 2^exp == x. + * So the IEEE exponent corresponding to exp==0 is 0x7e. */ + if (exp > 0x80) { + /* overflow to infinity anyway */ + *f = 0x7f800000 | sign; + *extra = 0; + mpfr_clear(significand); + return; + } + + if (exp <= -0x7e || mpfr_zero_p(x)) + exp = -0x7d; /* denormalise */ + expfield = exp + 0x7d; /* offset to cancel leading mantissa bit */ + + mpfr_div_2si(significand, x, exp - 24, GMP_RNDN); + mpfr_abs(significand, significand, GMP_RNDN); + mantfield = mpfr_get_ui(significand, GMP_RNDZ); + *f = sign + ((uint64_t)expfield << 23) + mantfield; + mpfr_sub_ui(significand, significand, mantfield, GMP_RNDN); + mpfr_mul_2ui(significand, significand, 32, GMP_RNDN); + mantfield = mpfr_get_ui(significand, GMP_RNDZ); + *extra = mantfield; + + mpfr_clear(significand); +} +static void get_mpc_d(const mpc_t z, + uint32 *rh, uint32 *rl, uint32 *rextra, + uint32 *ih, uint32 *il, uint32 *iextra) +{ + mpfr_t x, y; + mpfr_init2(x, MPFR_PREC); + mpfr_init2(y, MPFR_PREC); + mpc_real(x, z, GMP_RNDN); + mpc_imag(y, z, GMP_RNDN); + get_mpfr_d(x, rh, rl, rextra); + get_mpfr_d(y, ih, il, iextra); + mpfr_clear(x); + mpfr_clear(y); +} +static void get_mpc_f(const mpc_t z, + uint32 *r, uint32 *rextra, + uint32 *i, uint32 *iextra) +{ + mpfr_t x, y; + mpfr_init2(x, MPFR_PREC); + mpfr_init2(y, MPFR_PREC); + mpc_real(x, z, GMP_RNDN); + mpc_imag(y, z, GMP_RNDN); + get_mpfr_f(x, r, rextra); + get_mpfr_f(y, i, iextra); + mpfr_clear(x); + mpfr_clear(y); +} + +/* + * Implementation of mathlib functions that aren't trivially + * implementable using an existing mpfr or mpc function. + */ +int test_rred(mpfr_t ret, const mpfr_t x, int *quadrant) +{ + mpfr_t halfpi; + long quo; + int status; + + /* + * In the worst case of range reduction, we get an input of size + * around 2^1024, and must find its remainder mod pi, which means + * we need 1024 bits of pi at least. Plus, the remainder might + * happen to come out very very small if we're unlucky. How + * unlucky can we be? Well, conveniently, I once went through and + * actually worked that out using Paxson's modular minimisation + * algorithm, and it turns out that the smallest exponent you can + * get out of a nontrivial[1] double precision range reduction is + * 0x3c2, i.e. of the order of 2^-61. So we need 1024 bits of pi + * to get us down to the units digit, another 61 or so bits (say + * 64) to get down to the highest set bit of the output, and then + * some bits to make the actual mantissa big enough. + * + * [1] of course the output of range reduction can have an + * arbitrarily small exponent in the trivial case, where the + * input is so small that it's the identity function. That + * doesn't count. + */ + mpfr_init2(halfpi, MPFR_PREC + 1024 + 64); + mpfr_const_pi(halfpi, GMP_RNDN); + mpfr_div_ui(halfpi, halfpi, 2, GMP_RNDN); + + status = mpfr_remquo(ret, &quo, x, halfpi, GMP_RNDN); + *quadrant = quo & 3; + + mpfr_clear(halfpi); + + return status; +} +int test_lgamma(mpfr_t ret, const mpfr_t x, mpfr_rnd_t rnd) +{ + /* + * mpfr_lgamma takes an extra int * parameter to hold the output + * sign. We don't bother testing that, so this wrapper throws away + * the sign and hence fits into the same function prototype as all + * the other real->real mpfr functions. + * + * There is also mpfr_lngamma which has no sign output and hence + * has the right prototype already, but unfortunately it returns + * NaN in cases where gamma(x) < 0, so it's no use to us. + */ + int sign; + return mpfr_lgamma(ret, &sign, x, rnd); +} +int test_cpow(mpc_t ret, const mpc_t x, const mpc_t y, mpc_rnd_t rnd) +{ + /* + * For complex pow, we must bump up the precision by a huge amount + * if we want it to get the really difficult cases right. (Not + * that we expect the library under test to be getting those cases + * right itself, but we'd at least like the test suite to report + * them as wrong for the _right reason_.) + * + * This works around a bug in mpc_pow(), fixed by r1455 in the MPC + * svn repository (2014-10-14) and expected to be in any MPC + * release after 1.0.2 (which was the latest release already made + * at the time of the fix). So as and when we update to an MPC + * with the fix in it, we could remove this workaround. + * + * For the reasons for choosing this amount of extra precision, + * see analysis in complex/cpownotes.txt for the rationale for the + * amount. + */ + mpc_t xbig, ybig, retbig; + int status; + + mpc_init2(xbig, 1034 + 53 + 60 + MPFR_PREC); + mpc_init2(ybig, 1034 + 53 + 60 + MPFR_PREC); + mpc_init2(retbig, 1034 + 53 + 60 + MPFR_PREC); + + mpc_set(xbig, x, MPC_RNDNN); + mpc_set(ybig, y, MPC_RNDNN); + status = mpc_pow(retbig, xbig, ybig, rnd); + mpc_set(ret, retbig, rnd); + + mpc_clear(xbig); + mpc_clear(ybig); + mpc_clear(retbig); + + return status; +} + +/* + * Identify 'hard' values (NaN, Inf, nonzero denormal) for deciding + * whether microlib will decline to run a test. + */ +#define is_shard(in) ( \ + (((in)[0] & 0x7F800000) == 0x7F800000 || \ + (((in)[0] & 0x7F800000) == 0 && ((in)[0]&0x7FFFFFFF) != 0))) + +#define is_dhard(in) ( \ + (((in)[0] & 0x7FF00000) == 0x7FF00000 || \ + (((in)[0] & 0x7FF00000) == 0 && (((in)[0] & 0xFFFFF) | (in)[1]) != 0))) + +/* + * Identify integers. + */ +int is_dinteger(uint32 *in) +{ + uint32 out[3]; + if ((0x7FF00000 & ~in[0]) == 0) + return 0; /* not finite, hence not integer */ + test_ceil(in, out); + return in[0] == out[0] && in[1] == out[1]; +} +int is_sinteger(uint32 *in) +{ + uint32 out[3]; + if ((0x7F800000 & ~in[0]) == 0) + return 0; /* not finite, hence not integer */ + test_ceilf(in, out); + return in[0] == out[0]; +} + +/* + * Identify signalling NaNs. + */ +int is_dsnan(const uint32 *in) +{ + if ((in[0] & 0x7FF00000) != 0x7FF00000) + return 0; /* not the inf/nan exponent */ + if ((in[0] << 12) == 0 && in[1] == 0) + return 0; /* inf */ + if (in[0] & 0x00080000) + return 0; /* qnan */ + return 1; +} +int is_ssnan(const uint32 *in) +{ + if ((in[0] & 0x7F800000) != 0x7F800000) + return 0; /* not the inf/nan exponent */ + if ((in[0] << 9) == 0) + return 0; /* inf */ + if (in[0] & 0x00400000) + return 0; /* qnan */ + return 1; +} +int is_snan(const uint32 *in, int size) +{ + return size == 2 ? is_dsnan(in) : is_ssnan(in); +} + +/* + * Wrapper functions called to fix up unusual results after the main + * test function has run. + */ +void universal_wrapper(wrapperctx *ctx) +{ + /* + * Any SNaN input gives rise to a QNaN output. + */ + int op; + for (op = 0; op < wrapper_get_nops(ctx); op++) { + int size = wrapper_get_size(ctx, op); + + if (!wrapper_is_complex(ctx, op) && + is_snan(wrapper_get_ieee(ctx, op), size)) { + wrapper_set_nan(ctx); + } + } +} + +Testable functions[] = { + /* + * Trig functions: sin, cos, tan. We test the core function + * between -16 and +16: we assume that range reduction exists + * and will be used for larger arguments, and we'll test that + * separately. Also we only go down to 2^-27 in magnitude, + * because below that sin(x)=tan(x)=x and cos(x)=1 as far as + * double precision can tell, which is boring. + */ + {"sin", (funcptr)mpfr_sin, args1, {NULL}, + cases_uniform, 0x3e400000, 0x40300000}, + {"sinf", (funcptr)mpfr_sin, args1f, {NULL}, + cases_uniform_float, 0x39800000, 0x41800000}, + {"cos", (funcptr)mpfr_cos, args1, {NULL}, + cases_uniform, 0x3e400000, 0x40300000}, + {"cosf", (funcptr)mpfr_cos, args1f, {NULL}, + cases_uniform_float, 0x39800000, 0x41800000}, + {"tan", (funcptr)mpfr_tan, args1, {NULL}, + cases_uniform, 0x3e400000, 0x40300000}, + {"tanf", (funcptr)mpfr_tan, args1f, {NULL}, + cases_uniform_float, 0x39800000, 0x41800000}, + {"sincosf_sinf", (funcptr)mpfr_sin, args1f, {NULL}, + cases_uniform_float, 0x39800000, 0x41800000}, + {"sincosf_cosf", (funcptr)mpfr_cos, args1f, {NULL}, + cases_uniform_float, 0x39800000, 0x41800000}, + /* + * Inverse trig: asin, acos. Between 1 and -1, of course. acos + * goes down to 2^-54, asin to 2^-27. + */ + {"asin", (funcptr)mpfr_asin, args1, {NULL}, + cases_uniform, 0x3e400000, 0x3fefffff}, + {"asinf", (funcptr)mpfr_asin, args1f, {NULL}, + cases_uniform_float, 0x39800000, 0x3f7fffff}, + {"acos", (funcptr)mpfr_acos, args1, {NULL}, + cases_uniform, 0x3c900000, 0x3fefffff}, + {"acosf", (funcptr)mpfr_acos, args1f, {NULL}, + cases_uniform_float, 0x33800000, 0x3f7fffff}, + /* + * Inverse trig: atan. atan is stable (in double prec) with + * argument magnitude past 2^53, so we'll test up to there. + * atan(x) is boringly just x below 2^-27. + */ + {"atan", (funcptr)mpfr_atan, args1, {NULL}, + cases_uniform, 0x3e400000, 0x43400000}, + {"atanf", (funcptr)mpfr_atan, args1f, {NULL}, + cases_uniform_float, 0x39800000, 0x4b800000}, + /* + * atan2. Interesting cases arise when the exponents of the + * arguments differ by at most about 50. + */ + {"atan2", (funcptr)mpfr_atan2, args2, {NULL}, + atan2_cases, 0}, + {"atan2f", (funcptr)mpfr_atan2, args2f, {NULL}, + atan2_cases_float, 0}, + /* + * The exponentials: exp, sinh, cosh. They overflow at around + * 710. exp and sinh are boring below 2^-54, cosh below 2^-27. + */ + {"exp", (funcptr)mpfr_exp, args1, {NULL}, + cases_uniform, 0x3c900000, 0x40878000}, + {"expf", (funcptr)mpfr_exp, args1f, {NULL}, + cases_uniform_float, 0x33800000, 0x42dc0000}, + {"sinh", (funcptr)mpfr_sinh, args1, {NULL}, + cases_uniform, 0x3c900000, 0x40878000}, + {"sinhf", (funcptr)mpfr_sinh, args1f, {NULL}, + cases_uniform_float, 0x33800000, 0x42dc0000}, + {"cosh", (funcptr)mpfr_cosh, args1, {NULL}, + cases_uniform, 0x3e400000, 0x40878000}, + {"coshf", (funcptr)mpfr_cosh, args1f, {NULL}, + cases_uniform_float, 0x39800000, 0x42dc0000}, + /* + * tanh is stable past around 20. It's boring below 2^-27. + */ + {"tanh", (funcptr)mpfr_tanh, args1, {NULL}, + cases_uniform, 0x3e400000, 0x40340000}, + {"tanhf", (funcptr)mpfr_tanh, args1f, {NULL}, + cases_uniform, 0x39800000, 0x41100000}, + /* + * log must be tested only on positive numbers, but can cover + * the whole range of positive nonzero finite numbers. It never + * gets boring. + */ + {"log", (funcptr)mpfr_log, args1, {NULL}, log_cases, 0}, + {"logf", (funcptr)mpfr_log, args1f, {NULL}, log_cases_float, 0}, + {"log10", (funcptr)mpfr_log10, args1, {NULL}, log_cases, 0}, + {"log10f", (funcptr)mpfr_log10, args1f, {NULL}, log_cases_float, 0}, + /* + * pow. + */ + {"pow", (funcptr)mpfr_pow, args2, {NULL}, pow_cases, 0}, + {"powf", (funcptr)mpfr_pow, args2f, {NULL}, pow_cases_float, 0}, + /* + * Trig range reduction. We are able to test this for all + * finite values, but will only bother for things between 2^-3 + * and 2^+52. + */ + {"rred", (funcptr)test_rred, rred, {NULL}, rred_cases, 0}, + {"rredf", (funcptr)test_rred, rredf, {NULL}, rred_cases_float, 0}, + /* + * Square and cube root. + */ + {"sqrt", (funcptr)mpfr_sqrt, args1, {NULL}, log_cases, 0}, + {"sqrtf", (funcptr)mpfr_sqrt, args1f, {NULL}, log_cases_float, 0}, + {"cbrt", (funcptr)mpfr_cbrt, args1, {NULL}, log_cases, 0}, + {"cbrtf", (funcptr)mpfr_cbrt, args1f, {NULL}, log_cases_float, 0}, + {"hypot", (funcptr)mpfr_hypot, args2, {NULL}, atan2_cases, 0}, + {"hypotf", (funcptr)mpfr_hypot, args2f, {NULL}, atan2_cases_float, 0}, + /* + * Seminumerical functions. + */ + {"ceil", (funcptr)test_ceil, semi1, {NULL}, cases_semi1}, + {"ceilf", (funcptr)test_ceilf, semi1f, {NULL}, cases_semi1_float}, + {"floor", (funcptr)test_floor, semi1, {NULL}, cases_semi1}, + {"floorf", (funcptr)test_floorf, semi1f, {NULL}, cases_semi1_float}, + {"fmod", (funcptr)test_fmod, semi2, {NULL}, cases_semi2}, + {"fmodf", (funcptr)test_fmodf, semi2f, {NULL}, cases_semi2_float}, + {"ldexp", (funcptr)test_ldexp, t_ldexp, {NULL}, cases_ldexp}, + {"ldexpf", (funcptr)test_ldexpf, t_ldexpf, {NULL}, cases_ldexp_float}, + {"frexp", (funcptr)test_frexp, t_frexp, {NULL}, cases_semi1}, + {"frexpf", (funcptr)test_frexpf, t_frexpf, {NULL}, cases_semi1_float}, + {"modf", (funcptr)test_modf, t_modf, {NULL}, cases_semi1}, + {"modff", (funcptr)test_modff, t_modff, {NULL}, cases_semi1_float}, + + /* + * Classification and more semi-numericals + */ + {"copysign", (funcptr)test_copysign, semi2, {NULL}, cases_semi2}, + {"copysignf", (funcptr)test_copysignf, semi2f, {NULL}, cases_semi2_float}, + {"isfinite", (funcptr)test_isfinite, classify, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"isfinitef", (funcptr)test_isfinitef, classifyf, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"isinf", (funcptr)test_isinf, classify, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"isinff", (funcptr)test_isinff, classifyf, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"isnan", (funcptr)test_isnan, classify, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"isnanf", (funcptr)test_isnanf, classifyf, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"isnormal", (funcptr)test_isnormal, classify, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"isnormalf", (funcptr)test_isnormalf, classifyf, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"signbit", (funcptr)test_signbit, classify, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"signbitf", (funcptr)test_signbitf, classifyf, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"fpclassify", (funcptr)test_fpclassify, classify, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"fpclassifyf", (funcptr)test_fpclassifyf, classifyf, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + /* + * Comparisons + */ + {"isgreater", (funcptr)test_isgreater, compare, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"isgreaterequal", (funcptr)test_isgreaterequal, compare, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"isless", (funcptr)test_isless, compare, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"islessequal", (funcptr)test_islessequal, compare, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"islessgreater", (funcptr)test_islessgreater, compare, {NULL}, cases_uniform, 0, 0x7fffffff}, + {"isunordered", (funcptr)test_isunordered, compare, {NULL}, cases_uniform, 0, 0x7fffffff}, + + {"isgreaterf", (funcptr)test_isgreaterf, comparef, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"isgreaterequalf", (funcptr)test_isgreaterequalf, comparef, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"islessf", (funcptr)test_islessf, comparef, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"islessequalf", (funcptr)test_islessequalf, comparef, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"islessgreaterf", (funcptr)test_islessgreaterf, comparef, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + {"isunorderedf", (funcptr)test_isunorderedf, comparef, {NULL}, cases_uniform_float, 0, 0x7fffffff}, + + /* + * Inverse Hyperbolic functions + */ + {"atanh", (funcptr)mpfr_atanh, args1, {NULL}, cases_uniform, 0x3e400000, 0x3fefffff}, + {"asinh", (funcptr)mpfr_asinh, args1, {NULL}, cases_uniform, 0x3e400000, 0x3fefffff}, + {"acosh", (funcptr)mpfr_acosh, args1, {NULL}, cases_uniform_positive, 0x3ff00000, 0x7fefffff}, + + {"atanhf", (funcptr)mpfr_atanh, args1f, {NULL}, cases_uniform_float, 0x32000000, 0x3f7fffff}, + {"asinhf", (funcptr)mpfr_asinh, args1f, {NULL}, cases_uniform_float, 0x32000000, 0x3f7fffff}, + {"acoshf", (funcptr)mpfr_acosh, args1f, {NULL}, cases_uniform_float_positive, 0x3f800000, 0x7f800000}, + + /* + * Everything else (sitting in a section down here at the bottom + * because historically they were not tested because we didn't + * have reference implementations for them) + */ + {"csin", (funcptr)mpc_sin, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"csinf", (funcptr)mpc_sin, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + {"ccos", (funcptr)mpc_cos, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"ccosf", (funcptr)mpc_cos, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + {"ctan", (funcptr)mpc_tan, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"ctanf", (funcptr)mpc_tan, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + + {"casin", (funcptr)mpc_asin, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"casinf", (funcptr)mpc_asin, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + {"cacos", (funcptr)mpc_acos, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"cacosf", (funcptr)mpc_acos, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + {"catan", (funcptr)mpc_atan, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"catanf", (funcptr)mpc_atan, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + + {"csinh", (funcptr)mpc_sinh, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"csinhf", (funcptr)mpc_sinh, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + {"ccosh", (funcptr)mpc_cosh, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"ccoshf", (funcptr)mpc_cosh, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + {"ctanh", (funcptr)mpc_tanh, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"ctanhf", (funcptr)mpc_tanh, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + + {"casinh", (funcptr)mpc_asinh, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"casinhf", (funcptr)mpc_asinh, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + {"cacosh", (funcptr)mpc_acosh, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"cacoshf", (funcptr)mpc_acosh, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + {"catanh", (funcptr)mpc_atanh, args1c, {NULL}, complex_cases_uniform, 0x3f000000, 0x40300000}, + {"catanhf", (funcptr)mpc_atanh, args1fc, {NULL}, complex_cases_uniform_float, 0x38000000, 0x41800000}, + + {"cexp", (funcptr)mpc_exp, args1c, {NULL}, complex_cases_uniform, 0x3c900000, 0x40862000}, + {"cpow", (funcptr)test_cpow, args2c, {NULL}, complex_pow_cases, 0x3fc00000, 0x40000000}, + {"clog", (funcptr)mpc_log, args1c, {NULL}, complex_log_cases, 0, 0}, + {"csqrt", (funcptr)mpc_sqrt, args1c, {NULL}, complex_log_cases, 0, 0}, + + {"cexpf", (funcptr)mpc_exp, args1fc, {NULL}, complex_cases_uniform_float, 0x24800000, 0x42b00000}, + {"cpowf", (funcptr)test_cpow, args2fc, {NULL}, complex_pow_cases_float, 0x3e000000, 0x41000000}, + {"clogf", (funcptr)mpc_log, args1fc, {NULL}, complex_log_cases_float, 0, 0}, + {"csqrtf", (funcptr)mpc_sqrt, args1fc, {NULL}, complex_log_cases_float, 0, 0}, + + {"cdiv", (funcptr)mpc_div, args2c, {NULL}, complex_arithmetic_cases, 0, 0}, + {"cmul", (funcptr)mpc_mul, args2c, {NULL}, complex_arithmetic_cases, 0, 0}, + {"cadd", (funcptr)mpc_add, args2c, {NULL}, complex_arithmetic_cases, 0, 0}, + {"csub", (funcptr)mpc_sub, args2c, {NULL}, complex_arithmetic_cases, 0, 0}, + + {"cdivf", (funcptr)mpc_div, args2fc, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"cmulf", (funcptr)mpc_mul, args2fc, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"caddf", (funcptr)mpc_add, args2fc, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"csubf", (funcptr)mpc_sub, args2fc, {NULL}, complex_arithmetic_cases_float, 0, 0}, + + {"cabsf", (funcptr)mpc_abs, args1fcr, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"cabs", (funcptr)mpc_abs, args1cr, {NULL}, complex_arithmetic_cases, 0, 0}, + {"cargf", (funcptr)mpc_arg, args1fcr, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"carg", (funcptr)mpc_arg, args1cr, {NULL}, complex_arithmetic_cases, 0, 0}, + {"cimagf", (funcptr)mpc_imag, args1fcr, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"cimag", (funcptr)mpc_imag, args1cr, {NULL}, complex_arithmetic_cases, 0, 0}, + {"conjf", (funcptr)mpc_conj, args1fc, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"conj", (funcptr)mpc_conj, args1c, {NULL}, complex_arithmetic_cases, 0, 0}, + {"cprojf", (funcptr)mpc_proj, args1fc, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"cproj", (funcptr)mpc_proj, args1c, {NULL}, complex_arithmetic_cases, 0, 0}, + {"crealf", (funcptr)mpc_real, args1fcr, {NULL}, complex_arithmetic_cases_float, 0, 0}, + {"creal", (funcptr)mpc_real, args1cr, {NULL}, complex_arithmetic_cases, 0, 0}, + {"erfcf", (funcptr)mpfr_erfc, args1f, {NULL}, cases_biased_float, 0x1e800000, 0x41000000}, + {"erfc", (funcptr)mpfr_erfc, args1, {NULL}, cases_biased, 0x3bd00000, 0x403c0000}, + {"erff", (funcptr)mpfr_erf, args1f, {NULL}, cases_biased_float, 0x03800000, 0x40700000}, + {"erf", (funcptr)mpfr_erf, args1, {NULL}, cases_biased, 0x00800000, 0x40200000}, + {"exp2f", (funcptr)mpfr_exp2, args1f, {NULL}, cases_uniform_float, 0x33800000, 0x43c00000}, + {"exp2", (funcptr)mpfr_exp2, args1, {NULL}, cases_uniform, 0x3ca00000, 0x40a00000}, + {"expm1f", (funcptr)mpfr_expm1, args1f, {NULL}, cases_uniform_float, 0x33000000, 0x43800000}, + {"expm1", (funcptr)mpfr_expm1, args1, {NULL}, cases_uniform, 0x3c900000, 0x409c0000}, + {"fmaxf", (funcptr)mpfr_max, args2f, {NULL}, minmax_cases_float, 0, 0x7f7fffff}, + {"fmax", (funcptr)mpfr_max, args2, {NULL}, minmax_cases, 0, 0x7fefffff}, + {"fminf", (funcptr)mpfr_min, args2f, {NULL}, minmax_cases_float, 0, 0x7f7fffff}, + {"fmin", (funcptr)mpfr_min, args2, {NULL}, minmax_cases, 0, 0x7fefffff}, + {"lgammaf", (funcptr)test_lgamma, args1f, {NULL}, cases_uniform_float, 0x01800000, 0x7f800000}, + {"lgamma", (funcptr)test_lgamma, args1, {NULL}, cases_uniform, 0x00100000, 0x7ff00000}, + {"log1pf", (funcptr)mpfr_log1p, args1f, {NULL}, log1p_cases_float, 0, 0}, + {"log1p", (funcptr)mpfr_log1p, args1, {NULL}, log1p_cases, 0, 0}, + {"log2f", (funcptr)mpfr_log2, args1f, {NULL}, log_cases_float, 0, 0}, + {"log2", (funcptr)mpfr_log2, args1, {NULL}, log_cases, 0, 0}, + {"tgammaf", (funcptr)mpfr_gamma, args1f, {NULL}, cases_uniform_float, 0x2f800000, 0x43000000}, + {"tgamma", (funcptr)mpfr_gamma, args1, {NULL}, cases_uniform, 0x3c000000, 0x40800000}, +}; + +const int nfunctions = ( sizeof(functions)/sizeof(*functions) ); + +#define random_sign ( random_upto(1) ? 0x80000000 : 0 ) + +static int iszero(uint32 *x) { + return !((x[0] & 0x7FFFFFFF) || x[1]); +} + + +static void complex_log_cases(uint32 *out, uint32 param1, + uint32 param2) { + cases_uniform(out,0x00100000,0x7fefffff); + cases_uniform(out+2,0x00100000,0x7fefffff); +} + + +static void complex_log_cases_float(uint32 *out, uint32 param1, + uint32 param2) { + cases_uniform_float(out,0x00800000,0x7f7fffff); + cases_uniform_float(out+2,0x00800000,0x7f7fffff); +} + +static void complex_cases_biased(uint32 *out, uint32 lowbound, + uint32 highbound) { + cases_biased(out,lowbound,highbound); + cases_biased(out+2,lowbound,highbound); +} + +static void complex_cases_biased_float(uint32 *out, uint32 lowbound, + uint32 highbound) { + cases_biased_float(out,lowbound,highbound); + cases_biased_float(out+2,lowbound,highbound); +} + +static void complex_cases_uniform(uint32 *out, uint32 lowbound, + uint32 highbound) { + cases_uniform(out,lowbound,highbound); + cases_uniform(out+2,lowbound,highbound); +} + +static void complex_cases_uniform_float(uint32 *out, uint32 lowbound, + uint32 highbound) { + cases_uniform_float(out,lowbound,highbound); + cases_uniform(out+2,lowbound,highbound); +} + +static void complex_pow_cases(uint32 *out, uint32 lowbound, + uint32 highbound) { + /* + * Generating non-overflowing cases for complex pow: + * + * Our base has both parts within the range [1/2,2], and hence + * its magnitude is within [1/2,2*sqrt(2)]. The magnitude of its + * logarithm in base 2 is therefore at most the magnitude of + * (log2(2*sqrt(2)) + i*pi/log(2)), or in other words + * hypot(3/2,pi/log(2)) = 4.77. So the magnitude of the exponent + * input must be at most our output magnitude limit (as a power + * of two) divided by that. + * + * I also set the output magnitude limit a bit low, because we + * don't guarantee (and neither does glibc) to prevent internal + * overflow in cases where the output _magnitude_ overflows but + * scaling it back down by cos and sin of the argument brings it + * back in range. + */ + cases_uniform(out,0x3fe00000, 0x40000000); + cases_uniform(out+2,0x3fe00000, 0x40000000); + cases_uniform(out+4,0x3f800000, 0x40600000); + cases_uniform(out+6,0x3f800000, 0x40600000); +} + +static void complex_pow_cases_float(uint32 *out, uint32 lowbound, + uint32 highbound) { + /* + * Reasoning as above, though of course the detailed numbers are + * all different. + */ + cases_uniform_float(out,0x3f000000, 0x40000000); + cases_uniform_float(out+2,0x3f000000, 0x40000000); + cases_uniform_float(out+4,0x3d600000, 0x41900000); + cases_uniform_float(out+6,0x3d600000, 0x41900000); +} + +static void complex_arithmetic_cases(uint32 *out, uint32 lowbound, + uint32 highbound) { + cases_uniform(out,0,0x7fefffff); + cases_uniform(out+2,0,0x7fefffff); + cases_uniform(out+4,0,0x7fefffff); + cases_uniform(out+6,0,0x7fefffff); +} + +static void complex_arithmetic_cases_float(uint32 *out, uint32 lowbound, + uint32 highbound) { + cases_uniform_float(out,0,0x7f7fffff); + cases_uniform_float(out+2,0,0x7f7fffff); + cases_uniform_float(out+4,0,0x7f7fffff); + cases_uniform_float(out+6,0,0x7f7fffff); +} + +/* + * Included from fplib test suite, in a compact self-contained + * form. + */ + +void float32_case(uint32 *ret) { + int n, bits; + uint32 f; + static int premax, preptr; + static uint32 *specifics = NULL; + + if (!ret) { + if (specifics) + free(specifics); + specifics = NULL; + premax = preptr = 0; + return; + } + + if (!specifics) { + int exps[] = { + -127, -126, -125, -24, -4, -3, -2, -1, 0, 1, 2, 3, 4, + 24, 29, 30, 31, 32, 61, 62, 63, 64, 126, 127, 128 + }; + int sign, eptr; + uint32 se, j; + /* + * We want a cross product of: + * - each of two sign bits (2) + * - each of the above (unbiased) exponents (25) + * - the following list of fraction parts: + * * zero (1) + * * all bits (1) + * * one-bit-set (23) + * * one-bit-clear (23) + * * one-bit-and-above (20: 3 are duplicates) + * * one-bit-and-below (20: 3 are duplicates) + * (total 88) + * (total 4400) + */ + specifics = malloc(4400 * sizeof(*specifics)); + preptr = 0; + for (sign = 0; sign <= 1; sign++) { + for (eptr = 0; eptr < sizeof(exps)/sizeof(*exps); eptr++) { + se = (sign ? 0x80000000 : 0) | ((exps[eptr]+127) << 23); + /* + * Zero. + */ + specifics[preptr++] = se | 0; + /* + * All bits. + */ + specifics[preptr++] = se | 0x7FFFFF; + /* + * One-bit-set. + */ + for (j = 1; j && j <= 0x400000; j <<= 1) + specifics[preptr++] = se | j; + /* + * One-bit-clear. + */ + for (j = 1; j && j <= 0x400000; j <<= 1) + specifics[preptr++] = se | (0x7FFFFF ^ j); + /* + * One-bit-and-everything-below. + */ + for (j = 2; j && j <= 0x100000; j <<= 1) + specifics[preptr++] = se | (2*j-1); + /* + * One-bit-and-everything-above. + */ + for (j = 4; j && j <= 0x200000; j <<= 1) + specifics[preptr++] = se | (0x7FFFFF ^ (j-1)); + /* + * Done. + */ + } + } + assert(preptr == 4400); + premax = preptr; + } + + /* + * Decide whether to return a pre or a random case. + */ + n = random32() % (premax+1); + if (n < preptr) { + /* + * Return pre[n]. + */ + uint32 t; + t = specifics[n]; + specifics[n] = specifics[preptr-1]; + specifics[preptr-1] = t; /* (not really needed) */ + preptr--; + *ret = t; + } else { + /* + * Random case. + * Sign and exponent: + * - FIXME + * Significand: + * - with prob 1/5, a totally random bit pattern + * - with prob 1/5, all 1s down to some point and then random + * - with prob 1/5, all 1s up to some point and then random + * - with prob 1/5, all 0s down to some point and then random + * - with prob 1/5, all 0s up to some point and then random + */ + n = random32() % 5; + f = random32(); /* some random bits */ + bits = random32() % 22 + 1; /* 1-22 */ + switch (n) { + case 0: + break; /* leave f alone */ + case 1: + f |= (1< 0x3FF, the range is [-0x432/(e-0x3FF),+0x400/(e-0x3FF)] + * + * For e == 0x3FE or e == 0x3FF, the range gets infinite at one + * end or the other, so we have to be cleverer: pick a number n + * of useful bits in the mantissa (1 thru 52, so 1 must imply + * 0x3ff00000.00000001 whereas 52 is anything at least as big + * as 0x3ff80000.00000000; for e == 0x3fe, 1 necessarily means + * 0x3fefffff.ffffffff and 52 is anything at most as big as + * 0x3fe80000.00000000). Then, as it happens, a sensible + * maximum power is 2^(63-n) for e == 0x3fe, and 2^(62-n) for + * e == 0x3ff. + * + * We inevitably get some overflows in approximating the log + * curves by these nasty step functions, but that's all right - + * we do want _some_ overflows to be tested. + * + * Having got that, then, it's just a matter of inventing a + * probability distribution for all of this. + */ + int e, n; + uint32 dmin, dmax; + const uint32 pmin = 0x3e100000; + + /* + * Generate exponents in a slightly biased fashion. + */ + e = (random_upto(1) ? /* is exponent small or big? */ + 0x3FE - random_upto_biased(0x431,2) : /* small */ + 0x3FF + random_upto_biased(0x3FF,2)); /* big */ + + /* + * Now split into cases. + */ + if (e < 0x3FE || e > 0x3FF) { + uint32 imin, imax; + if (e < 0x3FE) + imin = 0x40000 / (0x3FE - e), imax = 0x43200 / (0x3FE - e); + else + imin = 0x43200 / (e - 0x3FF), imax = 0x40000 / (e - 0x3FF); + /* Power range runs from -imin to imax. Now convert to doubles */ + dmin = doubletop(imin, -8); + dmax = doubletop(imax, -8); + /* Compute the number of mantissa bits. */ + n = (e > 0 ? 53 : 52+e); + } else { + /* Critical exponents. Generate a top bit index. */ + n = 52 - random_upto_biased(51, 4); + if (e == 0x3FE) + dmax = 63 - n; + else + dmax = 62 - n; + dmax = (dmax << 20) + 0x3FF00000; + dmin = dmax; + } + /* Generate a mantissa. */ + if (n <= 32) { + out[0] = 0; + out[1] = random_upto((1 << (n-1)) - 1) + (1 << (n-1)); + } else if (n == 33) { + out[0] = 1; + out[1] = random_upto(0xFFFFFFFF); + } else if (n > 33) { + out[0] = random_upto((1 << (n-33)) - 1) + (1 << (n-33)); + out[1] = random_upto(0xFFFFFFFF); + } + /* Negate the mantissa if e == 0x3FE. */ + if (e == 0x3FE) { + out[1] = -out[1]; + out[0] = -out[0]; + if (out[1]) out[0]--; + } + /* Put the exponent on. */ + out[0] &= 0xFFFFF; + out[0] |= ((e > 0 ? e : 0) << 20); + /* Generate a power. Powers don't go below 2^-30. */ + if (random_upto(1)) { + /* Positive power */ + out[2] = dmax - random_upto_biased(dmax-pmin, 10); + } else { + /* Negative power */ + out[2] = (dmin - random_upto_biased(dmin-pmin, 10)) | 0x80000000; + } + out[3] = random_upto(0xFFFFFFFF); +} +static void pow_cases_float(uint32 *out, uint32 param1, + uint32 param2) { + /* + * Pick an exponent e (-0x16 to +0xFE) for x, and here's the + * range of numbers we can use as y: + * + * For e < 0x7E, the range is [-0x80/(0x7E-e),+0x95/(0x7E-e)] + * For e > 0x7F, the range is [-0x95/(e-0x7F),+0x80/(e-0x7F)] + * + * For e == 0x7E or e == 0x7F, the range gets infinite at one + * end or the other, so we have to be cleverer: pick a number n + * of useful bits in the mantissa (1 thru 23, so 1 must imply + * 0x3f800001 whereas 23 is anything at least as big as + * 0x3fc00000; for e == 0x7e, 1 necessarily means 0x3f7fffff + * and 23 is anything at most as big as 0x3f400000). Then, as + * it happens, a sensible maximum power is 2^(31-n) for e == + * 0x7e, and 2^(30-n) for e == 0x7f. + * + * We inevitably get some overflows in approximating the log + * curves by these nasty step functions, but that's all right - + * we do want _some_ overflows to be tested. + * + * Having got that, then, it's just a matter of inventing a + * probability distribution for all of this. + */ + int e, n; + uint32 dmin, dmax; + const uint32 pmin = 0x38000000; + + /* + * Generate exponents in a slightly biased fashion. + */ + e = (random_upto(1) ? /* is exponent small or big? */ + 0x7E - random_upto_biased(0x94,2) : /* small */ + 0x7F + random_upto_biased(0x7f,2)); /* big */ + + /* + * Now split into cases. + */ + if (e < 0x7E || e > 0x7F) { + uint32 imin, imax; + if (e < 0x7E) + imin = 0x8000 / (0x7e - e), imax = 0x9500 / (0x7e - e); + else + imin = 0x9500 / (e - 0x7f), imax = 0x8000 / (e - 0x7f); + /* Power range runs from -imin to imax. Now convert to doubles */ + dmin = floatval(imin, -8); + dmax = floatval(imax, -8); + /* Compute the number of mantissa bits. */ + n = (e > 0 ? 24 : 23+e); + } else { + /* Critical exponents. Generate a top bit index. */ + n = 23 - random_upto_biased(22, 4); + if (e == 0x7E) + dmax = 31 - n; + else + dmax = 30 - n; + dmax = (dmax << 23) + 0x3F800000; + dmin = dmax; + } + /* Generate a mantissa. */ + out[0] = random_upto((1 << (n-1)) - 1) + (1 << (n-1)); + out[1] = 0; + /* Negate the mantissa if e == 0x7E. */ + if (e == 0x7E) { + out[0] = -out[0]; + } + /* Put the exponent on. */ + out[0] &= 0x7FFFFF; + out[0] |= ((e > 0 ? e : 0) << 23); + /* Generate a power. Powers don't go below 2^-15. */ + if (random_upto(1)) { + /* Positive power */ + out[2] = dmax - random_upto_biased(dmax-pmin, 10); + } else { + /* Negative power */ + out[2] = (dmin - random_upto_biased(dmin-pmin, 10)) | 0x80000000; + } + out[3] = 0; +} + +void vet_for_decline(Testable *fn, uint32 *args, uint32 *result, int got_errno_in) { + int declined = 0; + + switch (fn->type) { + case args1: + case rred: + case semi1: + case t_frexp: + case t_modf: + case classify: + case t_ldexp: + declined |= lib_fo && is_dhard(args+0); + break; + case args1f: + case rredf: + case semi1f: + case t_frexpf: + case t_modff: + case classifyf: + declined |= lib_fo && is_shard(args+0); + break; + case args2: + case semi2: + case args1c: + case args1cr: + case compare: + declined |= lib_fo && is_dhard(args+0); + declined |= lib_fo && is_dhard(args+2); + break; + case args2f: + case semi2f: + case t_ldexpf: + case comparef: + case args1fc: + case args1fcr: + declined |= lib_fo && is_shard(args+0); + declined |= lib_fo && is_shard(args+2); + break; + case args2c: + declined |= lib_fo && is_dhard(args+0); + declined |= lib_fo && is_dhard(args+2); + declined |= lib_fo && is_dhard(args+4); + declined |= lib_fo && is_dhard(args+6); + break; + case args2fc: + declined |= lib_fo && is_shard(args+0); + declined |= lib_fo && is_shard(args+2); + declined |= lib_fo && is_shard(args+4); + declined |= lib_fo && is_shard(args+6); + break; + } + + switch (fn->type) { + case args1: /* return an extra-precise result */ + case args2: + case rred: + case semi1: /* return a double result */ + case semi2: + case t_ldexp: + case t_frexp: /* return double * int */ + case args1cr: + declined |= lib_fo && is_dhard(result); + break; + case args1f: + case args2f: + case rredf: + case semi1f: + case semi2f: + case t_ldexpf: + case args1fcr: + declined |= lib_fo && is_shard(result); + break; + case t_modf: /* return double * double */ + declined |= lib_fo && is_dhard(result+0); + declined |= lib_fo && is_dhard(result+2); + break; + case t_modff: /* return float * float */ + declined |= lib_fo && is_shard(result+2); + /* fall through */ + case t_frexpf: /* return float * int */ + declined |= lib_fo && is_shard(result+0); + break; + case args1c: + case args2c: + declined |= lib_fo && is_dhard(result+0); + declined |= lib_fo && is_dhard(result+4); + break; + case args1fc: + case args2fc: + declined |= lib_fo && is_shard(result+0); + declined |= lib_fo && is_shard(result+4); + break; + } + + /* Expect basic arithmetic tests to be declined if the command + * line said that would happen */ + declined |= (lib_no_arith && (fn->func == (funcptr)mpc_add || + fn->func == (funcptr)mpc_sub || + fn->func == (funcptr)mpc_mul || + fn->func == (funcptr)mpc_div)); + + if (!declined) { + if (got_errno_in) + ntests++; + else + ntests += 3; + } +} + +void docase(Testable *fn, uint32 *args) { + uint32 result[8]; /* real part in first 4, imaginary part in last 4 */ + char *errstr = NULL; + mpfr_t a, b, r; + mpc_t ac, bc, rc; + int rejected, printextra; + wrapperctx ctx; + + mpfr_init2(a, MPFR_PREC); + mpfr_init2(b, MPFR_PREC); + mpfr_init2(r, MPFR_PREC); + mpc_init2(ac, MPFR_PREC); + mpc_init2(bc, MPFR_PREC); + mpc_init2(rc, MPFR_PREC); + + printf("func=%s", fn->name); + + rejected = 0; /* FIXME */ + + switch (fn->type) { + case args1: + case rred: + case semi1: + case t_frexp: + case t_modf: + case classify: + printf(" op1=%08x.%08x", args[0], args[1]); + break; + case args1f: + case rredf: + case semi1f: + case t_frexpf: + case t_modff: + case classifyf: + printf(" op1=%08x", args[0]); + break; + case args2: + case semi2: + case compare: + printf(" op1=%08x.%08x", args[0], args[1]); + printf(" op2=%08x.%08x", args[2], args[3]); + break; + case args2f: + case semi2f: + case t_ldexpf: + case comparef: + printf(" op1=%08x", args[0]); + printf(" op2=%08x", args[2]); + break; + case t_ldexp: + printf(" op1=%08x.%08x", args[0], args[1]); + printf(" op2=%08x", args[2]); + break; + case args1c: + case args1cr: + printf(" op1r=%08x.%08x", args[0], args[1]); + printf(" op1i=%08x.%08x", args[2], args[3]); + break; + case args2c: + printf(" op1r=%08x.%08x", args[0], args[1]); + printf(" op1i=%08x.%08x", args[2], args[3]); + printf(" op2r=%08x.%08x", args[4], args[5]); + printf(" op2i=%08x.%08x", args[6], args[7]); + break; + case args1fc: + case args1fcr: + printf(" op1r=%08x", args[0]); + printf(" op1i=%08x", args[2]); + break; + case args2fc: + printf(" op1r=%08x", args[0]); + printf(" op1i=%08x", args[2]); + printf(" op2r=%08x", args[4]); + printf(" op2i=%08x", args[6]); + break; + default: + fprintf(stderr, "internal inconsistency?!\n"); + abort(); + } + + if (rejected == 2) { + printf(" - test case rejected\n"); + goto cleanup; + } + + wrapper_init(&ctx); + + if (rejected == 0) { + switch (fn->type) { + case args1: + set_mpfr_d(a, args[0], args[1]); + wrapper_op_real(&ctx, a, 2, args); + ((testfunc1)(fn->func))(r, a, GMP_RNDN); + get_mpfr_d(r, &result[0], &result[1], &result[2]); + wrapper_result_real(&ctx, r, 2, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpfr_d(r, &result[0], &result[1], &result[2]); + break; + case args1cr: + set_mpc_d(ac, args[0], args[1], args[2], args[3]); + wrapper_op_complex(&ctx, ac, 2, args); + ((testfunc1cr)(fn->func))(r, ac, GMP_RNDN); + get_mpfr_d(r, &result[0], &result[1], &result[2]); + wrapper_result_real(&ctx, r, 2, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpfr_d(r, &result[0], &result[1], &result[2]); + break; + case args1f: + set_mpfr_f(a, args[0]); + wrapper_op_real(&ctx, a, 1, args); + ((testfunc1)(fn->func))(r, a, GMP_RNDN); + get_mpfr_f(r, &result[0], &result[1]); + wrapper_result_real(&ctx, r, 1, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpfr_f(r, &result[0], &result[1]); + break; + case args1fcr: + set_mpc_f(ac, args[0], args[2]); + wrapper_op_complex(&ctx, ac, 1, args); + ((testfunc1cr)(fn->func))(r, ac, GMP_RNDN); + get_mpfr_f(r, &result[0], &result[1]); + wrapper_result_real(&ctx, r, 1, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpfr_f(r, &result[0], &result[1]); + break; + case args2: + set_mpfr_d(a, args[0], args[1]); + wrapper_op_real(&ctx, a, 2, args); + set_mpfr_d(b, args[2], args[3]); + wrapper_op_real(&ctx, b, 2, args+2); + ((testfunc2)(fn->func))(r, a, b, GMP_RNDN); + get_mpfr_d(r, &result[0], &result[1], &result[2]); + wrapper_result_real(&ctx, r, 2, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpfr_d(r, &result[0], &result[1], &result[2]); + break; + case args2f: + set_mpfr_f(a, args[0]); + wrapper_op_real(&ctx, a, 1, args); + set_mpfr_f(b, args[2]); + wrapper_op_real(&ctx, b, 1, args+2); + ((testfunc2)(fn->func))(r, a, b, GMP_RNDN); + get_mpfr_f(r, &result[0], &result[1]); + wrapper_result_real(&ctx, r, 1, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpfr_f(r, &result[0], &result[1]); + break; + case rred: + set_mpfr_d(a, args[0], args[1]); + wrapper_op_real(&ctx, a, 2, args); + ((testrred)(fn->func))(r, a, (int *)&result[3]); + get_mpfr_d(r, &result[0], &result[1], &result[2]); + wrapper_result_real(&ctx, r, 2, result); + /* We never need to mess about with the integer auxiliary + * output. */ + if (wrapper_run(&ctx, fn->wrappers)) + get_mpfr_d(r, &result[0], &result[1], &result[2]); + break; + case rredf: + set_mpfr_f(a, args[0]); + wrapper_op_real(&ctx, a, 1, args); + ((testrred)(fn->func))(r, a, (int *)&result[3]); + get_mpfr_f(r, &result[0], &result[1]); + wrapper_result_real(&ctx, r, 1, result); + /* We never need to mess about with the integer auxiliary + * output. */ + if (wrapper_run(&ctx, fn->wrappers)) + get_mpfr_f(r, &result[0], &result[1]); + break; + case semi1: + case semi1f: + errstr = ((testsemi1)(fn->func))(args, result); + break; + case semi2: + case compare: + errstr = ((testsemi2)(fn->func))(args, args+2, result); + break; + case semi2f: + case comparef: + case t_ldexpf: + errstr = ((testsemi2f)(fn->func))(args, args+2, result); + break; + case t_ldexp: + errstr = ((testldexp)(fn->func))(args, args+2, result); + break; + case t_frexp: + errstr = ((testfrexp)(fn->func))(args, result, result+2); + break; + case t_frexpf: + errstr = ((testfrexp)(fn->func))(args, result, result+2); + break; + case t_modf: + errstr = ((testmodf)(fn->func))(args, result, result+2); + break; + case t_modff: + errstr = ((testmodf)(fn->func))(args, result, result+2); + break; + case classify: + errstr = ((testclassify)(fn->func))(args, &result[0]); + break; + case classifyf: + errstr = ((testclassifyf)(fn->func))(args, &result[0]); + break; + case args1c: + set_mpc_d(ac, args[0], args[1], args[2], args[3]); + wrapper_op_complex(&ctx, ac, 2, args); + ((testfunc1c)(fn->func))(rc, ac, MPC_RNDNN); + get_mpc_d(rc, &result[0], &result[1], &result[2], &result[4], &result[5], &result[6]); + wrapper_result_complex(&ctx, rc, 2, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpc_d(rc, &result[0], &result[1], &result[2], &result[4], &result[5], &result[6]); + break; + case args2c: + set_mpc_d(ac, args[0], args[1], args[2], args[3]); + wrapper_op_complex(&ctx, ac, 2, args); + set_mpc_d(bc, args[4], args[5], args[6], args[7]); + wrapper_op_complex(&ctx, bc, 2, args+4); + ((testfunc2c)(fn->func))(rc, ac, bc, MPC_RNDNN); + get_mpc_d(rc, &result[0], &result[1], &result[2], &result[4], &result[5], &result[6]); + wrapper_result_complex(&ctx, rc, 2, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpc_d(rc, &result[0], &result[1], &result[2], &result[4], &result[5], &result[6]); + break; + case args1fc: + set_mpc_f(ac, args[0], args[2]); + wrapper_op_complex(&ctx, ac, 1, args); + ((testfunc1c)(fn->func))(rc, ac, MPC_RNDNN); + get_mpc_f(rc, &result[0], &result[1], &result[4], &result[5]); + wrapper_result_complex(&ctx, rc, 1, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpc_f(rc, &result[0], &result[1], &result[4], &result[5]); + break; + case args2fc: + set_mpc_f(ac, args[0], args[2]); + wrapper_op_complex(&ctx, ac, 1, args); + set_mpc_f(bc, args[4], args[6]); + wrapper_op_complex(&ctx, bc, 1, args+4); + ((testfunc2c)(fn->func))(rc, ac, bc, MPC_RNDNN); + get_mpc_f(rc, &result[0], &result[1], &result[4], &result[5]); + wrapper_result_complex(&ctx, rc, 1, result); + if (wrapper_run(&ctx, fn->wrappers)) + get_mpc_f(rc, &result[0], &result[1], &result[4], &result[5]); + break; + default: + fprintf(stderr, "internal inconsistency?!\n"); + abort(); + } + } + + switch (fn->type) { + case args1: /* return an extra-precise result */ + case args2: + case args1cr: + case rred: + printextra = 1; + if (rejected == 0) { + errstr = NULL; + if (!mpfr_zero_p(a)) { + if ((result[0] & 0x7FFFFFFF) == 0 && result[1] == 0) { + /* + * If the output is +0 or -0 apart from the extra + * precision in result[2], then there's a tricky + * judgment call about what we require in the + * output. If we output the extra bits and set + * errstr="?underflow" then mathtest will tolerate + * the function under test rounding down to zero + * _or_ up to the minimum denormal; whereas if we + * suppress the extra bits and set + * errstr="underflow", then mathtest will enforce + * that the function really does underflow to zero. + * + * But where to draw the line? It seems clear to + * me that numbers along the lines of + * 00000000.00000000.7ff should be treated + * similarly to 00000000.00000000.801, but on the + * other hand, we must surely be prepared to + * enforce a genuine underflow-to-zero in _some_ + * case where the true mathematical output is + * nonzero but absurdly tiny. + * + * I think a reasonable place to draw the + * distinction is at 00000000.00000000.400, i.e. + * one quarter of the minimum positive denormal. + * If a value less than that rounds up to the + * minimum denormal, that must mean the function + * under test has managed to make an error of an + * entire factor of two, and that's something we + * should fix. Above that, you can misround within + * the limits of your accuracy bound if you have + * to. + */ + if (result[2] < 0x40000000) { + /* Total underflow (ERANGE + UFL) is required, + * and we suppress the extra bits to make + * mathtest enforce that the output is really + * zero. */ + errstr = "underflow"; + printextra = 0; + } else { + /* Total underflow is not required, but if the + * function rounds down to zero anyway, then + * we should be prepared to tolerate it. */ + errstr = "?underflow"; + } + } else if (!(result[0] & 0x7ff00000)) { + /* + * If the output is denormal, we usually expect a + * UFL exception, warning the user of partial + * underflow. The exception is if the denormal + * being returned is just one of the input values, + * unchanged even in principle. I bodgily handle + * this by just special-casing the functions in + * question below. + */ + if (!strcmp(fn->name, "fmax") || + !strcmp(fn->name, "fmin") || + !strcmp(fn->name, "creal") || + !strcmp(fn->name, "cimag")) { + /* no error expected */ + } else { + errstr = "u"; + } + } else if ((result[0] & 0x7FFFFFFF) > 0x7FEFFFFF) { + /* + * Infinite results are usually due to overflow, + * but one exception is lgamma of a negative + * integer. + */ + if (!strcmp(fn->name, "lgamma") && + (args[0] & 0x80000000) != 0 && /* negative */ + is_dinteger(args)) { + errstr = "ERANGE status=z"; + } else { + errstr = "overflow"; + } + printextra = 0; + } + } else { + /* lgamma(0) is also a pole. */ + if (!strcmp(fn->name, "lgamma")) { + errstr = "ERANGE status=z"; + printextra = 0; + } + } + } + + if (!printextra || (rejected && !(rejected==1 && result[2]!=0))) { + printf(" result=%08x.%08x", + result[0], result[1]); + } else { + printf(" result=%08x.%08x.%03x", + result[0], result[1], (result[2] >> 20) & 0xFFF); + } + if (fn->type == rred) { + printf(" res2=%08x", result[3]); + } + break; + case args1f: + case args2f: + case args1fcr: + case rredf: + printextra = 1; + if (rejected == 0) { + errstr = NULL; + if (!mpfr_zero_p(a)) { + if ((result[0] & 0x7FFFFFFF) == 0) { + /* + * Decide whether to print the extra bits based on + * just how close to zero the number is. See the + * big comment in the double-precision case for + * discussion. + */ + if (result[1] < 0x40000000) { + errstr = "underflow"; + printextra = 0; + } else { + errstr = "?underflow"; + } + } else if (!(result[0] & 0x7f800000)) { + /* + * Functions which do not report partial overflow + * are listed here as special cases. (See the + * corresponding double case above for a fuller + * comment.) + */ + if (!strcmp(fn->name, "fmaxf") || + !strcmp(fn->name, "fminf") || + !strcmp(fn->name, "crealf") || + !strcmp(fn->name, "cimagf")) { + /* no error expected */ + } else { + errstr = "u"; + } + } else if ((result[0] & 0x7FFFFFFF) > 0x7F7FFFFF) { + /* + * Infinite results are usually due to overflow, + * but one exception is lgamma of a negative + * integer. + */ + if (!strcmp(fn->name, "lgammaf") && + (args[0] & 0x80000000) != 0 && /* negative */ + is_sinteger(args)) { + errstr = "ERANGE status=z"; + } else { + errstr = "overflow"; + } + printextra = 0; + } + } else { + /* lgamma(0) is also a pole. */ + if (!strcmp(fn->name, "lgammaf")) { + errstr = "ERANGE status=z"; + printextra = 0; + } + } + } + + if (!printextra || (rejected && !(rejected==1 && result[1]!=0))) { + printf(" result=%08x", + result[0]); + } else { + printf(" result=%08x.%03x", + result[0], (result[1] >> 20) & 0xFFF); + } + if (fn->type == rredf) { + printf(" res2=%08x", result[3]); + } + break; + case semi1: /* return a double result */ + case semi2: + case t_ldexp: + printf(" result=%08x.%08x", result[0], result[1]); + break; + case semi1f: + case semi2f: + case t_ldexpf: + printf(" result=%08x", result[0]); + break; + case t_frexp: /* return double * int */ + printf(" result=%08x.%08x res2=%08x", result[0], result[1], + result[2]); + break; + case t_modf: /* return double * double */ + printf(" result=%08x.%08x res2=%08x.%08x", + result[0], result[1], result[2], result[3]); + break; + case t_modff: /* return float * float */ + /* fall through */ + case t_frexpf: /* return float * int */ + printf(" result=%08x res2=%08x", result[0], result[2]); + break; + case classify: + case classifyf: + case compare: + case comparef: + printf(" result=%x", result[0]); + break; + case args1c: + case args2c: + if (0/* errstr */) { + printf(" resultr=%08x.%08x", result[0], result[1]); + printf(" resulti=%08x.%08x", result[4], result[5]); + } else { + printf(" resultr=%08x.%08x.%03x", + result[0], result[1], (result[2] >> 20) & 0xFFF); + printf(" resulti=%08x.%08x.%03x", + result[4], result[5], (result[6] >> 20) & 0xFFF); + } + /* Underflow behaviour doesn't seem to be specified for complex arithmetic */ + errstr = "?underflow"; + break; + case args1fc: + case args2fc: + if (0/* errstr */) { + printf(" resultr=%08x", result[0]); + printf(" resulti=%08x", result[4]); + } else { + printf(" resultr=%08x.%03x", + result[0], (result[1] >> 20) & 0xFFF); + printf(" resulti=%08x.%03x", + result[4], (result[5] >> 20) & 0xFFF); + } + /* Underflow behaviour doesn't seem to be specified for complex arithmetic */ + errstr = "?underflow"; + break; + } + + if (errstr && *(errstr+1) == '\0') { + printf(" errno=0 status=%c",*errstr); + } else if (errstr && *errstr == '?') { + printf(" maybeerror=%s", errstr+1); + } else if (errstr && errstr[0] == 'E') { + printf(" errno=%s", errstr); + } else { + printf(" error=%s", errstr && *errstr ? errstr : "0"); + } + + printf("\n"); + + vet_for_decline(fn, args, result, 0); + + cleanup: + mpfr_clear(a); + mpfr_clear(b); + mpfr_clear(r); + mpc_clear(ac); + mpc_clear(bc); + mpc_clear(rc); +} + +void gencases(Testable *fn, int number) { + int i; + uint32 args[8]; + + float32_case(NULL); + float64_case(NULL); + + printf("random=on\n"); /* signal to runtests.pl that the following tests are randomly generated */ + for (i = 0; i < number; i++) { + /* generate test point */ + fn->cases(args, fn->caseparam1, fn->caseparam2); + docase(fn, args); + } + printf("random=off\n"); +} + +static uint32 doubletop(int x, int scale) { + int e = 0x412 + scale; + while (!(x & 0x100000)) + x <<= 1, e--; + return (e << 20) + x; +} + +static uint32 floatval(int x, int scale) { + int e = 0x95 + scale; + while (!(x & 0x800000)) + x <<= 1, e--; + return (e << 23) + x; +} diff --git a/libc/AOR_v20.02/math/test/rtest/intern.h b/libc/AOR_v20.02/math/test/rtest/intern.h new file mode 100644 index 00000000000000..8b1cc4f3176cb4 --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/intern.h @@ -0,0 +1,92 @@ +/* + * intern.h + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef mathtest_intern_h +#define mathtest_intern_h + +#include +#include + +#include "types.h" +#include "wrappers.h" + +/* Generic function pointer. */ +typedef void (*funcptr)(void); + +/* Pointers to test function types. */ +typedef int (*testfunc1)(mpfr_t, mpfr_t, mpfr_rnd_t); +typedef int (*testfunc2)(mpfr_t, mpfr_t, mpfr_t, mpfr_rnd_t); +typedef int (*testrred)(mpfr_t, mpfr_t, int *); +typedef char * (*testsemi1)(uint32 *, uint32 *); +typedef char * (*testsemi2)(uint32 *, uint32 *, uint32 *); +typedef char * (*testsemi2f)(uint32 *, uint32 *, uint32 *); +typedef char * (*testldexp)(uint32 *, uint32 *, uint32 *); +typedef char * (*testfrexp)(uint32 *, uint32 *, uint32 *); +typedef char * (*testmodf)(uint32 *, uint32 *, uint32 *); +typedef char * (*testclassify)(uint32 *, uint32 *); +typedef char * (*testclassifyf)(uint32 *, uint32 *); + +typedef int (*testfunc1c)(mpc_t, mpc_t, mpc_rnd_t); +typedef int (*testfunc2c)(mpc_t, mpc_t, mpc_t, mpc_rnd_t); + +typedef int (*testfunc1cr)(mpfr_t, mpc_t, mpfr_rnd_t); + +/* Pointer to a function that generates random test cases. */ +typedef void (*casegen)(uint32 *, uint32, uint32); + +/* + * List of testable functions, their types, and their testable range. + */ +enum { + args1, /* afloat-based, one argument */ + args1f, /* same as args1 but in single prec */ + args2, /* afloat-based, two arguments */ + args2f, /* same as args2 but in single prec */ + rred, /* afloat-based, one arg, aux return */ + rredf, /* same as rred but in single prec */ + semi1, /* seminumerical, one argument */ + semi1f, /* seminumerical, 1 arg, float */ + semi2, /* seminumerical, two arguments */ + semi2f, /* seminumerical, 2 args, floats */ + t_ldexp, /* dbl * int -> dbl */ + t_ldexpf, /* sgl * int -> sgl */ + t_frexp, /* dbl -> dbl * int */ + t_frexpf, /* sgl -> sgl * int */ + t_modf, /* dbl -> dbl * dbl */ + t_modff, /* sgl -> sgl * sgl */ + classify, /* classify double: dbl -> int */ + classifyf, /* classify float: flt -> int */ + compare, /* compare doubles, returns int */ + comparef, /* compare floats, returns int */ + + args1c, /* acomplex-base, one argument */ + args2c, + args1fc, + args2fc, + args1cr, /* dbl-complex -> complex */ + args1fcr /* sgl-complex -> complex */ +}; + +typedef struct __testable Testable; +struct __testable { + char *name; + funcptr func; + int type; + wrapperfunc wrappers[MAXWRAPPERS]; + casegen cases; /* complex functions use the same casegen for both real and complex args */ + uint32 caseparam1, caseparam2; +}; + +extern Testable functions[]; +extern const int nfunctions; + +extern void init_pi(void); + +int nargs_(Testable* f); + +#endif diff --git a/libc/AOR_v20.02/math/test/rtest/main.c b/libc/AOR_v20.02/math/test/rtest/main.c new file mode 100644 index 00000000000000..c4ddd0f86fcbc8 --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/main.c @@ -0,0 +1,335 @@ +/* + * main.c + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include +#include + +#include "intern.h" + +void gencases(Testable *fn, int number); +void docase(Testable *fn, uint32 *args); +void vet_for_decline(Testable *fn, uint32 *args, uint32 *result, int got_errno_in); +void seed_random(uint32 seed); + +int check_declines = 0; +int lib_fo = 0; +int lib_no_arith = 0; +int ntests = 0; + +int nargs_(Testable* f) { + switch((f)->type) { + case args2: + case args2f: + case semi2: + case semi2f: + case t_ldexp: + case t_ldexpf: + case args1c: + case args1fc: + case args1cr: + case args1fcr: + case compare: + case comparef: + return 2; + case args2c: + case args2fc: + return 4; + default: + return 1; + } +} + +static int isdouble(Testable *f) +{ + switch (f->type) { + case args1: + case rred: + case semi1: + case t_frexp: + case t_modf: + case classify: + case t_ldexp: + case args2: + case semi2: + case args1c: + case args1cr: + case compare: + case args2c: + return 1; + case args1f: + case rredf: + case semi1f: + case t_frexpf: + case t_modff: + case classifyf: + case args2f: + case semi2f: + case t_ldexpf: + case comparef: + case args1fc: + case args1fcr: + case args2fc: + return 0; + default: + assert(0 && "Bad function type"); + } +} + +Testable *find_function(const char *func) +{ + int i; + for (i = 0; i < nfunctions; i++) { + if (func && !strcmp(func, functions[i].name)) { + return &functions[i]; + } + } + return NULL; +} + +void get_operand(const char *str, Testable *f, uint32 *word0, uint32 *word1) +{ + struct special { + unsigned dblword0, dblword1, sglword; + const char *name; + } specials[] = { + {0x00000000,0x00000000,0x00000000,"0"}, + {0x3FF00000,0x00000000,0x3f800000,"1"}, + {0x7FF00000,0x00000000,0x7f800000,"inf"}, + {0x7FF80000,0x00000001,0x7fc00000,"qnan"}, + {0x7FF00000,0x00000001,0x7f800001,"snan"}, + {0x3ff921fb,0x54442d18,0x3fc90fdb,"pi2"}, + {0x400921fb,0x54442d18,0x40490fdb,"pi"}, + {0x3fe921fb,0x54442d18,0x3f490fdb,"pi4"}, + {0x4002d97c,0x7f3321d2,0x4016cbe4,"3pi4"}, + }; + int i; + + for (i = 0; i < (int)(sizeof(specials)/sizeof(*specials)); i++) { + if (!strcmp(str, specials[i].name) || + ((str[0] == '-' || str[0] == '+') && + !strcmp(str+1, specials[i].name))) { + assert(f); + if (isdouble(f)) { + *word0 = specials[i].dblword0; + *word1 = specials[i].dblword1; + } else { + *word0 = specials[i].sglword; + *word1 = 0; + } + if (str[0] == '-') + *word0 |= 0x80000000U; + return; + } + } + + sscanf(str, "%"I32"x.%"I32"x", word0, word1); +} + +void dofile(FILE *fp, int translating) { + char buf[1024], sparebuf[1024], *p; + + /* + * Command syntax is: + * + * - "seed " sets a random seed + * + * - "test " generates random test lines + * + * - " op1=foo [op2=bar]" generates a specific test + * - "func= op1=foo [op2=bar]" does the same + * - "func= op1=foo result=bar" will just output the line as-is + * + * - a semicolon or a blank line is ignored + */ + while (fgets(buf, sizeof(buf), fp)) { + buf[strcspn(buf, "\r\n")] = '\0'; + strcpy(sparebuf, buf); + p = buf; + while (*p && isspace(*p)) p++; + if (!*p || *p == ';') { + /* Comment or blank line. Only print if `translating' is set. */ + if (translating) + printf("%s\n", buf); + continue; + } + if (!strncmp(buf, "seed ", 5)) { + seed_random(atoi(buf+5)); + } else if (!strncmp(buf, "random=", 7)) { + /* + * Copy 'random=on' / 'random=off' lines unconditionally + * to the output, so that random test failures can be + * accumulated into a recent-failures-list file and + * still identified as random-in-origin when re-run the + * next day. + */ + printf("%s\n", buf); + } else if (!strncmp(buf, "test ", 5)) { + char *p = buf+5; + char *q; + int ntests, i; + q = p; + while (*p && !isspace(*p)) p++; + if (*p) *p++ = '\0'; + while (*p && isspace(*p)) p++; + if (*p) + ntests = atoi(p); + else + ntests = 100; /* *shrug* */ + for (i = 0; i < nfunctions; i++) { + if (!strcmp(q, functions[i].name)) { + gencases(&functions[i], ntests); + break; + } + } + if (i == nfunctions) { + fprintf(stderr, "unknown test `%s'\n", q); + } + } else { + /* + * Parse a specific test line. + */ + uint32 ops[8], result[8]; + int got_op = 0; /* &1 for got_op1, &4 for got_op3 etc. */ + Testable *f = 0; + char *q, *r; + int got_result = 0, got_errno_in = 0; + + for (q = strtok(p, " \t"); q; q = strtok(NULL, " \t")) { + r = strchr(q, '='); + if (!r) { + f = find_function(q); + } else { + *r++ = '\0'; + + if (!strcmp(q, "func")) + f = find_function(r); + else if (!strcmp(q, "op1") || !strcmp(q, "op1r")) { + get_operand(r, f, &ops[0], &ops[1]); + got_op |= 1; + } else if (!strcmp(q, "op2") || !strcmp(q, "op1i")) { + get_operand(r, f, &ops[2], &ops[3]); + got_op |= 2; + } else if (!strcmp(q, "op2r")) { + get_operand(r, f, &ops[4], &ops[5]); + got_op |= 4; + } else if (!strcmp(q, "op2i")) { + get_operand(r, f, &ops[6], &ops[7]); + got_op |= 8; + } else if (!strcmp(q, "result") || !strcmp(q, "resultr")) { + get_operand(r, f, &result[0], &result[1]); + got_result |= 1; + } else if (!strcmp(q, "resulti")) { + get_operand(r, f, &result[4], &result[5]); + got_result |= 2; + } else if (!strcmp(q, "res2")) { + get_operand(r, f, &result[2], &result[3]); + got_result |= 4; + } else if (!strcmp(q, "errno_in")) { + got_errno_in = 1; + } + } + } + + /* + * Test cases already set up by the input are not + * reprocessed by default, unlike the fplib tests. (This + * is mostly for historical reasons, because we used to + * use a very slow and incomplete internal reference + * implementation; now our ref impl is MPFR/MPC it + * probably wouldn't be such a bad idea, though we'd still + * have to make sure all the special cases came out + * right.) If translating==2 (corresponding to the -T + * command-line option) then we regenerate everything + * regardless. + */ + if (got_result && translating < 2) { + if (f) + vet_for_decline(f, ops, result, got_errno_in); + puts(sparebuf); + continue; + } + + if (f && got_op==(1< 1 && 1==sscanf(*(argv+1),"%u",&seed)) { + seed_random(seed); + argv++; /* next in argv is seed value, so skip */ + --argc; + } else if (!strcmp(p, "-fo")) { + lib_fo = 1; + } else if (!strcmp(p, "-noarith")) { + lib_no_arith = 1; + } else { + fprintf(stderr, + "rtest: ignoring unrecognised option '%s'\n", p); + errs = 1; + } + } else { + files = 1; + if (!errs) { + fp = fopen(p, "r"); + if (fp) { + dofile(fp, translating); + fclose(fp); + } else { + perror(p); + errs = 1; + } + } + } + } + + /* + * If no filename arguments, use stdin. + */ + if (!files && !errs) { + dofile(stdin, translating); + } + + if (check_declines) { + fprintf(stderr, "Tests expected to run: %d\n", ntests); + fflush(stderr); + } + + return errs; +} diff --git a/libc/AOR_v20.02/math/test/rtest/random.c b/libc/AOR_v20.02/math/test/rtest/random.c new file mode 100644 index 00000000000000..b6ad6a79a7223d --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/random.c @@ -0,0 +1,100 @@ +/* + * random.c - random number generator for producing mathlib test cases + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "types.h" +#include "random.h" + +static uint32 seedbuf[55]; +static int seedptr; + +void seed_random(uint32 seed) { + int i; + + seedptr = 0; + for (i = 0; i < 55; i++) { + seed = seed % 44488 * 48271 - seed / 44488 * 3399; + seedbuf[i] = seed - 1; + } +} + +uint32 base_random(void) { + seedptr %= 55; + seedbuf[seedptr] += seedbuf[(seedptr+31)%55]; + return seedbuf[seedptr++]; +} + +uint32 random32(void) { + uint32 a, b, b1, b2; + a = base_random(); + b = base_random(); + for (b1 = 0x80000000, b2 = 1; b1 > b2; b1 >>= 1, b2 <<= 1) { + uint32 b3 = b1 | b2; + if ((b & b3) != 0 && (b & b3) != b3) + b ^= b3; + } + return a ^ b; +} + +/* + * random_upto: generate a uniformly randomised number in the range + * 0,...,limit-1. (Precondition: limit > 0.) + * + * random_upto_biased: generate a number in the same range, but with + * the probability skewed towards the high end by means of taking the + * maximum of 8*bias+1 samples from the uniform distribution on the + * same range. (I don't know why bias is given in that curious way - + * historical reasons, I expect.) + * + * For speed, I separate the implementation of random_upto into the + * two stages of (a) generate a bitmask which reduces a 32-bit random + * number to within a factor of two of the right range, (b) repeatedly + * generate numbers in that range until one is small enough. Splitting + * it up like that means that random_upto_biased can do (a) only once + * even when it does (b) lots of times. + */ + +static uint32 random_upto_makemask(uint32 limit) { + uint32 mask = 0xFFFFFFFF; + int i; + for (i = 16; i > 0; i >>= 1) + if ((limit & (mask >> i)) == limit) + mask >>= i; + return mask; +} + +static uint32 random_upto_internal(uint32 limit, uint32 mask) { + uint32 ret; + do { + ret = random32() & mask; + } while (ret > limit); + return ret; +} + +uint32 random_upto(uint32 limit) { + uint32 mask = random_upto_makemask(limit); + return random_upto_internal(limit, mask); +} + +uint32 random_upto_biased(uint32 limit, int bias) { + uint32 mask = random_upto_makemask(limit); + + uint32 ret = random_upto_internal(limit, mask); + while (bias--) { + uint32 tmp; + tmp = random_upto_internal(limit, mask); if (tmp < ret) ret = tmp; + tmp = random_upto_internal(limit, mask); if (tmp < ret) ret = tmp; + tmp = random_upto_internal(limit, mask); if (tmp < ret) ret = tmp; + tmp = random_upto_internal(limit, mask); if (tmp < ret) ret = tmp; + tmp = random_upto_internal(limit, mask); if (tmp < ret) ret = tmp; + tmp = random_upto_internal(limit, mask); if (tmp < ret) ret = tmp; + tmp = random_upto_internal(limit, mask); if (tmp < ret) ret = tmp; + tmp = random_upto_internal(limit, mask); if (tmp < ret) ret = tmp; + } + + return ret; +} diff --git a/libc/AOR_v20.02/math/test/rtest/random.h b/libc/AOR_v20.02/math/test/rtest/random.h new file mode 100644 index 00000000000000..5ab0c0f0dfcbdb --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/random.h @@ -0,0 +1,13 @@ +/* + * random.h - header for random.c + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "types.h" + +uint32 random32(void); +uint32 random_upto(uint32 limit); +uint32 random_upto_biased(uint32 limit, int bias); diff --git a/libc/AOR_v20.02/math/test/rtest/semi.c b/libc/AOR_v20.02/math/test/rtest/semi.c new file mode 100644 index 00000000000000..aefb2b81d4a58c --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/semi.c @@ -0,0 +1,906 @@ +/* + * semi.c: test implementations of mathlib seminumerical functions + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include "semi.h" + +static void test_rint(uint32 *in, uint32 *out, + int isfloor, int isceil) { + int sign = in[0] & 0x80000000; + int roundup = (isfloor && sign) || (isceil && !sign); + uint32 xh, xl, roundword; + int ex = (in[0] >> 20) & 0x7FF; /* exponent */ + int i; + + if ((ex > 0x3ff + 52 - 1) || /* things this big can't be fractional */ + ((in[0] & 0x7FFFFFFF) == 0 && in[1] == 0)) { /* zero */ + /* NaN, Inf, a large integer, or zero: just return the input */ + out[0] = in[0]; + out[1] = in[1]; + return; + } + + /* + * Special case: ex < 0x3ff, ie our number is in (0,1). Return + * 1 or 0 according to roundup. + */ + if (ex < 0x3ff) { + out[0] = sign | (roundup ? 0x3FF00000 : 0); + out[1] = 0; + return; + } + + /* + * We're not short of time here, so we'll do this the hideously + * inefficient way. Shift bit by bit so that the units place is + * somewhere predictable, round, and shift back again. + */ + xh = in[0]; + xl = in[1]; + roundword = 0; + for (i = ex; i < 0x3ff + 52; i++) { + if (roundword & 1) + roundword |= 2; /* preserve sticky bit */ + roundword = (roundword >> 1) | ((xl & 1) << 31); + xl = (xl >> 1) | ((xh & 1) << 31); + xh = xh >> 1; + } + if (roundword && roundup) { + xl++; + xh += (xl==0); + } + for (i = ex; i < 0x3ff + 52; i++) { + xh = (xh << 1) | ((xl >> 31) & 1); + xl = (xl & 0x7FFFFFFF) << 1; + } + out[0] = xh; + out[1] = xl; +} + +char *test_ceil(uint32 *in, uint32 *out) { + test_rint(in, out, 0, 1); + return NULL; +} + +char *test_floor(uint32 *in, uint32 *out) { + test_rint(in, out, 1, 0); + return NULL; +} + +static void test_rintf(uint32 *in, uint32 *out, + int isfloor, int isceil) { + int sign = *in & 0x80000000; + int roundup = (isfloor && sign) || (isceil && !sign); + uint32 x, roundword; + int ex = (*in >> 23) & 0xFF; /* exponent */ + int i; + + if ((ex > 0x7f + 23 - 1) || /* things this big can't be fractional */ + (*in & 0x7FFFFFFF) == 0) { /* zero */ + /* NaN, Inf, a large integer, or zero: just return the input */ + *out = *in; + return; + } + + /* + * Special case: ex < 0x7f, ie our number is in (0,1). Return + * 1 or 0 according to roundup. + */ + if (ex < 0x7f) { + *out = sign | (roundup ? 0x3F800000 : 0); + return; + } + + /* + * We're not short of time here, so we'll do this the hideously + * inefficient way. Shift bit by bit so that the units place is + * somewhere predictable, round, and shift back again. + */ + x = *in; + roundword = 0; + for (i = ex; i < 0x7F + 23; i++) { + if (roundword & 1) + roundword |= 2; /* preserve sticky bit */ + roundword = (roundword >> 1) | ((x & 1) << 31); + x = x >> 1; + } + if (roundword && roundup) { + x++; + } + for (i = ex; i < 0x7F + 23; i++) { + x = x << 1; + } + *out = x; +} + +char *test_ceilf(uint32 *in, uint32 *out) { + test_rintf(in, out, 0, 1); + return NULL; +} + +char *test_floorf(uint32 *in, uint32 *out) { + test_rintf(in, out, 1, 0); + return NULL; +} + +char *test_fmod(uint32 *a, uint32 *b, uint32 *out) { + int sign; + int32 aex, bex; + uint32 am[2], bm[2]; + + if (((a[0] & 0x7FFFFFFF) << 1) + !!a[1] > 0xFFE00000 || + ((b[0] & 0x7FFFFFFF) << 1) + !!b[1] > 0xFFE00000) { + /* a or b is NaN: return QNaN, optionally with IVO */ + uint32 an, bn; + out[0] = 0x7ff80000; + out[1] = 1; + an = ((a[0] & 0x7FFFFFFF) << 1) + !!a[1]; + bn = ((b[0] & 0x7FFFFFFF) << 1) + !!b[1]; + if ((an > 0xFFE00000 && an < 0xFFF00000) || + (bn > 0xFFE00000 && bn < 0xFFF00000)) + return "i"; /* at least one SNaN: IVO */ + else + return NULL; /* no SNaNs, but at least 1 QNaN */ + } + if ((b[0] & 0x7FFFFFFF) == 0 && b[1] == 0) { /* b==0: EDOM */ + out[0] = 0x7ff80000; + out[1] = 1; + return "EDOM status=i"; + } + if ((a[0] & 0x7FF00000) == 0x7FF00000) { /* a==Inf: EDOM */ + out[0] = 0x7ff80000; + out[1] = 1; + return "EDOM status=i"; + } + if ((b[0] & 0x7FF00000) == 0x7FF00000) { /* b==Inf: return a */ + out[0] = a[0]; + out[1] = a[1]; + return NULL; + } + if ((a[0] & 0x7FFFFFFF) == 0 && a[1] == 0) { /* a==0: return a */ + out[0] = a[0]; + out[1] = a[1]; + return NULL; + } + + /* + * OK. That's the special cases cleared out of the way. Now we + * have finite (though not necessarily normal) a and b. + */ + sign = a[0] & 0x80000000; /* we discard sign of b */ + test_frexp(a, am, (uint32 *)&aex); + test_frexp(b, bm, (uint32 *)&bex); + am[0] &= 0xFFFFF, am[0] |= 0x100000; + bm[0] &= 0xFFFFF, bm[0] |= 0x100000; + + while (aex >= bex) { + if (am[0] > bm[0] || (am[0] == bm[0] && am[1] >= bm[1])) { + am[1] -= bm[1]; + am[0] = am[0] - bm[0] - (am[1] > ~bm[1]); + } + if (aex > bex) { + am[0] = (am[0] << 1) | ((am[1] & 0x80000000) >> 31); + am[1] <<= 1; + aex--; + } else + break; + } + + /* + * Renormalise final result; this can be cunningly done by + * passing a denormal to ldexp. + */ + aex += 0x3fd; + am[0] |= sign; + test_ldexp(am, (uint32 *)&aex, out); + + return NULL; /* FIXME */ +} + +char *test_fmodf(uint32 *a, uint32 *b, uint32 *out) { + int sign; + int32 aex, bex; + uint32 am, bm; + + if ((*a & 0x7FFFFFFF) > 0x7F800000 || + (*b & 0x7FFFFFFF) > 0x7F800000) { + /* a or b is NaN: return QNaN, optionally with IVO */ + uint32 an, bn; + *out = 0x7fc00001; + an = *a & 0x7FFFFFFF; + bn = *b & 0x7FFFFFFF; + if ((an > 0x7f800000 && an < 0x7fc00000) || + (bn > 0x7f800000 && bn < 0x7fc00000)) + return "i"; /* at least one SNaN: IVO */ + else + return NULL; /* no SNaNs, but at least 1 QNaN */ + } + if ((*b & 0x7FFFFFFF) == 0) { /* b==0: EDOM */ + *out = 0x7fc00001; + return "EDOM status=i"; + } + if ((*a & 0x7F800000) == 0x7F800000) { /* a==Inf: EDOM */ + *out = 0x7fc00001; + return "EDOM status=i"; + } + if ((*b & 0x7F800000) == 0x7F800000) { /* b==Inf: return a */ + *out = *a; + return NULL; + } + if ((*a & 0x7FFFFFFF) == 0) { /* a==0: return a */ + *out = *a; + return NULL; + } + + /* + * OK. That's the special cases cleared out of the way. Now we + * have finite (though not necessarily normal) a and b. + */ + sign = a[0] & 0x80000000; /* we discard sign of b */ + test_frexpf(a, &am, (uint32 *)&aex); + test_frexpf(b, &bm, (uint32 *)&bex); + am &= 0x7FFFFF, am |= 0x800000; + bm &= 0x7FFFFF, bm |= 0x800000; + + while (aex >= bex) { + if (am >= bm) { + am -= bm; + } + if (aex > bex) { + am <<= 1; + aex--; + } else + break; + } + + /* + * Renormalise final result; this can be cunningly done by + * passing a denormal to ldexp. + */ + aex += 0x7d; + am |= sign; + test_ldexpf(&am, (uint32 *)&aex, out); + + return NULL; /* FIXME */ +} + +char *test_ldexp(uint32 *x, uint32 *np, uint32 *out) { + int n = *np; + int32 n2; + uint32 y[2]; + int ex = (x[0] >> 20) & 0x7FF; /* exponent */ + int sign = x[0] & 0x80000000; + + if (ex == 0x7FF) { /* inf/NaN; just return x */ + out[0] = x[0]; + out[1] = x[1]; + return NULL; + } + if ((x[0] & 0x7FFFFFFF) == 0 && x[1] == 0) { /* zero: return x */ + out[0] = x[0]; + out[1] = x[1]; + return NULL; + } + + test_frexp(x, y, (uint32 *)&n2); + ex = n + n2; + if (ex > 0x400) { /* overflow */ + out[0] = sign | 0x7FF00000; + out[1] = 0; + return "overflow"; + } + /* + * Underflow. 2^-1074 is 00000000.00000001; so if ex == -1074 + * then we have something [2^-1075,2^-1074). Under round-to- + * nearest-even, this whole interval rounds up to 2^-1074, + * except for the bottom endpoint which rounds to even and is + * an underflow condition. + * + * So, ex < -1074 is definite underflow, and ex == -1074 is + * underflow iff all mantissa bits are zero. + */ + if (ex < -1074 || (ex == -1074 && (y[0] & 0xFFFFF) == 0 && y[1] == 0)) { + out[0] = sign; /* underflow: correctly signed zero */ + out[1] = 0; + return "underflow"; + } + + /* + * No overflow or underflow; should be nice and simple, unless + * we have to denormalise and round the result. + */ + if (ex < -1021) { /* denormalise and round */ + uint32 roundword; + y[0] &= 0x000FFFFF; + y[0] |= 0x00100000; /* set leading bit */ + roundword = 0; + while (ex < -1021) { + if (roundword & 1) + roundword |= 2; /* preserve sticky bit */ + roundword = (roundword >> 1) | ((y[1] & 1) << 31); + y[1] = (y[1] >> 1) | ((y[0] & 1) << 31); + y[0] = y[0] >> 1; + ex++; + } + if (roundword > 0x80000000 || /* round up */ + (roundword == 0x80000000 && (y[1] & 1))) { /* round up to even */ + y[1]++; + y[0] += (y[1] == 0); + } + out[0] = sign | y[0]; + out[1] = y[1]; + /* Proper ERANGE underflow was handled earlier, but we still + * expect an IEEE Underflow exception if this partially + * underflowed result is not exact. */ + if (roundword) + return "u"; + return NULL; /* underflow was handled earlier */ + } else { + out[0] = y[0] + (ex << 20); + out[1] = y[1]; + return NULL; + } +} + +char *test_ldexpf(uint32 *x, uint32 *np, uint32 *out) { + int n = *np; + int32 n2; + uint32 y; + int ex = (*x >> 23) & 0xFF; /* exponent */ + int sign = *x & 0x80000000; + + if (ex == 0xFF) { /* inf/NaN; just return x */ + *out = *x; + return NULL; + } + if ((*x & 0x7FFFFFFF) == 0) { /* zero: return x */ + *out = *x; + return NULL; + } + + test_frexpf(x, &y, (uint32 *)&n2); + ex = n + n2; + if (ex > 0x80) { /* overflow */ + *out = sign | 0x7F800000; + return "overflow"; + } + /* + * Underflow. 2^-149 is 00000001; so if ex == -149 then we have + * something [2^-150,2^-149). Under round-to- nearest-even, + * this whole interval rounds up to 2^-149, except for the + * bottom endpoint which rounds to even and is an underflow + * condition. + * + * So, ex < -149 is definite underflow, and ex == -149 is + * underflow iff all mantissa bits are zero. + */ + if (ex < -149 || (ex == -149 && (y & 0x7FFFFF) == 0)) { + *out = sign; /* underflow: correctly signed zero */ + return "underflow"; + } + + /* + * No overflow or underflow; should be nice and simple, unless + * we have to denormalise and round the result. + */ + if (ex < -125) { /* denormalise and round */ + uint32 roundword; + y &= 0x007FFFFF; + y |= 0x00800000; /* set leading bit */ + roundword = 0; + while (ex < -125) { + if (roundword & 1) + roundword |= 2; /* preserve sticky bit */ + roundword = (roundword >> 1) | ((y & 1) << 31); + y = y >> 1; + ex++; + } + if (roundword > 0x80000000 || /* round up */ + (roundword == 0x80000000 && (y & 1))) { /* round up to even */ + y++; + } + *out = sign | y; + /* Proper ERANGE underflow was handled earlier, but we still + * expect an IEEE Underflow exception if this partially + * underflowed result is not exact. */ + if (roundword) + return "u"; + return NULL; /* underflow was handled earlier */ + } else { + *out = y + (ex << 23); + return NULL; + } +} + +char *test_frexp(uint32 *x, uint32 *out, uint32 *nout) { + int ex = (x[0] >> 20) & 0x7FF; /* exponent */ + if (ex == 0x7FF) { /* inf/NaN; return x/0 */ + out[0] = x[0]; + out[1] = x[1]; + nout[0] = 0; + return NULL; + } + if (ex == 0) { /* denormals/zeros */ + int sign; + uint32 xh, xl; + if ((x[0] & 0x7FFFFFFF) == 0 && x[1] == 0) { + /* zero: return x/0 */ + out[0] = x[0]; + out[1] = x[1]; + nout[0] = 0; + return NULL; + } + sign = x[0] & 0x80000000; + xh = x[0] & 0x7FFFFFFF; + xl = x[1]; + ex = 1; + while (!(xh & 0x100000)) { + ex--; + xh = (xh << 1) | ((xl >> 31) & 1); + xl = (xl & 0x7FFFFFFF) << 1; + } + out[0] = sign | 0x3FE00000 | (xh & 0xFFFFF); + out[1] = xl; + nout[0] = ex - 0x3FE; + return NULL; + } + out[0] = 0x3FE00000 | (x[0] & 0x800FFFFF); + out[1] = x[1]; + nout[0] = ex - 0x3FE; + return NULL; /* ordinary number; no error */ +} + +char *test_frexpf(uint32 *x, uint32 *out, uint32 *nout) { + int ex = (*x >> 23) & 0xFF; /* exponent */ + if (ex == 0xFF) { /* inf/NaN; return x/0 */ + *out = *x; + nout[0] = 0; + return NULL; + } + if (ex == 0) { /* denormals/zeros */ + int sign; + uint32 xv; + if ((*x & 0x7FFFFFFF) == 0) { + /* zero: return x/0 */ + *out = *x; + nout[0] = 0; + return NULL; + } + sign = *x & 0x80000000; + xv = *x & 0x7FFFFFFF; + ex = 1; + while (!(xv & 0x800000)) { + ex--; + xv = xv << 1; + } + *out = sign | 0x3F000000 | (xv & 0x7FFFFF); + nout[0] = ex - 0x7E; + return NULL; + } + *out = 0x3F000000 | (*x & 0x807FFFFF); + nout[0] = ex - 0x7E; + return NULL; /* ordinary number; no error */ +} + +char *test_modf(uint32 *x, uint32 *fout, uint32 *iout) { + int ex = (x[0] >> 20) & 0x7FF; /* exponent */ + int sign = x[0] & 0x80000000; + uint32 fh, fl; + + if (((x[0] & 0x7FFFFFFF) | (!!x[1])) > 0x7FF00000) { + /* + * NaN input: return the same in _both_ outputs. + */ + fout[0] = iout[0] = x[0]; + fout[1] = iout[1] = x[1]; + return NULL; + } + + test_rint(x, iout, 0, 0); + fh = x[0] - iout[0]; + fl = x[1] - iout[1]; + if (!fh && !fl) { /* no fraction part */ + fout[0] = sign; + fout[1] = 0; + return NULL; + } + if (!(iout[0] & 0x7FFFFFFF) && !iout[1]) { /* no integer part */ + fout[0] = x[0]; + fout[1] = x[1]; + return NULL; + } + while (!(fh & 0x100000)) { + ex--; + fh = (fh << 1) | ((fl >> 31) & 1); + fl = (fl & 0x7FFFFFFF) << 1; + } + fout[0] = sign | (ex << 20) | (fh & 0xFFFFF); + fout[1] = fl; + return NULL; +} + +char *test_modff(uint32 *x, uint32 *fout, uint32 *iout) { + int ex = (*x >> 23) & 0xFF; /* exponent */ + int sign = *x & 0x80000000; + uint32 f; + + if ((*x & 0x7FFFFFFF) > 0x7F800000) { + /* + * NaN input: return the same in _both_ outputs. + */ + *fout = *iout = *x; + return NULL; + } + + test_rintf(x, iout, 0, 0); + f = *x - *iout; + if (!f) { /* no fraction part */ + *fout = sign; + return NULL; + } + if (!(*iout & 0x7FFFFFFF)) { /* no integer part */ + *fout = *x; + return NULL; + } + while (!(f & 0x800000)) { + ex--; + f = f << 1; + } + *fout = sign | (ex << 23) | (f & 0x7FFFFF); + return NULL; +} + +char *test_copysign(uint32 *x, uint32 *y, uint32 *out) +{ + int ysign = y[0] & 0x80000000; + int xhigh = x[0] & 0x7fffffff; + + out[0] = ysign | xhigh; + out[1] = x[1]; + + /* There can be no error */ + return NULL; +} + +char *test_copysignf(uint32 *x, uint32 *y, uint32 *out) +{ + int ysign = y[0] & 0x80000000; + int xhigh = x[0] & 0x7fffffff; + + out[0] = ysign | xhigh; + + /* There can be no error */ + return NULL; +} + +char *test_isfinite(uint32 *x, uint32 *out) +{ + int xhigh = x[0]; + /* Being finite means that the exponent is not 0x7ff */ + if ((xhigh & 0x7ff00000) == 0x7ff00000) out[0] = 0; + else out[0] = 1; + return NULL; +} + +char *test_isfinitef(uint32 *x, uint32 *out) +{ + /* Being finite means that the exponent is not 0xff */ + if ((x[0] & 0x7f800000) == 0x7f800000) out[0] = 0; + else out[0] = 1; + return NULL; +} + +char *test_isinff(uint32 *x, uint32 *out) +{ + /* Being infinite means that our bottom 30 bits equate to 0x7f800000 */ + if ((x[0] & 0x7fffffff) == 0x7f800000) out[0] = 1; + else out[0] = 0; + return NULL; +} + +char *test_isinf(uint32 *x, uint32 *out) +{ + int xhigh = x[0]; + int xlow = x[1]; + /* Being infinite means that our fraction is zero and exponent is 0x7ff */ + if (((xhigh & 0x7fffffff) == 0x7ff00000) && (xlow == 0)) out[0] = 1; + else out[0] = 0; + return NULL; +} + +char *test_isnanf(uint32 *x, uint32 *out) +{ + /* Being NaN means that our exponent is 0xff and non-0 fraction */ + int exponent = x[0] & 0x7f800000; + int fraction = x[0] & 0x007fffff; + if ((exponent == 0x7f800000) && (fraction != 0)) out[0] = 1; + else out[0] = 0; + return NULL; +} + +char *test_isnan(uint32 *x, uint32 *out) +{ + /* Being NaN means that our exponent is 0x7ff and non-0 fraction */ + int exponent = x[0] & 0x7ff00000; + int fractionhigh = x[0] & 0x000fffff; + if ((exponent == 0x7ff00000) && ((fractionhigh != 0) || x[1] != 0)) + out[0] = 1; + else out[0] = 0; + return NULL; +} + +char *test_isnormalf(uint32 *x, uint32 *out) +{ + /* Being normal means exponent is not 0 and is not 0xff */ + int exponent = x[0] & 0x7f800000; + if (exponent == 0x7f800000) out[0] = 0; + else if (exponent == 0) out[0] = 0; + else out[0] = 1; + return NULL; +} + +char *test_isnormal(uint32 *x, uint32 *out) +{ + /* Being normal means exponent is not 0 and is not 0x7ff */ + int exponent = x[0] & 0x7ff00000; + if (exponent == 0x7ff00000) out[0] = 0; + else if (exponent == 0) out[0] = 0; + else out[0] = 1; + return NULL; +} + +char *test_signbitf(uint32 *x, uint32 *out) +{ + /* Sign bit is bit 31 */ + out[0] = (x[0] >> 31) & 1; + return NULL; +} + +char *test_signbit(uint32 *x, uint32 *out) +{ + /* Sign bit is bit 31 */ + out[0] = (x[0] >> 31) & 1; + return NULL; +} + +char *test_fpclassify(uint32 *x, uint32 *out) +{ + int exponent = (x[0] & 0x7ff00000) >> 20; + int fraction = (x[0] & 0x000fffff) | x[1]; + + if ((exponent == 0x00) && (fraction == 0)) out[0] = 0; + else if ((exponent == 0x00) && (fraction != 0)) out[0] = 4; + else if ((exponent == 0x7ff) && (fraction == 0)) out[0] = 3; + else if ((exponent == 0x7ff) && (fraction != 0)) out[0] = 7; + else out[0] = 5; + return NULL; +} + +char *test_fpclassifyf(uint32 *x, uint32 *out) +{ + int exponent = (x[0] & 0x7f800000) >> 23; + int fraction = x[0] & 0x007fffff; + + if ((exponent == 0x000) && (fraction == 0)) out[0] = 0; + else if ((exponent == 0x000) && (fraction != 0)) out[0] = 4; + else if ((exponent == 0xff) && (fraction == 0)) out[0] = 3; + else if ((exponent == 0xff) && (fraction != 0)) out[0] = 7; + else out[0] = 5; + return NULL; +} + +/* + * Internal function that compares doubles in x & y and returns -3, -2, -1, 0, + * 1 if they compare to be signaling, unordered, less than, equal or greater + * than. + */ +static int fpcmp4(uint32 *x, uint32 *y) +{ + int result = 0; + + /* + * Sort out whether results are ordered or not to begin with + * NaNs have exponent 0x7ff, and non-zero fraction. Signaling NaNs take + * higher priority than quiet ones. + */ + if ((x[0] & 0x7fffffff) >= 0x7ff80000) result = -2; + else if ((x[0] & 0x7fffffff) > 0x7ff00000) result = -3; + else if (((x[0] & 0x7fffffff) == 0x7ff00000) && (x[1] != 0)) result = -3; + if ((y[0] & 0x7fffffff) >= 0x7ff80000 && result != -3) result = -2; + else if ((y[0] & 0x7fffffff) > 0x7ff00000) result = -3; + else if (((y[0] & 0x7fffffff) == 0x7ff00000) && (y[1] != 0)) result = -3; + if (result != 0) return result; + + /* + * The two forms of zero are equal + */ + if (((x[0] & 0x7fffffff) == 0) && x[1] == 0 && + ((y[0] & 0x7fffffff) == 0) && y[1] == 0) + return 0; + + /* + * If x and y have different signs we can tell that they're not equal + * If x is +ve we have x > y return 1 - otherwise y is +ve return -1 + */ + if ((x[0] >> 31) != (y[0] >> 31)) + return ((x[0] >> 31) == 0) - ((y[0] >> 31) == 0); + + /* + * Now we have both signs the same, let's do an initial compare of the + * values. + * + * Whoever designed IEEE754's floating point formats is very clever and + * earns my undying admiration. Once you remove the sign-bit, the + * floating point numbers can be ordered using the standard <, ==, > + * operators will treating the fp-numbers as integers with that bit- + * pattern. + */ + if ((x[0] & 0x7fffffff) < (y[0] & 0x7fffffff)) result = -1; + else if ((x[0] & 0x7fffffff) > (y[0] & 0x7fffffff)) result = 1; + else if (x[1] < y[1]) result = -1; + else if (x[1] > y[1]) result = 1; + else result = 0; + + /* + * Now we return the result - is x is positive (and therefore so is y) we + * return the plain result - otherwise we negate it and return. + */ + if ((x[0] >> 31) == 0) return result; + else return -result; +} + +/* + * Internal function that compares floats in x & y and returns -3, -2, -1, 0, + * 1 if they compare to be signaling, unordered, less than, equal or greater + * than. + */ +static int fpcmp4f(uint32 *x, uint32 *y) +{ + int result = 0; + + /* + * Sort out whether results are ordered or not to begin with + * NaNs have exponent 0xff, and non-zero fraction - we have to handle all + * signaling cases over the quiet ones + */ + if ((x[0] & 0x7fffffff) >= 0x7fc00000) result = -2; + else if ((x[0] & 0x7fffffff) > 0x7f800000) result = -3; + if ((y[0] & 0x7fffffff) >= 0x7fc00000 && result != -3) result = -2; + else if ((y[0] & 0x7fffffff) > 0x7f800000) result = -3; + if (result != 0) return result; + + /* + * The two forms of zero are equal + */ + if (((x[0] & 0x7fffffff) == 0) && ((y[0] & 0x7fffffff) == 0)) + return 0; + + /* + * If x and y have different signs we can tell that they're not equal + * If x is +ve we have x > y return 1 - otherwise y is +ve return -1 + */ + if ((x[0] >> 31) != (y[0] >> 31)) + return ((x[0] >> 31) == 0) - ((y[0] >> 31) == 0); + + /* + * Now we have both signs the same, let's do an initial compare of the + * values. + * + * Whoever designed IEEE754's floating point formats is very clever and + * earns my undying admiration. Once you remove the sign-bit, the + * floating point numbers can be ordered using the standard <, ==, > + * operators will treating the fp-numbers as integers with that bit- + * pattern. + */ + if ((x[0] & 0x7fffffff) < (y[0] & 0x7fffffff)) result = -1; + else if ((x[0] & 0x7fffffff) > (y[0] & 0x7fffffff)) result = 1; + else result = 0; + + /* + * Now we return the result - is x is positive (and therefore so is y) we + * return the plain result - otherwise we negate it and return. + */ + if ((x[0] >> 31) == 0) return result; + else return -result; +} + +char *test_isgreater(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4(x, y); + *out = (result == 1); + return result == -3 ? "i" : NULL; +} + +char *test_isgreaterequal(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4(x, y); + *out = (result >= 0); + return result == -3 ? "i" : NULL; +} + +char *test_isless(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4(x, y); + *out = (result == -1); + return result == -3 ? "i" : NULL; +} + +char *test_islessequal(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4(x, y); + *out = (result == -1) || (result == 0); + return result == -3 ? "i" : NULL; +} + +char *test_islessgreater(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4(x, y); + *out = (result == -1) || (result == 1); + return result == -3 ? "i" : NULL; +} + +char *test_isunordered(uint32 *x, uint32 *y, uint32 *out) +{ + int normal = 0; + int result = fpcmp4(x, y); + + test_isnormal(x, out); + normal |= *out; + test_isnormal(y, out); + normal |= *out; + *out = (result == -2) || (result == -3); + return result == -3 ? "i" : NULL; +} + +char *test_isgreaterf(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4f(x, y); + *out = (result == 1); + return result == -3 ? "i" : NULL; +} + +char *test_isgreaterequalf(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4f(x, y); + *out = (result >= 0); + return result == -3 ? "i" : NULL; +} + +char *test_islessf(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4f(x, y); + *out = (result == -1); + return result == -3 ? "i" : NULL; +} + +char *test_islessequalf(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4f(x, y); + *out = (result == -1) || (result == 0); + return result == -3 ? "i" : NULL; +} + +char *test_islessgreaterf(uint32 *x, uint32 *y, uint32 *out) +{ + int result = fpcmp4f(x, y); + *out = (result == -1) || (result == 1); + return result == -3 ? "i" : NULL; +} + +char *test_isunorderedf(uint32 *x, uint32 *y, uint32 *out) +{ + int normal = 0; + int result = fpcmp4f(x, y); + + test_isnormalf(x, out); + normal |= *out; + test_isnormalf(y, out); + normal |= *out; + *out = (result == -2) || (result == -3); + return result == -3 ? "i" : NULL; +} diff --git a/libc/AOR_v20.02/math/test/rtest/semi.h b/libc/AOR_v20.02/math/test/rtest/semi.h new file mode 100644 index 00000000000000..0aaeee7a0acbea --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/semi.h @@ -0,0 +1,54 @@ +/* + * semi.h: header for semi.c + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef test_semi_h +#define test_semi_h + +#include "types.h" + +char *test_ceil(uint32 *in, uint32 *out); +char *test_floor(uint32 *in, uint32 *out); +char *test_fmod(uint32 *a, uint32 *b, uint32 *out); +char *test_ldexp(uint32 *x, uint32 *n, uint32 *out); +char *test_frexp(uint32 *x, uint32 *out, uint32 *nout); +char *test_modf(uint32 *x, uint32 *iout, uint32 *fout); +char *test_ceilf(uint32 *in, uint32 *out); +char *test_floorf(uint32 *in, uint32 *out); +char *test_fmodf(uint32 *a, uint32 *b, uint32 *out); +char *test_ldexpf(uint32 *x, uint32 *n, uint32 *out); +char *test_frexpf(uint32 *x, uint32 *out, uint32 *nout); +char *test_modff(uint32 *x, uint32 *iout, uint32 *fout); + +char *test_copysign(uint32 *x, uint32 *y, uint32 *out); +char *test_copysignf(uint32 *x, uint32 *y, uint32 *out); +char *test_isfinite(uint32 *x, uint32 *out); +char *test_isfinitef(uint32 *x, uint32 *out); +char *test_isinf(uint32 *x, uint32 *out); +char *test_isinff(uint32 *x, uint32 *out); +char *test_isnan(uint32 *x, uint32 *out); +char *test_isnanf(uint32 *x, uint32 *out); +char *test_isnormal(uint32 *x, uint32 *out); +char *test_isnormalf(uint32 *x, uint32 *out); +char *test_signbit(uint32 *x, uint32 *out); +char *test_signbitf(uint32 *x, uint32 *out); +char *test_fpclassify(uint32 *x, uint32 *out); +char *test_fpclassifyf(uint32 *x, uint32 *out); + +char *test_isgreater(uint32 *x, uint32 *y, uint32 *out); +char *test_isgreaterequal(uint32 *x, uint32 *y, uint32 *out); +char *test_isless(uint32 *x, uint32 *y, uint32 *out); +char *test_islessequal(uint32 *x, uint32 *y, uint32 *out); +char *test_islessgreater(uint32 *x, uint32 *y, uint32 *out); +char *test_isunordered(uint32 *x, uint32 *y, uint32 *out); +char *test_isgreaterf(uint32 *x, uint32 *y, uint32 *out); +char *test_isgreaterequalf(uint32 *x, uint32 *y, uint32 *out); +char *test_islessf(uint32 *x, uint32 *y, uint32 *out); +char *test_islessequalf(uint32 *x, uint32 *y, uint32 *out); +char *test_islessgreaterf(uint32 *x, uint32 *y, uint32 *out); +char *test_isunorderedf(uint32 *x, uint32 *y, uint32 *out); +#endif diff --git a/libc/AOR_v20.02/math/test/rtest/types.h b/libc/AOR_v20.02/math/test/rtest/types.h new file mode 100644 index 00000000000000..36806a68dcab5a --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/types.h @@ -0,0 +1,26 @@ +/* + * types.h + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef mathtest_types_h +#define mathtest_types_h + +#include + +#if UINT_MAX == 4294967295 +typedef unsigned int uint32; +typedef int int32; +#define I32 "" +#elif ULONG_MAX == 4294967295 +typedef unsigned long uint32; +typedef long int32; +#define I32 "l" +#else +#error Could not find an unsigned 32-bit integer type +#endif + +#endif diff --git a/libc/AOR_v20.02/math/test/rtest/wrappers.c b/libc/AOR_v20.02/math/test/rtest/wrappers.c new file mode 100644 index 00000000000000..71b90ea47fad91 --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/wrappers.c @@ -0,0 +1,262 @@ +/* + * wrappers.c - wrappers to modify output of MPFR/MPC test functions + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include + +#include "intern.h" + +void wrapper_init(wrapperctx *ctx) +{ + int i; + ctx->nops = ctx->nresults = 0; + for (i = 0; i < 2; i++) { + ctx->mpfr_ops[i] = NULL; + ctx->mpc_ops[i] = NULL; + ctx->ieee_ops[i] = NULL; + } + ctx->mpfr_result = NULL; + ctx->mpc_result = NULL; + ctx->ieee_result = NULL; + ctx->need_regen = 0; +} + +void wrapper_op_real(wrapperctx *ctx, const mpfr_t r, + int size, const uint32 *ieee) +{ + assert(ctx->nops < 2); + ctx->mpfr_ops[ctx->nops] = r; + ctx->ieee_ops[ctx->nops] = ieee; + ctx->size_ops[ctx->nops] = size; + ctx->nops++; +} + +void wrapper_op_complex(wrapperctx *ctx, const mpc_t c, + int size, const uint32 *ieee) +{ + assert(ctx->nops < 2); + ctx->mpc_ops[ctx->nops] = c; + ctx->ieee_ops[ctx->nops] = ieee; + ctx->size_ops[ctx->nops] = size; + ctx->nops++; +} + +void wrapper_result_real(wrapperctx *ctx, mpfr_t r, + int size, uint32 *ieee) +{ + assert(ctx->nresults < 1); + ctx->mpfr_result = r; + ctx->ieee_result = ieee; + ctx->size_result = size; + ctx->nresults++; +} + +void wrapper_result_complex(wrapperctx *ctx, mpc_t c, + int size, uint32 *ieee) +{ + assert(ctx->nresults < 1); + ctx->mpc_result = c; + ctx->ieee_result = ieee; + ctx->size_result = size; + ctx->nresults++; +} + +int wrapper_run(wrapperctx *ctx, wrapperfunc wrappers[MAXWRAPPERS]) +{ + int i; + for (i = 0; i < MAXWRAPPERS && wrappers[i]; i++) + wrappers[i](ctx); + universal_wrapper(ctx); + return ctx->need_regen; +} + +mpfr_srcptr wrapper_get_mpfr(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpfr_result); + return ctx->mpfr_result; + } else { + assert(ctx->mpfr_ops[op]); + return ctx->mpfr_ops[op]; + } +} + +const uint32 *wrapper_get_ieee(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpfr_result); + return ctx->ieee_result; + } else { + assert(ctx->mpfr_ops[op]); + return ctx->ieee_ops[op]; + } +} + +int wrapper_get_nops(wrapperctx *ctx) +{ + return ctx->nops; +} + +int wrapper_get_size(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpfr_result || ctx->mpc_result); + return ctx->size_result; + } else { + assert(ctx->mpfr_ops[op] || ctx->mpc_ops[op]); + return ctx->size_ops[op]; + } +} + +int wrapper_is_complex(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpfr_result || ctx->mpc_result); + return ctx->mpc_result != NULL; + } else { + assert(ctx->mpfr_ops[op] || ctx->mpc_ops[op]); + return ctx->mpc_ops[op] != NULL; + } +} + +mpc_srcptr wrapper_get_mpc(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpc_result); + return ctx->mpc_result; + } else { + assert(ctx->mpc_ops[op]); + return ctx->mpc_ops[op]; + } +} + +mpfr_srcptr wrapper_get_mpfr_r(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpc_result); + return mpc_realref(ctx->mpc_result); + } else { + assert(ctx->mpc_ops[op]); + return mpc_realref(ctx->mpc_ops[op]); + } +} + +mpfr_srcptr wrapper_get_mpfr_i(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpc_result); + return mpc_imagref(ctx->mpc_result); + } else { + assert(ctx->mpc_ops[op]); + return mpc_imagref(ctx->mpc_ops[op]); + } +} + +const uint32 *wrapper_get_ieee_r(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpc_result); + return ctx->ieee_result; + } else { + assert(ctx->mpc_ops[op]); + return ctx->ieee_ops[op]; + } +} + +const uint32 *wrapper_get_ieee_i(wrapperctx *ctx, int op) +{ + if (op < 0) { + assert(ctx->mpc_result); + return ctx->ieee_result + 4; + } else { + assert(ctx->mpc_ops[op]); + return ctx->ieee_ops[op] + 2; + } +} + +void wrapper_set_sign(wrapperctx *ctx, uint32 sign) +{ + assert(ctx->mpfr_result); + ctx->ieee_result[0] |= (sign & 0x80000000U); +} + +void wrapper_set_sign_r(wrapperctx *ctx, uint32 sign) +{ + assert(ctx->mpc_result); + ctx->ieee_result[0] |= (sign & 0x80000000U); +} + +void wrapper_set_sign_i(wrapperctx *ctx, uint32 sign) +{ + assert(ctx->mpc_result); + ctx->ieee_result[4] |= (sign & 0x80000000U); +} + +void wrapper_set_nan(wrapperctx *ctx) +{ + assert(ctx->mpfr_result); + mpfr_set_nan(ctx->mpfr_result); + ctx->need_regen = 1; +} + +void wrapper_set_nan_r(wrapperctx *ctx) +{ + assert(ctx->mpc_result); + mpfr_set_nan(mpc_realref(ctx->mpc_result)); /* FIXME: better way? */ + ctx->need_regen = 1; +} + +void wrapper_set_nan_i(wrapperctx *ctx) +{ + assert(ctx->mpc_result); + mpfr_set_nan(mpc_imagref(ctx->mpc_result)); /* FIXME: better way? */ + ctx->need_regen = 1; +} + +void wrapper_set_int(wrapperctx *ctx, int val) +{ + assert(ctx->mpfr_result); + mpfr_set_si(ctx->mpfr_result, val, GMP_RNDN); + ctx->need_regen = 1; +} + +void wrapper_set_int_r(wrapperctx *ctx, int val) +{ + assert(ctx->mpc_result); + mpfr_set_si(mpc_realref(ctx->mpc_result), val, GMP_RNDN); + ctx->need_regen = 1; +} + +void wrapper_set_int_i(wrapperctx *ctx, int val) +{ + assert(ctx->mpc_result); + mpfr_set_si(mpc_realref(ctx->mpc_result), val, GMP_RNDN); + ctx->need_regen = 1; +} + +void wrapper_set_mpfr(wrapperctx *ctx, const mpfr_t val) +{ + assert(ctx->mpfr_result); + mpfr_set(ctx->mpfr_result, val, GMP_RNDN); + ctx->need_regen = 1; +} + +void wrapper_set_mpfr_r(wrapperctx *ctx, const mpfr_t val) +{ + assert(ctx->mpc_result); + mpfr_set(mpc_realref(ctx->mpc_result), val, GMP_RNDN); + ctx->need_regen = 1; +} + +void wrapper_set_mpfr_i(wrapperctx *ctx, const mpfr_t val) +{ + assert(ctx->mpc_result); + mpfr_set(mpc_realref(ctx->mpc_result), val, GMP_RNDN); + ctx->need_regen = 1; +} diff --git a/libc/AOR_v20.02/math/test/rtest/wrappers.h b/libc/AOR_v20.02/math/test/rtest/wrappers.h new file mode 100644 index 00000000000000..e2e653a0f01e15 --- /dev/null +++ b/libc/AOR_v20.02/math/test/rtest/wrappers.h @@ -0,0 +1,115 @@ +/* + * wrappers.h - wrappers to modify output of MPFR/MPC test functions + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +typedef struct { + /* Structure type should be considered opaque outside wrappers.c, + * though we have to define it here so its size is known. */ + int nops; + int nresults; + mpfr_srcptr mpfr_ops[2]; + mpfr_ptr mpfr_result; + mpc_srcptr mpc_ops[2]; + mpc_ptr mpc_result; + const uint32 *ieee_ops[2]; + uint32 *ieee_result; + int size_ops[2]; + int size_result; + int need_regen; +} wrapperctx; + +typedef void (*wrapperfunc)(wrapperctx *ctx); +#define MAXWRAPPERS 3 + +/* + * Functions for the test harness to call. + * + * When the test harness executes a test function, it should + * initialise a wrapperctx with wrapper_init, then provide all the + * operands and results in both mpfr/mpc and IEEE (+ extrabits) + * formats via wrapper_op_* and wrapper_result_*. Then it should run + * the function's wrappers using wrapper_run(), and if that returns + * true then the primary result has been rewritten in mpfr/mpc format + * and it should therefore retranslate into IEEE. + * + * 'size' in all prototypes below represents an FP type by giving the + * number of 32-bit words it requires, so 1=float and 2=double. Input + * operands will be that many words (or that many for both their real + * and imag parts); outputs will have one extra word for 'extrabits'. + * + * This system only applies at all to reference functions using + * mpfr/mpc. The seminumerical functions we implement in pure IEEE + * form are expected to handle all their own special cases correctly. + */ + +void wrapper_init(wrapperctx *ctx); + +/* Real operand. */ +void wrapper_op_real(wrapperctx *ctx, const mpfr_t r, + int size, const uint32 *ieee); + +/* Complex operand. Real part starts at ieee[0], the imag part at ieee[2]. */ +void wrapper_op_complex(wrapperctx *ctx, const mpc_t c, + int size, const uint32 *ieee); + +/* Real result. ieee contains size+1 words, as discussed above. */ +void wrapper_result_real(wrapperctx *ctx, mpfr_t r, + int size, uint32 *ieee); + +/* Complex result. ieee contains size+1 words of real part starting at + * ieee[0], and another size+1 of imag part starting at ieee[4]. */ +void wrapper_result_complex(wrapperctx *ctx, mpc_t c, + int size, uint32 *ieee); + +int wrapper_run(wrapperctx *ctx, wrapperfunc wrappers[MAXWRAPPERS]); + +/* + * Functions for wrappers to call. 'op' indicates which operand is + * being requested: 0,1 means first and second, and -1 means the + * result. + */ + +mpfr_srcptr wrapper_get_mpfr(wrapperctx *ctx, int op); +const uint32 *wrapper_get_ieee(wrapperctx *ctx, int op); + +mpc_srcptr wrapper_get_mpc(wrapperctx *ctx, int op); +mpfr_srcptr wrapper_get_mpfr_r(wrapperctx *ctx, int op); +mpfr_srcptr wrapper_get_mpfr_i(wrapperctx *ctx, int op); +const uint32 *wrapper_get_ieee_r(wrapperctx *ctx, int op); +const uint32 *wrapper_get_ieee_i(wrapperctx *ctx, int op); + +/* Query operand count + types */ +int wrapper_get_nops(wrapperctx *ctx); +int wrapper_get_size(wrapperctx *ctx, int op); +int wrapper_is_complex(wrapperctx *ctx, int op); + +/* Change just the sign of the result. Only the top bit of 'sign' is used. */ +void wrapper_set_sign(wrapperctx *ctx, uint32 sign); +void wrapper_set_sign_r(wrapperctx *ctx, uint32 sign); +void wrapper_set_sign_i(wrapperctx *ctx, uint32 sign); + +/* Set a result to NaN. */ +void wrapper_set_nan(wrapperctx *ctx); +void wrapper_set_nan_r(wrapperctx *ctx); +void wrapper_set_nan_i(wrapperctx *ctx); + +/* Set a result to an integer value (converted to the appropriate + * float format). */ +void wrapper_set_int(wrapperctx *ctx, int val); +void wrapper_set_int_r(wrapperctx *ctx, int val); +void wrapper_set_int_i(wrapperctx *ctx, int val); + +/* Set a result to a new MPFR float. */ +void wrapper_set_mpfr(wrapperctx *ctx, const mpfr_t val); +void wrapper_set_mpfr_r(wrapperctx *ctx, const mpfr_t val); +void wrapper_set_mpfr_i(wrapperctx *ctx, const mpfr_t val); + +/* + * A universal wrapper called for _all_ functions, that doesn't have + * to be specified individually everywhere. + */ +void universal_wrapper(wrapperctx *ctx); diff --git a/libc/AOR_v20.02/math/test/runulp.sh b/libc/AOR_v20.02/math/test/runulp.sh new file mode 100755 index 00000000000000..431829bfc52ff3 --- /dev/null +++ b/libc/AOR_v20.02/math/test/runulp.sh @@ -0,0 +1,295 @@ +#!/bin/bash + +# ULP error check script. +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#set -x +set -eu + +# cd to bin directory. +cd "${0%/*}" + +rmodes='n u d z' +#rmodes=n +flags="${ULPFLAGS:--q}" +emu="$@" + +FAIL=0 +PASS=0 + +t() { + [ $r = "n" ] && Lt=$L || Lt=$Ldir + $emu ./ulp -r $r -e $Lt $flags "$@" && PASS=$((PASS+1)) || FAIL=$((FAIL+1)) +} + +check() { + $emu ./ulp -f -q "$@" >/dev/null +} + +Ldir=0.5 +for r in $rmodes +do +L=0.01 +t exp 0 0xffff000000000000 10000 +t exp 0x1p-6 0x1p6 40000 +t exp -0x1p-6 -0x1p6 40000 +t exp 633.3 733.3 10000 +t exp -633.3 -777.3 10000 + +L=0.01 +t exp2 0 0xffff000000000000 10000 +t exp2 0x1p-6 0x1p6 40000 +t exp2 -0x1p-6 -0x1p6 40000 +t exp2 633.3 733.3 10000 +t exp2 -633.3 -777.3 10000 + +L=0.02 +t log 0 0xffff000000000000 10000 +t log 0x1p-4 0x1p4 40000 +t log 0 inf 40000 + +L=0.05 +t log2 0 0xffff000000000000 10000 +t log2 0x1p-4 0x1p4 40000 +t log2 0 inf 40000 + +L=0.05 +t pow 0.5 2.0 x 0 inf 20000 +t pow -0.5 -2.0 x 0 inf 20000 +t pow 0.5 2.0 x -0 -inf 20000 +t pow -0.5 -2.0 x -0 -inf 20000 +t pow 0.5 2.0 x 0x1p-10 0x1p10 40000 +t pow 0.5 2.0 x -0x1p-10 -0x1p10 40000 +t pow 0 inf x 0.5 2.0 80000 +t pow 0 inf x -0.5 -2.0 80000 +t pow 0x1.fp-1 0x1.08p0 x 0x1p8 0x1p17 80000 +t pow 0x1.fp-1 0x1.08p0 x -0x1p8 -0x1p17 80000 +t pow 0 0x1p-1000 x 0 1.0 50000 +t pow 0x1p1000 inf x 0 1.0 50000 +t pow 0x1.ffffffffffff0p-1 0x1.0000000000008p0 x 0x1p60 0x1p68 50000 +t pow 0x1.ffffffffff000p-1 0x1p0 x 0x1p50 0x1p52 50000 +t pow -0x1.ffffffffff000p-1 -0x1p0 x 0x1p50 0x1p52 50000 + +L=0.01 +t expf 0 0xffff0000 10000 +t expf 0x1p-14 0x1p8 50000 +t expf -0x1p-14 -0x1p8 50000 + +L=0.01 +t exp2f 0 0xffff0000 10000 +t exp2f 0x1p-14 0x1p8 50000 +t exp2f -0x1p-14 -0x1p8 50000 + +L=0.32 +t logf 0 0xffff0000 10000 +t logf 0x1p-4 0x1p4 50000 +t logf 0 inf 50000 + +L=0.26 +t log2f 0 0xffff0000 10000 +t log2f 0x1p-4 0x1p4 50000 +t log2f 0 inf 50000 + +L=0.06 +t sinf 0 0xffff0000 10000 +t sinf 0x1p-14 0x1p54 50000 +t sinf -0x1p-14 -0x1p54 50000 + +L=0.06 +t cosf 0 0xffff0000 10000 +t cosf 0x1p-14 0x1p54 50000 +t cosf -0x1p-14 -0x1p54 50000 + +L=0.06 +t sincosf_sinf 0 0xffff0000 10000 +t sincosf_sinf 0x1p-14 0x1p54 50000 +t sincosf_sinf -0x1p-14 -0x1p54 50000 + +L=0.06 +t sincosf_cosf 0 0xffff0000 10000 +t sincosf_cosf 0x1p-14 0x1p54 50000 +t sincosf_cosf -0x1p-14 -0x1p54 50000 + +L=0.4 +t powf 0x1p-1 0x1p1 x 0x1p-7 0x1p7 50000 +t powf 0x1p-1 0x1p1 x -0x1p-7 -0x1p7 50000 +t powf 0x1p-70 0x1p70 x 0x1p-1 0x1p1 50000 +t powf 0x1p-70 0x1p70 x -0x1p-1 -0x1p1 50000 +t powf 0x1.ep-1 0x1.1p0 x 0x1p8 0x1p14 50000 +t powf 0x1.ep-1 0x1.1p0 x -0x1p8 -0x1p14 50000 +done + +# vector functions +Ldir=0.5 +r='n' +flags="${ULPFLAGS:--q} -f" +runs= +check __s_exp 1 && runs=1 +runv= +check __v_exp 1 && runv=1 +runvn= +check __vn_exp 1 && runvn=1 + +range_exp=' + 0 0xffff000000000000 10000 + 0x1p-6 0x1p6 400000 + -0x1p-6 -0x1p6 400000 + 633.3 733.3 10000 + -633.3 -777.3 10000 +' + +range_log=' + 0 0xffff000000000000 10000 + 0x1p-4 0x1p4 400000 + 0 inf 400000 +' + +range_pow=' + 0x1p-1 0x1p1 x 0x1p-10 0x1p10 50000 + 0x1p-1 0x1p1 x -0x1p-10 -0x1p10 50000 + 0x1p-500 0x1p500 x 0x1p-1 0x1p1 50000 + 0x1p-500 0x1p500 x -0x1p-1 -0x1p1 50000 + 0x1.ep-1 0x1.1p0 x 0x1p8 0x1p16 50000 + 0x1.ep-1 0x1.1p0 x -0x1p8 -0x1p16 50000 +' + +range_sin=' + 0 0xffff000000000000 10000 + 0x1p-4 0x1p4 400000 + -0x1p-23 0x1p23 400000 +' +range_cos="$range_sin" + +range_expf=' + 0 0xffff0000 10000 + 0x1p-14 0x1p8 500000 + -0x1p-14 -0x1p8 500000 +' + +range_expf_1u="$range_expf" +range_exp2f="$range_expf" +range_exp2f_1u="$range_expf" + +range_logf=' + 0 0xffff0000 10000 + 0x1p-4 0x1p4 500000 +' + +range_sinf=' + 0 0xffff0000 10000 + 0x1p-4 0x1p4 300000 +-0x1p-9 -0x1p9 300000 +' +range_cosf="$range_sinf" + +range_powf=' + 0x1p-1 0x1p1 x 0x1p-7 0x1p7 50000 + 0x1p-1 0x1p1 x -0x1p-7 -0x1p7 50000 + 0x1p-70 0x1p70 x 0x1p-1 0x1p1 50000 + 0x1p-70 0x1p70 x -0x1p-1 -0x1p1 50000 + 0x1.ep-1 0x1.1p0 x 0x1p8 0x1p14 50000 + 0x1.ep-1 0x1.1p0 x -0x1p8 -0x1p14 50000 +' + +# error limits +L_exp=1.9 +L_log=1.2 +L_pow=0.05 +L_sin=3.0 +L_cos=3.0 +L_expf=1.49 +L_expf_1u=0.4 +L_exp2f=1.49 +L_exp2f_1u=0.4 +L_logf=2.9 +L_sinf=1.4 +L_cosf=1.4 +L_powf=2.1 + +while read G F R +do + [ "$R" = 1 ] || continue + case "$G" in \#*) continue ;; esac + eval range="\${range_$G}" + eval L="\${L_$G}" + while read X + do + [ -n "$X" ] || continue + case "$X" in \#*) continue ;; esac + t $F $X + done << EOF +$range +EOF +done << EOF +# group symbol run +exp __s_exp $runs +exp __v_exp $runv +exp __vn_exp $runvn +exp _ZGVnN2v_exp $runvn + +log __s_log $runs +log __v_log $runv +log __vn_log $runvn +log _ZGVnN2v_log $runvn + +pow __s_pow $runs +pow __v_pow $runv +pow __vn_pow $runvn +pow _ZGVnN2vv_pow $runvn + +sin __s_sin $runs +sin __v_sin $runv +sin __vn_sin $runvn +sin _ZGVnN2v_sin $runvn + +cos __s_cos $runs +cos __v_cos $runv +cos __vn_cos $runvn +cos _ZGVnN2v_cos $runvn + +expf __s_expf $runs +expf __v_expf $runv +expf __vn_expf $runvn +expf _ZGVnN4v_expf $runvn + +expf_1u __s_expf_1u $runs +expf_1u __v_expf_1u $runv +expf_1u __vn_expf_1u $runvn + +exp2f __s_exp2f $runs +exp2f __v_exp2f $runv +exp2f __vn_exp2f $runvn +exp2f _ZGVnN4v_exp2f $runvn + +exp2f_1u __s_exp2f_1u $runs +exp2f_1u __v_exp2f_1u $runv +exp2f_1u __vn_exp2f_1u $runvn + +logf __s_logf $runs +logf __v_logf $runv +logf __vn_logf $runvn +logf _ZGVnN4v_logf $runvn + +sinf __s_sinf $runs +sinf __v_sinf $runv +sinf __vn_sinf $runvn +sinf _ZGVnN4v_sinf $runvn + +cosf __s_cosf $runs +cosf __v_cosf $runv +cosf __vn_cosf $runvn +cosf _ZGVnN4v_cosf $runvn + +powf __s_powf $runs +powf __v_powf $runv +powf __vn_powf $runvn +powf _ZGVnN4vv_powf $runvn +EOF + +[ 0 -eq $FAIL ] || { + echo "FAILED $FAIL PASSED $PASS" + exit 1 +} diff --git a/libc/AOR_v20.02/math/test/testcases/directed/cosf.tst b/libc/AOR_v20.02/math/test/testcases/directed/cosf.tst new file mode 100644 index 00000000000000..8c7621a4550c62 --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/cosf.tst @@ -0,0 +1,26 @@ +; cosf.tst - Directed test cases for SP cosine +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=cosf op1=7fc00001 result=7fc00001 errno=0 +func=cosf op1=ffc00001 result=7fc00001 errno=0 +func=cosf op1=7f800001 result=7fc00001 errno=0 status=i +func=cosf op1=ff800001 result=7fc00001 errno=0 status=i +func=cosf op1=7f800000 result=7fc00001 errno=EDOM status=i +func=cosf op1=ff800000 result=7fc00001 errno=EDOM status=i +func=cosf op1=00000000 result=3f800000 errno=0 +func=cosf op1=80000000 result=3f800000 errno=0 +; SDCOMP-26094: check cosf in the cases for which the range reducer +; returns values furthest beyond its nominal upper bound of pi/4. +func=cosf op1=46427f1b result=3f34dc5c.565 error=0 +func=cosf op1=4647e568 result=3f34dc33.c1f error=0 +func=cosf op1=46428bac result=bf34dbf2.8e3 error=0 +func=cosf op1=4647f1f9 result=bf34dbc9.f9b error=0 +func=cosf op1=4647fe8a result=3f34db60.313 error=0 +func=cosf op1=45d8d7f1 result=bf35006a.7fd error=0 +func=cosf op1=45d371a4 result=3f350056.39b error=0 +func=cosf op1=45ce0b57 result=bf350041.f38 error=0 +func=cosf op1=45d35882 result=bf34ffec.868 error=0 +func=cosf op1=45cdf235 result=3f34ffd8.404 error=0 diff --git a/libc/AOR_v20.02/math/test/testcases/directed/exp.tst b/libc/AOR_v20.02/math/test/testcases/directed/exp.tst new file mode 100644 index 00000000000000..7c466d6b6ca9ba --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/exp.tst @@ -0,0 +1,32 @@ +; Directed test cases for exp +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=exp op1=7ff80000.00000001 result=7ff80000.00000001 errno=0 +func=exp op1=fff80000.00000001 result=7ff80000.00000001 errno=0 +func=exp op1=7ff00000.00000001 result=7ff80000.00000001 errno=0 status=i +func=exp op1=fff00000.00000001 result=7ff80000.00000001 errno=0 status=i +func=exp op1=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=exp op1=fff00000.00000000 result=00000000.00000000 errno=0 +func=exp op1=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=ox +func=exp op1=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=ux +func=exp op1=00000000.00000000 result=3ff00000.00000000 errno=0 +func=exp op1=80000000.00000000 result=3ff00000.00000000 errno=0 +func=exp op1=00000000.00000001 result=3ff00000.00000000 errno=0 +func=exp op1=80000000.00000001 result=3ff00000.00000000 errno=0 +func=exp op1=3c900000.00000000 result=3ff00000.00000000.400 errno=0 +func=exp op1=bc900000.00000000 result=3fefffff.ffffffff.800 errno=0 +func=exp op1=3fe00000.00000000 result=3ffa6129.8e1e069b.c97 errno=0 +func=exp op1=bfe00000.00000000 result=3fe368b2.fc6f9609.fe8 errno=0 +func=exp op1=3ff00000.00000000 result=4005bf0a.8b145769.535 errno=0 +func=exp op1=bff00000.00000000 result=3fd78b56.362cef37.c6b errno=0 +func=exp op1=40000000.00000000 result=401d8e64.b8d4ddad.cc3 errno=0 +func=exp op1=c0000000.00000000 result=3fc152aa.a3bf81cb.9fe errno=0 +func=exp op1=3ff12345.6789abcd result=40075955.c34718ed.6e3 errno=0 +func=exp op1=40862e42.fefa39ef result=7fefffff.ffffff2a.1b1 errno=0 +func=exp op1=40862e42.fefa39f0 result=7ff00000.00000000 errno=ERANGE status=ox +func=exp op1=c0874910.d52d3051 result=00000000.00000001 status=ux +func=exp op1=c0874910.d52d3052 result=00000000.00000000 errno=ERANGE status=ux +func=exp op1=c085d589.f2fe5107 result=00f00000.000000f1.46b errno=0 diff --git a/libc/AOR_v20.02/math/test/testcases/directed/exp2.tst b/libc/AOR_v20.02/math/test/testcases/directed/exp2.tst new file mode 100644 index 00000000000000..b8bcef0e7fcad6 --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/exp2.tst @@ -0,0 +1,31 @@ +; Directed test cases for exp2 +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=exp2 op1=7ff80000.00000001 result=7ff80000.00000001 errno=0 +func=exp2 op1=fff80000.00000001 result=7ff80000.00000001 errno=0 +func=exp2 op1=7ff00000.00000001 result=7ff80000.00000001 errno=0 status=i +func=exp2 op1=fff00000.00000001 result=7ff80000.00000001 errno=0 status=i +func=exp2 op1=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=exp2 op1=fff00000.00000000 result=00000000.00000000 errno=0 +func=exp2 op1=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=ox +func=exp2 op1=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=ux +func=exp2 op1=00000000.00000000 result=3ff00000.00000000 errno=0 +func=exp2 op1=80000000.00000000 result=3ff00000.00000000 errno=0 +func=exp2 op1=00000000.00000001 result=3ff00000.00000000 errno=0 +func=exp2 op1=80000000.00000001 result=3ff00000.00000000 errno=0 +func=exp2 op1=3ca00000.00000000 result=3ff00000.00000000.58c errno=0 +func=exp2 op1=bc900000.00000000 result=3fefffff.ffffffff.a74 errno=0 +func=exp2 op1=3fe00000.00000000 result=3ff6a09e.667f3bcc.909 errno=0 +func=exp2 op1=bfe00000.00000000 result=3fe6a09e.667f3bcc.909 errno=0 +func=exp2 op1=3ff00000.00000000 result=40000000.00000000 errno=0 +func=exp2 op1=bff00000.00000000 result=3fe00000.00000000 errno=0 +func=exp2 op1=40000000.00000000 result=40100000.00000000 errno=0 +func=exp2 op1=c0000000.00000000 result=3fd00000.00000000 errno=0 +func=exp2 op1=3ff12345.6789abcd result=4000cef3.c5d12321.663 errno=0 +func=exp2 op1=408fffff.ffffffff result=7fefffff.fffffd3a.37a errno=0 +func=exp2 op1=40900000.00000000 result=7ff00000.00000000 errno=ERANGE status=ox +func=exp2 op1=c090ca00.00000000 result=00000000.00000000.b50 status=ux +func=exp2 op1=c090cc00.00000000 result=00000000.00000000 errno=ERANGE status=ux diff --git a/libc/AOR_v20.02/math/test/testcases/directed/exp2f.tst b/libc/AOR_v20.02/math/test/testcases/directed/exp2f.tst new file mode 100644 index 00000000000000..2a7cc2b256b51d --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/exp2f.tst @@ -0,0 +1,26 @@ +; exp2f.tst - Directed test cases for exp2f +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=exp2f op1=7fc00001 result=7fc00001 errno=0 +func=exp2f op1=ffc00001 result=7fc00001 errno=0 +func=exp2f op1=7f800001 result=7fc00001 errno=0 status=i +func=exp2f op1=ff800001 result=7fc00001 errno=0 status=i +func=exp2f op1=7f800000 result=7f800000 errno=0 +func=exp2f op1=7f7fffff result=7f800000 errno=ERANGE status=ox +func=exp2f op1=ff800000 result=00000000 errno=0 +func=exp2f op1=ff7fffff result=00000000 errno=ERANGE status=ux +func=exp2f op1=00000000 result=3f800000 errno=0 +func=exp2f op1=80000000 result=3f800000 errno=0 +func=exp2f op1=42fa0001 result=7e00002c.5c8 errno=0 +func=exp2f op1=42ffffff result=7f7fffa7.470 errno=0 +func=exp2f op1=43000000 result=7f800000 errno=ERANGE status=ox +func=exp2f op1=43000001 result=7f800000 errno=ERANGE status=ox +func=exp2f op1=c2fa0001 result=00ffffa7.470 errno=0 +func=exp2f op1=c2fc0000 result=00800000 errno=0 +func=exp2f op1=c2fc0001 result=007fffd3.a38 errno=0 status=ux +func=exp2f op1=c3150000 result=00000001 errno=0 +func=exp2f op1=c3158000 result=00000000.800 errno=ERANGE status=ux +func=exp2f op1=c3165432 result=00000000.4bd errno=ERANGE status=ux diff --git a/libc/AOR_v20.02/math/test/testcases/directed/expf.tst b/libc/AOR_v20.02/math/test/testcases/directed/expf.tst new file mode 100644 index 00000000000000..13ce50418f668a --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/expf.tst @@ -0,0 +1,24 @@ +; expf.tst - Directed test cases for expf +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=expf op1=7fc00001 result=7fc00001 errno=0 +func=expf op1=ffc00001 result=7fc00001 errno=0 +func=expf op1=7f800001 result=7fc00001 errno=0 status=i +func=expf op1=ff800001 result=7fc00001 errno=0 status=i +func=expf op1=7f800000 result=7f800000 errno=0 +func=expf op1=7f7fffff result=7f800000 errno=ERANGE status=ox +func=expf op1=ff800000 result=00000000 errno=0 +func=expf op1=ff7fffff result=00000000 errno=ERANGE status=ux +func=expf op1=00000000 result=3f800000 errno=0 +func=expf op1=80000000 result=3f800000 errno=0 +func=expf op1=42affff8 result=7ef87ed4.e0c errno=0 +func=expf op1=42b00008 result=7ef88698.f67 errno=0 +func=expf op1=42cffff8 result=7f800000 errno=ERANGE status=ox +func=expf op1=42d00008 result=7f800000 errno=ERANGE status=ox +func=expf op1=c2affff8 result=0041eecc.041 errno=0 status=ux +func=expf op1=c2b00008 result=0041ecbc.95e errno=0 status=ux +func=expf op1=c2cffff8 result=00000000 errno=ERANGE status=ux +func=expf op1=c2d00008 result=00000000 errno=ERANGE status=ux diff --git a/libc/AOR_v20.02/math/test/testcases/directed/log.tst b/libc/AOR_v20.02/math/test/testcases/directed/log.tst new file mode 100644 index 00000000000000..f0cb8008a121ab --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/log.tst @@ -0,0 +1,22 @@ +; Directed test cases for log +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=log op1=7ff80000.00000001 result=7ff80000.00000001 errno=0 +func=log op1=fff80000.00000001 result=7ff80000.00000001 errno=0 +func=log op1=7ff00000.00000001 result=7ff80000.00000001 errno=0 status=i +func=log op1=fff00000.00000001 result=7ff80000.00000001 errno=0 status=i +func=log op1=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=log op1=fff00000.00000000 result=7ff80000.00000001 errno=EDOM status=i +func=log op1=7fefffff.ffffffff result=40862e42.fefa39ef.354 errno=0 +func=log op1=ffefffff.ffffffff result=7ff80000.00000001 errno=EDOM status=i +func=log op1=3ff00000.00000000 result=00000000.00000000 errno=0 +func=log op1=bff00000.00000000 result=7ff80000.00000001 errno=EDOM status=i +func=log op1=00000000.00000000 result=fff00000.00000000 errno=ERANGE status=z +func=log op1=80000000.00000000 result=fff00000.00000000 errno=ERANGE status=z +func=log op1=00000000.00000001 result=c0874385.446d71c3.639 errno=0 +func=log op1=80000000.00000001 result=7ff80000.00000001 errno=EDOM status=i +func=log op1=40000000.00000000 result=3fe62e42.fefa39ef.358 errno=0 +func=log op1=3fe00000.00000000 result=bfe62e42.fefa39ef.358 errno=0 diff --git a/libc/AOR_v20.02/math/test/testcases/directed/log2.tst b/libc/AOR_v20.02/math/test/testcases/directed/log2.tst new file mode 100644 index 00000000000000..702f2779b400ca --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/log2.tst @@ -0,0 +1,22 @@ +; Directed test cases for log2 +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=log2 op1=7ff80000.00000001 result=7ff80000.00000001 errno=0 +func=log2 op1=fff80000.00000001 result=7ff80000.00000001 errno=0 +func=log2 op1=7ff00000.00000001 result=7ff80000.00000001 errno=0 status=i +func=log2 op1=fff00000.00000001 result=7ff80000.00000001 errno=0 status=i +func=log2 op1=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=log2 op1=fff00000.00000000 result=7ff80000.00000001 errno=EDOM status=i +func=log2 op1=7fefffff.ffffffff result=408fffff.ffffffff.ffa errno=0 +func=log2 op1=ffefffff.ffffffff result=7ff80000.00000001 errno=EDOM status=i +func=log2 op1=3ff00000.00000000 result=00000000.00000000 errno=0 +func=log2 op1=bff00000.00000000 result=7ff80000.00000001 errno=EDOM status=i +func=log2 op1=00000000.00000000 result=fff00000.00000000 errno=ERANGE status=z +func=log2 op1=80000000.00000000 result=fff00000.00000000 errno=ERANGE status=z +func=log2 op1=00000000.00000001 result=c090c800.00000000 errno=0 +func=log2 op1=80000000.00000001 result=7ff80000.00000001 errno=EDOM status=i +func=log2 op1=40000000.00000000 result=3ff00000.00000000 errno=0 +func=log2 op1=3fe00000.00000000 result=bff00000.00000000 errno=0 diff --git a/libc/AOR_v20.02/math/test/testcases/directed/log2f.tst b/libc/AOR_v20.02/math/test/testcases/directed/log2f.tst new file mode 100644 index 00000000000000..2f1a01e93ee993 --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/log2f.tst @@ -0,0 +1,28 @@ +; log2f.tst - Directed test cases for log2f +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=log2f op1=7fc00001 result=7fc00001 errno=0 +func=log2f op1=ffc00001 result=7fc00001 errno=0 +func=log2f op1=7f800001 result=7fc00001 errno=0 status=i +func=log2f op1=ff800001 result=7fc00001 errno=0 status=i +func=log2f op1=ff810000 result=7fc00001 errno=0 status=i +func=log2f op1=7f800000 result=7f800000 errno=0 +func=log2f op1=ff800000 result=7fc00001 errno=EDOM status=i +func=log2f op1=3f800000 result=00000000 errno=0 +func=log2f op1=00000000 result=ff800000 errno=ERANGE status=z +func=log2f op1=80000000 result=ff800000 errno=ERANGE status=z +func=log2f op1=80000001 result=7fc00001 errno=EDOM status=i + +func=log2f op1=3f7d70a4 result=bc6d8f8b.7d4 error=0 +func=log2f op1=3f604189 result=be4394c8.395 error=0 +func=log2f op1=3f278034 result=bf1caa73.88e error=0 +func=log2f op1=3edd3c36 result=bf9af3b9.619 error=0 +func=log2f op1=3e61259a result=c00bdb95.650 error=0 +func=log2f op1=3f8147ae result=3c6b3267.d6a error=0 +func=log2f op1=3f8fbe77 result=3e2b5fe2.a1c error=0 +func=log2f op1=3fac3eea result=3edb4d5e.1fc error=0 +func=log2f op1=3fd6e632 result=3f3f5d3a.827 error=0 +func=log2f op1=40070838 result=3f89e055.a0a error=0 diff --git a/libc/AOR_v20.02/math/test/testcases/directed/logf.tst b/libc/AOR_v20.02/math/test/testcases/directed/logf.tst new file mode 100644 index 00000000000000..d19cc154f363ad --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/logf.tst @@ -0,0 +1,70 @@ +; logf.tst - Directed test cases for logf +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=logf op1=7fc00001 result=7fc00001 errno=0 +func=logf op1=ffc00001 result=7fc00001 errno=0 +func=logf op1=7f800001 result=7fc00001 errno=0 status=i +func=logf op1=ff800001 result=7fc00001 errno=0 status=i +func=logf op1=ff810000 result=7fc00001 errno=0 status=i +func=logf op1=7f800000 result=7f800000 errno=0 +func=logf op1=ff800000 result=7fc00001 errno=EDOM status=i +func=logf op1=3f800000 result=00000000 errno=0 +func=logf op1=00000000 result=ff800000 errno=ERANGE status=z +func=logf op1=80000000 result=ff800000 errno=ERANGE status=z +func=logf op1=80000001 result=7fc00001 errno=EDOM status=i + +; Directed tests for the special-case handling of log of things +; very near 1 +func=logf op1=3f781e49 result=bd0016d9.4ae error=0 +func=logf op1=3f78e602 result=bce675e5.f31 error=0 +func=logf op1=3f844a18 result=3d07030e.ae1 error=0 +func=logf op1=3f79b55b result=bccbd88a.6cb error=0 +func=logf op1=3f7e2f5f result=bbe92452.74a error=0 +func=logf op1=3f7f1c03 result=bb6462c1.c2c error=0 +func=logf op1=3f78b213 result=bced23e2.f56 error=0 +func=logf op1=3f87d5c0 result=3d735847.b7a error=0 +func=logf op1=3f7fa6ad result=bab2c532.12d error=0 +func=logf op1=3f87c06a result=3d70d4b6.b5e error=0 +func=logf op1=3f79cf30 result=bcc88942.6e9 error=0 +func=logf op1=3f794c77 result=bcd94c6f.b1e error=0 +func=logf op1=3f835655 result=3cd2d8a0.0bf error=0 +func=logf op1=3f81b5c0 result=3c596d08.520 error=0 +func=logf op1=3f805e2f result=3b3c18d4.d2b error=0 +func=logf op1=3f7aa609 result=bcad0f90.fdb error=0 +func=logf op1=3f7a9091 result=bcafcd59.f83 error=0 +func=logf op1=3f7a7475 result=bcb36490.a0f error=0 +func=logf op1=3f823417 result=3c8bd287.fa6 error=0 +func=logf op1=3f7fbcc3 result=ba868bac.14c error=0 +func=logf op1=3f805fc9 result=3b3f4a76.169 error=0 +func=logf op1=3f833d43 result=3cccbc4f.cb7 error=0 +func=logf op1=3f7cb1de result=bc54e91e.6b5 error=0 +func=logf op1=3f7f2793 result=bb58c8af.bfc error=0 +func=logf op1=3f7bb8c3 result=bc8a0fc9.93c error=0 +func=logf op1=3f81d349 result=3c67fe09.42e error=0 +func=logf op1=3f7c254d result=bc788cf4.610 error=0 +func=logf op1=3f7f789d result=bb0786d9.6c6 error=0 +func=logf op1=3f7ed1f2 result=bb97605f.963 error=0 +func=logf op1=3f826067 result=3c96b4af.5e1 error=0 +func=logf op1=3f821a68 result=3c8581f9.dac error=0 +func=logf op1=3f864e1a result=3d44f368.e66 error=0 +func=logf op1=3f7fea3d result=b9ae1f66.b58 error=0 +func=logf op1=3f7cf4f5 result=bc43ed76.1c5 error=0 +func=logf op1=3f84c223 result=3d15814e.36d error=0 +func=logf op1=3f7dae6d result=bc1511d5.0aa error=0 +func=logf op1=3f7c0a3c result=bc7f6c0d.758 error=0 +func=logf op1=3f858b22 result=3d2da861.f36 error=0 +func=logf op1=3f85d7c7 result=3d36d490.ee9 error=0 +func=logf op1=3f7f2109 result=bb5f5851.2ed error=0 +func=logf op1=3f83809c result=3cdd23f7.6b1 error=0 +func=logf op1=3f83d96e result=3cf2b9c8.0b1 error=0 +func=logf op1=3f86ca84 result=3d53bee8.53f error=0 +func=logf op1=3f83548e result=3cd269c3.39d error=0 +func=logf op1=3f7c199c result=bc7b84b6.0da error=0 +func=logf op1=3f83133f result=3cc27c0a.9dd error=0 +func=logf op1=3f7c97b4 result=bc5b89dd.399 error=0 +func=logf op1=3f810bc1 result=3c05553c.011 error=0 +func=logf op1=3f7dadb8 result=bc153f7e.fbb error=0 +func=logf op1=3f87be56 result=3d709602.538 error=0 diff --git a/libc/AOR_v20.02/math/test/testcases/directed/pow.tst b/libc/AOR_v20.02/math/test/testcases/directed/pow.tst new file mode 100644 index 00000000000000..474cc377e5f059 --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/pow.tst @@ -0,0 +1,1419 @@ +; Directed test cases for pow +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=pow op1=00000000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=00000000.00000001 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=00100000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=1fffffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=3bdfffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=3be00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=3fe00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=3ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=40000000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=40080000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=40120000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=40180000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=407ff800.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=408ff800.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=43dfffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=43e00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=7fefffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=00000000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=80000000.00000001 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=80100000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=9fffffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=bbdfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=bbe00000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=bfe00000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=bff00000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=c0000000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=c0080000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=c0120000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=c0180000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=c07f3000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=c090ce00.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=00000000.00000000 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=00000000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=00000000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=3bdfffff.ffffffff result=3fefffff.ffffffff.d17 errno=0 +func=pow op1=00000000.00000001 op2=3be00000.00000000 result=3fefffff.ffffffff.d17 errno=0 +func=pow op1=00000000.00000001 op2=3fe00000.00000000 result=1e600000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=3ff00000.00000000 result=00000000.00000001 errno=0 status=u +func=pow op1=00000000.00000001 op2=40000000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=40080000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=40120000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=40180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=407ff800.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=408ff800.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00000000.00000001 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=00000000.00000001 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=bbdfffff.ffffffff result=3ff00000.00000000.174 errno=0 +func=pow op1=00000000.00000001 op2=bbe00000.00000000 result=3ff00000.00000000.174 errno=0 +func=pow op1=00000000.00000001 op2=bfe00000.00000000 result=61800000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=bff00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=c0000000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=c0080000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=c0120000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=c0180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=c07f3000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=c090ce00.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00000000.00000001 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=00000000.00000001 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=00000000.00000001 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=3bdfffff.ffffffff result=3fefffff.ffffffff.d3b errno=0 +func=pow op1=00100000.00000000 op2=3be00000.00000000 result=3fefffff.ffffffff.d3b errno=0 +func=pow op1=00100000.00000000 op2=3fe00000.00000000 result=20000000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=3ff00000.00000000 result=00100000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=40000000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=40080000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=40120000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=40180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=407ff800.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=408ff800.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=00100000.00000000 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=00100000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=bbdfffff.ffffffff result=3ff00000.00000000.162 errno=0 +func=pow op1=00100000.00000000 op2=bbe00000.00000000 result=3ff00000.00000000.162 errno=0 +func=pow op1=00100000.00000000 op2=bfe00000.00000000 result=5fe00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=bff00000.00000000 result=7fd00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=c0000000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=c0080000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=c0120000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=c0180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=c07f3000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=c090ce00.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=00100000.00000000 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=00100000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=00100000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=3bdfffff.ffffffff result=3fefffff.ffffffff.e9d errno=0 +func=pow op1=1fffffff.ffffffff op2=3be00000.00000000 result=3fefffff.ffffffff.e9d errno=0 +func=pow op1=1fffffff.ffffffff op2=3fe00000.00000000 result=2ff6a09e.667f3bcc.360 errno=0 +func=pow op1=1fffffff.ffffffff op2=3ff00000.00000000 result=1fffffff.ffffffff errno=0 +func=pow op1=1fffffff.ffffffff op2=40000000.00000000 result=000fffff.ffffffff errno=0 status=u +func=pow op1=1fffffff.ffffffff op2=40080000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=1fffffff.ffffffff op2=40120000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=1fffffff.ffffffff op2=40180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=1fffffff.ffffffff op2=407ff800.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=1fffffff.ffffffff op2=408ff800.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=1fffffff.ffffffff op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=1fffffff.ffffffff op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=1fffffff.ffffffff op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=1fffffff.ffffffff op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=1fffffff.ffffffff op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=bbdfffff.ffffffff result=3ff00000.00000000.0b1 errno=0 +func=pow op1=1fffffff.ffffffff op2=bbe00000.00000000 result=3ff00000.00000000.0b1 errno=0 +func=pow op1=1fffffff.ffffffff op2=bfe00000.00000000 result=4fe6a09e.667f3bcc.eb0 errno=0 +func=pow op1=1fffffff.ffffffff op2=bff00000.00000000 result=5fe00000.00000000.800 errno=0 +func=pow op1=1fffffff.ffffffff op2=c0000000.00000000 result=7fd00000.00000001 errno=0 +func=pow op1=1fffffff.ffffffff op2=c0080000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=1fffffff.ffffffff op2=c0120000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=1fffffff.ffffffff op2=c0180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=1fffffff.ffffffff op2=c07f3000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=1fffffff.ffffffff op2=c090ce00.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=1fffffff.ffffffff op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=1fffffff.ffffffff op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=1fffffff.ffffffff op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=1fffffff.ffffffff op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=1fffffff.ffffffff op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=1fffffff.ffffffff op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=3bdfffff.ffffffff result=3fefffff.ffffffff.fff errno=0 +func=pow op1=3fe00000.00000000 op2=3be00000.00000000 result=3fefffff.ffffffff.fff errno=0 +func=pow op1=3fe00000.00000000 op2=3fe00000.00000000 result=3fe6a09e.667f3bcc.908 errno=0 +func=pow op1=3fe00000.00000000 op2=3ff00000.00000000 result=3fe00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=40000000.00000000 result=3fd00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=40080000.00000000 result=3fc00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=40120000.00000000 result=3fa6a09e.667f3bcc.908 errno=0 +func=pow op1=3fe00000.00000000 op2=40180000.00000000 result=3f900000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=407ff800.00000000 result=1ff6a09e.667f3bcc.908 errno=0 +func=pow op1=3fe00000.00000000 op2=408ff800.00000000 result=00080000.00000000 errno=0 status=u +func=pow op1=3fe00000.00000000 op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fe00000.00000000 op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fe00000.00000000 op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fe00000.00000000 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3fe00000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=bbdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=bbe00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=bfe00000.00000000 result=3ff6a09e.667f3bcc.908 errno=0 +func=pow op1=3fe00000.00000000 op2=bff00000.00000000 result=40000000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=c0000000.00000000 result=40100000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=c0080000.00000000 result=40200000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=c0120000.00000000 result=4036a09e.667f3bcc.908 errno=0 +func=pow op1=3fe00000.00000000 op2=c0180000.00000000 result=40500000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=c07f3000.00000000 result=5f200000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=c090ce00.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fe00000.00000000 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fe00000.00000000 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fe00000.00000000 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fe00000.00000000 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=3fe00000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3fe00000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=3bdfffff.ffffffff result=3fefffff.ffffffff.fff errno=0 +func=pow op1=3fef9800.00000000 op2=3be00000.00000000 result=3fefffff.ffffffff.fff errno=0 +func=pow op1=3fef9800.00000000 op2=3fe00000.00000000 result=3fefcbd5.7acb4a6e.860 errno=0 +func=pow op1=3fef9800.00000000 op2=3ff00000.00000000 result=3fef9800.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=40000000.00000000 result=3fef3152.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=40080000.00000000 result=3feecbf1.b5800000 errno=0 +func=pow op1=3fef9800.00000000 op2=40120000.00000000 result=3fee3649.b95eb051.74b errno=0 +func=pow op1=3fef9800.00000000 op2=40180000.00000000 result=3feda378.fe2081dd.720 errno=0 +func=pow op1=3fef9800.00000000 op2=407ff800.00000000 result=3f57c7a0.fdc7f7ec.294 errno=0 +func=pow op1=3fef9800.00000000 op2=408ff800.00000000 result=3ec1abd4.ca4dcd2b.5aa errno=0 +func=pow op1=3fef9800.00000000 op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fef9800.00000000 op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fef9800.00000000 op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fef9800.00000000 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3fef9800.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=bbdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=bbe00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=bfe00000.00000000 result=3ff01a40.0d91bee3.a6e errno=0 +func=pow op1=3fef9800.00000000 op2=bff00000.00000000 result=3ff034ab.2c50040d.2ac errno=0 +func=pow op1=3fef9800.00000000 op2=c0000000.00000000 result=3ff06a03.b86753dd.bb6 errno=0 +func=pow op1=3fef9800.00000000 op2=c0080000.00000000 result=3ff0a00b.defc06f4.558 errno=0 +func=pow op1=3fef9800.00000000 op2=c0120000.00000000 result=3ff0f266.4d09b66a.72f errno=0 +func=pow op1=3fef9800.00000000 op2=c0180000.00000000 result=3ff14658.ab6c8d31.ec8 errno=0 +func=pow op1=3fef9800.00000000 op2=c07f3000.00000000 result=40825a4f.79ba0328.8d7 errno=0 +func=pow op1=3fef9800.00000000 op2=c090ce00.00000000 result=412c5521.b1a8d47f.54d errno=0 +func=pow op1=3fef9800.00000000 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fef9800.00000000 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fef9800.00000000 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fef9800.00000000 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=3fef9800.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3fef9800.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3fefffff.ffffffe0 op2=4386128b.68cf9fbc result=003ff70a.f0af9c79.372 errno=0 +func=pow op1=3fefffff.ffffffe0 op2=c386128b.68cf9fbc result=7fa0047b.c8f04d90.332 errno=0 +func=pow op1=3fefffff.ffffffff op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=3bdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=3be00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=3fe00000.00000000 result=3fefffff.ffffffff.800 errno=0 +func=pow op1=3fefffff.ffffffff op2=3ff00000.00000000 result=3fefffff.ffffffff errno=0 +func=pow op1=3fefffff.ffffffff op2=40000000.00000000 result=3fefffff.fffffffe errno=0 +func=pow op1=3fefffff.ffffffff op2=40080000.00000000 result=3fefffff.fffffffd errno=0 +func=pow op1=3fefffff.ffffffff op2=40120000.00000000 result=3fefffff.fffffffb.800 errno=0 +func=pow op1=3fefffff.ffffffff op2=40180000.00000000 result=3fefffff.fffffffa errno=0 +func=pow op1=3fefffff.ffffffff op2=407ff800.00000000 result=3fefffff.fffffe00.800 errno=0 +func=pow op1=3fefffff.ffffffff op2=408ff800.00000000 result=3fefffff.fffffc01 errno=0 +func=pow op1=3fefffff.ffffffff op2=4386128b.68cf9fbc result=3df1d45f.3e91e17c.d0c errno=0 +func=pow op1=3fefffff.ffffffff op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fefffff.ffffffff op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fefffff.ffffffff op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3fefffff.ffffffff op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3fefffff.ffffffff op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=bbdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=bbe00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=bfe00000.00000000 result=3ff00000.00000000.400 errno=0 +func=pow op1=3fefffff.ffffffff op2=bff00000.00000000 result=3ff00000.00000000.800 errno=0 +func=pow op1=3fefffff.ffffffff op2=c0000000.00000000 result=3ff00000.00000001 errno=0 +func=pow op1=3fefffff.ffffffff op2=c0080000.00000000 result=3ff00000.00000001.800 errno=0 +func=pow op1=3fefffff.ffffffff op2=c0120000.00000000 result=3ff00000.00000002.400 errno=0 +func=pow op1=3fefffff.ffffffff op2=c0180000.00000000 result=3ff00000.00000003 errno=0 +func=pow op1=3fefffff.ffffffff op2=c07f3000.00000000 result=3ff00000.000000f9.800 errno=0 +func=pow op1=3fefffff.ffffffff op2=c090ce00.00000000 result=3ff00000.00000219.c00 errno=0 +func=pow op1=3fefffff.ffffffff op2=c386128b.68cf9fbc result=41ecb761.33b97fcc.60b errno=0 +func=pow op1=3fefffff.ffffffff op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fefffff.ffffffff op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fefffff.ffffffff op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3fefffff.ffffffff op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=3fefffff.ffffffff op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3fefffff.ffffffff op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=3bdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=3be00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=3fe00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=3ff00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=40000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=40080000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=40120000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=40180000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=407ff800.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=408ff800.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=43dfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=43e00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=7fefffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=7ff00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3ff00000.00000000 op2=7ff80000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=bbdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=bbe00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=bfe00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=bff00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=c0000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=c0080000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=c0120000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=c0180000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=c07f3000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=c090ce00.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=c3dfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=c3e00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=ffefffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=fff00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3ff00000.00000000 op2=fff80000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=3bdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=3be00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=3fe00000.00000000 result=3ff00000.00000000.800 errno=0 +func=pow op1=3ff00000.00000001 op2=3ff00000.00000000 result=3ff00000.00000001 errno=0 +func=pow op1=3ff00000.00000001 op2=40000000.00000000 result=3ff00000.00000002 errno=0 +func=pow op1=3ff00000.00000001 op2=40080000.00000000 result=3ff00000.00000003 errno=0 +func=pow op1=3ff00000.00000001 op2=40120000.00000000 result=3ff00000.00000004.800 errno=0 +func=pow op1=3ff00000.00000001 op2=40180000.00000000 result=3ff00000.00000006 errno=0 +func=pow op1=3ff00000.00000001 op2=407ff800.00000000 result=3ff00000.000001ff.800 errno=0 +func=pow op1=3ff00000.00000001 op2=408ff800.00000000 result=3ff00000.000003ff errno=0 +func=pow op1=3ff00000.00000001 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3ff00000.00000001 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3ff00000.00000001 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3ff00000.00000001 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3ff00000.00000001 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=bbdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=bbe00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=bfe00000.00000000 result=3fefffff.ffffffff errno=0 +func=pow op1=3ff00000.00000001 op2=bff00000.00000000 result=3fefffff.fffffffe errno=0 +func=pow op1=3ff00000.00000001 op2=c0000000.00000000 result=3fefffff.fffffffc errno=0 +func=pow op1=3ff00000.00000001 op2=c0080000.00000000 result=3fefffff.fffffffa errno=0 +func=pow op1=3ff00000.00000001 op2=c0120000.00000000 result=3fefffff.fffffff7 errno=0 +func=pow op1=3ff00000.00000001 op2=c0180000.00000000 result=3fefffff.fffffff4 errno=0 +func=pow op1=3ff00000.00000001 op2=c07f3000.00000000 result=3fefffff.fffffc1a errno=0 +func=pow op1=3ff00000.00000001 op2=c090ce00.00000000 result=3fefffff.fffff799 errno=0 +func=pow op1=3ff00000.00000001 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3ff00000.00000001 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3ff00000.00000001 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3ff00000.00000001 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=3ff00000.00000001 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3ff00000.00000001 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=3bdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=3be00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=3fe00000.00000000 result=3ff019eb.020ee283.520 errno=0 +func=pow op1=3ff03400.00000000 op2=3ff00000.00000000 result=3ff03400.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=40000000.00000000 result=3ff068a9.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=40080000.00000000 result=3ff09dfd.25400000 errno=0 +func=pow op1=3ff03400.00000000 op2=40120000.00000000 result=3ff0ef41.05a27f91.ece errno=0 +func=pow op1=3ff03400.00000000 op2=40180000.00000000 result=3ff14212.5220325e.b90 errno=0 +func=pow op1=3ff03400.00000000 op2=407ff800.00000000 result=4083d3b3.8a3213c3.297 errno=0 +func=pow op1=3ff03400.00000000 op2=408ff800.00000000 result=411891bb.7f728082.d88 errno=0 +func=pow op1=3ff03400.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3ff03400.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3ff03400.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=3ff03400.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3ff03400.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=bbdfffff.ffffffff result=3fefffff.ffffffff.fff errno=0 +func=pow op1=3ff03400.00000000 op2=bbe00000.00000000 result=3fefffff.ffffffff.fff errno=0 +func=pow op1=3ff03400.00000000 op2=bfe00000.00000000 result=3fefcc7d.6c7d2e30.865 errno=0 +func=pow op1=3ff03400.00000000 op2=bff00000.00000000 result=3fef994d.c3455e8c.b6a errno=0 +func=pow op1=3ff03400.00000000 op2=c0000000.00000000 result=3fef33e5.1aaea6ee.309 errno=0 +func=pow op1=3ff03400.00000000 op2=c0080000.00000000 result=3feecfc1.e487ed2b.638 errno=0 +func=pow op1=3ff03400.00000000 op2=c0120000.00000000 result=3fee3be6.60bd4449.151 errno=0 +func=pow op1=3ff03400.00000000 op2=c0180000.00000000 result=3fedaad0.65924e45.6c1 errno=0 +func=pow op1=3ff03400.00000000 op2=c07f3000.00000000 result=3f5e3bf6.471a7841.69b errno=0 +func=pow op1=3ff03400.00000000 op2=c090ce00.00000000 result=3eb57de0.09c1a44f.f1a errno=0 +func=pow op1=3ff03400.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3ff03400.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3ff03400.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=3ff03400.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=3ff03400.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=3ff03400.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=3bdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=3be00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=3fe00000.00000000 result=3ff6a09e.667f3bcc.908 errno=0 +func=pow op1=40000000.00000000 op2=3ff00000.00000000 result=40000000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=40000000.00000000 result=40100000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=40080000.00000000 result=40200000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=40120000.00000000 result=4036a09e.667f3bcc.908 errno=0 +func=pow op1=40000000.00000000 op2=40180000.00000000 result=40500000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=407ff800.00000000 result=5fe6a09e.667f3bcc.908 errno=0 +func=pow op1=40000000.00000000 op2=408ff800.00000000 result=7fe00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40000000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40000000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40000000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=40000000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=bbdfffff.ffffffff result=3fefffff.ffffffff.fff errno=0 +func=pow op1=40000000.00000000 op2=bbe00000.00000000 result=3fefffff.ffffffff.fff errno=0 +func=pow op1=40000000.00000000 op2=bfe00000.00000000 result=3fe6a09e.667f3bcc.908 errno=0 +func=pow op1=40000000.00000000 op2=bff00000.00000000 result=3fe00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=c0000000.00000000 result=3fd00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=c0080000.00000000 result=3fc00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=c0120000.00000000 result=3fa6a09e.667f3bcc.908 errno=0 +func=pow op1=40000000.00000000 op2=c0180000.00000000 result=3f900000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=c07f3000.00000000 result=20c00000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=c08f3a00.00000000 result=017ae89f.995ad3ad.5e8 errno=0 +func=pow op1=40000000.00000000 op2=c090ce00.00000000 result=00000000.00000000.5a8 errno=ERANGE status=u +func=pow op1=40000000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40000000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40000000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40000000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=40000000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=40000000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=3bdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=3be00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=3fe00000.00000000 result=3ffbb67a.e8584caa.73b errno=0 +func=pow op1=40080000.00000000 op2=3ff00000.00000000 result=40080000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=40000000.00000000 result=40220000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=40080000.00000000 result=403b0000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=40120000.00000000 result=40618979.c707e083.dd3 errno=0 +func=pow op1=40080000.00000000 op2=40180000.00000000 result=4086c800.00000000 errno=0 +func=pow op1=40080000.00000000 op2=407ff800.00000000 result=729a2473.a65e6847.3ca errno=0 +func=pow op1=40080000.00000000 op2=408ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40080000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40080000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40080000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40080000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=40080000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=bbdfffff.ffffffff result=3fefffff.ffffffff.ffe errno=0 +func=pow op1=40080000.00000000 op2=bbe00000.00000000 result=3fefffff.ffffffff.ffe errno=0 +func=pow op1=40080000.00000000 op2=bfe00000.00000000 result=3fe279a7.4590331c.4d2 errno=0 +func=pow op1=40080000.00000000 op2=bff00000.00000000 result=3fd55555.55555555.555 errno=0 +func=pow op1=40080000.00000000 op2=c0000000.00000000 result=3fbc71c7.1c71c71c.71c errno=0 +func=pow op1=40080000.00000000 op2=c0080000.00000000 result=3fa2f684.bda12f68.4bd errno=0 +func=pow op1=40080000.00000000 op2=c0120000.00000000 result=3f7d3205.2b8e89a7.fb7 errno=0 +func=pow op1=40080000.00000000 op2=c0180000.00000000 result=3f567980.e0bf08c7.765 errno=0 +func=pow op1=40080000.00000000 op2=c07f3000.00000000 result=0e81314b.59b2f0d0.9a8 errno=0 +func=pow op1=40080000.00000000 op2=c090ce00.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40080000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40080000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40080000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40080000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=40080000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=40080000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=3bdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=3be00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=3fe00000.00000000 result=4000f876.ccdf6cd9.6c6 errno=0 +func=pow op1=40120000.00000000 op2=3ff00000.00000000 result=40120000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=40000000.00000000 result=40344000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=40080000.00000000 result=4056c800.00000000 errno=0 +func=pow op1=40120000.00000000 op2=40120000.00000000 result=408b2efd.cb8aa24b.053 errno=0 +func=pow op1=40120000.00000000 op2=40180000.00000000 result=40c037e2.00000000 errno=0 +func=pow op1=40120000.00000000 op2=407ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40120000.00000000 op2=408ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40120000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40120000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40120000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40120000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=40120000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=bbdfffff.ffffffff result=3fefffff.ffffffff.ffe errno=0 +func=pow op1=40120000.00000000 op2=bbe00000.00000000 result=3fefffff.ffffffff.ffe errno=0 +func=pow op1=40120000.00000000 op2=bfe00000.00000000 result=3fde2b7d.ddfefa66.160 errno=0 +func=pow op1=40120000.00000000 op2=bff00000.00000000 result=3fcc71c7.1c71c71c.71c errno=0 +func=pow op1=40120000.00000000 op2=c0000000.00000000 result=3fa948b0.fcd6e9e0.652 errno=0 +func=pow op1=40120000.00000000 op2=c0080000.00000000 result=3f867980.e0bf08c7.765 errno=0 +func=pow op1=40120000.00000000 op2=c0120000.00000000 result=3f52d5bc.e225fd84.857 errno=0 +func=pow op1=40120000.00000000 op2=c0180000.00000000 result=3f1f91bd.1b62b9ce.c8a errno=0 +func=pow op1=40120000.00000000 op2=c07f3000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40120000.00000000 op2=c090ce00.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40120000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40120000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40120000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40120000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=40120000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=40120000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=3bdfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=3be00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=3fe00000.00000000 result=4003988e.1409212e.7d0 errno=0 +func=pow op1=40180000.00000000 op2=3ff00000.00000000 result=40180000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=40000000.00000000 result=40420000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=40080000.00000000 result=406b0000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=40120000.00000000 result=40a8cd13.d15b8dfe.d63 errno=0 +func=pow op1=40180000.00000000 op2=40180000.00000000 result=40e6c800.00000000 errno=0 +func=pow op1=40180000.00000000 op2=407ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40180000.00000000 op2=408ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40180000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40180000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40180000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=40180000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=40180000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=bbdfffff.ffffffff result=3fefffff.ffffffff.ffe errno=0 +func=pow op1=40180000.00000000 op2=bbe00000.00000000 result=3fefffff.ffffffff.ffe errno=0 +func=pow op1=40180000.00000000 op2=bfe00000.00000000 result=3fda20bd.700c2c3d.fc0 errno=0 +func=pow op1=40180000.00000000 op2=bff00000.00000000 result=3fc55555.55555555.555 errno=0 +func=pow op1=40180000.00000000 op2=c0000000.00000000 result=3f9c71c7.1c71c71c.71c errno=0 +func=pow op1=40180000.00000000 op2=c0080000.00000000 result=3f72f684.bda12f68.4bd errno=0 +func=pow op1=40180000.00000000 op2=c0120000.00000000 result=3f34a4ee.2c48d3f1.c3f errno=0 +func=pow op1=40180000.00000000 op2=c0180000.00000000 result=3ef67980.e0bf08c7.765 errno=0 +func=pow op1=40180000.00000000 op2=c07f3000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40180000.00000000 op2=c090ce00.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40180000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40180000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40180000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=40180000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=40180000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=40180000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=3bdfffff.ffffffff result=3ff00000.00000000.053 errno=0 +func=pow op1=4f0fffff.ffffffff op2=3be00000.00000000 result=3ff00000.00000000.053 errno=0 +func=pow op1=4f0fffff.ffffffff op2=3fe00000.00000000 result=477fffff.ffffffff.800 errno=0 +func=pow op1=4f0fffff.ffffffff op2=3ff00000.00000000 result=4f0fffff.ffffffff errno=0 +func=pow op1=4f0fffff.ffffffff op2=40000000.00000000 result=5e2fffff.fffffffe errno=0 +func=pow op1=4f0fffff.ffffffff op2=40080000.00000000 result=6d4fffff.fffffffd errno=0 +func=pow op1=4f0fffff.ffffffff op2=40120000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=4f0fffff.ffffffff op2=40180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=4f0fffff.ffffffff op2=407ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=4f0fffff.ffffffff op2=408ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=4f0fffff.ffffffff op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=4f0fffff.ffffffff op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=4f0fffff.ffffffff op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=4f0fffff.ffffffff op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=4f0fffff.ffffffff op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=bbdfffff.ffffffff result=3fefffff.ffffffff.f58 errno=0 +func=pow op1=4f0fffff.ffffffff op2=bbe00000.00000000 result=3fefffff.ffffffff.f58 errno=0 +func=pow op1=4f0fffff.ffffffff op2=bfe00000.00000000 result=38600000.00000000.400 errno=0 +func=pow op1=4f0fffff.ffffffff op2=bff00000.00000000 result=30d00000.00000000.800 errno=0 +func=pow op1=4f0fffff.ffffffff op2=c0000000.00000000 result=21b00000.00000001 errno=0 +func=pow op1=4f0fffff.ffffffff op2=c0080000.00000000 result=12900000.00000001.800 errno=0 +func=pow op1=4f0fffff.ffffffff op2=c0120000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=4f0fffff.ffffffff op2=c0180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=4f0fffff.ffffffff op2=c07f3000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=4f0fffff.ffffffff op2=c090ce00.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=4f0fffff.ffffffff op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=4f0fffff.ffffffff op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=4f0fffff.ffffffff op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=4f0fffff.ffffffff op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=4f0fffff.ffffffff op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=4f0fffff.ffffffff op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=00000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=00100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=1fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=3bdfffff.ffffffff result=3ff00000.00000000.162 errno=0 +func=pow op1=7fefffff.ffffffff op2=3be00000.00000000 result=3ff00000.00000000.162 errno=0 +func=pow op1=7fefffff.ffffffff op2=3fe00000.00000000 result=5fefffff.ffffffff.800 errno=0 +func=pow op1=7fefffff.ffffffff op2=3ff00000.00000000 result=7fefffff.ffffffff errno=0 +func=pow op1=7fefffff.ffffffff op2=40000000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=40080000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=40120000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=40180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=407ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=408ff800.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=4386128b.68cf9fbc result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=7fefffff.ffffffff op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7fefffff.ffffffff op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=80000000.00000001 result=3ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=80100000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=9fffffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=bbdfffff.ffffffff result=3fefffff.ffffffff.d3a errno=0 +func=pow op1=7fefffff.ffffffff op2=bbe00000.00000000 result=3fefffff.ffffffff.d3a errno=0 +func=pow op1=7fefffff.ffffffff op2=bfe00000.00000000 result=1ff00000.00000000.400 errno=0 +func=pow op1=7fefffff.ffffffff op2=bff00000.00000000 result=00040000.00000000.200 errno=0 status=u +func=pow op1=7fefffff.ffffffff op2=c0000000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=c0080000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=c0120000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=c0180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=c07f3000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=c090ce00.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=c386128b.68cf9fbc result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=7fefffff.ffffffff op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7fefffff.ffffffff op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7fefffff.ffffffff op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=00000000.00000001 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=00100000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=1fffffff.ffffffff result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=3bdfffff.ffffffff result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=3be00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=3fe00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=3ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=40000000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=40080000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=40120000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=40180000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=407ff800.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=408ff800.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=80000000.00000001 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=80100000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=9fffffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=bbdfffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=bbe00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=bfe00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=bff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=c0000000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=c0080000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=c0120000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=c0180000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=c07f3000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=c090ce00.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=7ff00000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=7ff00000.00000001 op2=00000000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=00000000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=00100000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=3be00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=3fe00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=3ff00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=40000000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=40080000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=40120000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=40180000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=407ff800.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=408ff800.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=43dfffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=43e00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=7fefffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=7ff00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=80000000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=80000000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=80100000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=bbe00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=bfe00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=bff00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=c0000000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=c0080000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=c0120000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=c0180000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=c07f3000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=c090ce00.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=c3dfffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=c3e00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=ffefffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=fff00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff00000.00000001 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff80000.00000001 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=00000000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=00100000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=3be00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=3fe00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=3ff00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=40000000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=40080000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=40120000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=40180000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=407ff800.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=408ff800.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=43dfffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=43e00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=7fefffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=7ff00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff80000.00000001 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=80000000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=80100000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=bbe00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=bfe00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=bff00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=c0000000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=c0080000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=c0120000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=c0180000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=c07f3000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=c090ce00.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=c3dfffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=c3e00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=ffefffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=fff00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=7ff80000.00000001 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=7ff80000.00000001 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=00000000.00000001 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=00100000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=1fffffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=3bdfffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=3be00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=3fe00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=3ff00000.00000000 result=80000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=40000000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=40080000.00000000 result=80000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=40120000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=40180000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=407ff800.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=408ff800.00000000 result=80000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=43dfffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=43e00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=7fefffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=80000000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=80000000.00000001 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=80100000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=9fffffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=bbdfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=bbe00000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=bfe00000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=bff00000.00000000 result=fff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=c0000000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=c0080000.00000000 result=fff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=c0120000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=c0180000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=c07f3000.00000000 result=fff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=c090ce00.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=z +func=pow op1=80000000.00000000 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=80000000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=80000000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=80000000.00000001 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=80000000.00000001 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=3ff00000.00000000 result=80000000.00000001 errno=0 status=u +func=pow op1=80000000.00000001 op2=40000000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80000000.00000001 op2=40080000.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=80000000.00000001 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=40180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80000000.00000001 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=408ff800.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=80000000.00000001 op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80000000.00000001 op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80000000.00000001 op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80000000.00000001 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80000000.00000001 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=80000000.00000001 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=80000000.00000001 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=80000000.00000001 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=bff00000.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=80000000.00000001 op2=c0000000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80000000.00000001 op2=c0080000.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=80000000.00000001 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=c0180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80000000.00000001 op2=c07f3000.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=80000000.00000001 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80000000.00000001 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80000000.00000001 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80000000.00000001 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80000000.00000001 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=80000000.00000001 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=80000000.00000001 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=80100000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=80100000.00000000 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=3ff00000.00000000 result=80100000.00000000 errno=0 +func=pow op1=80100000.00000000 op2=40000000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80100000.00000000 op2=40080000.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=80100000.00000000 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=40180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80100000.00000000 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=408ff800.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=80100000.00000000 op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80100000.00000000 op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80100000.00000000 op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=80100000.00000000 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=80100000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=80100000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=80100000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=80100000.00000000 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=bff00000.00000000 result=ffd00000.00000000 errno=0 +func=pow op1=80100000.00000000 op2=c0000000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80100000.00000000 op2=c0080000.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=80100000.00000000 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=c0180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80100000.00000000 op2=c07f3000.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=80100000.00000000 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=80100000.00000000 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80100000.00000000 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80100000.00000000 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=80100000.00000000 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=80100000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=80100000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=9fffffff.ffffffff op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=9fffffff.ffffffff op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=3ff00000.00000000 result=9fffffff.ffffffff errno=0 +func=pow op1=9fffffff.ffffffff op2=40000000.00000000 result=000fffff.ffffffff errno=0 status=u +func=pow op1=9fffffff.ffffffff op2=40080000.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=9fffffff.ffffffff op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=40180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=9fffffff.ffffffff op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=408ff800.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=9fffffff.ffffffff op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=9fffffff.ffffffff op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=9fffffff.ffffffff op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=9fffffff.ffffffff op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=9fffffff.ffffffff op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=9fffffff.ffffffff op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=9fffffff.ffffffff op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=9fffffff.ffffffff op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=bff00000.00000000 result=dfe00000.00000000.800 errno=0 +func=pow op1=9fffffff.ffffffff op2=c0000000.00000000 result=7fd00000.00000001 errno=0 +func=pow op1=9fffffff.ffffffff op2=c0080000.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=9fffffff.ffffffff op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=c0180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=9fffffff.ffffffff op2=c07f3000.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=9fffffff.ffffffff op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=9fffffff.ffffffff op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=9fffffff.ffffffff op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=9fffffff.ffffffff op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=9fffffff.ffffffff op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=9fffffff.ffffffff op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=9fffffff.ffffffff op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=3ff00000.00000000 result=bfe00000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=40000000.00000000 result=3fd00000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=40080000.00000000 result=bfc00000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=40180000.00000000 result=3f900000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=408ff800.00000000 result=80080000.00000000 errno=0 status=u +func=pow op1=bfe00000.00000000 op2=4386128b.68cf9fbc result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bfe00000.00000000 op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bfe00000.00000000 op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bfe00000.00000000 op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bfe00000.00000000 op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=bfe00000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=bff00000.00000000 result=c0000000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=c0000000.00000000 result=40100000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=c0080000.00000000 result=c0200000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=c0180000.00000000 result=40500000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=c07f3000.00000000 result=df200000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfe00000.00000000 op2=c386128b.68cf9fbc result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bfe00000.00000000 op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bfe00000.00000000 op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bfe00000.00000000 op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bfe00000.00000000 op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=bfe00000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=bfe00000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=bfefffff.ffffffe0 op2=4386128b.68cf9fbc result=003ff70a.f0af9c79.372 errno=0 +func=pow op1=bfefffff.ffffffe0 op2=c386128b.68cf9fbc result=7fa0047b.c8f04d90.332 errno=0 +func=pow op1=bfefffff.ffffffff op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bfefffff.ffffffff op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=3ff00000.00000000 result=bfefffff.ffffffff errno=0 +func=pow op1=bfefffff.ffffffff op2=40000000.00000000 result=3fefffff.fffffffe errno=0 +func=pow op1=bfefffff.ffffffff op2=40080000.00000000 result=bfefffff.fffffffd errno=0 +func=pow op1=bfefffff.ffffffff op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=40180000.00000000 result=3fefffff.fffffffa errno=0 +func=pow op1=bfefffff.ffffffff op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=408ff800.00000000 result=bfefffff.fffffc01 errno=0 +func=pow op1=bfefffff.ffffffff op2=4386128b.68cf9fbc result=3df1d45f.3e91e17c.d0c errno=0 +func=pow op1=bfefffff.ffffffff op2=43dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bfefffff.ffffffff op2=43e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bfefffff.ffffffff op2=7fefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bfefffff.ffffffff op2=7ff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=bfefffff.ffffffff op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=bfefffff.ffffffff op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=bfefffff.ffffffff op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bfefffff.ffffffff op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=bff00000.00000000 result=bff00000.00000000.800 errno=0 +func=pow op1=bfefffff.ffffffff op2=c0000000.00000000 result=3ff00000.00000001 errno=0 +func=pow op1=bfefffff.ffffffff op2=c0080000.00000000 result=bff00000.00000001.800 errno=0 +func=pow op1=bfefffff.ffffffff op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=c0180000.00000000 result=3ff00000.00000003 errno=0 +func=pow op1=bfefffff.ffffffff op2=c07f3000.00000000 result=bff00000.000000f9.800 errno=0 +func=pow op1=bfefffff.ffffffff op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bfefffff.ffffffff op2=c386128b.68cf9fbc result=41ecb761.33b97fcc.60b errno=0 +func=pow op1=bfefffff.ffffffff op2=c3dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bfefffff.ffffffff op2=c3e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bfefffff.ffffffff op2=ffefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bfefffff.ffffffff op2=fff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=bfefffff.ffffffff op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=bfefffff.ffffffff op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=3ff00000.00000000 result=bff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=40000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=40080000.00000000 result=bff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=40180000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=408ff800.00000000 result=bff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=43dfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=43e00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=7fefffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=7ff00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=bff00000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=bff00000.00000000 result=bff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=c0000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=c0080000.00000000 result=bff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=c0180000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=c07f3000.00000000 result=bff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000000 op2=c3dfffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=c3e00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=ffefffff.ffffffff result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=fff00000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=bff00000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=bff00000.00000001 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000001 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=3ff00000.00000000 result=bff00000.00000001 errno=0 +func=pow op1=bff00000.00000001 op2=40000000.00000000 result=3ff00000.00000002 errno=0 +func=pow op1=bff00000.00000001 op2=40080000.00000000 result=bff00000.00000003 errno=0 +func=pow op1=bff00000.00000001 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=40180000.00000000 result=3ff00000.00000006 errno=0 +func=pow op1=bff00000.00000001 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=408ff800.00000000 result=bff00000.000003ff errno=0 +func=pow op1=bff00000.00000001 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bff00000.00000001 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bff00000.00000001 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=bff00000.00000001 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=bff00000.00000001 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=bff00000.00000001 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=bff00000.00000001 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=bff00000.00000001 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=bff00000.00000000 result=bfefffff.fffffffe errno=0 +func=pow op1=bff00000.00000001 op2=c0000000.00000000 result=3fefffff.fffffffc errno=0 +func=pow op1=bff00000.00000001 op2=c0080000.00000000 result=bfefffff.fffffffa errno=0 +func=pow op1=bff00000.00000001 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=c0180000.00000000 result=3fefffff.fffffff4 errno=0 +func=pow op1=bff00000.00000001 op2=c07f3000.00000000 result=bfefffff.fffffc1a errno=0 +func=pow op1=bff00000.00000001 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=bff00000.00000001 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bff00000.00000001 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bff00000.00000001 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=bff00000.00000001 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=bff00000.00000001 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=bff00000.00000001 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=3ff00000.00000000 result=c0000000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=40000000.00000000 result=40100000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=40080000.00000000 result=c0200000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=40180000.00000000 result=40500000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=408ff800.00000000 result=ffe00000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0000000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0000000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0000000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=c0000000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=bff00000.00000000 result=bfe00000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=c0000000.00000000 result=3fd00000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=c0080000.00000000 result=bfc00000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=c0180000.00000000 result=3f900000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=c07f3000.00000000 result=a0c00000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0000000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0000000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0000000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0000000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=c0000000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=c0000000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=3ff00000.00000000 result=c0080000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=40000000.00000000 result=40220000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=40080000.00000000 result=c03b0000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=40180000.00000000 result=4086c800.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=408ff800.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=c0080000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0080000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0080000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0080000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=c0080000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=bff00000.00000000 result=bfd55555.55555555.555 errno=0 +func=pow op1=c0080000.00000000 op2=c0000000.00000000 result=3fbc71c7.1c71c71c.71c errno=0 +func=pow op1=c0080000.00000000 op2=c0080000.00000000 result=bfa2f684.bda12f68.4bd errno=0 +func=pow op1=c0080000.00000000 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=c0180000.00000000 result=3f567980.e0bf08c7.765 errno=0 +func=pow op1=c0080000.00000000 op2=c07f3000.00000000 result=8e81314b.59b2f0d0.9a8 errno=0 +func=pow op1=c0080000.00000000 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0080000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0080000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0080000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0080000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=c0080000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=c0080000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=3ff00000.00000000 result=c0120000.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=40000000.00000000 result=40344000.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=40080000.00000000 result=c056c800.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=40180000.00000000 result=40c037e2.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=408ff800.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=c0120000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0120000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0120000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0120000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=c0120000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=bff00000.00000000 result=bfcc71c7.1c71c71c.71c errno=0 +func=pow op1=c0120000.00000000 op2=c0000000.00000000 result=3fa948b0.fcd6e9e0.652 errno=0 +func=pow op1=c0120000.00000000 op2=c0080000.00000000 result=bf867980.e0bf08c7.765 errno=0 +func=pow op1=c0120000.00000000 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=c0180000.00000000 result=3f1f91bd.1b62b9ce.c8a errno=0 +func=pow op1=c0120000.00000000 op2=c07f3000.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=c0120000.00000000 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0120000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0120000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0120000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0120000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=c0120000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=c0120000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=3ff00000.00000000 result=c0180000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=40000000.00000000 result=40420000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=40080000.00000000 result=c06b0000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=40180000.00000000 result=40e6c800.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=408ff800.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=c0180000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0180000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0180000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=c0180000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=c0180000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=bff00000.00000000 result=bfc55555.55555555.555 errno=0 +func=pow op1=c0180000.00000000 op2=c0000000.00000000 result=3f9c71c7.1c71c71c.71c errno=0 +func=pow op1=c0180000.00000000 op2=c0080000.00000000 result=bf72f684.bda12f68.4bd errno=0 +func=pow op1=c0180000.00000000 op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=c0180000.00000000 result=3ef67980.e0bf08c7.765 errno=0 +func=pow op1=c0180000.00000000 op2=c07f3000.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=c0180000.00000000 op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=c0180000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0180000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0180000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=c0180000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=c0180000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=c0180000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=ffefffff.ffffffff op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=ffefffff.ffffffff op2=00000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=00100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=1fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=3be00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=3fe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=3ff00000.00000000 result=ffefffff.ffffffff errno=0 +func=pow op1=ffefffff.ffffffff op2=40000000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=ffefffff.ffffffff op2=40080000.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=ffefffff.ffffffff op2=40120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=40180000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=ffefffff.ffffffff op2=407ff800.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=408ff800.00000000 result=fff00000.00000000 errno=ERANGE status=o +func=pow op1=ffefffff.ffffffff op2=43dfffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=ffefffff.ffffffff op2=43e00000.00000000 result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=ffefffff.ffffffff op2=7fefffff.ffffffff result=7ff00000.00000000 errno=ERANGE status=o +func=pow op1=ffefffff.ffffffff op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=ffefffff.ffffffff op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=ffefffff.ffffffff op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=ffefffff.ffffffff op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=ffefffff.ffffffff op2=80000000.00000001 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=80100000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=9fffffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=bbe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=bfe00000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=bff00000.00000000 result=80040000.00000000.200 errno=0 status=u +func=pow op1=ffefffff.ffffffff op2=c0000000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=ffefffff.ffffffff op2=c0080000.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=ffefffff.ffffffff op2=c0120000.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=c0180000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=ffefffff.ffffffff op2=c07f3000.00000000 result=80000000.00000000 errno=ERANGE status=u +func=pow op1=ffefffff.ffffffff op2=c090ce00.00000000 result=7ff80000.00000000 errno=EDOM status=i +func=pow op1=ffefffff.ffffffff op2=c3dfffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=ffefffff.ffffffff op2=c3e00000.00000000 result=00000000.00000000 errno=ERANGE status=u +func=pow op1=ffefffff.ffffffff op2=ffefffff.ffffffff result=00000000.00000000 errno=ERANGE status=u +func=pow op1=ffefffff.ffffffff op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=ffefffff.ffffffff op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=ffefffff.ffffffff op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=00000000.00000001 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=00100000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=1fffffff.ffffffff result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=3bdfffff.ffffffff result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=3be00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=3fe00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=3ff00000.00000000 result=fff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=40000000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=40080000.00000000 result=fff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=40120000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=40180000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=407ff800.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=408ff800.00000000 result=fff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=43dfffff.ffffffff result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=43e00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=7fefffff.ffffffff result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=7ff00000.00000000 result=7ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000000 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=80000000.00000001 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=80100000.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=9fffffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=bbdfffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=bbe00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=bfe00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=bff00000.00000000 result=80000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=c0000000.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=c0080000.00000000 result=80000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=c0120000.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=c0180000.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=c07f3000.00000000 result=80000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=c090ce00.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=c3dfffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=c3e00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=ffefffff.ffffffff result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=fff00000.00000000 result=00000000.00000000 errno=0 +func=pow op1=fff00000.00000000 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000000 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=fff00000.00000001 op2=00000000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=00000000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=00100000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=3be00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=3fe00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=3ff00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=40000000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=40080000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=40120000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=40180000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=407ff800.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=408ff800.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=43dfffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=43e00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=7fefffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=7ff00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=80000000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=80000000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=80100000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=bbe00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=bfe00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=bff00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=c0000000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=c0080000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=c0120000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=c0180000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=c07f3000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=c090ce00.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=c3dfffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=c3e00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=ffefffff.ffffffff result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=fff00000.00000000 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff00000.00000001 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff80000.00000001 op2=00000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=00000000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=00100000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=1fffffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=3bdfffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=3be00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=3fe00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=3ff00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=40000000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=40080000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=40120000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=40180000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=407ff800.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=408ff800.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=43dfffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=43e00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=7fefffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=7ff00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=7ff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff80000.00000001 op2=7ff80000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=80000000.00000000 result=3ff00000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=80000000.00000001 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=80100000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=9fffffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=bbdfffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=bbe00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=bfe00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=bff00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=c0000000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=c0080000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=c0120000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=c0180000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=c07f3000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=c090ce00.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=c3dfffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=c3e00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=ffefffff.ffffffff result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=fff00000.00000000 result=7ff80000.00000000 errno=0 +func=pow op1=fff80000.00000001 op2=fff00000.00000001 result=7ff80000.00000000 errno=0 status=i +func=pow op1=fff80000.00000001 op2=fff80000.00000001 result=7ff80000.00000000 errno=0 diff --git a/libc/AOR_v20.02/math/test/testcases/directed/powf.tst b/libc/AOR_v20.02/math/test/testcases/directed/powf.tst new file mode 100644 index 00000000000000..9719b1f991ed9e --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/powf.tst @@ -0,0 +1,247 @@ +; powf.tst - Directed test cases for powf +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +func=powf op1=7f800001 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=7fc00001 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=ffc00001 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=7f800000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=40800000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=40400000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=3f000000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=00000000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=80000000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=bf000000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=c0400000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=c0800000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=ff800000 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=7f800001 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=7fc00001 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=ffc00001 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=7f800000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=40800000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=40400000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=3f000000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=00000000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=80000000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=bf000000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=c0400000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=c0800000 result=7fc00001 errno=0 status=i +func=powf op1=ff800001 op2=ff800000 result=7fc00001 errno=0 status=i +func=powf op1=7fc00001 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=7fc00001 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=7fc00001 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=7f800000 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=40800000 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=40400000 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=3f000000 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=00000000 result=3f800000 errno=0 +func=powf op1=7fc00001 op2=80000000 result=3f800000 errno=0 +func=powf op1=7fc00001 op2=bf000000 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=c0400000 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=c0800000 result=7fc00001 errno=0 +func=powf op1=7fc00001 op2=ff800000 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=ffc00001 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=ffc00001 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=7f800000 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=40800000 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=40400000 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=3f000000 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=00000000 result=3f800000 errno=0 +func=powf op1=ffc00001 op2=80000000 result=3f800000 errno=0 +func=powf op1=ffc00001 op2=bf000000 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=c0400000 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=c0800000 result=7fc00001 errno=0 +func=powf op1=ffc00001 op2=ff800000 result=7fc00001 errno=0 +func=powf op1=7f800000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=7f800000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=7f800000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=7f800000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=7f800000 op2=7f800000 result=7f800000 errno=0 +func=powf op1=7f800000 op2=40800000 result=7f800000 errno=0 +func=powf op1=7f800000 op2=40400000 result=7f800000 errno=0 +func=powf op1=7f800000 op2=3f000000 result=7f800000 errno=0 +func=powf op1=7f800000 op2=00000001 result=7f800000 errno=0 +func=powf op1=7f800000 op2=00000000 result=3f800000 errno=0 +func=powf op1=7f800000 op2=80000000 result=3f800000 errno=0 +func=powf op1=7f800000 op2=bf000000 result=00000000 errno=0 +func=powf op1=7f800000 op2=c0400000 result=00000000 errno=0 +func=powf op1=7f800000 op2=c0800000 result=00000000 errno=0 +func=powf op1=7f800000 op2=ff800000 result=00000000 errno=0 +func=powf op1=40800000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=40800000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=40800000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=40800000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=40800000 op2=7f800000 result=7f800000 errno=0 +func=powf op1=40800000 op2=40800000 result=43800000 errno=0 +func=powf op1=40800000 op2=40400000 result=42800000 errno=0 +func=powf op1=40800000 op2=3f000000 result=40000000 errno=0 +func=powf op1=40800000 op2=00000000 result=3f800000 errno=0 +func=powf op1=40800000 op2=80000000 result=3f800000 errno=0 +func=powf op1=40800000 op2=bf000000 result=3f000000 errno=0 +func=powf op1=40800000 op2=c0400000 result=3c800000 errno=0 +func=powf op1=40800000 op2=c0800000 result=3b800000 errno=0 +func=powf op1=40800000 op2=ff800000 result=00000000 errno=0 +func=powf op1=3f800000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=3f800000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=3f800000 op2=7fc00001 result=3f800000 errno=0 +func=powf op1=3f800000 op2=ffc00001 result=3f800000 errno=0 +func=powf op1=3f800000 op2=7f800000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=40800000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=40400000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=3f000000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=00000000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=80000000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=bf000000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=c0400000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=c0800000 result=3f800000 errno=0 +func=powf op1=3f800000 op2=ff800000 result=3f800000 errno=0 +func=powf op1=3e800000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=3e800000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=3e800000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=3e800000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=3e800000 op2=7f800000 result=00000000 errno=0 +func=powf op1=3e800000 op2=40800000 result=3b800000 errno=0 +func=powf op1=3e800000 op2=40400000 result=3c800000 errno=0 +func=powf op1=3e800000 op2=3f000000 result=3f000000 errno=0 +func=powf op1=3e800000 op2=00000000 result=3f800000 errno=0 +func=powf op1=3e800000 op2=80000000 result=3f800000 errno=0 +func=powf op1=3e800000 op2=bf000000 result=40000000 errno=0 +func=powf op1=3e800000 op2=c0400000 result=42800000 errno=0 +func=powf op1=3e800000 op2=c0800000 result=43800000 errno=0 +func=powf op1=3e800000 op2=ff800000 result=7f800000 errno=0 +func=powf op1=00000001 op2=bf800000 result=7f800000 errno=ERANGE status=ox +func=powf op1=00000000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=00000000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=00000000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=00000000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=00000000 op2=7f800000 result=00000000 errno=0 +func=powf op1=00000000 op2=40800000 result=00000000 errno=0 +func=powf op1=00000000 op2=40400000 result=00000000 errno=0 +func=powf op1=00000000 op2=3f000000 result=00000000 errno=0 +func=powf op1=00000000 op2=00000000 result=3f800000 errno=0 +func=powf op1=00000000 op2=80000000 result=3f800000 errno=0 +func=powf op1=00000000 op2=bf000000 result=7f800000 errno=ERANGE status=z +func=powf op1=00000000 op2=c0400000 result=7f800000 errno=ERANGE status=z +func=powf op1=00000000 op2=c0800000 result=7f800000 errno=ERANGE status=z +func=powf op1=00000000 op2=ff800000 result=7f800000 errno=ERANGE +func=powf op1=80000000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=80000000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=80000000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=80000000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=80000000 op2=7f800000 result=00000000 errno=0 +func=powf op1=80000000 op2=40800000 result=00000000 errno=0 +func=powf op1=80000000 op2=40400000 result=80000000 errno=0 +func=powf op1=80000000 op2=3f000000 result=00000000 errno=0 +func=powf op1=80000000 op2=00000000 result=3f800000 errno=0 +func=powf op1=80000000 op2=80000000 result=3f800000 errno=0 +func=powf op1=80000000 op2=bf000000 result=7f800000 errno=ERANGE status=z +func=powf op1=80000000 op2=c0400000 result=ff800000 errno=ERANGE status=z +func=powf op1=80000000 op2=c0800000 result=7f800000 errno=ERANGE status=z +func=powf op1=80000000 op2=ff800000 result=7f800000 errno=ERANGE +func=powf op1=be800000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=be800000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=be800000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=be800000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=be800000 op2=7f800000 result=00000000 errno=0 +func=powf op1=be800000 op2=40800000 result=3b800000 errno=0 +func=powf op1=be800000 op2=40400000 result=bc800000 errno=0 +func=powf op1=be800000 op2=3f000000 result=7fc00001 errno=EDOM status=i +func=powf op1=be800000 op2=00000000 result=3f800000 errno=0 +func=powf op1=be800000 op2=80000000 result=3f800000 errno=0 +func=powf op1=be800000 op2=bf000000 result=7fc00001 errno=EDOM status=i +func=powf op1=be800000 op2=c0400000 result=c2800000 errno=0 +func=powf op1=be800000 op2=c0800000 result=43800000 errno=0 +func=powf op1=be800000 op2=ff800000 result=7f800000 errno=0 +func=powf op1=bf800000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=bf800000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=bf800000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=bf800000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=bf800000 op2=7f800000 result=3f800000 errno=0 +func=powf op1=bf800000 op2=40800000 result=3f800000 errno=0 +func=powf op1=bf800000 op2=40400000 result=bf800000 errno=0 +func=powf op1=bf800000 op2=3f000000 result=7fc00001 errno=EDOM status=i +func=powf op1=bf800000 op2=00000000 result=3f800000 errno=0 +func=powf op1=bf800000 op2=80000000 result=3f800000 errno=0 +func=powf op1=bf800000 op2=bf000000 result=7fc00001 errno=EDOM status=i +func=powf op1=bf800000 op2=c0400000 result=bf800000 errno=0 +func=powf op1=bf800000 op2=c0800000 result=3f800000 errno=0 +func=powf op1=bf800000 op2=ff800000 result=3f800000 errno=0 +func=powf op1=c0800000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=c0800000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=c0800000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=c0800000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=c0800000 op2=7f800000 result=7f800000 errno=0 +func=powf op1=c0800000 op2=40800000 result=43800000 errno=0 +func=powf op1=c0800000 op2=40400000 result=c2800000 errno=0 +func=powf op1=c0800000 op2=3f000000 result=7fc00001 errno=EDOM status=i +func=powf op1=c0800000 op2=00000000 result=3f800000 errno=0 +func=powf op1=c0800000 op2=80000000 result=3f800000 errno=0 +func=powf op1=c0800000 op2=bf000000 result=7fc00001 errno=EDOM status=i +func=powf op1=c0800000 op2=c0400000 result=bc800000 errno=0 +func=powf op1=c0800000 op2=c0800000 result=3b800000 errno=0 +func=powf op1=c0800000 op2=ff800000 result=00000000 errno=0 +func=powf op1=ff800000 op2=7f800001 result=7fc00001 errno=0 status=i +func=powf op1=ff800000 op2=ff800001 result=7fc00001 errno=0 status=i +func=powf op1=ff800000 op2=7fc00001 result=7fc00001 errno=0 +func=powf op1=ff800000 op2=ffc00001 result=7fc00001 errno=0 +func=powf op1=ff800000 op2=7f800000 result=7f800000 errno=0 +func=powf op1=ff800000 op2=40800000 result=7f800000 errno=0 +func=powf op1=ff800000 op2=40400000 result=ff800000 errno=0 +func=powf op1=ff800000 op2=3f000000 result=7f800000 errno=0 +func=powf op1=ff800000 op2=00000000 result=3f800000 errno=0 +func=powf op1=ff800000 op2=80000000 result=3f800000 errno=0 +func=powf op1=ff800000 op2=bf000000 result=00000000 errno=0 +func=powf op1=ff800000 op2=c0400000 result=80000000 errno=0 +func=powf op1=ff800000 op2=c0800000 result=00000000 errno=0 +func=powf op1=ff800000 op2=ff800000 result=00000000 errno=0 + + +func=powf op1=36c27f9d op2=4109fa51 result=00000000 errno=ERANGE status=ux +func=powf op1=351738cd op2=c0c55691 result=7f800000 errno=ERANGE status=ox +func=powf op1=42836035 op2=41a99f40 result=7f800000 errno=ERANGE status=ox +func=powf op1=32bd53f3 op2=40bcba58 result=00000000 errno=ERANGE status=ux +func=powf op1=32dc5bff op2=40be62ea result=00000000 errno=ERANGE status=ux +func=powf op1=3a8a3f66 op2=4172bd43 result=00000000 errno=ERANGE status=ux +func=powf op1=28f0e770 op2=c035b4ca result=7f800000 errno=ERANGE status=ox +func=powf op1=40886699 op2=c28f703a result=00000000 errno=ERANGE status=ux +func=powf op1=414bd593 op2=c22370cf result=00000000 errno=ERANGE status=ux +func=powf op1=3a2f1163 op2=c1422d45 result=7f800000 errno=ERANGE status=ox +func=powf op1=434f5cf3 op2=41851272 result=7f800000 errno=ERANGE status=ox +func=powf op1=2e0e27a4 op2=c06b13f5 result=7f800000 errno=ERANGE status=ox +func=powf op1=39aef7a6 op2=414fd60a result=00000000 errno=ERANGE status=ux +func=powf op1=21c80729 op2=c00a04ab result=7f800000 errno=ERANGE status=ox +func=powf op1=42455a4b op2=c1d55905 result=00000000 errno=ERANGE status=ux +func=powf op1=2d173e0b op2=c05ee797 result=7f800000 errno=ERANGE status=ox +func=powf op1=452edf9a op2=4132dd7f result=7f800000 errno=ERANGE status=ox +func=powf op1=406bf67b op2=c29f5f12 result=00000000 errno=ERANGE status=ux +func=powf op1=2d82a6fc op2=4085779e result=00000000 errno=ERANGE status=ux +func=powf op1=4551f827 op2=41304516 result=7f800000 errno=ERANGE status=ox +func=powf op1=3a917c51 op2=41726c0a result=00000001.37f errno=0 status=ux +; iso c allows both errno=ERANGE and errno=0 +;func=powf op1=3b19bbaa op2=4188e6fb result=00000000.b5f errno=0 status=ux +;func=powf op1=4088bd18 op2=c28ef056 result=00000000.986 errno=0 status=ux +func=powf op1=3f7ffd76 op2=4a09221e result=00aa9d24.3ad error=0 + +func=powf op1=007fffff op2=bf000001 result=5f00002c.2b2 error=0 +func=powf op1=000007ff op2=bf000001 result=62000830.96f error=0 +func=powf op1=007fffff op2=80800001 result=3f800000.000 error=0 +func=powf op1=00000000 op2=800007ff result=7f800000 errno=ERANGE status=z +func=powf op1=00000000 op2=000007ff result=00000000 error=0 +func=powf op1=bf800000 op2=ff7fffff result=3f800000 error=0 +func=powf op1=2e4e4f30 op2=406b0dc2 result=007e9c59.eb4 errno=0 status=u + +; SDCOMP-25549: ensure the biggest overflow case possible is not +; mishandled. Also check the analogous underflow, and also ensure that +; our massive-overflow checks do not affect numbers _just within_ the +; range. +func=powf op1=7f7fffff op2=7f7fffff result=7f800000 error=overflow +func=powf op1=7f7fffff op2=ff7fffff result=00000000 error=underflow +func=powf op1=54cb3000 op2=403fffff result=7f7fffb2.a95 error=0 diff --git a/libc/AOR_v20.02/math/test/testcases/directed/sincosf.tst b/libc/AOR_v20.02/math/test/testcases/directed/sincosf.tst new file mode 100644 index 00000000000000..d22fd98026940f --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/sincosf.tst @@ -0,0 +1,52 @@ +; Directed test cases for SP sincos +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + + +func=sincosf_sinf op1=7fc00001 result=7fc00001 errno=0 +func=sincosf_sinf op1=ffc00001 result=7fc00001 errno=0 +func=sincosf_sinf op1=7f800001 result=7fc00001 errno=0 status=i +func=sincosf_sinf op1=ff800001 result=7fc00001 errno=0 status=i +func=sincosf_sinf op1=7f800000 result=7fc00001 errno=EDOM status=i +func=sincosf_sinf op1=ff800000 result=7fc00001 errno=EDOM status=i +func=sincosf_sinf op1=00000000 result=00000000 errno=0 +func=sincosf_sinf op1=80000000 result=80000000 errno=0 +func=sincosf_sinf op1=c70d39a1 result=be37fad5.7ed errno=0 +func=sincosf_sinf op1=46427f1b result=3f352d80.f9b error=0 +func=sincosf_sinf op1=4647e568 result=3f352da9.7be error=0 +func=sincosf_sinf op1=46428bac result=bf352dea.924 error=0 +func=sincosf_sinf op1=4647f1f9 result=bf352e13.146 error=0 +func=sincosf_sinf op1=4647fe8a result=3f352e7c.ac9 error=0 +func=sincosf_sinf op1=45d8d7f1 result=3f35097b.cb0 error=0 +func=sincosf_sinf op1=45d371a4 result=bf350990.102 error=0 +func=sincosf_sinf op1=45ce0b57 result=3f3509a4.554 error=0 +func=sincosf_sinf op1=45d35882 result=3f3509f9.bdb error=0 +func=sincosf_sinf op1=45cdf235 result=bf350a0e.02c error=0 + +func=sincosf_cosf op1=7fc00001 result=7fc00001 errno=0 +func=sincosf_cosf op1=ffc00001 result=7fc00001 errno=0 +func=sincosf_cosf op1=7f800001 result=7fc00001 errno=0 status=i +func=sincosf_cosf op1=ff800001 result=7fc00001 errno=0 status=i +func=sincosf_cosf op1=7f800000 result=7fc00001 errno=EDOM status=i +func=sincosf_cosf op1=ff800000 result=7fc00001 errno=EDOM status=i +func=sincosf_cosf op1=00000000 result=3f800000 errno=0 +func=sincosf_cosf op1=80000000 result=3f800000 errno=0 +func=sincosf_cosf op1=46427f1b result=3f34dc5c.565 error=0 +func=sincosf_cosf op1=4647e568 result=3f34dc33.c1f error=0 +func=sincosf_cosf op1=46428bac result=bf34dbf2.8e3 error=0 +func=sincosf_cosf op1=4647f1f9 result=bf34dbc9.f9b error=0 +func=sincosf_cosf op1=4647fe8a result=3f34db60.313 error=0 +func=sincosf_cosf op1=45d8d7f1 result=bf35006a.7fd error=0 +func=sincosf_cosf op1=45d371a4 result=3f350056.39b error=0 +func=sincosf_cosf op1=45ce0b57 result=bf350041.f38 error=0 +func=sincosf_cosf op1=45d35882 result=bf34ffec.868 error=0 +func=sincosf_cosf op1=45cdf235 result=3f34ffd8.404 error=0 + +; no underflow +func=sincosf_sinf op1=17800000 result=17800000.000 +func=sincosf_cosf op1=17800000 result=3f800000.000 +; underflow +func=sincosf_sinf op1=00400000 result=00400000.000 status=ux +func=sincosf_cosf op1=00400000 result=3f800000.000 status=ux diff --git a/libc/AOR_v20.02/math/test/testcases/directed/sinf.tst b/libc/AOR_v20.02/math/test/testcases/directed/sinf.tst new file mode 100644 index 00000000000000..022bf14248790f --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/directed/sinf.tst @@ -0,0 +1,29 @@ +; sinf.tst - Directed test cases for SP sine +; +; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +; See https://llvm.org/LICENSE.txt for license information. +; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + + +func=sinf op1=7fc00001 result=7fc00001 errno=0 +func=sinf op1=ffc00001 result=7fc00001 errno=0 +func=sinf op1=7f800001 result=7fc00001 errno=0 status=i +func=sinf op1=ff800001 result=7fc00001 errno=0 status=i +func=sinf op1=7f800000 result=7fc00001 errno=EDOM status=i +func=sinf op1=ff800000 result=7fc00001 errno=EDOM status=i +func=sinf op1=00000000 result=00000000 errno=0 +func=sinf op1=80000000 result=80000000 errno=0 +; Directed test for a failure I found while developing mathbench +func=sinf op1=c70d39a1 result=be37fad5.7ed errno=0 +; SDCOMP-26094: check sinf in the cases for which the range reducer +; returns values furthest beyond its nominal upper bound of pi/4. +func=sinf op1=46427f1b result=3f352d80.f9b error=0 +func=sinf op1=4647e568 result=3f352da9.7be error=0 +func=sinf op1=46428bac result=bf352dea.924 error=0 +func=sinf op1=4647f1f9 result=bf352e13.146 error=0 +func=sinf op1=4647fe8a result=3f352e7c.ac9 error=0 +func=sinf op1=45d8d7f1 result=3f35097b.cb0 error=0 +func=sinf op1=45d371a4 result=bf350990.102 error=0 +func=sinf op1=45ce0b57 result=3f3509a4.554 error=0 +func=sinf op1=45d35882 result=3f3509f9.bdb error=0 +func=sinf op1=45cdf235 result=bf350a0e.02c error=0 diff --git a/libc/AOR_v20.02/math/test/testcases/random/double.tst b/libc/AOR_v20.02/math/test/testcases/random/double.tst new file mode 100644 index 00000000000000..3c9ab6b16a7112 --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/random/double.tst @@ -0,0 +1,11 @@ +!! double.tst - Random test case specification for DP functions +!! +!! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +!! See https://llvm.org/LICENSE.txt for license information. +!! SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +test exp 10000 +test exp2 10000 +test log 10000 +test log2 10000 +test pow 40000 diff --git a/libc/AOR_v20.02/math/test/testcases/random/float.tst b/libc/AOR_v20.02/math/test/testcases/random/float.tst new file mode 100644 index 00000000000000..c142d63cd59494 --- /dev/null +++ b/libc/AOR_v20.02/math/test/testcases/random/float.tst @@ -0,0 +1,16 @@ +!! single.tst - Random test case specification for SP functions +!! +!! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +!! See https://llvm.org/LICENSE.txt for license information. +!! SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +test sinf 10000 +test cosf 10000 +test sincosf_sinf 5000 +test sincosf_cosf 5000 +test tanf 10000 +test expf 10000 +test exp2f 10000 +test logf 10000 +test log2f 10000 +test powf 10000 diff --git a/libc/AOR_v20.02/math/test/traces/exp.txt b/libc/AOR_v20.02/math/test/traces/exp.txt new file mode 100644 index 00000000000000..cb067d5174b987 --- /dev/null +++ b/libc/AOR_v20.02/math/test/traces/exp.txt @@ -0,0 +1,16000 @@ +0x1.0bc8e7ca4ae1bp+0 +0x1.f9a012f44a109p-1 +-0x1.87a0e64ca4704p-15 +0x1.d2d48a18a7775p-1 +0x1.bb1c1c3d91533p-1 +-0x1.f99f18cd2896bp-16 +0x1.58bb57317e405p-1 +0x1.4a09091f7ebeep-1 +-0x1.44718c44e91cfp-16 +0x1.45fa2a0b71c2bp-1 +0x1.38762d53b5588p-1 +-0x1.2a455304fad52p-16 +0x1.b7bf404f6d792p-1 +0x1.89b7f02cc3616p-1 +-0x1.4725ae5fe330ep-15 +0x1.7f67cd7b4808bp-1 +0x1.55ed18823552ep-1 +-0x1.a739b0e2abe9dp-16 +0x1.1b3e775bae9c8p-1 +0x1.f6023db8868e1p-2 +-0x1.104f2fa39a12bp-16 +0x1.0bd9b65f01703p-1 +0x1.da4b53554e44dp-2 +-0x1.f526b52905e9p-17 +0x1.1fc5ef99d9612p+0 +0x1.47b931f513835p+0 +-0x1.02b1bcc2094d9p-15 +0x1.f8c730332548cp-1 +0x1.19482cc4dc1fbp+0 +-0x1.4e16557b341d3p-16 +0x1.786dce71f0b35p-1 +0x1.950d7d5198b4fp-1 +-0x1.accc5b8b72601p-17 +0x1.6472662268d79p-1 +0x1.7d9d06ca67edep-1 +-0x1.8a3bc4d1f5a5ep-17 +0x1.330645d7c99bp+0 +0x1.25004ff9555e8p+0 +-0x1.85274bbfa239fp-16 +0x1.0e7034f78e1c8p+0 +0x1.0206cf3f5e944p+0 +-0x1.f6fe344c539b3p-17 +0x1.96178955052a6p-1 +0x1.8350a15e7b7f3p-1 +-0x1.43010b67688cep-17 +0x1.80e714f138abdp-1 +0x1.6f163e464ed4fp-1 +-0x1.290da68f570f6p-17 +0x1.866c2178a9c97p-1 +0x1.bfcc4605ca00fp-1 +-0x1.64605f46a2fcep-16 +0x1.5b7d18d8e3aa9p-1 +0x1.8edce4d6b667cp-1 +-0x1.d3991eb7496cep-17 +0x1.091ab83c3e1dep-1 +0x1.30a7ebf8b2b71p-1 +-0x1.31d7428d2d8c1p-17 +0x1.f7a9b86f13311p-2 +0x1.21731afa77bcp-1 +-0x1.1b12f6ef29b44p-17 +-0x1.55d0cf4bd6aedp-15 +-0x1.25823bbb48bbep-12 +-0x1.fe511e97488b2p-11 +-0x1.fad0a09045dfbp-12 +-0x1.6fd87d61b4565p-12 +-0x1.a696db0624feep-17 +-0x1.391ed5a843f93p-10 +-0x1.c0d23587c5b89p-13 +-0x1.ab2db00aab2bp-8 +-0x1.51454310d0d1ap-15 +-0x1.219b1f96fb68fp-12 +-0x1.f787fe3ab5957p-11 +-0x1.f4136be018f61p-12 +-0x1.6af456684d5d7p-12 +-0x1.a0f85a4951aeep-17 +-0x1.34f4f7483a40bp-10 +-0x1.bada6a468f999p-13 +-0x1.904f3271e320ep-8 +-0x1.6ef45c7e39f2dp-14 +-0x1.3b18489716499p-11 +-0x1.676135bbac0d2p-9 +-0x1.64e9dfd8b7b9dp-10 +-0x1.030c2446c9cbbp-10 +-0x1.c5ab2d2a80e96p-16 +-0x1.502620236748fp-9 +-0x1.3c129a3c7817bp-11 +-0x1.717e3cfc30badp-8 +-0x1.7a09e60ef3104p-14 +-0x1.449ccea9996edp-11 +-0x1.6f9478a715612p-9 +-0x1.6d0ebaeabbb5cp-10 +-0x1.08f553d1f44d1p-10 +-0x1.d35f3ec8d2735p-16 +-0x1.5a4d7410d726cp-9 +-0x1.4348e47189b65p-11 +-0x1.772522f4ede6ep-8 +0x1.eb4c6556b12d7p+0 +0x1.c78d83bb1f656p+0 +0x1.82554515ca9b4p+0 +0x1.7a5752267c5ep+0 +-0x1.baeff44302d03p-11 +-0x1.ff192f3a7845cp-9 +-0x1.c6ae5efe8bdf3p-11 +-0x1.004fd940223a6p-8 +-0x1.eb04054469baap-11 +-0x1.0a2bef6fa2f01p-8 +-0x1.f4bda156f6f34p-11 +-0x1.0e54a74941224p-8 +-0x1.316794c2bd16dp+1 +-0x1.2744e628de6b1p+1 +-0x1.1561ea85396a7p+1 +-0x1.13783f72337e1p+1 +0x1.1be6fb2f548d9p+0 +0x1.2f396c4a3e018p+0 +-0x1.43c7400a6a41ep-16 +0x1.faf80233f4ac5p-1 +0x1.0e5997ca43621p+0 +-0x1.be176460d5163p-17 +0x1.726af18c6831ap-1 +0x1.8a1507006fe7p-1 +-0x1.1248da21acf8cp-17 +0x1.6137dfe69cb01p-1 +0x1.77af5095c20fcp-1 +-0x1.f06f1162f80c9p-18 +0x1.0b4138270aadep+0 +0x1.f8ab0e7abaaddp-1 +-0x1.b07fb061ab57fp-16 +0x1.d329c20a8834dp-1 +0x1.bb6a281e171b9p-1 +-0x1.24d8119880a4ep-16 +0x1.4887fe52441bep-1 +0x1.3adb99f0adca9p-1 +-0x1.5f00a4462f7e6p-17 +0x1.37fc1a54b3b3ap-1 +0x1.2b51441c7ed21p-1 +-0x1.3aad4df57e683p-17 +0x1.b6e0e5cdb8814p-1 +0x1.88ea86c20d327p-1 +-0x1.69e0bfed21c86p-16 +0x1.7fadac863af12p-1 +0x1.562d044f71695p-1 +-0x1.eb40d77a4cbf4p-17 +0x1.0df266740689ep-1 +0x1.de10b589c297bp-2 +-0x1.27c44134c8ad1p-17 +0x1.005d3ec1e3844p-1 +0x1.c5a6d77299e1fp-2 +-0x1.0990b0824e5c8p-17 +0x1.1f3b683769bcp+0 +0x1.46fe91f73c74bp+0 +-0x1.1dc9f3fb7e704p-16 +0x1.f91fa179e8983p-1 +0x1.1980bfef1ca66p+0 +-0x1.8324232505363p-17 +0x1.672c047064c53p-1 +0x1.80cb5c8b7345ap-1 +-0x1.d0218dd0a4ae5p-18 +0x1.557ef25d43723p-1 +0x1.6c3f1d2131329p-1 +-0x1.a02687bbcbf92p-18 +0x1.3277f30380566p+0 +0x1.247835c271822p+0 +-0x1.ae4f1af9c0612p-17 +0x1.0e9e354cb664p+0 +0x1.0232c519cf5e9p+0 +-0x1.23bfc166c09e8p-17 +0x1.83cb9a1fa9b76p-1 +0x1.71d921fbbf9f7p-1 +-0x1.5e2e37a2a0e17p-18 +0x1.7104192eacf23p-1 +0x1.5fec2cd4640cdp-1 +-0x1.3a23dfd29efdep-18 +0x1.85c8033af3a7bp-1 +0x1.bf117beffe23ep-1 +-0x1.8f2e45077bf6dp-17 +0x1.5bb3f676bfdc6p-1 +0x1.8f1b82cdd4ad3p-1 +-0x1.1383d2cfaa7cdp-17 +0x1.fb4bc7e4bdfd9p-2 +0x1.2387fa2ca3c38p-1 +-0x1.5502d584bdce5p-18 +0x1.e3a8e8ecc911ep-2 +0x1.15fc9cd7550a2p-1 +-0x1.35176ab5d2703p-18 +-0x1.bc50e8cbec091p-16 +-0x1.7d85f68d9e75fp-13 +-0x1.4bac53421d4c4p-11 +-0x1.4965a9b38b1acp-12 +-0x1.de26ec6632542p-13 +-0x1.12a7d81daf54bp-17 +-0x1.9704180babc5p-11 +-0x1.23b4722da4131p-13 +-0x1.4058511042dffp-8 +-0x1.b73843d7d3701p-16 +-0x1.7925b26eca533p-13 +-0x1.47de6f8c74e56p-11 +-0x1.459e74dbe6a5cp-12 +-0x1.d8aaedd2be649p-13 +-0x1.0f815f961159p-17 +-0x1.9258f94292e7dp-11 +-0x1.205bea433c1cbp-13 +-0x1.307ea72f3973dp-8 +-0x1.096a93e42122ep-14 +-0x1.c7d01e5c4271cp-12 +-0x1.190dde864af2ap-9 +-0x1.1720218f8b44p-10 +-0x1.952d8afe6e587p-11 +-0x1.4822ddad3a041p-16 +-0x1.e645021eecea8p-10 +-0x1.ee5f191472ed8p-12 +-0x1.1e2ba1fd33442p-8 +-0x1.104cc21249014p-14 +-0x1.d3a266969020fp-12 +-0x1.1e93ac6387dc3p-9 +-0x1.1c9c3bbe570abp-10 +-0x1.9d23bbfd33cebp-11 +-0x1.50a5767b5229p-16 +-0x1.f2e1804ab699fp-10 +-0x1.f815f71d71353p-12 +-0x1.1f66c69c85a9bp-8 +0x1.ec0a2f1a13a13p+0 +0x1.c983c13939d9ep+0 +0x1.7b5bc7ae0f58p+0 +0x1.76ab9008c5bccp+0 +-0x1.5a21caee0887bp-11 +-0x1.8fccc5aaf830ep-9 +-0x1.761f8aafc3841p-11 +-0x1.a679d60e7d736p-9 +-0x1.a09c9ae19194ap-11 +-0x1.c2375f769b782p-9 +-0x1.a839256aacd37p-11 +-0x1.c9594c19acb9bp-9 +-0x1.318d698f68218p+1 +-0x1.27bd5fa4ad9c3p+1 +-0x1.13d7262c75cbp+1 +-0x1.129d11aed61fep+1 +0x1.1c4ed45ed6302p+0 +0x1.2fa9f7126a579p+0 +-0x1.9593aab77dc94p-17 +0x1.fe083fe721866p-1 +0x1.100065f65d077p+0 +-0x1.3d4376d995e0ep-17 +0x1.649862520ec0ep-1 +0x1.7b4bc4886f2d6p-1 +-0x1.73bf097d7bd02p-18 +0x1.59566a0fd2a4bp-1 +0x1.6f42749dc6504p-1 +-0x1.5c0e06460e0bap-18 +0x1.0bb8309b9dd43p+0 +0x1.f981e48d78bf5p-1 +-0x1.0b0d55ffac244p-16 +0x1.d67450f27e4a9p-1 +0x1.be6d879dae2adp-1 +-0x1.9b61a692b839dp-17 +0x1.3b385912d643ap-1 +0x1.2e5bee37a1ee2p-1 +-0x1.d10305bb95fb1p-18 +0x1.3075a30b26c85p-1 +0x1.243cacb4cfd5p-1 +-0x1.afb355362aa1cp-18 +0x1.b7a3dbe5d41c2p-1 +0x1.899ea199ea7cfp-1 +-0x1.bfa337caf498bp-17 +0x1.82607b561eb3bp-1 +0x1.58a526d26b49ep-1 +-0x1.5994917024f5ap-17 +0x1.03052ab7edd65p-1 +0x1.ca6c0e4884c9p-2 +-0x1.892f83c0d6536p-18 +0x1.f45f6d34ab89ap-2 +0x1.ba8fe072370bbp-2 +-0x1.6d884f538d259p-18 +0x1.1fb4df4a49797p+0 +0x1.47a232d0abff9p+0 +-0x1.610d6ec920811p-17 +0x1.fc89b50d47161p-1 +0x1.1bb09c754c33ep+0 +-0x1.10017a206a2c1p-17 +0x1.58f4c02e6aea3p-1 +0x1.7040c8f681b9p-1 +-0x1.33910faafa2f2p-18 +0x1.4d70b6d3c2336p-1 +0x1.62f2c4f2db129p-1 +-0x1.1d9178071945ep-18 +0x1.32f4be494ef09p+0 +0x1.24ef8c8d6e286p+0 +-0x1.0a0bf761e395dp-17 +0x1.1064b329ae851p+0 +0x1.03e51abe3dfd8p+0 +-0x1.9a4e11bf809bep-18 +0x1.74b1f50ecb381p-1 +0x1.636f2da89f7e2p-1 +-0x1.d0bb7af97df98p-19 +0x1.6871f0ce88b24p-1 +0x1.57bded528c71p-1 +-0x1.afb2d9d0d7919p-19 +0x1.8657ec0b8681ap-1 +0x1.bfb54610b2146p-1 +-0x1.f41100cb2e427p-18 +0x1.5dd1986eabf65p-1 +0x1.91859feea5b23p-1 +-0x1.87fea6b4d610fp-18 +0x1.e84cbca3d5ed6p-2 +0x1.18a561fdcf3a2p-1 +-0x1.cf6477271338ap-19 +0x1.d8d5570a61634p-2 +0x1.0fc7f945f119bp-1 +-0x1.b2736504f19dbp-19 +-0x1.204ac7b1e02d4p-16 +-0x1.ef1945eefd725p-14 +-0x1.ae68b74f5f7b4p-12 +-0x1.ab7499cb3f36p-13 +-0x1.363f24975c4efp-13 +-0x1.646aeeda75fb8p-18 +-0x1.081714f77c349p-11 +-0x1.7a8ae7a8a22e7p-14 +-0x1.f63bb3ac18381p-9 +-0x1.1d9c27018f50fp-16 +-0x1.ea7e17ac560a9p-14 +-0x1.aa679bed0974cp-12 +-0x1.a77a8740af16dp-13 +-0x1.335c3a2b99b59p-13 +-0x1.611a0ccf0b5dap-18 +-0x1.05a2189f90ae9p-11 +-0x1.77055417539fep-14 +-0x1.f7b9b06355a41p-9 +-0x1.7fe46f9f05981p-15 +-0x1.49a390858437fp-12 +-0x1.b742ace6ee1efp-10 +-0x1.b43f02b140894p-11 +-0x1.3ca07cd02ee92p-11 +-0x1.da9be5f53eef5p-17 +-0x1.5faa307f675e9p-10 +-0x1.8253ce06bcd45p-12 +-0x1.df9e90da91848p-9 +-0x1.87ecbadd29994p-15 +-0x1.508940f0e0ec9p-12 +-0x1.be3fd226aeffp-10 +-0x1.bb2fe0e25820dp-11 +-0x1.41aa22d770e55p-11 +-0x1.e48a1c24b64aep-17 +-0x1.6705dbd6d4e21p-10 +-0x1.8879596aae10fp-12 +-0x1.e40700ae605a3p-9 +0x1.ee196d63d1a1ep+0 +0x1.cb89a9e7ee7fdp+0 +0x1.7545c5d0f353ap+0 +0x1.745b89c598a63p+0 +-0x1.1e9edd489a7dbp-11 +-0x1.4ba19e53b9d57p-9 +-0x1.3bffcfe9c6d0fp-11 +-0x1.6563bada8b6e7p-9 +-0x1.66fabe8683aa9p-11 +-0x1.82d885cb5956bp-9 +-0x1.6961c67004b7p-11 +-0x1.8541381331089p-9 +-0x1.321a4b91de65ap+1 +-0x1.284eae5c30307p+1 +-0x1.125d910035516p+1 +-0x1.120af0b188e9dp+1 +0x1.1dcf3fb19956dp+0 +0x1.314aa53149f19p+0 +-0x1.23fa975eb2f89p-17 +0x1.00d8ea806725bp+0 +0x1.11f9ffaabd9ebp+0 +-0x1.dcb913bc60efp-18 +0x1.57086a8059f81p-1 +0x1.6ccbd1601abap-1 +-0x1.065cb884efc11p-18 +0x1.540506d83dcb2p-1 +0x1.699361703175p-1 +-0x1.f804ad6f23526p-19 +0x1.0d719e3e1994ep+0 +0x1.fc9ea10314862p-1 +-0x1.7c1ef29b75b31p-17 +0x1.da66de7b98302p-1 +0x1.c20a0b7472cf5p-1 +-0x1.316cf0cc5d374p-17 +0x1.2e43e900c748fp-1 +0x1.222bc5df0d497p-1 +-0x1.402489cbd441bp-18 +0x1.2b669a3c8725ep-1 +0x1.1f790f9322cc6p-1 +-0x1.316f8ce238d91p-18 +0x1.ba773a22c61f6p-1 +0x1.8c3b198be06e8p-1 +-0x1.3f01f1ac4cf4fp-17 +0x1.859cfff82ba79p-1 +0x1.5b9baca0d764p-1 +-0x1.00f239033b917p-17 +0x1.f0c5189d3664cp-2 +0x1.b7547b1a9b83p-2 +-0x1.0fbeeea7b4fc2p-18 +0x1.ec11041bf87e7p-2 +0x1.b31ca01da2f98p-2 +-0x1.038a7f00ec2bfp-18 +0x1.21774d0b3a6cap+0 +0x1.4a020bdfc56dep+0 +-0x1.f6ade46db1a2cp-18 +0x1.00509a0cb1574p+0 +0x1.1e515069b6065p+0 +-0x1.940366f7aa48fp-18 +0x1.4b16e7fffd998p-1 +0x1.603e17d30510cp-1 +-0x1.a7ad8b54adf6cp-19 +0x1.4804f0e3883bp-1 +0x1.5cb6c74824593p-1 +-0x1.944344ed01f38p-19 +0x1.34c35087587fap+0 +0x1.26a9e93ca1b73p+0 +-0x1.7b187443791fap-18 +0x1.128507abfd85bp+0 +0x1.05ed4f80ed356p+0 +-0x1.30f551ffa3bb7p-18 +0x1.65f142f07ec0ap-1 +0x1.555a709bcc7f2p-1 +-0x1.408f02cfdae56p-19 +0x1.62ac476006f31p-1 +0x1.523b9b41c420cp-1 +-0x1.31ff268757d15p-19 +0x1.886cb38facc1p-1 +0x1.c213977fe5b4dp-1 +-0x1.67fa5ee88e5d1p-18 +0x1.60593c1859becp-1 +0x1.94689df428332p-1 +-0x1.268d8f9fdfd9bp-18 +0x1.d5aae8dcb6724p-2 +0x1.0df76481d708ap-1 +-0x1.4804c77f3756ap-19 +0x1.d18763580e06ap-2 +0x1.0b97fc6542c51p-1 +-0x1.3b53989683e3bp-19 +-0x1.7555d618ed4f4p-17 +-0x1.4092e891f8617p-14 +-0x1.16b016a72710cp-12 +-0x1.14c681e2e1447p-13 +-0x1.91c43a38e352p-14 +-0x1.cd8ea765f9e05p-19 +-0x1.55fe78a91c098p-12 +-0x1.ea35892453127p-15 +-0x1.a22ae181393ecp-9 +-0x1.72d2a1bc72846p-17 +-0x1.3e6a9ac1f8b04p-14 +-0x1.14cff2f9dd63p-12 +-0x1.12e9a9b00d63p-13 +-0x1.8f100a85678b6p-14 +-0x1.ca73748d9c857p-19 +-0x1.53b1436f8d6e8p-12 +-0x1.e6e8f9b31e1afp-15 +-0x1.aba1c901618ecp-9 +-0x1.158d633180544p-15 +-0x1.dca799ec2270dp-13 +-0x1.56e9c85ef3b85p-10 +-0x1.548f5fe11b717p-11 +-0x1.ee5b2baa0ea8p-12 +-0x1.5723d697e8724p-17 +-0x1.fc80ff8f45efp-11 +-0x1.2d9727c96c6c8p-12 +-0x1.98cf95f250fb3p-9 +-0x1.19ba1e97a7225p-15 +-0x1.e3d2fd3c73d01p-13 +-0x1.5ada3eb885923p-10 +-0x1.5878eaa06b1bfp-11 +-0x1.f40901a500a1cp-12 +-0x1.5c4d1ea580e35p-17 +-0x1.0213830345a7dp-10 +-0x1.310e17cbd2581p-12 +-0x1.9ad4440247404p-9 +0x1.efe8e81ac6cf8p+0 +0x1.ccd25e998f07cp+0 +0x1.6ff0ff054442ap+0 +0x1.7374855f1c589p+0 +-0x1.e3c231cecca1cp-12 +-0x1.184768fb9dfe5p-9 +-0x1.0c1dc6713a304p-11 +-0x1.2f8c8bb136fp-9 +-0x1.3545831cbe2a9p-11 +-0x1.4c782b886a04ep-9 +-0x1.33ee362fa2b9cp-11 +-0x1.4b9b570488095p-9 +-0x1.32a51fa655a63p+1 +-0x1.28ad4ddff03a9p+1 +-0x1.11125fdecf6f6p+1 +-0x1.11cea12009ca9p+1 +0x1.1f4685c7f840ep+0 +0x1.32e188baffe8ap+0 +-0x1.b36dca98b4ccdp-18 +0x1.0207c3d0e7953p+0 +0x1.1340b3456a5dbp+0 +-0x1.6637ce5c1e0d7p-18 +0x1.4adae2842118fp-1 +0x1.5fc87beea9b0ep-1 +-0x1.773b122a8a4a5p-19 +0x1.51cf4e67a5cp-1 +0x1.6736d1313dff8p-1 +-0x1.75b691cdaa81dp-19 +0x1.0f222195f3179p+0 +0x1.ffaaabff52e77p-1 +-0x1.181b18745e845p-17 +0x1.dcf59de7a774fp-1 +0x1.c460a95cbc10fp-1 +-0x1.c4b5ef87c11b3p-18 +0x1.22b7f4ea4f4edp-1 +0x1.1749c34796833p-1 +-0x1.bd101749988cep-19 +0x1.294d9c0327eap-1 +0x1.1d7f13ac860a7p-1 +-0x1.ba2256f9470bap-19 +0x1.bd3bf5f783466p-1 +0x1.8eca62e506b4ap-1 +-0x1.d6cb4c22b09eep-18 +0x1.87b5ca10eb865p-1 +0x1.5d8755547309ap-1 +-0x1.7d827679f47d6p-18 +0x1.ddcf51a433905p-2 +0x1.a6557582369bdp-2 +-0x1.7b82df2323c24p-19 +0x1.e89f442e251fdp-2 +0x1.b0060d9bb9284p-2 +-0x1.791c68e90669fp-19 +0x1.23303d8945727p+0 +0x1.4c56b9c3229bfp+0 +-0x1.72879c5c8b449p-18 +0x1.01a3b12d38723p+0 +0x1.2005e0220a8bp+0 +-0x1.2b85bf3daaeccp-18 +0x1.3eb4661733bf3p-1 +0x1.520b5083e9f77p-1 +-0x1.26a504df65721p-19 +0x1.45c5260bf3121p-1 +0x1.5a21f71392c5bp-1 +-0x1.24bbc675ff588p-19 +0x1.3687d49120994p+0 +0x1.285aac656f5b3p+0 +-0x1.17a9823fe9303p-18 +0x1.13e53ff354efcp+0 +0x1.073dee448aa65p+0 +-0x1.c49807e65f454p-19 +0x1.58bf3a87a44d2p-1 +0x1.48c276e64d1fp-1 +-0x1.be9f6c4509c9p-20 +0x1.6046ee83ccfe8p-1 +0x1.4ff239811eb7fp-1 +-0x1.bbd391f8b32b1p-20 +0x1.8a74e7c74f3e4p-1 +0x1.c463812e2b757p-1 +-0x1.0c63b2e007b8cp-18 +0x1.61fbaee3ed867p-1 +0x1.9646087037fe5p-1 +-0x1.bac28fcdd3c91p-19 +0x1.c4f1635170b13p-2 +0x1.0460a2a4b2db5p-1 +-0x1.d6bde43e394bep-20 +0x1.ce7e685ebc77fp-2 +0x1.09da881927ccp-1 +-0x1.d4b2746fbd823p-20 +-0x1.e2338fdf37604p-18 +-0x1.9e0df54b07754p-15 +-0x1.67f46417143dcp-13 +-0x1.657c0ba52da59p-14 +-0x1.03763b8522b84p-14 +-0x1.2a131a5573ca5p-19 +-0x1.b9b88cf57f3fdp-13 +-0x1.3c940c2985343p-15 +-0x1.628f995e69784p-9 +-0x1.e06f33b13ec74p-18 +-0x1.9c898715cdeeep-15 +-0x1.66a2b682f0e7cp-13 +-0x1.642caf47257eep-14 +-0x1.0282d3fa6949cp-14 +-0x1.28fb798b40ad4p-19 +-0x1.b81a2a782453p-13 +-0x1.3b6b0fb5a1801p-15 +-0x1.6c10c33bdf077p-9 +-0x1.91286788cfbcap-16 +-0x1.5876e20a99868p-13 +-0x1.0b579c737c51dp-10 +-0x1.0981f615fd70ap-11 +-0x1.81690707c31ecp-12 +-0x1.eff456a945d03p-18 +-0x1.6f7b1aade20d6p-11 +-0x1.d64096d59aa99p-13 +-0x1.5ce33194bf102p-9 +-0x1.946b63bce69cdp-16 +-0x1.5b43dd3fc67b7p-13 +-0x1.0d02dbf98c50fp-10 +-0x1.0b2a470c12fdp-11 +-0x1.83d0f6c14de58p-12 +-0x1.f3fca310e764cp-18 +-0x1.7277fe2e3015bp-11 +-0x1.d9301d48701bbp-13 +-0x1.5daf058e62181p-9 +0x1.f1a6e81d9e686p+0 +0x1.cda236e012134p+0 +0x1.6c938969c29aep+0 +0x1.73ea9a06fc117p+0 +-0x1.986e7e13be5efp-12 +-0x1.d9f02bf9269dcp-10 +-0x1.c51a4b55ec724p-12 +-0x1.00ac86833ed91p-9 +-0x1.088eef781ceb3p-11 +-0x1.1bfc8930c3e7p-9 +-0x1.0619c2b77378dp-11 +-0x1.1a5f5e7ceb306p-9 +-0x1.332cb4d17d348p+1 +-0x1.28e7ddb057733p+1 +-0x1.1046881693028p+1 +-0x1.11e8ef14bb834p+1 +0x1.20b1a900d8162p+0 +0x1.346b61750cfb8p+0 +-0x1.457ac78655115p-18 +0x1.02c23ea3cff1bp+0 +0x1.1409e57563dcbp+0 +-0x1.0a0ccd6ce36e5p-18 +0x1.4339e43a29f14p-1 +0x1.57a25600e5afcp-1 +-0x1.11cd62ae91397p-19 +0x1.52c65274b2c75p-1 +0x1.683ec979b8d98p-1 +-0x1.1ad1b4650391p-19 +0x1.10c62cda24ef9p+0 +0x1.014fd386a82e2p+0 +-0x1.9d2ebe412c7ebp-18 +0x1.de89889a11743p-1 +0x1.c5d1cc7f74b8cp-1 +-0x1.4aac835f25dc1p-18 +0x1.1b8665ccaa3f8p-1 +0x1.107fbb2ebf41ep-1 +-0x1.3b1e798683afcp-19 +0x1.2a37ffb955a9p-1 +0x1.1e5bf34acd83cp-1 +-0x1.4664c61b615aep-19 +0x1.bfec3d029fc7fp-1 +0x1.914715c87a844p-1 +-0x1.5bc7fc52567d6p-18 +0x1.8900ee471b82cp-1 +0x1.5eb6b86c79dd5p-1 +-0x1.1741ac0c1c9ddp-18 +0x1.d1ff385e2d421p-2 +0x1.9bc1417be11cap-2 +-0x1.0e093fe33fd7ep-19 +0x1.ea2023798fbc2p-2 +0x1.b15f1b2a1e9b3p-2 +-0x1.1778f6b6ed81bp-19 +0x1.24dc18009ee0ap+0 +0x1.4e9b4254770d1p+0 +-0x1.1160dd524e056p-18 +0x1.0274c781552c1p+0 +0x1.211378d54420dp+0 +-0x1.b5be3cccc1052p-19 +0x1.36fa1d2d892d6p-1 +0x1.493b7b8cff761p-1 +-0x1.a17758e084a35p-20 +0x1.46c07f8a564f2p-1 +0x1.5b425494fcf85p-1 +-0x1.b06d853a895ep-20 +0x1.383e9ecdb04c3p+0 +0x1.29fe532a5364cp+0 +-0x1.9d0e2f2e8cfbbp-19 +0x1.14be5b081664ap+0 +0x1.080d6ccfec3acp+0 +-0x1.4b19de0d09ed8p-19 +0x1.50812740325dep-1 +0x1.40e4bcfcaa518p-1 +-0x1.3cfd2080195acp-20 +0x1.6152b1929ed85p-1 +0x1.50f1c6f2baa1ap-1 +-0x1.4856d0eae5a24p-20 +0x1.8c6c61a9fdb72p-1 +0x1.c6a04b29854b4p-1 +-0x1.912f25eb25b8p-19 +0x1.62fd5e053e86dp-1 +0x1.976c01dfade6ep-1 +-0x1.48efe190004b1p-19 +0x1.ba77d919d72fp-2 +0x1.fcbdcdca1579p-2 +-0x1.58a9cf2d5f47bp-20 +0x1.cfd1a9a741207p-2 +0x1.0a9d08b4bcb9fp-1 +-0x1.637226cb78634p-20 +-0x1.365e2123590c6p-18 +-0x1.0a814fc8f8b12p-15 +-0x1.cf5e3d5658589p-14 +-0x1.cc303950b7f6bp-15 +-0x1.4e01102287c65p-15 +-0x1.7fb5bd250d645p-20 +-0x1.1c50010443481p-13 +-0x1.9787aa1f2f633p-16 +-0x1.2cb1a204fa864p-9 +-0x1.365e2123590c7p-18 +-0x1.0a814fc8f8b13p-15 +-0x1.cf5e3d565858ap-14 +-0x1.cc303950b7f6cp-15 +-0x1.4e01102287c66p-15 +-0x1.7fb5bd250d646p-20 +-0x1.1c50010443482p-13 +-0x1.9787aa1f2f635p-16 +-0x1.34565d5a7bc2ap-9 +-0x1.21b2d8f31b98fp-16 +-0x1.f183a2a0cabdp-14 +-0x1.a01ef244513a3p-11 +-0x1.9d43ee7d086b9p-12 +-0x1.2bf28e6026af6p-12 +-0x1.66281649b79c8p-18 +-0x1.0960ebff5c2cfp-11 +-0x1.6df9ea318ef6ep-13 +-0x1.28b91e7250e6dp-9 +-0x1.21b2d8f31b98fp-16 +-0x1.f183a2a0cabdp-14 +-0x1.a01ef244513a3p-11 +-0x1.9d43ee7d086b9p-12 +-0x1.2bf28e6026af6p-12 +-0x1.66281649b79c8p-18 +-0x1.0960ebff5c2cfp-11 +-0x1.6df9ea318ef6ep-13 +-0x1.2a0e0e6a94a02p-9 +0x1.f56b0767b6181p+0 +0x1.cf54d635e6667p+0 +0x1.6bbfffe59ea0ap+0 +0x1.7698728a6cb01p+0 +-0x1.3dca1e5be7882p-12 +-0x1.71d1cf35b6ecbp-10 +-0x1.603b8c6001937p-12 +-0x1.8f978d99dc18fp-10 +-0x1.9e49cc5557543p-12 +-0x1.bca3a48fda3cp-10 +-0x1.9e3bd161642a8p-12 +-0x1.bef950956a564p-10 +-0x1.345243cc18e8dp+1 +-0x1.2960552d4b2fap+1 +-0x1.1014e7643e526p+1 +-0x1.1296eb39c13fap+1 +0x1.23b8a8bb53924p+0 +0x1.37b44f5c3d1bbp+0 +-0x1.b1e2dc0615167p-19 +0x1.043f9323f7bc5p+0 +0x1.15a5638df2b72p+0 +-0x1.5a59e45b473f9p-19 +0x1.415a6acc51448p-1 +0x1.55a242e65089dp-1 +-0x1.660b8ab35e4e4p-20 +0x1.591d619aa5ca2p-1 +0x1.6f057dd554272p-1 +-0x1.85510dd0fe31cp-20 +0x1.144bbc81053dap+0 +0x1.047b3c3afc8e5p+0 +-0x1.0dbb6af07255cp-18 +0x1.e1c54ee27e9dap-1 +0x1.c8c5eed7ede78p-1 +-0x1.a2ad484c57aa7p-19 +0x1.19c375461b793p-1 +0x1.0ed5dec8422a5p-1 +-0x1.8a01db23361a9p-20 +0x1.303f4de1d65f1p-1 +0x1.2409863efd811p-1 +-0x1.b11b03d9af4eep-20 +0x1.c5b17127fdc16p-1 +0x1.969eaeb0829fcp-1 +-0x1.c7304eab8cd72p-19 +0x1.8ba78bf0662cep-1 +0x1.6124aa4a8e81fp-1 +-0x1.62d7d9b8c544cp-19 +0x1.cf1ab1018abc8p-2 +0x1.992a63e7922a4p-2 +-0x1.54253f90bcca3p-20 +0x1.f4063722f4e4ep-2 +0x1.ba3fd6eaeb618p-2 +-0x1.74f95c62baa21p-20 +0x1.2871293eed8e7p+0 +0x1.537cd4bd88d96p+0 +-0x1.65215641a5141p-19 +0x1.042109f256b24p+0 +0x1.233ca50d4cd21p+0 +-0x1.15518a178683p-19 +0x1.351557180a3d9p-1 +0x1.471419ee48f29p-1 +-0x1.05398bf34b78fp-20 +0x1.4d3683ae8cd5dp-1 +0x1.62afbe466199ap-1 +-0x1.1f242c623e4cbp-20 +0x1.3bea2269b7829p+0 +0x1.2d80e9d28dc1p+0 +-0x1.0e322f5e86b45p-19 +0x1.167ada9dcd0d6p+0 +0x1.09b64139b0ccp+0 +-0x1.a4535c2ead5bep-20 +0x1.4e7bd17d07f8ap-1 +0x1.3ef70a01a5a5cp-1 +-0x1.8ddc932c9f3efp-21 +0x1.6833fd2f81445p-1 +0x1.5782cc3c58371p-1 +-0x1.b5215ff82e8b8p-21 +0x1.909f3558ab99fp-1 +0x1.cb66c980872bp-1 +-0x1.0b4f3ad828fedp-19 +0x1.650c5be532898p-1 +0x1.99c529a18c4c9p-1 +-0x1.ac64b7383d743p-20 +0x1.b7e59581bf2aap-2 +0x1.f9cac4aa67d69p-2 +-0x1.c49dbf88ad8cp-21 +0x1.d886ff1cd2713p-2 +0x1.0f9b106a32061p-1 +-0x1.ea80b053605acp-21 +-0x1.4896ed8de9dffp-19 +-0x1.1a26dc1493767p-16 +-0x1.ea92c2b665786p-15 +-0x1.e734f3dcae492p-16 +-0x1.619d3755b742p-16 +-0x1.963cdd47e7479p-21 +-0x1.2d01320c16de2p-14 +-0x1.af74ed01eb022p-17 +-0x1.d83a0e280e2abp-10 +-0x1.4896ed8de9e01p-19 +-0x1.1a26dc1493769p-16 +-0x1.ea92c2b665789p-15 +-0x1.e734f3dcae494p-16 +-0x1.619d3755b7423p-16 +-0x1.963cdd47e747cp-21 +-0x1.2d01320c16de4p-14 +-0x1.af74ed01eb025p-17 +-0x1.e177d43fe8e3ap-10 +-0x1.6161927fcc8efp-17 +-0x1.2f709144ddea2p-14 +-0x1.1b79dfd36d518p-11 +-0x1.1987e1ad2b6dp-12 +-0x1.98ab5d61f854p-13 +-0x1.b4e344c07dfbbp-19 +-0x1.43b70afc47fabp-12 +-0x1.f2a1ae418ff1p-14 +-0x1.d03da962ab44dp-10 +-0x1.6161927fcc8efp-17 +-0x1.2f709144ddea2p-14 +-0x1.1b79dfd36d518p-11 +-0x1.1987e1ad2b6dp-12 +-0x1.98ab5d61f854p-13 +-0x1.b4e344c07dfbbp-19 +-0x1.43b70afc47fabp-12 +-0x1.f2a1ae418ff1p-14 +-0x1.d9bf467daf125p-10 +0x1.f854462b26423p+0 +0x1.cf8d2ba76688cp+0 +0x1.6d20076fe302bp+0 +0x1.78bd86b494c0dp+0 +-0x1.c6de976d1070ap-13 +-0x1.0947d2681d7c5p-10 +-0x1.f68f92074f2f4p-13 +-0x1.1d2d541f32b3ap-10 +-0x1.2abbde6b0ffa4p-12 +-0x1.40e9a3c132a97p-10 +-0x1.2c216884a6c42p-12 +-0x1.4447cbcaad634p-10 +-0x1.35367083aec2ap+1 +-0x1.296ff7d918f3ap+1 +-0x1.106c18661578ap+1 +-0x1.131f98de306d7p+1 +0x1.26088d8f3e61fp+0 +0x1.3a36ed42332edp+0 +-0x1.efdb43f3ba425p-20 +0x1.0470d81c7a207p+0 +0x1.15da8ff0f485p+0 +-0x1.8064e8a4af9ffp-20 +0x1.44a3c4053fc65p-1 +0x1.5924d6873ee4ap-1 +-0x1.aa9892237561ep-21 +0x1.5e0b64ee1c17fp-1 +0x1.744a9d0d219dfp-1 +-0x1.d2c01f289d4fap-21 +0x1.17011ca2ac4f4p+0 +0x1.06ea5f81046f7p+0 +-0x1.29290cf1dfa97p-19 +0x1.e230705534b55p-1 +0x1.c927c18bd7f0ap-1 +-0x1.ba5330c870fb4p-20 +0x1.1cdb0a83a0367p-1 +0x1.11c15bf8d997p-1 +-0x1.b88c97efd1c1cp-21 +0x1.34f3341d2c2f2p-1 +0x1.2876885ee4c9ap-1 +-0x1.e891bc650d0e3p-21 +0x1.ca217596c9691p-1 +0x1.9abb6f205c584p-1 +-0x1.f7b871b737f81p-20 +0x1.8bff5f25bb236p-1 +0x1.61752d24a342fp-1 +-0x1.795fa3569aa7fp-20 +0x1.d42e9da276b22p-2 +0x1.9db6108f0412ep-2 +-0x1.8071553fcb99ap-21 +0x1.fbbeeb7e19ff3p-2 +0x1.c12db20d63653p-2 +-0x1.a8f4667086ec8p-21 +0x1.2b314905d262ap+0 +0x1.57412db6d968p+0 +-0x1.89d7338ab32a1p-20 +0x1.045870dbf4564p+0 +0x1.23844d6b99e4p+0 +-0x1.255d1b5ecff9dp-20 +0x1.3868394e4eb99p-1 +0x1.4adc42c53d2d4p-1 +-0x1.247e8d2ddfe46p-21 +0x1.523f9ccbd4023p-1 +0x1.687e4832a91cep-1 +-0x1.445f35a15d451p-21 +0x1.3eba8f237d3f2p+0 +0x1.3032017a39db6p+0 +-0x1.2ac09ffedb2cep-20 +0x1.16b456a632cefp+0 +0x1.09ed3255232a9p+0 +-0x1.be317711aa67ep-21 +0x1.5207c8e9bbe04p-1 +0x1.425986b43edb4p-1 +-0x1.bf6ce18d1165bp-22 +0x1.6d8fd21b241c3p-1 +0x1.5ca02679d9484p-1 +-0x1.efe55af1f2ea6p-22 +0x1.93d464e0cd2e5p-1 +0x1.cf0c81b3a968fp-1 +-0x1.3159ad8f4db2p-20 +0x1.6550743e4d6fbp-1 +0x1.9a12d5dfaffeap-1 +-0x1.dbe36126244cp-21 +0x1.bc68adf7dde53p-2 +0x1.fef7a80cb128dp-2 +-0x1.0efd74624d41cp-21 +0x1.df4caa16d362bp-2 +0x1.137cd299fc69p-1 +-0x1.2741a9645e53bp-21 +-0x1.185258820c1b2p-20 +-0x1.e16921a2b5e03p-18 +-0x1.a282f33328767p-16 +-0x1.9fa3bc4acefa3p-17 +-0x1.2dabb311a5a91p-17 +-0x1.5a905425499e6p-22 +-0x1.00c9f0d788787p-15 +-0x1.70142b4084e2ep-18 +-0x1.546ebe597d3fcp-10 +-0x1.185258820c1b5p-20 +-0x1.e16921a2b5e07p-18 +-0x1.a282f3332876bp-16 +-0x1.9fa3bc4acefa8p-17 +-0x1.2dabb311a5a94p-17 +-0x1.5a905425499e8p-22 +-0x1.00c9f0d788789p-15 +-0x1.70142b4084e32p-18 +-0x1.57e2e1a5043bp-10 +-0x1.6a3ec43d594bfp-18 +-0x1.370d11a5619efp-15 +-0x1.4ed96ce5873e6p-12 +-0x1.4c8d2eefdb2ffp-13 +-0x1.e2bb1e3d4031ap-14 +-0x1.bfd8b0c92e15ep-20 +-0x1.4bd5bd5f9725p-13 +-0x1.267f90423fdc4p-14 +-0x1.4fd5c61ce2b1ap-10 +-0x1.6a3ec43d594bfp-18 +-0x1.370d11a5619efp-15 +-0x1.4ed96ce5873e6p-12 +-0x1.4c8d2eefdb2ffp-13 +-0x1.e2bb1e3d4031ap-14 +-0x1.bfd8b0c92e15ep-20 +-0x1.4bd5bd5f9725p-13 +-0x1.267f90423fdc4p-14 +-0x1.58e0a5044fc3cp-10 +0x1.f89e7b4069b53p+0 +0x1.cedbe9ecb00b2p+0 +0x1.69e1be7c9b377p+0 +0x1.7a41017dd6083p+0 +-0x1.2784ae2274257p-13 +-0x1.58d6a233cb5afp-11 +-0x1.45448afd5d291p-13 +-0x1.71108724ce425p-11 +-0x1.893d31b2ab855p-13 +-0x1.a5daf25d9ae63p-11 +-0x1.857dbb0d735f7p-13 +-0x1.a53fa3a5490efp-11 +-0x1.354d00047ebd7p+1 +-0x1.293ef858e5dp+1 +-0x1.0fa7eff94e3c1p+1 +-0x1.137cfd7fa28f4p+1 +0x1.2642953ebfb94p+0 +0x1.3a75f2879ffcfp+0 +-0x1.d6addf0501766p-21 +0x1.03d645ea55d3fp+0 +0x1.1533bfaa730d3p+0 +-0x1.6fc0aacacabbdp-21 +0x1.3d381c11650cfp-1 +0x1.51381f2e6b93fp-1 +-0x1.b25d72269a2a4p-22 +0x1.6163345bad0f4p-1 +0x1.77dda566cb368p-1 +-0x1.df85f6043449fp-22 +0x1.1745523d2d0d6p+0 +0x1.0727a1535624ap+0 +-0x1.0784403ac42bcp-20 +0x1.e0e07abf86d36p-1 +0x1.c7f4f52257b03p-1 +-0x1.85a96f237896ep-21 +0x1.15e1c0d5ef0a6p-1 +0x1.0b2b0dd74c2ep-1 +-0x1.93434bedb87afp-22 +0x1.3825936cb2ebdp-1 +0x1.2b7843ee07747p-1 +-0x1.c689259e49f79p-22 +0x1.ca913589da196p-1 +0x1.9b230aa87167dp-1 +-0x1.c29fcb47fb9ffp-21 +0x1.8aebf4054edf6p-1 +0x1.6078b5b6d5d8p-1 +-0x1.5060118848ff3p-21 +0x1.c8baceaaeecp-2 +0x1.9376135f07d5cp-2 +-0x1.66fb43d2b4e0bp-22 +0x1.007f4a9f130ap-1 +0x1.c5e3fb81a8668p-2 +-0x1.924c7d2510563p-22 +0x1.2b767f0ae996dp+0 +0x1.57a033a014b78p+0 +-0x1.5dee55d6b325ep-21 +0x1.03aaaef6f8c48p+0 +0x1.22a3a2e32f8b5p+0 +-0x1.0308d6cd7958ep-21 +0x1.30e8968cc0d44p-1 +0x1.425670d07daafp-1 +-0x1.0c60461cb9218p-22 +0x1.55ab504627589p-1 +0x1.6c727091d18b9p-1 +-0x1.2e856678f89dcp-22 +0x1.3f0153fd2f9edp+0 +0x1.3075b30104ff8p+0 +-0x1.0ac49e5e066dfp-21 +0x1.16000923280abp+0 +0x1.0940deaacf281p+0 +-0x1.8c5d3cf448204p-22 +0x1.4a06e9bd2fe21p-1 +0x1.3ab64727a36f5p-1 +-0x1.9d9b2141ba5fp-23 +0x1.713348162dd4ap-1 +0x1.60193603c9772p-1 +-0x1.d1d1a41389415p-23 +0x1.9424eb27a5993p-1 +0x1.cf680d6ef860ep-1 +-0x1.21b94b28d3feap-21 +0x1.647ad380df1fp-1 +0x1.991f28013505bp-1 +-0x1.c8054919fd597p-22 +0x1.b238bfc76ad8fp-2 +0x1.f348412dbf348p-2 +-0x1.16854617b3cebp-22 +0x1.e3e47136f2fadp-2 +0x1.161ebbb10f5a2p-1 +-0x1.314c7c3ae6885p-22 +-0x1.79f483a938959p-22 +-0x1.448a71ee88ea8p-19 +-0x1.1a235bbca9d92p-17 +-0x1.1833b74c3f9c8p-18 +-0x1.96bd94d14c8b8p-19 +-0x1.d344cebee8cfap-24 +-0x1.5a39dd3d9f3e2p-17 +-0x1.f04732d2d7bd4p-20 +-0x1.baeaa9c1eac31p-11 +-0x1.79f483a93895dp-22 +-0x1.448a71ee88eacp-19 +-0x1.1a235bbca9d96p-17 +-0x1.1833b74c3f9ccp-18 +-0x1.96bd94d14c8bep-19 +-0x1.d344cebee8cffp-24 +-0x1.5a39dd3d9f3e6p-17 +-0x1.f04732d2d7bdcp-20 +-0x1.bcc4c5a45b025p-11 +-0x1.2f8d932394ebp-19 +-0x1.04a74e2ba4455p-16 +-0x1.4b2e796b03602p-13 +-0x1.48e8acf2b2f7dp-14 +-0x1.dd717dfdc9762p-15 +-0x1.7748eec8869b6p-21 +-0x1.1611e7514710dp-14 +-0x1.2345c2bfdbd05p-15 +-0x1.b7a83ccd59c74p-11 +-0x1.2f8d932394ebp-19 +-0x1.04a74e2ba4455p-16 +-0x1.4b2e796b03602p-13 +-0x1.48e8acf2b2f7dp-14 +-0x1.dd717dfdc9762p-15 +-0x1.7748eec8869b6p-21 +-0x1.1611e7514710dp-14 +-0x1.2345c2bfdbd05p-15 +-0x1.c1209f6160901p-11 +0x1.f84157a43cb05p+0 +0x1.cabba71b3acc7p+0 +0x1.6072ddfb418ffp+0 +0x1.7b4d84f165a2p+0 +-0x1.3dc05fcef8d0bp-14 +-0x1.72c141091433ep-12 +-0x1.6066e54aa98b3p-14 +-0x1.8ee40bbaa4b06p-12 +-0x1.afc1788d4af8ap-14 +-0x1.cd2909794edc8p-12 +-0x1.a18bad8fefb35p-14 +-0x1.c3eb31d4ec2fdp-12 +-0x1.3530fa0f9934fp+1 +-0x1.281a9b138e061p+1 +-0x1.0d791564d802dp+1 +-0x1.13bd260341827p+1 +0x1.25fa7d12d7c1ep+0 +0x1.3a27a7410f932p+0 +-0x1.55b80ca8f5c2bp-22 +0x1.00316e3ac0e5dp+0 +0x1.114558c113f12p+0 +-0x1.10285cc4ee887p-22 +0x1.278adf26a66f2p-1 +0x1.3a14f4cdda43ap-1 +-0x1.59d24a59bc236p-23 +0x1.63ac118313903p-1 +0x1.7a4f0dc3a8d19p-1 +-0x1.886979edb7129p-23 +0x1.16f0962a86874p+0 +0x1.06db87ee5324dp+0 +-0x1.4eeb7dbdb9d4cp-22 +0x1.d8fd6b04a0da5p-1 +0x1.c0bf734870126p-1 +-0x1.ec53308a79bc1p-23 +0x1.01aaca8171cc3p-1 +0x1.f0136222b2cb9p-2 +-0x1.0ac3719704ef6p-23 +0x1.3a55c7e9ec8a4p-1 +0x1.2d86f6b4a31dp-1 +-0x1.3aa92219c0b28p-23 +0x1.ca0662a3d803cp-1 +0x1.9aa2558352675p-1 +-0x1.23c4fac26ce39p-22 +0x1.8474a96fca858p-1 +0x1.5a8c532194cbap-1 +-0x1.b3db0a17943bbp-23 +0x1.a787aecf89d84p-2 +0x1.75c9da6a039c9p-2 +-0x1.ee5d7d991295ep-24 +0x1.024b2ce42685ep-1 +0x1.c91df3c5fef7fp-2 +-0x1.1fc0f8f03b35fp-23 +0x1.2b20840b74871p+0 +0x1.572a294cf0baap+0 +-0x1.bea14cbb71699p-23 +0x1.ff2aa58d9462fp-1 +0x1.1d608d36286c6p+0 +-0x1.48e546f3461c5p-23 +0x1.1b200da1a285p-1 +0x1.29c45761a65cep-1 +-0x1.649724ac261aap-24 +0x1.58027cb3142abp-1 +0x1.6f28130d4f64fp-1 +-0x1.a4d0c36940ec6p-24 +0x1.3ea96938197p+0 +0x1.30219a5a13a0bp+0 +-0x1.57f1bce386eb1p-23 +0x1.11c26f1d9919ep+0 +0x1.053356307d04ap+0 +-0x1.fd6173afbd85ap-24 +0x1.32bdd51d0ca3ap-1 +0x1.247e0e23c323bp-1 +-0x1.1670b7b5b1762p-24 +0x1.73b0664e9b5eep-1 +0x1.62795688298e3p-1 +-0x1.481a840068466p-24 +0x1.93c0e0d0f9c6ep-1 +0x1.cef651bd4b653p-1 +-0x1.a46adc068112dp-23 +0x1.5f71d6d7a9ac1p-1 +0x1.936098187514cp-1 +-0x1.52bbabe397976p-23 +0x1.9479096e60784p-2 +0x1.d126511efd42bp-2 +-0x1.c32261de87f7dp-24 +0x1.e708080324f34p-2 +0x1.17eb4aacb6b3p-1 +-0x1.f879c7ddb0417p-24 +-0x1.563eab5bbdad5p-24 +-0x1.25e0912c79f02p-21 +-0x1.fef674c54c06p-20 +-0x1.fb74d44a571bdp-21 +-0x1.704faadc32118p-21 +-0x1.a71ead038e25p-26 +-0x1.398378b8bc80dp-19 +-0x1.c1639f316d0f8p-22 +-0x1.dc1c32971f302p-12 +-0x1.563eab5bbdad9p-24 +-0x1.25e0912c79f05p-21 +-0x1.fef674c54c065p-20 +-0x1.fb74d44a571c2p-21 +-0x1.704faadc3211cp-21 +-0x1.a71ead038e255p-26 +-0x1.398378b8bc81p-19 +-0x1.c1639f316d0fdp-22 +-0x1.ddec8fc48acaap-12 +-0x1.5dfe48cc49229p-21 +-0x1.2c87d93f17c39p-18 +-0x1.cac23ac44653p-15 +-0x1.c79c4fb622d57p-16 +-0x1.4aae7d8930418p-16 +-0x1.b0b308b469f3dp-23 +-0x1.409c9034af5ccp-16 +-0x1.9379da0445b64p-17 +-0x1.da920d4690a4ep-12 +-0x1.5dfe48cc49229p-21 +-0x1.2c87d93f17c39p-18 +-0x1.cac23ac44653p-15 +-0x1.c79c4fb622d57p-16 +-0x1.4aae7d8930418p-16 +-0x1.b0b308b469f3dp-23 +-0x1.409c9034af5ccp-16 +-0x1.9379da0445b64p-17 +-0x1.e2b2628680863p-12 +0x1.d486c4d771485p+0 +0x1.b2190abcdd46p+0 +0x1.58f8c918e9ebcp+0 +0x1.6e2c6c57c5f5ap+0 +-0x1.87584e5ccc472p-15 +-0x1.bdc57d4e075ebp-13 +-0x1.a709fbd46d743p-15 +-0x1.d7ceb99fe0132p-13 +-0x1.f35d4a6045b94p-15 +-0x1.09c58fded7a71p-12 +-0x1.e54327f381765p-15 +-0x1.04e8e5c2c8a92p-12 +-0x1.2ad338de829c2p+1 +-0x1.21791e6a61dfep+1 +-0x1.0bc75cfb9810fp+1 +-0x1.10a3b005517dfp+1 +0x1.08c298e9e3f4dp+0 +0x1.1a845a5520f55p+0 +-0x1.fd5c676c5c7b2p-24 +0x1.d3296679759cfp-1 +0x1.f1d7377638b4p-1 +-0x1.c1d9ca2953326p-24 +0x1.162874d6211ddp-1 +0x1.2789d412b796p-1 +-0x1.4917417c44c7cp-24 +0x1.46b9ac6a2c3b8p-1 +0x1.5b5f1e5c5bc6ap-1 +-0x1.6576b2c4144f3p-24 +0x1.eb9fbf96584aap-1 +0x1.d1c30572938d5p-1 +-0x1.90dd510dc4f39p-24 +0x1.a93748a53b1dbp-1 +0x1.94d85d2657595p-1 +-0x1.4d7c45aa0c9d2p-24 +0x1.e33bda35fecadp-2 +0x1.d19f2249309b2p-2 +-0x1.b0a74f98ce802p-25 +0x1.1ed21b72e651ap-1 +0x1.139c3b52aedafp-1 +-0x1.e21c86717032p-25 +0x1.93bb55e5fd66cp-1 +0x1.688d802fa18f7p-1 +-0x1.6b6f18bc643f5p-24 +0x1.5d477f7bc94d6p-1 +0x1.36caee67ebf05p-1 +-0x1.335932944bc1bp-24 +0x1.8d2aa9d2dc8a1p-2 +0x1.5e44c40260d8ap-2 +-0x1.a179fe8f0ab92p-25 +0x1.d768ba7482aadp-2 +0x1.a099c87cc267fp-2 +-0x1.cbcde6b2965ep-25 +0x1.0938121dae581p+0 +0x1.29d7e7aa2f56dp+0 +-0x1.0d3b66a0e2d71p-24 +0x1.cd63f8758ae59p-1 +0x1.fbdf2e6a63961p-1 +-0x1.c06c9a0f0600ap-25 +0x1.09c7bdf595135p-1 +0x1.1665a5d1ad57cp-1 +-0x1.2260f50a17c9ap-25 +0x1.3a84c0f36903ep-1 +0x1.4d442ca1b4e3dp-1 +-0x1.43e75699cd5d9p-25 +0x1.1bc1bf2037c85p+0 +0x1.0ec173f214c6fp+0 +-0x1.a6a6cb1ea19b4p-25 +0x1.ef9679f146cbfp-1 +0x1.d8c824bac73fp-1 +-0x1.61766c42807f8p-25 +0x1.2029e300ec3a5p-1 +0x1.12c4491b351c5p-1 +-0x1.cc26bbeed635p-26 +0x1.544868d5237adp-1 +0x1.447fd12643d53p-1 +-0x1.00825ec307cd8p-25 +0x1.6b490e8083d68p-1 +0x1.a0e21cc98996fp-1 +-0x1.3c9ff51c69be7p-24 +0x1.403c73c4c7a61p-1 +0x1.6fbcde721356ep-1 +-0x1.1b801f9df82d8p-24 +0x1.7c9fef4951653p-2 +0x1.b5c71b929a93ap-2 +-0x1.b366c710e3ba5p-25 +0x1.bf45bbaea9068p-2 +0x1.012035d59c1a6p-1 +-0x1.d2ba821ca5c18p-25 +-0x1.2db7f01920f6cp-26 +-0x1.03140a28fd3p-23 +-0x1.c27596ba20279p-22 +-0x1.bf5e401b1c6c8p-23 +-0x1.44b302c00e84fp-23 +-0x1.7504512fda49cp-28 +-0x1.1463b14357afcp-21 +-0x1.8c2d3d9ff89dbp-24 +-0x1.0f0c28a8b5fcep-12 +-0x1.2db7f01920f7p-26 +-0x1.03140a28fd304p-23 +-0x1.c27596ba20281p-22 +-0x1.bf5e401b1c6cfp-23 +-0x1.44b302c00e854p-23 +-0x1.7504512fda4a1p-28 +-0x1.1463b14357affp-21 +-0x1.8c2d3d9ff89e1p-24 +-0x1.1094c1242549bp-12 +-0x1.c4ef49c879ce3p-23 +-0x1.84ec86c807507p-20 +-0x1.97aecdda4adc6p-16 +-0x1.94e29ce002f9cp-17 +-0x1.25dd7c864e868p-17 +-0x1.17fbb9c11bd56p-24 +-0x1.9ee93fa628ce2p-18 +-0x1.668e149f3b807p-18 +-0x1.0ec2860f887cbp-12 +-0x1.c4ef49c879ce3p-23 +-0x1.84ec86c807507p-20 +-0x1.97aecdda4adc6p-16 +-0x1.94e29ce002f9cp-17 +-0x1.25dd7c864e868p-17 +-0x1.17fbb9c11bd56p-24 +-0x1.9ee93fa628ce2p-18 +-0x1.668e149f3b807p-18 +-0x1.11ac029325c74p-12 +0x1.be94080c14245p+0 +0x1.a64f1f5d84ac7p+0 +0x1.51f6bf8e50e5p+0 +0x1.670a92a5c5535p+0 +-0x1.cc867f16a8d1p-15 +-0x1.02b7dcc25f968p-12 +-0x1.e6957e1eafe32p-15 +-0x1.0d7f76a5c4c9dp-12 +-0x1.1c37a9740aeddp-14 +-0x1.2d8b62e5ee46dp-12 +-0x1.13f7410400a44p-14 +-0x1.27b80b22bc40ap-12 +-0x1.24d313d00633bp+1 +-0x1.1e699c1a46417p+1 +-0x1.0a38d229c3ef6p+1 +-0x1.0efbb54e057bep+1 +0x1.eaa7ba6d98798p-1 +0x1.058f97445a7bap+0 +-0x1.1adc0a0dc1cfap-23 +0x1.bc8288b3f37f6p-1 +0x1.d97fdc27bc252p-1 +-0x1.fd0eabc91d4d7p-24 +0x1.05bcbacdc5c9fp-1 +0x1.16084c88c5ee6p-1 +-0x1.7576aa2b948bep-24 +0x1.369fbf9f5113ep-1 +0x1.4a2d838176e8ap-1 +-0x1.95b817d912b1ep-24 +0x1.c1cb2cc319078p-1 +0x1.ab7b16673acc1p-1 +-0x1.c5dfc340a918fp-24 +0x1.91f6f9b0a8cf6p-1 +0x1.7f569b2cb1bbbp-1 +-0x1.8320fff178ba1p-24 +0x1.c529e54db7fd6p-2 +0x1.b508d4c6f40c6p-2 +-0x1.f9417d62654c5p-25 +0x1.0fb503d332c4fp-1 +0x1.0554926279b56p-1 +-0x1.197cca5c412b7p-24 +0x1.716f9c383b11bp-1 +0x1.492941ff7249bp-1 +-0x1.9b2a245c3e274p-24 +0x1.4a34e4f986cb6p-1 +0x1.2576fa5e887ecp-1 +-0x1.63a077e866aedp-24 +0x1.7477e3a4d0608p-2 +0x1.4844896faad5fp-2 +-0x1.e4f01fd5ecccap-25 +0x1.be96cbae960aap-2 +0x1.8a643244ccbbbp-2 +-0x1.0b1ad2932b9b7p-24 +0x1.e710127cb9065p-1 +0x1.0e051c4ba3a44p+0 +-0x1.3063b744b7248p-24 +0x1.b4fb95582fa4p-1 +0x1.ddc81842668c8p-1 +-0x1.03e498022222ep-24 +0x1.f2fccc6c9474ap-2 +0x1.045c7de82d9f1p-1 +-0x1.52a5b0b6fae7cp-25 +0x1.2a4316d7e4568p-1 +0x1.3acfb3378a317p-1 +-0x1.79b4e5c780c0cp-25 +0x1.0535f7a2bf8ep+0 +0x1.f26b1b68b98c3p-1 +-0x1.dd22d19ef6628p-25 +0x1.d5fb6d96a0acbp-1 +0x1.c052cf6da7p-1 +-0x1.990da2837f6c2p-25 +0x1.0eb0ca05a8b2ep-1 +0x1.0218c398d8b0ep-1 +-0x1.0c000b867afbap-25 +0x1.42ed82257657bp-1 +0x1.33effd3497d58p-1 +-0x1.2ab59f0386b28p-25 +0x1.5070e5676e8c7p-1 +0x1.824024bb732bfp-1 +-0x1.623983b1fdec1p-24 +0x1.30a0358c8f002p-1 +0x1.5de4119a5f32ep-1 +-0x1.4220bee69fe18p-24 +0x1.661b4223b5f3cp-2 +0x1.9becb34ea11c9p-2 +-0x1.ef3b91ae66694p-25 +0x1.a92b44cbf2f4cp-2 +0x1.e8e5a71b5d253p-2 +-0x1.097bb3d90d576p-24 +-0x1.602c0d8f408fbp-26 +-0x1.2e66ca73f205fp-23 +-0x1.06e491f787037p-21 +-0x1.0516bc98b712bp-22 +-0x1.7afef1d69c947p-23 +-0x1.b3649b86c6f6dp-28 +-0x1.429b81f0385d4p-21 +-0x1.ce6d07101512bp-24 +-0x1.30796e60d262ap-12 +-0x1.602c0d8f40901p-26 +-0x1.2e66ca73f2063p-23 +-0x1.06e491f78703bp-21 +-0x1.0516bc98b713p-22 +-0x1.7afef1d69c94dp-23 +-0x1.b3649b86c6f74p-28 +-0x1.429b81f0385d9p-21 +-0x1.ce6d071015132p-24 +-0x1.321680daee09bp-12 +-0x1.1d6f2be3afa5cp-22 +-0x1.ea30d82d42355p-20 +-0x1.185fd38229b09p-15 +-0x1.1673484ad6b3ap-16 +-0x1.9432a2dd8f722p-17 +-0x1.60e270954f611p-24 +-0x1.0578e4318f8f9p-17 +-0x1.ed2cf540ecbf6p-18 +-0x1.3047c0f2eadedp-12 +-0x1.1d6f2be3afa5cp-22 +-0x1.ea30d82d42355p-20 +-0x1.185fd38229b09p-15 +-0x1.1673484ad6b3ap-16 +-0x1.9432a2dd8f722p-17 +-0x1.60e270954f611p-24 +-0x1.0578e4318f8f9p-17 +-0x1.ed2cf540ecbf6p-18 +-0x1.332196a52059ap-12 +0x1.7a728f4cc5063p-1 +0x1.6a3c1b38769b6p-1 +0x1.47875e0b8ac1ap-1 +0x1.4ff8d04ceb327p-1 +-0x1.65f2eb5d2b215p-2 +-0x1.026618861c944p+0 +-0x1.5de5bc67afe56p-2 +-0x1.faaad856fc03fp-1 +-0x1.24a94effc5f47p-1 +-0x1.8113d0189d112p+0 +-0x1.10450bd16b53ep-1 +-0x1.6b3a86b28f805p+0 +-0x1.0ac6fd7e994c8p+1 +-0x1.07cd4e7cad6cep+1 +-0x1.00a31b476d2b2p+1 +-0x1.ffc6394f682c7p+0 +0x1.0ba50d44d105dp-1 +0x1.1c544b4912887p-1 +-0x1.559a876b0d6f8p-4 +0x1.d6ab41eff14b4p-2 +0x1.f3ce8e104f144p-2 +-0x1.401c3a766e6d9p-4 +0x1.2cf2b4686cf37p-2 +0x1.3f44ad3769cbp-2 +-0x1.5bf5bfa24edfap-3 +0x1.19f3f5cbbc932p-2 +0x1.2b162503a7e5ep-2 +-0x1.37fe52e5ac845p-3 +0x1.cff448c93e93ap-2 +0x1.bf4ca6772839fp-2 +-0x1.64b07bf52becdp-4 +0x1.954c83bb59b3ep-2 +0x1.876a40635562ep-2 +-0x1.4b59140fc6c6bp-4 +0x1.fe318c628dd6ep-3 +0x1.eec49b2102485p-3 +-0x1.49a2cf23539fep-3 +0x1.dd331e07004e6p-3 +0x1.cef9a83749148p-3 +-0x1.2cc51188eba3dp-3 +0x1.7d54ddfeef2e7p-2 +0x1.5028c344ff59ap-2 +-0x1.28d34b755c6c9p-4 +0x1.4d264113b3d47p-2 +0x1.254eefe0d83c9p-2 +-0x1.13bea12911bd4p-4 +0x1.a374e61b7281fp-3 +0x1.70223891fa4e9p-3 +-0x1.1259bd1119c31p-3 +0x1.8856d1729199p-3 +0x1.5838135f71cecp-3 +-0x1.f4a2eeedee189p-4 +0x1.feaf48d12ceddp-2 +0x1.0ad246a44fcbap-1 +-0x1.d70a7f692944bp-5 +0x1.befd0eb78c4cp-2 +0x1.cfbaad5565c35p-2 +-0x1.b59522c06f668p-5 +0x1.1aac4ad233c23p-2 +0x1.201976f32495dp-2 +-0x1.b3669142713ccp-4 +0x1.08867dc5c53c7p-2 +0x1.0d1808725a53bp-2 +-0x1.8d41d360a1ccep-4 +0x1.14f7ec375d615p-1 +0x1.0815fecded965p-1 +-0x1.61701321a2836p-5 +0x1.e57b5a5bb7f06p-2 +0x1.cede6eb0ae24dp-2 +-0x1.485585296387cp-5 +0x1.33fe8cbd7d27ap-2 +0x1.259970ade795p-2 +-0x1.46b30e3f0dee4p-4 +0x1.2051516e04deap-2 +0x1.12d66694e6895p-2 +-0x1.2a13a1781f8d8p-4 +0x1.6e34ec7e38158p-2 +0x1.a539adf5afe97p-2 +-0x1.385cd0147a635p-5 +0x1.41ea39ec38f2bp-2 +0x1.725bd389d6397p-2 +-0x1.223107106958p-5 +0x1.9b69de266d95ap-3 +0x1.d991bc7ed5bafp-3 +-0x1.208cd897a863fp-4 +0x1.816bd9b87c6f1p-3 +0x1.bbac8951dd52p-3 +-0x1.074a22e65eb97p-4 +-0x1.c809585429fa8p-11 +-0x1.87965d14d4637p-8 +-0x1.546bc10e4b2d4p-6 +-0x1.5215b9699063p-7 +-0x1.eac35d8bb635bp-8 +-0x1.19e6932730a8dp-12 +-0x1.a1c0a515dbe0dp-6 +-0x1.2b6603325db44p-8 +-0x1.3f98febeb8da6p-1 +-0x1.c38c2a9d1edcdp-11 +-0x1.83bb9797325b1p-8 +-0x1.5111eb24db8c7p-6 +-0x1.4ec1c67ddb354p-7 +-0x1.e5eeadb148b66p-8 +-0x1.172034ac2ac68p-12 +-0x1.9da3f06aaa0c1p-6 +-0x1.28738ce62de1fp-8 +-0x1.37b010d29bc88p-1 +-0x1.d26259a3ba1c1p-11 +-0x1.9078ffd28959ap-8 +-0x1.67248ea61ac62p-6 +-0x1.64ada3502576ep-7 +-0x1.02e06c12896c2p-7 +-0x1.204c113b46dffp-12 +-0x1.ab3b44834f8cep-6 +-0x1.3bdd423e573ep-8 +-0x1.9ce85bf5159d6p-1 +-0x1.df1f249297785p-11 +-0x1.9b68f645f743bp-8 +-0x1.70a44d7b18fb5p-6 +-0x1.6e1cb23582b25p-7 +-0x1.09b944b5da7e9p-7 +-0x1.282bbd154cfa5p-12 +-0x1.b6e6519bfde34p-6 +-0x1.4437f777fe9e5p-8 +-0x1.90df26cab377p-1 +0x1.84c3da8abf67bp-1 +0x1.76821732bbf2p-1 +0x1.4f5ff9165960fp-1 +0x1.587ac3224e1bdp-1 +-0x1.4a5b62f8e425dp-2 +-0x1.e400067087bdp-1 +-0x1.394b7be1d046p-2 +-0x1.cf6e408b0155p-1 +-0x1.14038eba8015dp-1 +-0x1.6ea05b88b4f5p+0 +-0x1.fcb79214cdbe9p-2 +-0x1.5745302fe2dd8p+0 +-0x1.0b7e5c37b2a4ep+1 +-0x1.08780734ad925p+1 +-0x1.013cf7eab7922p+1 +-0x1.00749309c72efp+1 +0x1.132eb888a3f88p-1 +0x1.245d9455f9cf8p-1 +-0x1.321007b0aa44dp-4 +0x1.e570267db728dp-2 +0x1.01c4c07819c2p-1 +-0x1.0fb36c1e3a13p-4 +0x1.3bfee163ea4bp-2 +0x1.4f4255cd58c23p-2 +-0x1.4277f00b85e9dp-3 +0x1.285de17e4890dp-2 +0x1.3a667a450177dp-2 +-0x1.1cb1dac88a0f7p-3 +0x1.ddc466628c3a2p-2 +0x1.cc6dc85b9d214p-2 +-0x1.43908d58edecfp-4 +0x1.a2a0b78b738fdp-2 +0x1.9421faa65e9b1p-2 +-0x1.1fafe938c9757p-4 +0x1.0c3521268315dp-2 +0x1.0401c37c4528p-2 +-0x1.3329b8845cec3p-3 +0x1.f639a045392c8p-3 +0x1.e717a36af6c18p-3 +-0x1.14aea509e075ep-3 +0x1.88ad41f92adc8p-2 +0x1.5a4447d2391c2p-2 +-0x1.0d419b278cef2p-4 +0x1.58196241dea85p-2 +0x1.2f093c38f6f97p-2 +-0x1.decedbba0eec8p-5 +0x1.b901d142623ebp-3 +0x1.8326992229ffp-3 +-0x1.ff4a2c6204086p-4 +0x1.9ce85353165a6p-3 +0x1.6a5b46d6ef6f3p-3 +-0x1.cc898d28ab323p-4 +0x1.06d27adbb4fcap-1 +0x1.131c47cb7f1bbp-1 +-0x1.ab496127ddfa7p-5 +0x1.cd7ca8f6cc476p-2 +0x1.df8c6f899ea54p-2 +-0x1.7be81cc2ea262p-5 +0x1.2914f5f6cca76p-2 +0x1.2f3e2f9d41d62p-2 +-0x1.95b65e92e29d7p-4 +0x1.164ab9286bf5ap-2 +0x1.1b811fb5ddf09p-2 +-0x1.6d6f992b98ebdp-4 +0x1.1cfdfae3fa226p-1 +0x1.0fbdaa83f8c88p-1 +-0x1.409b778e69d42p-5 +0x1.f514d4b65caadp-2 +0x1.ddbfcb5ca5fp-2 +-0x1.1d0e993b00f02p-5 +0x1.439b6a0a578d7p-2 +0x1.347c9c92c908fp-2 +-0x1.306c452985563p-4 +0x1.2f3ed0a1a93fep-2 +0x1.211235ffcef5bp-2 +-0x1.1233212ad52efp-4 +0x1.788b3471d3364p-2 +0x1.b117caf8b6941p-2 +-0x1.1b5ff13c89435p-5 +0x1.4c0915d9999f4p-2 +0x1.7dfbdf2777092p-2 +-0x1.f7f7011a478dp-6 +0x1.b001bc0c49759p-3 +0x1.f14096eda05d6p-3 +-0x1.0ce31f8bdea22p-4 +0x1.9524ed8dad876p-3 +0x1.d25be0cab8539p-3 +-0x1.e46d689f2bcabp-5 +-0x1.c0100dde63a12p-11 +-0x1.80bd8ea5d8e55p-8 +-0x1.4e77fa20990b2p-6 +-0x1.4c2c675bd3a14p-7 +-0x1.e22ea2123ce5bp-8 +-0x1.14f8be4131689p-12 +-0x1.9a72b8185eed6p-6 +-0x1.2629dbb34d02cp-8 +-0x1.30345739287d7p-1 +-0x1.bba3f9bfa5cbcp-11 +-0x1.7cf17817280b8p-8 +-0x1.4b2ae7fd80251p-6 +-0x1.48e521c9d6a37p-7 +-0x1.dd6c5929243b1p-8 +-0x1.123cf1cd07a1ap-12 +-0x1.9665ad86658d3p-6 +-0x1.23429f64f0885p-8 +-0x1.2499d2fde6108p-1 +-0x1.cac5dd76f5178p-11 +-0x1.89efe20ba522fp-8 +-0x1.61760ebd0138cp-6 +-0x1.5f091e9340467p-7 +-0x1.fd8ffc1dab2fcp-8 +-0x1.1b979a9b4a6bep-12 +-0x1.a4425b507f306p-6 +-0x1.36de089b41e7ap-8 +-0x1.8de1d529f3537p-1 +-0x1.d7523621dce91p-11 +-0x1.94b63ef9ad58ep-8 +-0x1.6ad1a38fe1535p-6 +-0x1.685442fe6107ep-7 +-0x1.0586c55b03e78p-7 +-0x1.235953f37e172p-12 +-0x1.afc1074ed72b7p-6 +-0x1.3f18ef75b97ebp-8 +-0x1.809dcf7020aa6p-1 +0x1.9b17ac274212p-1 +0x1.9197e26127e49p-1 +0x1.5e6fe6ff67a88p-1 +0x1.69bd3a496e508p-1 +-0x1.143dac457a285p-2 +-0x1.a27ef947237dbp-1 +-0x1.eba52e36f0501p-3 +-0x1.7d9785fa1328cp-1 +-0x1.e9c83077059ccp-2 +-0x1.4bbc228c50328p+0 +-0x1.b681bdb630f56p-2 +-0x1.2fb35fd8f0cbap+0 +-0x1.0ceab1fa31b98p+1 +-0x1.09cae108b5cc8p+1 +-0x1.026a026419492p+1 +-0x1.0191721b9377bp+1 +0x1.21e3e3ca98ecap-1 +0x1.340d337de8356p-1 +-0x1.dceb796f53f19p-5 +0x1.012169827d922p-1 +0x1.111f76201784fp-1 +-0x1.76a1a7585d38fp-5 +0x1.58fe75e858d1ep-2 +0x1.6e1564d7a9ad5p-2 +-0x1.13dfb9c29e725p-3 +0x1.4431235f48d84p-2 +0x1.57f870a53edc7p-2 +-0x1.d120878d3fbd4p-4 +0x1.f8ddd7672e2p-2 +0x1.e626f17fd07f7p-2 +-0x1.0435822795bdcp-4 +0x1.bcc52227c73afp-2 +0x1.ad0b773498296p-2 +-0x1.a52b8c7917f27p-5 +0x1.2594c87a14aaap-2 +0x1.1c68cecfb6e51p-2 +-0x1.09befc7d7acdcp-3 +0x1.135d65d2039b1p-2 +0x1.0ae4d47368364p-2 +-0x1.ccf37f91617a3p-4 +0x1.9eeef480fee71p-2 +0x1.6e1d7011ac3b1p-2 +-0x1.b10dc114b7f56p-5 +0x1.6d92e146499bfp-2 +0x1.4221c0d30c323p-2 +-0x1.5e75cadc3b09dp-5 +0x1.e2b64c76b2dedp-3 +0x1.a7fbcf3eee3eap-3 +-0x1.ba57d4b1b486fp-4 +0x1.c4c57955be105p-3 +0x1.8d895fd56c2fdp-3 +-0x1.7f9ddef81aaa7p-4 +0x1.15794fdc2d767p-1 +0x1.236fedb67a90bp-1 +-0x1.5799eee409ef6p-5 +0x1.e9e1d4086da96p-2 +0x1.feb0dac549042p-2 +-0x1.160ed2b3ca1b4p-5 +0x1.44eec34b33dc9p-2 +0x1.4ca64ac7044b5p-2 +-0x1.5effc03fb1ed7p-4 +0x1.30f14fe92a74cp-2 +0x1.3786484368617p-2 +-0x1.30650e4667c2bp-4 +0x1.2cb127ee60493p-1 +0x1.1eb86096a6a0ap-1 +-0x1.01d0a82b6a03dp-5 +0x1.09cd245073e52p-1 +0x1.fadd6867a6e95p-2 +-0x1.a145226e599cep-6 +0x1.61c2532a31071p-2 +0x1.513d3c73966ep-2 +-0x1.075e7a3fe791fp-4 +0x1.4c1eecbebb3abp-2 +0x1.3c9ae97669485p-2 +-0x1.c8cb997af1b6dp-5 +0x1.8cb7d0052e74bp-2 +0x1.c83ffc83fd264p-2 +-0x1.c7db9208756aep-6 +0x1.5fca5ed3c33d5p-2 +0x1.94ac081657591p-2 +-0x1.71017b2b0dc02p-6 +0x1.d7b2f3ac36391p-3 +0x1.0f725d7a2fda9p-2 +-0x1.d14c0f4aeeb08p-5 +0x1.bb398bc613258p-3 +0x1.fe270a391a4aep-3 +-0x1.93911d4f1382fp-5 +-0x1.b06be751c525cp-11 +-0x1.734f4a95d115ep-8 +-0x1.42caf850f01eap-6 +-0x1.4093e87209418p-7 +-0x1.d159926edef82p-8 +-0x1.0b4d8ffa76502p-12 +-0x1.8c1eb6eb31329p-6 +-0x1.1be50a9e69a24p-8 +-0x1.1121017dd3e94p-1 +-0x1.ac242972ea38cp-11 +-0x1.6fa267a42d042p-8 +-0x1.3f9906189ec73p-6 +-0x1.3d67932431ceap-7 +-0x1.ccbe6420203cfp-8 +-0x1.08a839bec61adp-12 +-0x1.8832f5ae0ee32p-6 +-0x1.1915a973f4e5ap-8 +-0x1.fe50322f27be1p-2 +-0x1.bbe6ec836c2p-11 +-0x1.7d2af4ba2e1a9p-8 +-0x1.565c4346418d1p-6 +-0x1.5402d36563791p-7 +-0x1.ed8f267bde9a2p-8 +-0x1.12665431610d7p-12 +-0x1.96a301803d474p-6 +-0x1.2d1ab07a6e5cdp-8 +-0x1.70f232ec856eep-1 +-0x1.c80c52c336a58p-11 +-0x1.8798ebc3b9c72p-8 +-0x1.5f6aff203fb03p-6 +-0x1.5d01a5d7dce19p-7 +-0x1.fa9debceeab0fp-8 +-0x1.19e86a7453cefp-12 +-0x1.a1c35f836937p-6 +-0x1.3512010d21adp-8 +-0x1.60332ae1f28b9p-1 +0x1.bbf324aeaa46ep-1 +0x1.adcb2d5449b7ep-1 +0x1.7a0ec81eeec4ap-1 +0x1.8bdc0ec332112p-1 +-0x1.b12f5c65136c5p-3 +-0x1.55ed694649587p-1 +-0x1.95242f3b57d43p-3 +-0x1.4455187c30c31p-1 +-0x1.8074c93e1d99p-2 +-0x1.0f3c78a5ccd3dp+0 +-0x1.3b65cce2999a7p-2 +-0x1.d09af8374728ep-1 +-0x1.0f90b75dfd82ap+1 +-0x1.0c4d6082b637bp+1 +-0x1.0490b9cd521p+1 +-0x1.039555a9f3b1bp+1 +0x1.3c5597e568e88p-1 +0x1.504640be6fa2p-1 +-0x1.5b96dbe44446dp-5 +0x1.1b953ed815ccep-1 +0x1.2d52ea5e278a2p-1 +-0x1.25f64c692aad5p-5 +0x1.8c8f5b8dbac67p-2 +0x1.a4ecb5e330944p-2 +-0x1.9016aaa9ca35dp-4 +0x1.75417461b1958p-2 +0x1.8c22be56db31cp-2 +-0x1.2236ed6788d4ap-4 +0x1.150d5a1f67b04p-1 +0x1.0a62517e83a6cp-1 +-0x1.8637020a8da21p-5 +0x1.ed389a2428794p-2 +0x1.db1a8ef72d84p-2 +-0x1.503a90d69d8d5p-5 +0x1.5310a276ce1cdp-2 +0x1.480fd7d40987p-2 +-0x1.8ad7f89b91388p-4 +0x1.3e7355541cf69p-2 +0x1.344abf1a5b308p-2 +-0x1.302bf6b16e786p-4 +0x1.c75dfde244aefp-2 +0x1.923e023e690ap-2 +-0x1.44b3c374b862cp-5 +0x1.955e88cdb423fp-2 +0x1.6595204f253f1p-2 +-0x1.17c75cea8ac9ap-5 +0x1.16bb4db722aa6p-2 +0x1.ea1ac0e48430bp-3 +-0x1.489b5154c557bp-4 +0x1.05caeb10377d5p-2 +0x1.cc1f12fd4ec25p-3 +-0x1.fa3ee2f4cbc07p-5 +0x1.30040f089827p-1 +0x1.415345320915fp-1 +-0x1.019f8f0fc9f59p-5 +0x1.0f2e6aa8d1977p-1 +0x1.1c6919ac5feb9p-1 +-0x1.bbf258528a621p-6 +0x1.76bd2c6a869e8p-2 +0x1.81b21c632357fp-2 +-0x1.04be31a8deb66p-4 +0x1.602f34349fb91p-2 +0x1.6999ace00b20ap-2 +-0x1.91ae7c4233533p-5 +0x1.4912e3d66a52p-1 +0x1.39cd693dec597p-1 +-0x1.829bcfa642cb8p-6 +0x1.25f3ba2e49b03p-1 +0x1.184a1a5294224p-1 +-0x1.4d1bf9f7e269dp-6 +0x1.97980ceab7f82p-2 +0x1.849460937c51fp-2 +-0x1.874ad1e6ddf54p-5 +0x1.7f3aa1db1caabp-2 +0x1.6d57cb0f0bf2fp-2 +-0x1.2d648ce321135p-5 +0x1.b101cec6093e9p-2 +0x1.f1e390466e045p-2 +-0x1.55e614f5cf38ap-6 +0x1.8410d7947ae9cp-2 +0x1.be51b81e151eap-2 +-0x1.26a77f79a8ce9p-6 +0x1.0f26ee403fcdep-2 +0x1.38078607d09bbp-2 +-0x1.59baa055d65f7p-5 +0x1.fe644a9a43ee3p-3 +0x1.25b03e3033a81p-2 +-0x1.0a61106cbfb95p-5 +-0x1.941c760646534p-11 +-0x1.5b001719484p-8 +-0x1.2da8eb5fd2763p-6 +-0x1.2b96fb897c2cbp-7 +-0x1.b2e23f2c007fbp-8 +-0x1.f39b0e9720c4cp-13 +-0x1.722fb0b96b4ep-6 +-0x1.094eeddd95132p-8 +-0x1.d04c58bc6155p-2 +-0x1.90167d110cf43p-11 +-0x1.578bad9940efdp-8 +-0x1.2aa81186894d7p-6 +-0x1.289b685b5bc92p-7 +-0x1.ae8dd7e26894cp-8 +-0x1.eea1b1b9d81p-13 +-0x1.6e802ef319e66p-6 +-0x1.06aaba84e6291p-8 +-0x1.bd725bb4ec2p-2 +-0x1.a0fc6d4998149p-11 +-0x1.660e4158c9fddp-8 +-0x1.4244a9fa0bf5p-6 +-0x1.400e860bdb4dep-7 +-0x1.d097f39acb0aap-8 +-0x1.01c2f13510012p-12 +-0x1.7dfaf63e1cdb8p-6 +-0x1.1b6eeb861760dp-8 +-0x1.3cea46148e199p-1 +-0x1.ac677e7d71248p-11 +-0x1.6fdc38aa6723bp-8 +-0x1.4ac84e15c40acp-6 +-0x1.488335197b104p-7 +-0x1.dcde338394994p-8 +-0x1.08d1d8e319c51p-12 +-0x1.8870a3ae97602p-6 +-0x1.22ebe743eb6ecp-8 +-0x1.2394babf8fd5ap-1 +0x1.ec3f2e8a4e611p-1 +0x1.e174a930e7a0bp-1 +0x1.a6c0bbedbf491p-1 +0x1.b989d0438a564p-1 +-0x1.28b872208b3f7p-3 +-0x1.f137ca18b577dp-2 +-0x1.159f29946e85bp-3 +-0x1.d7a2823477f89p-2 +-0x1.e4b100d2778cfp-3 +-0x1.737902aa4d945p-1 +-0x1.a0e2228def0c4p-3 +-0x1.4af793f1530e3p-1 +-0x1.13574c23dda83p+1 +-0x1.0feaee0c78c1cp+1 +-0x1.079336d50806fp+1 +-0x1.06724d00a15cdp+1 +0x1.600a70d73479cp-1 +0x1.766d0282792a7p-1 +-0x1.a7b5268761e35p-6 +0x1.3fc3a8a5b64efp-1 +0x1.53efdfd18ab63p-1 +-0x1.65fc8a73208ep-6 +0x1.d19ae86d3dccp-2 +0x1.ee6a0a3fff05dp-2 +-0x1.9ed99fedb288ap-5 +0x1.b820e371a0a9ep-2 +0x1.d34a18db2096bp-2 +-0x1.4239b6642aa63p-5 +0x1.36dbb37993173p-1 +0x1.2a420a5ed50fcp-1 +-0x1.f0798bda6b993p-6 +0x1.18454446c9c61p-1 +0x1.0d6cd9c9dc80cp-1 +-0x1.adc8faa3c411cp-6 +0x1.90bd2e7a64d2dp-2 +0x1.830fd20ef1d26p-2 +-0x1.b5d0b045f5508p-5 +0x1.79e00c52a1f67p-2 +0x1.6d372738020afp-2 +-0x1.6977d68656825p-5 +0x1.fee0f967494eep-2 +0x1.c3fdb2aee7b24p-2 +-0x1.9d1dddfa0e97dp-6 +0x1.cca70da651351p-2 +0x1.96f8ab9993363p-2 +-0x1.659f2b571b9ecp-6 +0x1.4967431a56dbap-2 +0x1.21fb5339a1023p-2 +-0x1.6c5858f3fc342p-5 +0x1.369e92b9492a9p-2 +0x1.114fc91121307p-2 +-0x1.2cc8db40b8a7ap-5 +0x1.544a633ab8013p-1 +0x1.6ada4a76ad4ccp-1 +-0x1.47c12aa88c69dp-6 +0x1.337a5d3bc3b79p-1 +0x1.45411670c6e8p-1 +-0x1.1bb74e0648f87p-6 +0x1.ba067a8870c14p-2 +0x1.ca538bc4ab60fp-2 +-0x1.2114e8bc5f6cbp-5 +0x1.a11d6ad660583p-2 +0x1.af4e0039afd92p-2 +-0x1.dd4912d33c335p-6 +0x1.6fbbed2f04f5bp-1 +0x1.5eb2f09c0f10ap-1 +-0x1.ebdc8d1a8158ap-7 +0x1.4cc5280579769p-1 +0x1.3d546c38fd1f9p-1 +-0x1.a9c5ac8c8a5b7p-7 +0x1.e023ac3441777p-2 +0x1.c9c5d6b0d39f1p-2 +-0x1.b1d1acdd4850ep-6 +0x1.c54ea0afdd608p-2 +0x1.b02ddfc84b532p-2 +-0x1.661ecae1b98fp-6 +0x1.e20ac469ddbdbp-2 +0x1.150f3f27d5651p-1 +-0x1.b3395e47e79d6p-7 +0x1.b5b72c5dcab41p-2 +0x1.f74a3e6c59a26p-2 +-0x1.78d8f1ff353fep-7 +0x1.3e71fbce5c67bp-2 +0x1.6e5f730b5e32fp-2 +-0x1.7f893e3df3ecbp-6 +0x1.2cfdcc659893p-2 +0x1.5a51fc89d3b9fp-2 +-0x1.3cb46df192a6dp-6 +-0x1.6d47ebbe055eep-11 +-0x1.39a8646b9adf4p-8 +-0x1.10ac886ef9d4bp-6 +-0x1.0ecd8442a1b86p-7 +-0x1.8918bf8f2d2c3p-8 +-0x1.c3997e0708491p-13 +-0x1.4e9da704f1368p-6 +-0x1.dfa17913b3fb1p-9 +-0x1.66c4467fcd5aap-2 +-0x1.699c282c14e4ap-11 +-0x1.368170a5524fcp-8 +-0x1.0def0545a05d9p-6 +-0x1.0c14d1789c1d5p-7 +-0x1.85256c3064aap-8 +-0x1.bf0fa7b143e4cp-13 +-0x1.4b40c7f4ea5d6p-6 +-0x1.dacf850fdff73p-9 +-0x1.5844e1fcdea37p-2 +-0x1.7c11788152e65p-11 +-0x1.465af3784cac6p-8 +-0x1.26b5bda27f9ep-6 +-0x1.24b003587e261p-7 +-0x1.a8dd5176c0585p-8 +-0x1.d5e1989a175dbp-13 +-0x1.5c29685df7fadp-6 +-0x1.03322683d3dfep-8 +-0x1.dfd2c99e11d41p-2 +-0x1.867cf74be08c2p-11 +-0x1.4f4d76bc06d3dp-8 +-0x1.2e7a9a6b5ce0ap-6 +-0x1.2c673a39160f5p-7 +-0x1.b41088d4e2325p-8 +-0x1.e2c370cbdea5p-13 +-0x1.65b4f7e6fa92ap-6 +-0x1.0a075850fd919p-8 +-0x1.c29baf311d3a4p-2 +0x1.1ab313abc94b5p+0 +0x1.12ea37f88bbc1p+0 +0x1.e23579219b429p-1 +0x1.ec7a771499666p-1 +-0x1.3f1280ec49281p-4 +-0x1.23b1e9cc016c7p-2 +-0x1.524b36ad7ad0cp-4 +-0x1.32f2e8e5a2f86p-2 +-0x1.09c0b85deb586p-3 +-0x1.c2287059688e1p-2 +-0x1.063bf3be3e249p-3 +-0x1.c05cdc1efa12p-2 +-0x1.180c1c0a4baa9p+1 +-0x1.147d4e0a45756p+1 +-0x1.0b5a628e57017p+1 +-0x1.0a00317271182p+1 +0x1.8978966c4a4b5p-1 +0x1.a2c323c867aa7p-1 +-0x1.6e3423993bd38p-7 +0x1.6a750037e84a6p-1 +0x1.8190bcdf318c5p-1 +-0x1.7f38d9e0c5649p-7 +0x1.11b5fca34867ap-1 +0x1.22cbe4462466p-1 +-0x1.5a882d2707887p-6 +0x1.035e5f4545f32p-1 +0x1.13820fb978663p-1 +-0x1.50ca8625f4019p-6 +0x1.5efcc7c240d3dp-1 +0x1.4fe2b6180fffcp-1 +-0x1.d15bb3f851dfbp-7 +0x1.40d9f95b8776dp-1 +0x1.33a65b8b0b032p-1 +-0x1.e4692b3401e9p-7 +0x1.db11051a6be87p-2 +0x1.c9dcdb59a66c1p-2 +-0x1.91243e59ac65ap-6 +0x1.c0d88184d879bp-2 +0x1.b0ecc5737ce7dp-2 +-0x1.93385a25109cfp-6 +0x1.2060c9f653579p-1 +0x1.ff43db3042ad7p-2 +-0x1.8339d8778dcf6p-7 +0x1.07a496427d61ep-1 +0x1.d2baa0c631f7dp-2 +-0x1.9314f102f0d6bp-7 +0x1.86756704579b9p-2 +0x1.584a3e0514608p-2 +-0x1.4dcf683c98481p-6 +0x1.70ebeb70acdfdp-2 +0x1.451c6746c7d2ep-2 +-0x1.4f851f67b5137p-6 +0x1.7f143f1100148p-1 +0x1.9ce9b7227f7fap-1 +-0x1.332d2569133abp-7 +0x1.5ef963c7a9a2ep-1 +0x1.773d5bae1eb18p-1 +-0x1.3fc0f40afcb06p-7 +0x1.055c3fba0d0c8p-1 +0x1.117cf15053222p-1 +-0x1.08d2d09b39374p-6 +0x1.ee4ddb63ada41p-2 +0x1.01c7ac418ebddp-1 +-0x1.0a2dcc9a63cep-6 +0x1.9d21f0e6e6e6cp-1 +0x1.8a096be623df4p-1 +-0x1.cd003608b9bc7p-8 +0x1.7b173471e1c9fp-1 +0x1.6989f98551f03p-1 +-0x1.dfdf30461b29p-8 +0x1.1b6ca85a52919p-1 +0x1.0e3ec76bb0117p-1 +-0x1.8d6c17dbac184p-7 +0x1.0c2d1175ea8acp-1 +0x1.ff65503aae138p-2 +-0x1.8f73142d18e8ap-7 +0x1.0d7f431071d73p-1 +0x1.35afe212176b6p-1 +-0x1.986a96b224a06p-8 +0x1.f05ad132f414ep-2 +0x1.1d4316a8dc749p-1 +-0x1.a91b2c5d35d96p-8 +0x1.768688796113p-2 +0x1.aec6a601a51fbp-2 +-0x1.5fbcfb6e19684p-7 +0x1.62dbe6c5e8a4ap-2 +0x1.98321297019d4p-2 +-0x1.618a1b0844b6dp-7 +-0x1.3ebc8c7b5c9a8p-11 +-0x1.11b0f45e2e68dp-8 +-0x1.dbdbf57b108dep-7 +-0x1.d897ffe88d5a1p-8 +-0x1.57020981d1045p-8 +-0x1.8a0e6d9048e26p-13 +-0x1.23fa9188df8d7p-6 +-0x1.a2840ae99ce87p-9 +-0x1.d3a7eec592f2bp-3 +-0x1.3b7cea21ebcf9p-11 +-0x1.0ee6d9c7482c8p-8 +-0x1.d7025df51518p-7 +-0x1.d3c6ed88ed1e5p-8 +-0x1.5383133e7980bp-8 +-0x1.860a45baf4021p-13 +-0x1.2100bfdf09aeap-6 +-0x1.9e40119c4d2c9p-9 +-0x1.e5c6c5f7285d5p-3 +-0x1.4fd0f20afdab6p-11 +-0x1.205b6ca2b080ap-8 +-0x1.05ad414c71108p-6 +-0x1.03e18ed3ad9ep-7 +-0x1.793e243a8a554p-8 +-0x1.9f2c0e140a055p-13 +-0x1.339fe7baaf18bp-6 +-0x1.cc496d6c4bf05p-9 +-0x1.451541130aa6dp-2 +-0x1.590a188704e8ep-11 +-0x1.2846e2df34b64p-8 +-0x1.0c8d70208aed9p-6 +-0x1.0ab5a97a4d259p-7 +-0x1.8327af633cd9p-8 +-0x1.aa9329b62195ep-13 +-0x1.3c12d6a153883p-6 +-0x1.d8619250031c3p-9 +-0x1.499a35c96764ep-2 +0x1.488563c9c8e86p+0 +0x1.3dbe8665070c9p+0 +0x1.0e5ed84387ad5p+0 +0x1.0d8777ef9c8c6p+0 +-0x1.3d8495f347551p-5 +-0x1.3830868b7444p-3 +-0x1.69fb0035339e1p-5 +-0x1.5ee5688081aecp-3 +-0x1.1a312f8f66873p-4 +-0x1.02db0a73e8c1ep-2 +-0x1.57db9cf490c7dp-4 +-0x1.359901172f26fp-2 +-0x1.1d8b4122c94a9p+1 +-0x1.19b40816afc2fp+1 +-0x1.0f9a064eef647p+1 +-0x1.0e311a0d831eep+1 +0x1.b5dd6269b6af5p-1 +0x1.d25d59fd25f75p-1 +-0x1.331f3c2d7f07fp-8 +0x1.974839cbbd6b4p-1 +0x1.b18f76d66227fp-1 +-0x1.65a5f286a00f7p-8 +0x1.3cb06f980e821p-1 +0x1.50a74067d90acp-1 +-0x1.170d35f3cdfe5p-7 +0x1.2ec4d1726766p-1 +0x1.41cb0f3c3a4d6p-1 +-0x1.83892219f972p-7 +0x1.8b3897116bd46p-1 +0x1.791589b3f3e39p-1 +-0x1.9c3d50723ef35p-8 +0x1.6c9a5cd45128fp-1 +0x1.5c994a0a528c9p-1 +-0x1.d8fa7315a2ea5p-8 +0x1.15628590f038bp-1 +0x1.0ab2d02bdd917p-1 +-0x1.5995f162883ffp-7 +0x1.086173c52ddecp-1 +0x1.fccb5ca4b325ep-2 +-0x1.dd9d947c1d14cp-7 +0x1.44ac966b3206p-1 +0x1.20729ca9b6bbap-1 +-0x1.570ef1c00ca12p-8 +0x1.2b8d3ccaef2d2p-1 +0x1.09b76d4658778p-1 +-0x1.8999ad05766f7p-8 +0x1.c7e9dc9d0e5bp-2 +0x1.92bb23d2228e4p-2 +-0x1.1f99c1e427ea2p-7 +0x1.b28e760f1af23p-2 +0x1.7fa307ea95d29p-2 +-0x1.8d71c59885f2bp-7 +0x1.ade1da6ada1e6p-1 +0x1.d51d5e05a8a76p-1 +-0x1.1019441f1790dp-8 +0x1.8d86efc1c6957p-1 +0x1.ae185d4648503p-1 +-0x1.38316dbf112f1p-8 +0x1.305fb3016ad29p-1 +0x1.41bb2ef089632p-1 +-0x1.c84045244965cp-8 +0x1.225e10769f752p-1 +0x1.31e7c0a699f5fp-1 +-0x1.3b476085a11c3p-7 +0x1.ce8447732540fp-1 +0x1.b93183758eb4bp-1 +-0x1.986492011655ep-9 +0x1.ac68b547233d1p-1 +0x1.989f5ed8d4039p-1 +-0x1.d48f0d9c58974p-9 +0x1.4974bf0a2b552p-1 +0x1.3a2acb1f13242p-1 +-0x1.565f22efa1dc8p-8 +0x1.3a7d2d834b4d2p-1 +0x1.2be28a6ce4445p-1 +-0x1.d926ee5ab3697p-8 +0x1.2c0c7f04c14dcp-1 +0x1.58a7e3cf0a88cp-1 +-0x1.6a5f38bea1b8ep-9 +0x1.16ff4fb0042ebp-1 +0x1.4090aa76206f8p-1 +-0x1.9f9fb774c07f2p-9 +0x1.b17e81eeb88b6p-2 +0x1.f2729c8e394e7p-2 +-0x1.2f7dfa037ff64p-8 +0x1.9e63794e860ep-2 +0x1.dc87331a040cp-2 +-0x1.a31e39ab18e95p-8 +-0x1.0b9b608e09495p-11 +-0x1.cb933544fecfbp-9 +-0x1.8f866c406fbeep-7 +-0x1.8cc890027b0dcp-8 +-0x1.1ffc24b06f1afp-8 +-0x1.4ad82fc0849a2p-13 +-0x1.ea48731dfc29bp-7 +-0x1.5f615c16a24cdp-9 +-0x1.18396a4f9feeap-3 +-0x1.08d2865832c2ep-11 +-0x1.c6cafd895f89p-9 +-0x1.8b5e2ab1577dep-7 +-0x1.88a79c117acc6p-8 +-0x1.1cfd021a4e12dp-8 +-0x1.4766e1bae9c64p-13 +-0x1.e52e6e9443866p-7 +-0x1.5bb95a117dbcap-9 +-0x1.335af1fb3263bp-3 +-0x1.1f346e923d514p-11 +-0x1.ed3b407226e45p-9 +-0x1.c2c76b4b926e4p-7 +-0x1.bfaf84eb71431p-8 +-0x1.44edfedbba65dp-8 +-0x1.6312cf2276dbap-13 +-0x1.071819d5c3925p-6 +-0x1.8c7535c914442p-9 +-0x1.9bd1bcbe50094p-3 +-0x1.271d0f0dafd47p-11 +-0x1.fad03f21c6291p-9 +-0x1.ce915eedd645ap-7 +-0x1.cb64c2cebb5dcp-8 +-0x1.4d6d63cfe236cp-8 +-0x1.6cd9dedef56c1p-13 +-0x1.0e56c2f93cff5p-6 +-0x1.96d37bc4d843ep-9 +-0x1.e37bf014ece17p-3 +0x1.78a783679c293p+0 +0x1.74af3d6671c44p+0 +0x1.41730d3a4802ap+0 +0x1.2ffd229e3fe0dp+0 +-0x1.3288ebcf36776p-6 +-0x1.3ea7d24eebadep-4 +-0x1.3a4fe07797eaep-6 +-0x1.45befcdb1071bp-4 +-0x1.b722c10bb3dd1p-6 +-0x1.b72cde12084fbp-4 +-0x1.6529663d36a52p-5 +-0x1.57f463091c394p-3 +-0x1.2337293ebee0cp+1 +-0x1.1ee12b0c034dbp+1 +-0x1.1449f44c0b166p+1 +-0x1.12deb3deee2d4p+1 +0x1.df8ace70461bdp-1 +0x1.ff2893be8410cp-1 +-0x1.fe70e462dae1bp-10 +0x1.c00af16ec6a8p-1 +0x1.dd4b30443f0d9p-1 +-0x1.01ba6ae6a6744p-9 +0x1.68a6fdc4e0efp-1 +0x1.7fa28f011e467p-1 +-0x1.2a12c5e26ae58p-9 +0x1.5bb59d4a11c71p-1 +0x1.71cb8a292ef25p-1 +-0x1.3f198ff928c3cp-8 +0x1.b61b2e677872cp-1 +0x1.a0bacca4fb9d5p-1 +-0x1.5f5bd866b9d79p-9 +0x1.95905c84f54b4p-1 +0x1.82ac584d05fdcp-1 +-0x1.61ff81d3ae77cp-9 +0x1.3f1d965752d4dp-1 +0x1.3204f8fa91abap-1 +-0x1.918a39483cd03p-9 +0x1.32b88576a6d94p-1 +0x1.265d8d8866efp-1 +-0x1.9df3708119bf1p-8 +0x1.67d9f33ea2818p-1 +0x1.406b69f6134bep-1 +-0x1.2473b394aa157p-9 +0x1.4d28c1dbe3988p-1 +0x1.2824dbf5ae662p-1 +-0x1.26a69ffebccd1p-9 +0x1.0637cc5aced0ep-1 +0x1.d02af97c3bb7bp-2 +-0x1.4e41fab8ed53dp-9 +0x1.f815ea1569a86p-2 +0x1.bde4bbea1582bp-2 +-0x1.5882bd60beac8p-8 +0x1.dadf1cb9b7de8p-1 +0x1.06590dd2f3e32p+0 +-0x1.cfd540c62f6a8p-10 +0x1.b8c4b986e4d3p-1 +0x1.e26b0f83f0271p-1 +-0x1.d3507ed73f104p-10 +0x1.5d1ea42929f62p-1 +0x1.751592d74bc39p-1 +-0x1.090a65826649bp-9 +0x1.4fdcabe06d717p-1 +0x1.65bd4294329f9p-1 +-0x1.113d142d74c96p-8 +0x1.fdb1135a7cb11p-1 +0x1.e64179dfa81d4p-1 +-0x1.5c2163ee9ac3cp-10 +0x1.d9f59cdf960adp-1 +0x1.c41f4bbe9ad6bp-1 +-0x1.5ebca93df3ffcp-10 +0x1.791ece89aace9p-1 +0x1.67a881d4f67e8p-1 +-0x1.8dd750e6c8d6dp-10 +0x1.6b05c41d970cp-1 +0x1.5a33b271d55a6p-1 +-0x1.9a18e0c319462p-9 +0x1.48c6164a90632p-1 +0x1.797e41cf7a8b7p-1 +-0x1.35842f656dde6p-10 +0x1.330f41dde36e2p-1 +0x1.60ac9741fd184p-1 +-0x1.37d2057dee591p-10 +0x1.eddfe91650804p-2 +0x1.1bd7430ef8d14p-1 +-0x1.61d5701642325p-10 +0x1.dc1772b334a38p-2 +0x1.11a61ad1956eap-1 +-0x1.6be6654f5f6cep-9 +-0x1.ae97e3cb49e7cp-12 +-0x1.71bd6b5e2a953p-9 +-0x1.416da01b961a7p-7 +-0x1.3f38f5f18325fp-8 +-0x1.cf61f1b72916p-9 +-0x1.0a2c42085c4a5p-13 +-0x1.8a71fd7f5de77p-7 +-0x1.1ab1cb70b338cp-9 +-0x1.3e4000aceec12p-4 +-0x1.a9f93c0a82d57p-12 +-0x1.6dc5e6fee5462p-9 +-0x1.3dfaccdb9d80bp-7 +-0x1.3bcc3195b4faap-8 +-0x1.ca693b3a403b2p-9 +-0x1.075131f368602p-13 +-0x1.86369e3d7e9f4p-7 +-0x1.17a95ab7476b7p-9 +-0x1.432e3203dd66ep-4 +-0x1.daf116b46b2f9p-12 +-0x1.97d221fb46d96p-9 +-0x1.78874ab3ee0c3p-7 +-0x1.75f1d49959f72p-8 +-0x1.0f6897a8b6ddap-8 +-0x1.259647d4b3be2p-13 +-0x1.b312185262155p-7 +-0x1.4b27a851f368dp-9 +-0x1.913f9ee4ca917p-4 +-0x1.e811c0db42574p-12 +-0x1.a317da6037acap-9 +-0x1.824f3a3955acp-7 +-0x1.7fa8955d6cf95p-8 +-0x1.1675798359bd4p-8 +-0x1.2db3b027b1345p-13 +-0x1.bf18a248d76cap-7 +-0x1.53c1db37fb0cp-9 +-0x1.2822530b2eae5p-3 +0x1.a0b2e8ae07ddcp+0 +0x1.a10760198c5e9p+0 +0x1.6efe97d493a28p+0 +0x1.6099d613824d5p+0 +-0x1.44e186bf906e4p-7 +-0x1.5ebec90b078cbp-5 +-0x1.312cdffff3265p-7 +-0x1.4a002a5a40372p-5 +-0x1.942c09b51ef17p-7 +-0x1.a7a8e8e408e33p-5 +-0x1.412bbb3b8647dp-6 +-0x1.493c3f3975f26p-4 +-0x1.27d751258c4b9p+1 +-0x1.22a1530e31bebp+1 +-0x1.17f004f4a5b7cp+1 +-0x1.170c227945452p+1 +0x1.feb04fa18bc22p-1 +0x1.105b045acf7cfp+0 +-0x1.d61a3f27077bbp-11 +0x1.db6c8bc52b4c5p-1 +0x1.faba34de22947p-1 +-0x1.a4a3007f3734bp-11 +0x1.888acac422cbbp-1 +0x1.a1c46fe926f78p-1 +-0x1.ad9abd20c0c8cp-11 +0x1.80f141eb2bb4ap-1 +0x1.99a0fb38fab52p-1 +-0x1.c46210c20a485p-10 +0x1.d7293215504ap-1 +0x1.bf130feae4d34p-1 +-0x1.461747e9c0981p-10 +0x1.b1cdb297cad9cp-1 +0x1.9cc40dc1e8b93p-1 +-0x1.240a1a08534ffp-10 +0x1.5e137f0ffe519p-1 +0x1.4f08a28ceb321p-1 +-0x1.280a2dbd89efdp-10 +0x1.56a427a76260dp-1 +0x1.481432a85a557p-1 +-0x1.33172c5f6d155p-9 +0x1.82f4c7ea2502cp-1 +0x1.592ce45cd5cc3p-1 +-0x1.0f7d930ad3b8cp-10 +0x1.6452967dcace8p-1 +0x1.3d345d0fb76ccp-1 +-0x1.e64f2ee04e9d1p-11 +0x1.1fa15561d4ab4p-1 +0x1.fdea92d28b612p-2 +-0x1.ed13740de4b07p-11 +0x1.198737f568837p-1 +0x1.f2eaafc978a92p-2 +-0x1.ff487038750e3p-10 +0x1.fd4544a8dbba4p-1 +0x1.1c28ebd632abbp+0 +-0x1.ae7f167976a6fp-11 +0x1.d6602f6fb06ecp-1 +0x1.0388c5db6e0dap+0 +-0x1.818a4c9e0b604p-11 +0x1.7e1c5ea1397e3p-1 +0x1.9bc440a4e25b8p-1 +-0x1.86d29648f2c05p-11 +0x1.7634705089d6dp-1 +0x1.926e3bbe1815fp-1 +-0x1.9565a8e71a2f7p-10 +0x1.10c6314aa0cc3p+0 +0x1.0442466613ecp+0 +-0x1.4329a9287ba67p-11 +0x1.f8fdc64173876p-1 +0x1.e1c3e0d5a9e62p-1 +-0x1.216a344aa32fep-11 +0x1.9c1b99bfe98dep-1 +0x1.890ef4884e13ep-1 +-0x1.2563664f0820cp-11 +0x1.93bc692c5892cp-1 +0x1.8110d4c91984ap-1 +-0x1.304585220027ep-10 +0x1.5e45ad29a5726p-1 +0x1.920a165c6dbe1p-1 +-0x1.1ff967ffc9034p-11 +0x1.45eef1f53d428p-1 +0x1.763f82e4c462ap-1 +-0x1.01ff63226f99cp-11 +0x1.0cdbb9e6ae199p-1 +0x1.34f4983659c78p-1 +-0x1.05e34753197d8p-11 +0x1.07a1eaae14d0dp-1 +0x1.2ef85142de936p-1 +-0x1.0eb76d86fba54p-10 +-0x1.55aa05708dcf4p-12 +-0x1.2560ed3514bd4p-9 +-0x1.fe16d8ffb2c6fp-8 +-0x1.fa96c156f78d9p-9 +-0x1.6fae7c82b228cp-9 +-0x1.a666e6aae1379p-14 +-0x1.38fb4d67f4ed1p-7 +-0x1.c09ef5953b109p-10 +-0x1.7bd1beb667dccp-5 +-0x1.51d9f6427a1d5p-12 +-0x1.221acef4905c3p-9 +-0x1.f865a2b9cee54p-8 +-0x1.f4ef8b0117e1cp-9 +-0x1.6b9419fcac51p-9 +-0x1.a1b0310b8dd24p-14 +-0x1.357d2ec22e7ffp-7 +-0x1.bb9d5941f1314p-10 +-0x1.66594f04221a6p-5 +-0x1.866477a7792fbp-12 +-0x1.4f386d6ddf23p-9 +-0x1.396a13632dabdp-7 +-0x1.37437d415ec68p-8 +-0x1.c3d45b0fa8cc1p-9 +-0x1.e2a5271e2c1b2p-14 +-0x1.659e86c2b53fap-7 +-0x1.13a5778f53f12p-9 +-0x1.aa470ace895p-5 +-0x1.913bd1f75119dp-12 +-0x1.58878e0775151p-9 +-0x1.417d16e2cee16p-7 +-0x1.3f48518e342a8p-8 +-0x1.cf783cd5757d8p-9 +-0x1.f00c57a4b16a3p-14 +-0x1.6f8ce3d8a0916p-7 +-0x1.1abf652a72585p-9 +-0x1.3ddd23dc6846cp-4 +0x1.be012a047ca81p+0 +0x1.b2bc2117ad0d5p+0 +0x1.8fc1aab5524fap+0 +0x1.8a1d734aca48ap+0 +-0x1.7f4e503448645p-8 +-0x1.a87c963a3c384p-6 +-0x1.8bae7f6bd65a3p-8 +-0x1.b3304beea4e2ap-6 +-0x1.ae9abc6bb4584p-8 +-0x1.d03e9fa456cd2p-6 +-0x1.296d93c6db51p-7 +-0x1.3dded4e843f64p-5 +-0x1.2b695091a45f7p+1 +-0x1.24c67b623f894p+1 +-0x1.1a54d21c873dep+1 +-0x1.19c8cff23f3dcp+1 +0x1.0a8df83cd9102p+0 +0x1.1c748a8e4161p+0 +-0x1.ddaefac632b79p-12 +0x1.ea51e21eeab74p-1 +0x1.05615e22d1966p+0 +-0x1.c4308ad92ed8cp-12 +0x1.9c6b93a6f462p-1 +0x1.b71175c74f6c3p-1 +-0x1.707c486bc4a05p-12 +0x1.97f302dc00417p-1 +0x1.b24684b67288ep-1 +-0x1.4329cc8e243c6p-11 +0x1.ef9178b6d3db8p-1 +0x1.d55ad700209a4p-1 +-0x1.4b91295f80501p-11 +0x1.c17076a75e46ep-1 +0x1.ab27bb7b39fa7p-1 +-0x1.39b55ee8e71a4p-11 +0x1.71b36d1e220b5p-1 +0x1.615a04b174abap-1 +-0x1.fda61a662bffdp-12 +0x1.6d438d7513461p-1 +0x1.5d37159d62a65p-1 +-0x1.be349bb60e0f6p-11 +0x1.96f7026baf99ap-1 +0x1.6b857bc5f8c9ap-1 +-0x1.1422dd3bec1b4p-11 +0x1.71253949d8191p-1 +0x1.48e55d22414ddp-1 +-0x1.0549a47bced17p-11 +0x1.2fbc29cbf977cp-1 +0x1.0d7ef5d2b3a56p-1 +-0x1.a8a653ef35729p-12 +0x1.2c18136e47667p-1 +0x1.0a34d42d91aefp-1 +-0x1.739e0accc0137p-11 +0x1.0b40d2d757dc5p+0 +0x1.2c7f4c43d32fap+0 +-0x1.b5c144493f874p-12 +0x1.e6b19109ce0ddp-1 +0x1.0dc9669ee6cb2p+0 +-0x1.9e2cb731547e6p-12 +0x1.92ed640cbc33fp-1 +0x1.b48e12f451ab7p-1 +-0x1.5070301bfd13ap-12 +0x1.8e3a3bddb7162p-1 +0x1.aeee8b16c628dp-1 +-0x1.26899d7a69b43p-11 +0x1.1ddcf7465917dp+0 +0x1.10c4e123d05f6p+0 +-0x1.48acd02d35c2dp-12 +0x1.0504abe1ad041p+0 +0x1.f20ce77aeb677p-1 +-0x1.36f8850677ba6p-12 +0x1.b21c9a90a7f61p-1 +0x1.9e115a911f127p-1 +-0x1.f941d31c56554p-13 +0x1.ad261b170eaddp-1 +0x1.995436d71aa83p-1 +-0x1.ba3c0d119ff0bp-12 +0x1.6dc44b85c9046p-1 +0x1.a3b65ffbce01fp-1 +-0x1.25a9b4974c061p-12 +0x1.5035a7c0c6b02p-1 +0x1.81fc7e0ede245p-1 +-0x1.1601ffef6d241p-12 +0x1.1a885c10c429ep-1 +0x1.449cbaaf252cep-1 +-0x1.c4eaa447a827cp-13 +0x1.1774d0944e48fp-1 +0x1.41172fdb6f69bp-1 +-0x1.8afaa40619f53p-12 +-0x1.0a12ae8bbe64ap-12 +-0x1.c8f0cff700d29p-10 +-0x1.8d3c2e425a97ap-8 +-0x1.8a8257e3e3ee2p-9 +-0x1.1e5591bfa5854p-9 +-0x1.48f2b1be9af1cp-14 +-0x1.e778fdf6e9c33p-8 +-0x1.5d5dc33f3cae7p-10 +-0x1.e6540683abd45p-6 +-0x1.06f23b786c92p-12 +-0x1.c39228de6d0e6p-10 +-0x1.8891256639e51p-8 +-0x1.85df82642ada5p-9 +-0x1.1af82aacac992p-9 +-0x1.451517b16259ep-14 +-0x1.e1be7ccdb776fp-8 +-0x1.5942bc598a10bp-10 +-0x1.ea6753697ca48p-6 +-0x1.3e86349ae62abp-12 +-0x1.11824a94a183bp-9 +-0x1.03c43160d44bap-7 +-0x1.01fbda0f57031p-8 +-0x1.767d177ab2f1cp-9 +-0x1.89cb3e349bccdp-14 +-0x1.23c8c98d27a49p-7 +-0x1.c8ed2c04fe329p-10 +-0x1.f1945ade6ab7p-6 +-0x1.476c08bcbb14ep-12 +-0x1.192634f77ca65p-9 +-0x1.0a63d0edca62dp-7 +-0x1.088fd6d8e56c4p-8 +-0x1.80099050895fdp-9 +-0x1.94cb56f6a0544p-14 +-0x1.2bef64c51f45p-7 +-0x1.d493c197d2deap-10 +-0x1.4ee9b0c6bb41dp-5 +0x1.d551fbc174fa4p+0 +0x1.bfee165df5907p+0 +0x1.a3b9c6add0d49p+0 +0x1.a479e13aac6dep+0 +-0x1.e18450b5237d1p-9 +-0x1.0fd71974a2d0dp-6 +-0x1.04635f64fb977p-8 +-0x1.21fd2e0972543p-6 +-0x1.0da9eb368b306p-8 +-0x1.277191f529a5bp-6 +-0x1.38a02c16e1a8ap-8 +-0x1.561996614a211p-6 +-0x1.2e3542ea62605p+1 +-0x1.263d767e56e37p+1 +-0x1.1baeec18ef73fp+1 +-0x1.1b0c26775f146p+1 +0x1.12df072cb2f9ap+0 +0x1.25722dd052438p+0 +-0x1.03130b8b9c22ep-12 +0x1.f42f226bb08f2p-1 +0x1.0ab187423b25cp+0 +-0x1.dcb489449f0e2p-13 +0x1.a74bf1353afcap-1 +0x1.c2bb5b40fc08dp-1 +-0x1.80f037848c23ep-13 +0x1.a23660b1075b2p-1 +0x1.bd4761e791de2p-1 +-0x1.02a3040315512p-12 +0x1.010608a7cf271p+0 +0x1.e62626f3fca15p-1 +-0x1.67042f81bca66p-12 +0x1.cbe85c25be737p-1 +0x1.b4c3ef02dcb01p-1 +-0x1.49ca66ac018e8p-12 +0x1.7c8d77c243fa9p-1 +0x1.6b74a1a62fb5cp-1 +-0x1.0999094dd2899p-12 +0x1.77783644bcbf6p-1 +0x1.66b99ed31c19bp-1 +-0x1.657e441b1e887p-12 +0x1.a61c470e22606p-1 +0x1.79735dad13a99p-1 +-0x1.2b1abae733d23p-12 +0x1.79babb98c612dp-1 +0x1.50bc6b09652bbp-1 +-0x1.12d16793f9bb3p-12 +0x1.38a3a9afb5f6dp-1 +0x1.158c4f13190ebp-1 +-0x1.bad743da07fc4p-13 +0x1.3477f3b37837cp-1 +0x1.11c6739bced7dp-1 +-0x1.29ec6b6b0c229p-12 +0x1.14c201ea72696p+0 +0x1.3900d187a54b4p+0 +-0x1.da08782be589bp-13 +0x1.f19678517d309p-1 +0x1.14b1c532e064p+0 +-0x1.b372d559b6b89p-13 +0x1.9e67bf9e5cdfep-1 +0x1.c25ac0682b036p-1 +-0x1.5eb18831c5fc2p-13 +0x1.990827229d5bap-1 +0x1.bbe1e42c1c4e5p-1 +-0x1.d800f3e5dece7p-13 +0x1.27af4b92b926p+0 +0x1.1a288917c15dfp+0 +-0x1.63fde9f535cfap-13 +0x1.0ab2380cefcep+0 +0x1.fce6b5c279d97p-1 +-0x1.47082b6d8b873p-13 +0x1.be3830b04d4ccp-1 +0x1.a9a12bfb93528p-1 +-0x1.07670469986bdp-13 +0x1.b88db0afdc23fp-1 +0x1.a4380c85436b9p-1 +-0x1.6274625bbd00dp-13 +0x1.79460969e813fp-1 +0x1.b0d36e2401eeep-1 +-0x1.3f076c4f6920dp-13 +0x1.5704ab46854f9p-1 +0x1.89c29d4592f02p-1 +-0x1.25896a59635d7p-13 +0x1.2204ac07557fp-1 +0x1.4d2dfc574df5fp-1 +-0x1.da406d1603d57p-14 +0x1.1e84ccc008721p-1 +0x1.492cb8c75ca4dp-1 +-0x1.3e30893ce614dp-13 +-0x1.93a3726c3d0e9p-13 +-0x1.5a982dacc0c18p-10 +-0x1.2d4ea2e52ee2fp-8 +-0x1.2b3d51a961e6fp-9 +-0x1.b260176219003p-10 +-0x1.f30572467da52p-15 +-0x1.71c0d5d756bb8p-8 +-0x1.08ff868e628c5p-10 +-0x1.452a0e967bc1dp-6 +-0x1.8e8d1724adbb1p-13 +-0x1.5639e07550947p-10 +-0x1.298274f399b1p-8 +-0x1.2777cf94c692p-9 +-0x1.ace68fe80c9f5p-10 +-0x1.ecbb5549fb0e3p-15 +-0x1.6d17cf90088a5p-8 +-0x1.05a87fa749dd5p-10 +-0x1.4fe001558172p-6 +-0x1.016f60fdf1571p-12 +-0x1.ba1b3aac06d85p-10 +-0x1.ac5454c1d3d5bp-8 +-0x1.a963de804b7d7p-9 +-0x1.34bf63e329548p-9 +-0x1.3e44d804d444fp-14 +-0x1.d7a5a94541e2cp-8 +-0x1.78b6accd20931p-10 +-0x1.489ec88ae33cep-6 +-0x1.08ae4dc161fbep-12 +-0x1.c68cc93f3d97p-10 +-0x1.b71c339681f4p-8 +-0x1.b418ccf77ac48p-9 +-0x1.3c84c13fb38c6p-9 +-0x1.473a19f55586bp-14 +-0x1.e4ec1241dba13p-8 +-0x1.8231f79a9bf9ep-10 +-0x1.7bdd21b89148dp-6 +0x1.e3497721ce903p+0 +0x1.c5c2823abccf1p+0 +0x1.aaf641805c5cep+0 +0x1.a994060f0c2fbp+0 +-0x1.4c41c97087835p-9 +-0x1.7ba0f3cc0b3d3p-7 +-0x1.6fb2410f51ab8p-9 +-0x1.9c18c3ee83c38p-7 +-0x1.6839f2509261p-9 +-0x1.8d8465907f4f5p-7 +-0x1.70f9049b867b2p-9 +-0x1.96c920349330ep-7 +-0x1.30154bf0ebb4ap+1 +-0x1.26f1c71efb073p+1 +-0x1.1bc9c8aa5b1b6p+1 +-0x1.1abff71af8ffdp+1 +0x1.183a9370c7df3p+0 +0x1.2b3eb21c0ebcfp+0 +-0x1.30d85c6b9dcbep-13 +0x1.f8d740f4ff99bp-1 +0x1.0d33f4c118f59p+0 +-0x1.076c2f7a4b337p-13 +0x1.a821645c07d13p-1 +0x1.c3a052cc8d90ap-1 +-0x1.93172b3511bc2p-14 +0x1.9fd05c12a1329p-1 +0x1.bab4f356bf4d5p-1 +-0x1.a535598a9d5d8p-14 +0x1.0711273d4b69dp+0 +0x1.f1191e45a3ffdp-1 +-0x1.a5104a4d685a3p-13 +0x1.d0e1ee964771fp-1 +0x1.b9535d642270dp-1 +-0x1.6aad22fe78bc9p-13 +0x1.7d6351277948p-1 +0x1.6c3b8d3a0da7dp-1 +-0x1.14acd8b306d47p-13 +0x1.7513f5afb0557p-1 +0x1.647f79d82ac78p-1 +-0x1.21572c0da3e47p-13 +0x1.b003fb0c07317p-1 +0x1.8294a12ffb9cep-1 +-0x1.5ef20c9cf1a9ep-13 +0x1.7dcefc9be302bp-1 +0x1.547726de3120cp-1 +-0x1.2e6bbe286d4dfp-13 +0x1.3953208523aedp-1 +0x1.162b17227b0a2p-1 +-0x1.cdad4e5d14b75p-14 +0x1.328191e681428p-1 +0x1.100031afae42p-1 +-0x1.e2c54fb764834p-14 +0x1.1af38da37265cp+0 +0x1.413fc7391606ap+0 +-0x1.16014d140d2c4p-13 +0x1.f6c195ce0187cp-1 +0x1.17fd58b7fb486p+0 +-0x1.deee26c140444p-14 +0x1.9f49afdbbc38p-1 +0x1.c36b66e3505c5p-1 +-0x1.6d5d98dfe616bp-14 +0x1.968076807fe6fp-1 +0x1.b8d79f86864ffp-1 +-0x1.7e150cf70f4c7p-14 +0x1.2e110717f8f7cp+0 +0x1.20429a72670aep+0 +-0x1.a1a953a20a4f6p-14 +0x1.0d62efa7d5946p+0 +0x1.01057cfc0796bp+0 +-0x1.67d08705a60bep-14 +0x1.bf26557a2577ep-1 +0x1.aa84963ffe6f9p-1 +-0x1.12862f07e498ap-14 +0x1.b5e2616f1be68p-1 +0x1.a1ab8e41d2fdep-1 +-0x1.1f1158521065ap-14 +0x1.80b129db48feap-1 +0x1.b94657823edcbp-1 +-0x1.779a2a0f8d8e3p-14 +0x1.5a3bc677c3d6ap-1 +0x1.8d6e294616331p-1 +-0x1.44aaf42d6ddddp-14 +0x1.22979abfe5a6bp-1 +0x1.4dd6205a7a075p-1 +-0x1.f156fe0cd29ep-15 +0x1.1cde383326c5p-1 +0x1.47490f366a758p-1 +-0x1.03d966b7e16a5p-14 +-0x1.2667b1d73dd4dp-13 +-0x1.f998c7e156a86p-11 +-0x1.b788aa8b8f4f4p-9 +-0x1.b48485614db4bp-10 +-0x1.3cd2f02cee97ep-10 +-0x1.6bf9a615e3407p-15 +-0x1.0db09f77011a8p-8 +-0x1.82915c80e601ep-11 +-0x1.d218c720e1c7cp-7 +-0x1.224f1a9d072c2p-13 +-0x1.f28ffb85cc71bp-11 +-0x1.b16b2b0620fe8p-9 +-0x1.ae71c406d18bfp-10 +-0x1.386a7fac571f7p-10 +-0x1.66e944a56f3a6p-15 +-0x1.09f00f8bcccdap-8 +-0x1.7d30837abdc59p-11 +-0x1.e3de0a657a76p-7 +-0x1.9b04414d91f3fp-13 +-0x1.60ee0d36ae953p-10 +-0x1.5ece1d0097c89p-8 +-0x1.5c65d7527a113p-9 +-0x1.f9bbc0a213188p-10 +-0x1.fc2498173a559p-15 +-0x1.78831443b69dcp-8 +-0x1.348806aa40f88p-10 +-0x1.c13f4cee3acf7p-7 +-0x1.a6b327abc03efp-13 +-0x1.6af64392e957dp-10 +-0x1.677d4dd756556p-8 +-0x1.6505c699be6dp-9 +-0x1.0320647a810f7p-9 +-0x1.054b22114d6ecp-14 +-0x1.8336e51301e3dp-8 +-0x1.3c2b4fa8bf194p-10 +-0x1.caafb4bdb3f42p-7 +0x1.ea4bcee1f3bb1p+0 +0x1.c841d275e7c84p+0 +0x1.a7a235c2794fbp+0 +0x1.a26278e97f22cp+0 +-0x1.eb7299256bb19p-10 +-0x1.1a8efd261c3a3p-7 +-0x1.141b2e8df5d51p-9 +-0x1.3673f56280992p-7 +-0x1.1251896aa3e78p-9 +-0x1.2e9d38e1a5b39p-7 +-0x1.13ebbeeacf7abp-9 +-0x1.2f7bf7744a601p-7 +-0x1.312254ef380fep+1 +-0x1.2743874db01ap+1 +-0x1.1ac4d8218fdbap+1 +-0x1.19476928752b8p+1 +0x1.1b283479cb24cp+0 +0x1.2e6ab302f84e2p+0 +-0x1.792877ca0eabbp-14 +0x1.faef0d0490efep-1 +0x1.0e54c39c83d8ep+0 +-0x1.3a70760f3e05cp-14 +0x1.9ff7c66657971p-1 +0x1.badf36ec9ad4bp-1 +-0x1.dd1d95152183ap-15 +0x1.93c7b47ef5fdcp-1 +0x1.adcea2db83ed5p-1 +-0x1.cb6e64873f581p-15 +0x1.0a66f7e2a6e69p+0 +0x1.f720d2f050d7ep-1 +-0x1.034f805a42dedp-13 +0x1.d32025f492e7ap-1 +0x1.bb615b2455c1dp-1 +-0x1.ae340ea05efbfp-14 +0x1.753b3b14c6b31p-1 +0x1.64a40d8b4465dp-1 +-0x1.45281dc9cbebp-14 +0x1.692379b6d7af4p-1 +0x1.595ddb249b0d6p-1 +-0x1.38e326ee48bfbp-14 +0x1.b57b3ca947ec1p-1 +0x1.87a02fa5a6ed8p-1 +-0x1.b07bbe71dfc6p-14 +0x1.7fa5cb7c60b1p-1 +0x1.5625cf00f49a9p-1 +-0x1.6701cd718a221p-14 +0x1.32a1cb4282cf1p-1 +0x1.101d53d6520a4p-1 +-0x1.0f8d4c75d5b8bp-14 +0x1.28b570b680078p-1 +0x1.07263896bc0a1p-1 +-0x1.055774d4f817fp-14 +0x1.1e5c8104e0205p+0 +0x1.45d29bbe43aa8p+0 +-0x1.5674ad3b3ea7ap-14 +0x1.f915a86803ca6p-1 +0x1.197a5e9cf2da5p+0 +-0x1.1c17dcac383e5p-14 +0x1.96aa040cd4332p-1 +0x1.b909849862d46p-1 +-0x1.ad72e71e051c3p-15 +0x1.89dab4d3cead8p-1 +0x1.a9b6aa34f24ddp-1 +-0x1.9d3ebec1cbd7p-15 +0x1.3192e099a550bp+0 +0x1.239d278980736p+0 +-0x1.0152e72a81716p-14 +0x1.0e990569ac6f2p+0 +0x1.022dd0205eba1p+0 +-0x1.ab0c11695139cp-15 +0x1.b60e39b66068bp-1 +0x1.a1d56c3f18f87p-1 +-0x1.42d00986603b7p-15 +0x1.a8873ca76b01p-1 +0x1.94eac860e9c9bp-1 +-0x1.36a41f9dc7p-15 +0x1.84bfa92d0864ep-1 +0x1.bde498859a631p-1 +-0x1.d0cde9f3f5304p-15 +0x1.5badc6cc959fbp-1 +0x1.8f14736917957p-1 +-0x1.83b664bd1e382p-15 +0x1.1cf95854395bfp-1 +0x1.47681b523288fp-1 +-0x1.26966f1bd1256p-15 +0x1.149687338caep-1 +0x1.3dce84c956be5p-1 +-0x1.1bbff3518fa71p-15 +-0x1.931c1244bbe2dp-14 +-0x1.5a23ef490c6dp-11 +-0x1.2ce9a650db6afp-9 +-0x1.2ad9067d3a22cp-10 +-0x1.b1ce815dcc81cp-11 +-0x1.f25e149c5518bp-16 +-0x1.7144d30cbda0ep-9 +-0x1.08a6b557a2aa2p-11 +-0x1.5fc14f7385135p-7 +-0x1.8c9a4ce3d594ap-14 +-0x1.548d93f86fa08p-11 +-0x1.280e3089f4e8dp-9 +-0x1.26061924d93c2p-10 +-0x1.aacde35f60678p-11 +-0x1.ea52acdde7128p-16 +-0x1.6b4ee4d3ed827p-9 +-0x1.0461176b2fce1p-11 +-0x1.6f08c489fc6f7p-7 +-0x1.42bd480c82316p-13 +-0x1.1520de0c6c4c2p-10 +-0x1.1ce87eb4ee707p-8 +-0x1.1af3fc80603d5p-9 +-0x1.9abbe5fc47eeap-10 +-0x1.8f01500e6944fp-15 +-0x1.27a546870113bp-8 +-0x1.f526900cbaf88p-11 +-0x1.5553be8781db9p-7 +-0x1.4c090fd52a7bap-13 +-0x1.1d1c5390b421ap-10 +-0x1.23cf7fbd3a6b2p-8 +-0x1.21cedd5f931f4p-9 +-0x1.a4af46890ce81p-10 +-0x1.9a7f74029a06fp-15 +-0x1.302946590edd2p-8 +-0x1.00a55a3f47342p-10 +-0x1.53be6a9ba9618p-7 +0x1.eb8bf89454788p+0 +0x1.c7a7f2f515f94p+0 +0x1.9cfc3110eb24ap+0 +0x1.93dbf95a48e72p+0 +-0x1.84ecf5a476302p-10 +-0x1.c0121cab87d6ap-8 +-0x1.a04d799b00c98p-10 +-0x1.d486a9c5ddd6bp-8 +-0x1.a6e9e3976a851p-10 +-0x1.d05064228956dp-8 +-0x1.ab651c002d635p-10 +-0x1.d2e7ba96fe6b4p-8 +-0x1.3159ec5eb84c6p+1 +-0x1.272a2f9d82937p+1 +-0x1.18f173f65bbcap+1 +-0x1.170134085e52fp+1 +0x1.1bc16cdc2ba29p+0 +0x1.2f10b9a9d3e79p+0 +-0x1.e9060a8d4868dp-15 +0x1.fa4944107649ep-1 +0x1.0dfb65b04820cp+0 +-0x1.69599b9af074ap-15 +0x1.90fdaa525128ep-1 +0x1.aad17e4efb7fbp-1 +-0x1.06481ca384c5fp-15 +0x1.809331b48bb3p-1 +0x1.993c449167a79p-1 +-0x1.dc04280f71e3fp-16 +0x1.0b1639385db3bp+0 +0x1.f85d6769c4af2p-1 +-0x1.4e440ec7fb203p-14 +0x1.d26e5ac9c1c83p-1 +0x1.babe84d4a1be3p-1 +-0x1.e9b9dd945d63ap-15 +0x1.66629bbcacdccp-1 +0x1.56cbe91410a49p-1 +-0x1.6126112fb1dfap-15 +0x1.56485e1f26794p-1 +0x1.47be48f70dfddp-1 +-0x1.3f516b162f48ap-15 +0x1.b69a703a7c855p-1 +0x1.88a971482e879p-1 +-0x1.16ef0f5452916p-14 +0x1.7f140536c9fc9p-1 +0x1.55a073b975b36p-1 +-0x1.9927889240cd4p-15 +0x1.2672ffa5746ebp-1 +0x1.051c124e83906p-1 +-0x1.276d064499a05p-15 +0x1.193be27280b3cp-1 +0x1.f262f2c0c367ep-2 +-0x1.0b46bd6abc73cp-15 +0x1.1f0f80a6f331ep+0 +0x1.46c3748fa0ce9p+0 +-0x1.b981bef7c0e36p-15 +0x1.f85d210277f4ap-1 +0x1.190459495239bp+0 +-0x1.43786e8f9f9f1p-15 +0x1.86ef037636df6p-1 +0x1.a63c6484d5de7p-1 +-0x1.d286b582b298p-16 +0x1.75d2c4828bc0fp-1 +0x1.91fb2b828695cp-1 +-0x1.a5daacf5fedep-16 +0x1.324ad5f6adb05p+0 +0x1.244d119e64483p+0 +-0x1.4be0f509027b5p-15 +0x1.0e390a09f666p+0 +0x1.01d216f499ae6p+0 +-0x1.e688afcce2b5ep-16 +0x1.a570e0b64820fp-1 +0x1.91f825cb24a81p-1 +-0x1.5eef1fe55e78fp-16 +0x1.9354eeb72f5d2p-1 +0x1.80ae0ac63c41ap-1 +-0x1.3d63dbc708773p-16 +0x1.8593f88090b59p-1 +0x1.bed64052e1328p-1 +-0x1.2d5b2926938ep-15 +0x1.5b3b49b3fa383p-1 +0x1.8e91c94c4b1a1p-1 +-0x1.bdc5ac1917344p-16 +0x1.12ab559245a2fp-1 +0x1.3b9c1cbdf46d8p-1 +-0x1.4450ced32bcd5p-16 +0x1.07613e480e1a5p-1 +0x1.2eae3c5f0a47fp-1 +-0x1.26802cd8645eep-16 +-0x1.06acd0ab0dd59p-14 +-0x1.c31af22a420a9p-12 +-0x1.8829b2171aedbp-10 +-0x1.8578c4d13e34ep-11 +-0x1.1aad9906542bp-11 +-0x1.44bf4584277c1p-16 +-0x1.e13f4ee52151bp-10 +-0x1.58e7c0698dc66p-12 +-0x1.17ff2e54aa527p-7 +-0x1.02c72dd893225p-14 +-0x1.bc69a7a102f11p-12 +-0x1.825844faadf22p-10 +-0x1.7fb1903c5afa3p-11 +-0x1.167bfe07dac89p-11 +-0x1.3fede2f9309aap-16 +-0x1.da1b89ba70be4p-10 +-0x1.53c9cf08c83b6p-12 +-0x1.1563d61edc481p-7 +-0x1.ef6788b9ae7d9p-14 +-0x1.a96441dd3167ap-11 +-0x1.c9ca0fadb0d15p-9 +-0x1.c6a5d896ef8cbp-10 +-0x1.49fb9b2cafefep-10 +-0x1.323c7201f3edp-15 +-0x1.c5d0c6afc40c5p-9 +-0x1.929f96be4d64cp-11 +-0x1.0271221c5a446p-7 +-0x1.fdf02bc4bd3bp-14 +-0x1.b5df13af76821p-11 +-0x1.d490894ae1924p-9 +-0x1.d159644a2a9bdp-10 +-0x1.51bff70c378fp-10 +-0x1.3b385efd2305p-15 +-0x1.d321115cad7b5p-9 +-0x1.9c19a7602d0e5p-11 +-0x1.0088658b785e2p-7 +0x1.ebd559b91ab84p+0 +0x1.c6c63e48af92p+0 +0x1.8d15ef8fa86f5p+0 +0x1.845b4eb5b8e78p+0 +-0x1.27e36c7faec94p-10 +-0x1.5547a3ae5469ep-8 +-0x1.2c3e83541027ap-10 +-0x1.521b01dc6aacp-8 +-0x1.3750c3f4a91bap-10 +-0x1.5338268072e29p-8 +-0x1.41813b95124e8p-10 +-0x1.5cb35aef4d97p-8 +-0x1.3160b0d10ca96p+1 +-0x1.270e00da1731ap+1 +-0x1.16f2581c185afp+1 +-0x1.14f46803c9542p+1 +0x1.1bd409d145008p+0 +0x1.2f24e5340e3d7p+0 +-0x1.2176d1d77615ap-15 +0x1.f99092d1c9cb6p-1 +0x1.0d97d7d8f061ap+0 +-0x1.7b4fd3ed943cp-16 +0x1.801339916429p-1 +0x1.98b341025fac4p-1 +-0x1.edec4573b9258p-17 +0x1.6e9e904c08e88p-1 +0x1.8604a31e07636p-1 +-0x1.c8e4284a34efap-17 +0x1.0b2b87e090585p+0 +0x1.f883e2fb3e866p-1 +-0x1.881fe6b349ac7p-15 +0x1.d1a869783a3b9p-1 +0x1.ba0933a19085dp-1 +-0x1.fa62f45de556bp-16 +0x1.55cb87909d3a5p-1 +0x1.47496dc5bbc33p-1 +-0x1.44d3829a68ap-16 +0x1.44dcbdc8d350cp-1 +0x1.376a5152c73b5p-1 +-0x1.2abe72e78fd73p-16 +0x1.b6bd5b09b977dp-1 +0x1.88c9b20998764p-1 +-0x1.478f9b4245a09p-15 +0x1.7e71b97405216p-1 +0x1.550bff05d40cp-1 +-0x1.a7dd352039848p-16 +0x1.18d56c7fd0f77p-1 +0x1.f1aa575529d9bp-2 +-0x1.10a1161d2d372p-16 +0x1.0aef6c5f5c43fp-1 +0x1.d8a5f9cb645ap-2 +-0x1.f5f170a1bfc7fp-17 +0x1.1f2542b71fcfp+0 +0x1.46e0bfcfe65fp+0 +-0x1.030579778af56p-15 +0x1.f78fa76320b7fp-1 +0x1.1881002d93d77p+0 +-0x1.4e97722f588cap-16 +0x1.754deab83de37p-1 +0x1.915eb3eb7af2bp-1 +-0x1.ad4cb012c10ap-17 +0x1.6341c343572e8p-1 +0x1.7c39cfd658dcdp-1 +-0x1.8adb61de37c54p-17 +0x1.3261317f33373p+0 +0x1.246272ebeb93ap+0 +-0x1.85a51a850df45p-16 +0x1.0dce262763ccep+0 +0x1.016bf159af872p+0 +-0x1.f7c054c2592aap-17 +0x1.92c82cd86acb8p-1 +0x1.8027a9ec1e7efp-1 +-0x1.4360c032b83d1p-17 +0x1.7fa3a32a497f9p-1 +0x1.6de17de9c402cp-1 +-0x1.2985dab4ddb87p-17 +0x1.85adc359ec3f3p-1 +0x1.bef39b8f330a7p-1 +-0x1.64d0723296308p-16 +0x1.5abbbf00483aep-1 +0x1.8e00387a11155p-1 +-0x1.d446c39dd352bp-17 +0x1.07094243262c3p-1 +0x1.2e49737963ec9p-1 +-0x1.322990133692bp-17 +0x1.f613428e02158p-2 +0x1.208a3776ac5bfp-1 +-0x1.1b7f51c1407c6p-17 +-0x1.55f68649d9d2fp-15 +-0x1.25a29e3c8ddb9p-12 +-0x1.fe896d4a1fcf2p-11 +-0x1.fb088c5849434p-12 +-0x1.700113c20c582p-12 +-0x1.a6c57b904afa3p-17 +-0x1.3941621e6c642p-10 +-0x1.c103bb2f79b7ap-13 +-0x1.ab83a502cb20dp-8 +-0x1.516afa0ed3f5cp-15 +-0x1.21bb821840889p-12 +-0x1.f7c04ced8cd97p-11 +-0x1.f44b57a81c59ap-12 +-0x1.6b1cecc8a55f4p-12 +-0x1.a126fad377aa2p-17 +-0x1.351783be62abbp-10 +-0x1.bb0befee4398ap-13 +-0x1.90abf576bf95cp-8 +-0x1.6fd6d4231e2fcp-14 +-0x1.3bdabeda7a4d4p-11 +-0x1.6a90935760a2ep-9 +-0x1.6813a51277bfcp-10 +-0x1.0557df3fd668bp-10 +-0x1.c6c328e442053p-16 +-0x1.50f594c33a5d5p-9 +-0x1.3edfb665b68ebp-11 +-0x1.71e16415076b8p-8 +-0x1.7aec5db3d74d2p-14 +-0x1.455f44ecfd728p-11 +-0x1.72c3d642c9f6dp-9 +-0x1.703880247bbbbp-10 +-0x1.0b410ecb00ea1p-10 +-0x1.d4773a82938f2p-16 +-0x1.5b1ce8b0aa3b3p-9 +-0x1.4616009ac82d4p-11 +-0x1.7788e869cfadp-8 +0x1.ea92db9614de7p+0 +0x1.c6d48a338f729p+0 +0x1.80d375ba68eb6p+0 +0x1.79e4c50fe1f03p+0 +-0x1.bc4614b03cfc4p-11 +-0x1.00313483d20eep-8 +-0x1.c81727f2bb5e8p-11 +-0x1.00fd845f5d005p-8 +-0x1.ed4e50b34dae7p-11 +-0x1.0b341c97f20a7p-8 +-0x1.f60f4c2a27f28p-11 +-0x1.0efae802423b6p-8 +-0x1.312dc0c316a23p+1 +-0x1.2711d1eac3672p+1 +-0x1.150a3b36e2409p+1 +-0x1.135f59b345108p+1 +0x1.1b47bb017d19bp+0 +0x1.2e8cdba5b3308p+0 +-0x1.447dbcd144f6dp-16 +0x1.f9a99b19990b6p-1 +0x1.0da55600b2579p+0 +-0x1.bf31d2c990b38p-17 +0x1.6f60eaf7c46d5p-1 +0x1.86d4924f1fa4p-1 +-0x1.12cf94e3acecdp-17 +0x1.60542bb8b3516p-1 +0x1.76bbd7eaf340dp-1 +-0x1.f1d891ef44f5ep-18 +0x1.0a8b01be21a9fp+0 +0x1.f761ee7f6a254p-1 +-0x1.b17f58a95f41ap-16 +0x1.d1c33b7a69a11p-1 +0x1.ba21c55d64b4cp-1 +-0x1.259d4279cdbc4p-16 +0x1.45984cb1c77b8p-1 +0x1.381a56f21c2afp-1 +-0x1.5fc9efbd83aa7p-17 +0x1.3722399c4194ap-1 +0x1.2a845e5662636p-1 +-0x1.3ba3c4f4eca74p-17 +0x1.b5b64bb8d85eap-1 +0x1.87d6ba4fe0878p-1 +-0x1.6ab63113035c7p-16 +0x1.7e87b701a899ap-1 +0x1.55201c45f0e3bp-1 +-0x1.ec8a86331539bp-17 +0x1.0b89616959141p-1 +0x1.d9bad9721ff17p-2 +-0x1.286d0bfd00409p-17 +0x1.ff54c3e67c905p-2 +0x1.c465a7cec03d9p-2 +-0x1.0a5f736df5b73p-17 +0x1.1e8151413fa91p+0 +0x1.46041ec85adbbp+0 +-0x1.1e72947c66905p-16 +0x1.f7ab7f34fc869p-1 +0x1.1892cb79b8574p+0 +-0x1.84283918acc92p-17 +0x1.6409f404bd237p-1 +0x1.7d23368f199e6p-1 +-0x1.d129e8678a699p-18 +0x1.5495d8a0995cdp-1 +0x1.6b3187da47fcap-1 +-0x1.a16bc78f63347p-18 +0x1.31b8b703ff30dp+0 +0x1.23c1565549553p+0 +-0x1.af4cc254c4216p-17 +0x1.0ddca252fe7e8p+0 +0x1.0179c8f56d782p+0 +-0x1.248382ed5ba18p-17 +0x1.8078314edf749p-1 +0x1.6eac6421d3953p-1 +-0x1.5ef467766dd6bp-18 +0x1.700c2f7f670e3p-1 +0x1.5eff8bb5f298p-1 +-0x1.3b199165d0089p-18 +0x1.84eb57c8c2bc9p-1 +0x1.be16511cec9f2p-1 +-0x1.90124338ea1f4p-17 +0x1.5acd08432b5d6p-1 +0x1.8e13f32a60c56p-1 +-0x1.1434dd025c4f5p-17 +0x1.f71e62c306956p-2 +0x1.21234594c0897p-1 +-0x1.55b3abacc09fep-18 +0x1.e270107bfad97p-2 +0x1.15494e453555ap-1 +-0x1.35fa68580123p-18 +-0x1.bc9c56c7f2515p-16 +-0x1.7dc6bb9028b54p-13 +-0x1.4be4a1f4f4905p-11 +-0x1.499d957b8e7e4p-12 +-0x1.de781926e257cp-13 +-0x1.12d678a7d55p-17 +-0x1.974930f7fc9afp-11 +-0x1.23e5f7d558122p-13 +-0x1.40cae79eb868cp-8 +-0x1.b783b1d3d9b85p-16 +-0x1.7966777154927p-13 +-0x1.4816be3f4c296p-11 +-0x1.45d660a3ea094p-12 +-0x1.d8fc1a936e683p-13 +-0x1.0fb0002037544p-17 +-0x1.929e122ee3bdbp-11 +-0x1.208d6feaf01bcp-13 +-0x1.30f890586f31bp-8 +-0x1.0a4d0b89055fdp-14 +-0x1.c9550ae30a791p-12 +-0x1.1c3d3c21ff886p-9 +-0x1.1a49e6c94b4ap-10 +-0x1.99c500f087929p-11 +-0x1.493ad966fb1ffp-16 +-0x1.e7e3eb5e93136p-10 +-0x1.f3f95166efdb8p-12 +-0x1.1eab9c4ddc973p-8 +-0x1.112f39b72d3e3p-14 +-0x1.d527531d58285p-12 +-0x1.21c309ff3c71fp-9 +-0x1.1fc600f81710ap-10 +-0x1.a1bb31ef4d08dp-11 +-0x1.51bd72351344ep-16 +-0x1.f480698a5cc2dp-10 +-0x1.fdb02f6fee233p-12 +-0x1.1fe8f5b392848p-8 +0x1.eb11ae4e71a11p+0 +0x1.c88e1ca40c6ep+0 +0x1.79db5bf80c521p+0 +0x1.764c680d76ecp+0 +-0x1.5babd96fdd21bp-11 +-0x1.914f12b261c6cp-9 +-0x1.77be52f1c5b6fp-11 +-0x1.a80cd976eda4p-9 +-0x1.a2d9accdca60bp-11 +-0x1.c449abe0e68edp-9 +-0x1.a9962ba8c07ffp-11 +-0x1.cabb1039b1f81p-9 +-0x1.3147291a1f6p+1 +-0x1.277bbdca5ef71p+1 +-0x1.13809d9bd3e61p+1 +-0x1.12888cfdc1f59p+1 +0x1.1b8dc689626aap+0 +0x1.2ed8c1b24d088p+0 +-0x1.97066ac2e4549p-17 +0x1.fc5dc9c21042ep-1 +0x1.0f1a7843aca05p+0 +-0x1.3e60e07232424p-17 +0x1.618451e59073dp-1 +0x1.78010e38e79bcp-1 +-0x1.74db91e5126f2p-18 +0x1.58980d00d82bap-1 +0x1.6e76f9340d741p-1 +-0x1.5d8261cdd9c19p-18 +0x1.0adb1e16b1e95p+0 +0x1.f7f2a56626e47p-1 +-0x1.0c0e4fdd237cfp-16 +0x1.d4a9d67a2b867p-1 +0x1.bcc9d93d5e073p-1 +-0x1.9ced4ffb3cca8p-17 +0x1.3845465fda6c3p-1 +0x1.2b9612afcf67cp-1 +-0x1.d29c51d0cff2fp-18 +0x1.2fc05057e9f8p-1 +0x1.2391f74b6d82p-1 +-0x1.b1a500cc2f614p-18 +0x1.b63994089538ap-1 +0x1.884ffa30abc6cp-1 +-0x1.c150bf9e3e8eap-17 +0x1.80e894bb228c5p-1 +0x1.574d247df9fcep-1 +-0x1.5adfaa293b167p-17 +0x1.0099506661cd8p-1 +0x1.c612b6ff21251p-2 +-0x1.8a877b900f4e6p-18 +0x1.f335b4265923ap-2 +0x1.b984c6ef804a9p-2 +-0x1.6f2a8652f22c1p-18 +0x1.1ed324225bbf8p+0 +0x1.4672354aaf673p+0 +-0x1.626084c3cab82p-17 +0x1.faae28a00c0e8p-1 +0x1.1a7fd943517acp+0 +-0x1.11066fe27467cp-17 +0x1.55cd393d3c04ep-1 +0x1.6c99ac04be8c9p-1 +-0x1.349e30fd1eb07p-18 +0x1.4cae7a33a0fe6p-1 +0x1.62131b97eac1p-1 +-0x1.1eda11697f79p-18 +0x1.320cceb2ba588p+0 +0x1.2411c0a3f62d9p+0 +-0x1.0b0b34f0ab8dp-17 +0x1.0f6d761372b77p+0 +0x1.02f8d45762506p+0 +-0x1.9bd70fe86574cp-18 +0x1.715757f49fae2p-1 +0x1.603ba1be459b3p-1 +-0x1.d2502a70b463bp-19 +0x1.67a32d1c3dc81p-1 +0x1.56f8952cab1d5p-1 +-0x1.b1a403e0591f5p-19 +0x1.854c66837361ap-1 +0x1.be84ca4a244b9p-1 +-0x1.f5dfd48e06a51p-18 +0x1.5cab0d547aba5p-1 +0x1.90357fe0a428p-1 +-0x1.8964cd74f0af5p-18 +0x1.e411f0d3af7f5p-2 +0x1.1638cf68077ep-1 +-0x1.d0d63325a8293p-19 +0x1.d7cfd948012b7p-2 +0x1.0f32136060d4p-1 +-0x1.b445c1223f9d6p-19 +-0x1.209635ade6758p-16 +-0x1.ef9acff411f0ep-14 +-0x1.aed954b50e034p-12 +-0x1.abe4715b45fd2p-13 +-0x1.369051580c529p-13 +-0x1.64c82feec1f21p-18 +-0x1.085c2de3cd0a7p-11 +-0x1.7aedf2f80a2c9p-14 +-0x1.f75fee163823dp-9 +-0x1.1de794fd95993p-16 +-0x1.eaffa1b16a892p-14 +-0x1.aad83952b7fccp-12 +-0x1.a7ea5ed0b5ddfp-13 +-0x1.33ad66ec49b93p-13 +-0x1.61774de357543p-18 +-0x1.05e7318be1848p-11 +-0x1.77685f66bb9ep-14 +-0x1.f8e05b2b4fca5p-9 +-0x1.81a95ee8ce11fp-15 +-0x1.4b287d0c4c3f5p-12 +-0x1.bda1681e574a6p-10 +-0x1.ba928d24c0953p-11 +-0x1.4137f2c248234p-11 +-0x1.dccbdd68c1271p-17 +-0x1.614919bf0d877p-10 +-0x1.87ee065939c25p-12 +-0x1.e0cfe40480c1cp-9 +-0x1.89b1aa26f2132p-15 +-0x1.520e2d77a8f3fp-12 +-0x1.c49e8d5e182a7p-10 +-0x1.c1836b55d82ccp-11 +-0x1.464198c98a1f7p-11 +-0x1.e6ba13983882ap-17 +-0x1.68a4c5167b0afp-10 +-0x1.8e1391bd2afefp-12 +-0x1.e53c16adaa65dp-9 +0x1.ecd32d8a4a5ecp+0 +0x1.ca4df2e8c0bb4p+0 +0x1.73d15d863b567p+0 +0x1.7409d88ceb74ep+0 +-0x1.20619103b86f5p-11 +-0x1.4d5fa331bb3f4p-9 +-0x1.3dd59f3e5b381p-11 +-0x1.672f9649d7aep-9 +-0x1.6934b675e41a9p-11 +-0x1.84f59b5c8de9fp-9 +-0x1.6adb592fc2446p-11 +-0x1.86c7667039584p-9 +-0x1.31bfb9467cep+1 +-0x1.27f974baf44eap+1 +-0x1.120a5a2a2cf54p+1 +-0x1.11f9aa79265dp+1 +0x1.1cd8876026d4ap+0 +0x1.303f34b596c0fp+0 +-0x1.257107172b0b9p-17 +0x1.ff8d05e401afep-1 +0x1.10d20811eeda1p+0 +-0x1.def8d63785d19p-18 +0x1.53ff85a835b5ep-1 +0x1.698d7f6e36702p-1 +-0x1.07877cc8177a6p-18 +0x1.53633905583a1p-1 +0x1.68e67632451b1p-1 +-0x1.fb0148a5489f6p-19 +0x1.0c561f5dae6cap+0 +0x1.fa9f046f2f1dap-1 +-0x1.7e2275271edb8p-17 +0x1.d816ea181870cp-1 +0x1.bfec938611029p-1 +-0x1.32f99f9288e16p-17 +0x1.2b615fc6b5812p-1 +0x1.1f742298872e7p-1 +-0x1.41c4202b4c7dep-18 +0x1.2accf23624d06p-1 +0x1.1ee84b14e0fcap-1 +-0x1.336592ad58eecp-18 +0x1.b8a6aa811e366p-1 +0x1.8a8dc18782901p-1 +-0x1.40b12dba392cfp-17 +0x1.83b7ae10f5f19p-1 +0x1.59df4e4f55b5ep-1 +-0x1.023e85801520ap-17 +0x1.ec086e5b10e1ep-2 +0x1.b314ed67ac80cp-2 +-0x1.111cf8243d279p-18 +0x1.eb14b62bfff02p-2 +0x1.b23a64875f1a3p-2 +-0x1.053122134b5acp-18 +0x1.2056124340689p+0 +0x1.487b8a9b7d47bp+0 +-0x1.f956356977e6ap-18 +0x1.fe3bb8f0c55aep-1 +0x1.1cc71a1770ac2p+0 +-0x1.960eb29245972p-18 +0x1.47ff55f83eab1p-1 +0x1.5cb0577f0a575p-1 +-0x1.a9d0bdbe98653p-19 +0x1.476033fdc6288p-1 +0x1.5bf9a2416b77cp-1 +-0x1.96da8ff79acb7p-19 +0x1.339a5319e2cd6p+0 +0x1.258de4f362327p+0 +-0x1.7d18c2053e0f9p-18 +0x1.11464799cba1ep+0 +0x1.04bcaf3f8358dp+0 +-0x1.327f75626305dp-18 +0x1.62a64f0dccd45p-1 +0x1.5235e89bf3bcp-1 +-0x1.422b724eb2184p-19 +0x1.61fccfcfbd745p-1 +0x1.5194239381974p-1 +-0x1.33f586579d21ep-19 +0x1.8716c0928457p-1 +0x1.c08e747a95649p-1 +-0x1.69ce1d102ed72p-18 +0x1.5ede20fb6b4d7p-1 +0x1.92b80c9023d92p-1 +-0x1.27f76183e2d21p-18 +0x1.d17fd3dd2d65cp-2 +0x1.0b93a6c800c9ap-1 +-0x1.49860ca621cap-19 +0x1.d0a9280cdefc7p-2 +0x1.0b18944e6a337p-1 +-0x1.3d31d9cb4da33p-19 +-0x1.75ecb210f9dfbp-17 +-0x1.411472970cep-14 +-0x1.1720b40cd598cp-12 +-0x1.15365972e80b8p-13 +-0x1.926693ba43594p-14 +-0x1.ce49298e91cd7p-19 +-0x1.5688aa81bdb55p-12 +-0x1.eafb9fc3230ecp-15 +-0x1.a389ae4a5afe2p-9 +-0x1.73697db47f14dp-17 +-0x1.3eec24c70d2eep-14 +-0x1.1540905f8bebp-12 +-0x1.13598140142a1p-13 +-0x1.8fb26406c7929p-14 +-0x1.cb2df6b634729p-19 +-0x1.543b75482f1a6p-12 +-0x1.e7af1051ee174p-15 +-0x1.acfcbb86cf42ap-9 +-0x1.1752527b48ce1p-15 +-0x1.dfb172f9b27f7p-13 +-0x1.5d4883965ce3cp-10 +-0x1.5ae2ea549b7d5p-11 +-0x1.f78a178e411c2p-12 +-0x1.5953ce0b6aa9ep-17 +-0x1.ffbed20e9240ap-11 +-0x1.3331601be95a8p-12 +-0x1.9a35a0abeafd6p-9 +-0x1.1b7f0de16f9c2p-15 +-0x1.e6dcd64a03debp-13 +-0x1.6138f9efeebd9p-10 +-0x1.5ecc7513eb27dp-11 +-0x1.fd37ed893315ep-12 +-0x1.5e7d1619031afp-17 +-0x1.03b26c42ebd0ap-10 +-0x1.36a8501e4f461p-12 +-0x1.9c403f105e4dbp-9 +0x1.ee4b3b91e0ed9p+0 +0x1.cb4a9951b742cp+0 +0x1.6e8d56ca2addfp+0 +0x1.73226a2f32938p+0 +-0x1.e7ba097e0efdep-12 +-0x1.1a429aaf2f4b7p-9 +-0x1.0e2b18014341dp-11 +-0x1.31939ce089486p-9 +-0x1.378aa07a3caaep-11 +-0x1.4ead75e729e82p-9 +-0x1.3597e62878978p-11 +-0x1.4d578e6b5937ep-9 +-0x1.3230e685aa51bp+1 +-0x1.28423469f272ep+1 +-0x1.10c3890791b5p+1 +-0x1.11bd8ea8b90c6p+1 +0x1.1e0c97c83cc53p+0 +0x1.318d2628a7161p+0 +-0x1.b6621ce998ebep-18 +0x1.00b0d798084e3p+0 +0x1.11cec5dd586adp+0 +-0x1.687e6b8fd7611p-18 +0x1.47eaa7d3e8c9dp-1 +0x1.5ca4e5cbc07e9p-1 +-0x1.79ad3d046b105p-19 +0x1.512ec22221b9ep-1 +0x1.668b415568d16p-1 +-0x1.78c57ea2fd0bdp-19 +0x1.0db8360073a5ap+0 +0x1.fd1dfc1c1abb2p-1 +-0x1.1a202822f9369p-17 +0x1.da10580405c7dp-1 +0x1.c1baea19c6009p-1 +-0x1.c7d23c9cb8d1ap-18 +0x1.1ff1bb1c17e04p-1 +0x1.14abad0cd96bcp-1 +-0x1.c05bd873e8f75p-19 +0x1.28b5562b311bcp-1 +0x1.1cef91ab869eap-1 +-0x1.be1674f9de003p-19 +0x1.baeae7b3218c1p-1 +0x1.8ca607f507f1ap-1 +-0x1.da2d379bfd948p-18 +0x1.85560fda3589ap-1 +0x1.5b5ab69f8691dp-1 +-0x1.801e53a5f43f6p-18 +0x1.d9410bc684a35p-2 +0x1.a240c62dcd9f3p-2 +-0x1.7e4b4ce536189p-19 +0x1.e7a53ae09f9c8p-2 +0x1.af25e7588f156p-2 +-0x1.7c7228e75e63dp-19 +0x1.21bf4bb0502a1p+0 +0x1.4a635bccf18c6p+0 +-0x1.75320f19b2ee2p-18 +0x1.0023c6a5507b7p+0 +0x1.1e17aa05eb0fep+0 +-0x1.2d930b5f39093p-18 +0x1.3bb9b80603bdep-1 +0x1.4ea489ba82dcdp-1 +-0x1.28d11dc5e55dbp-19 +0x1.4521d64682ef9p-1 +0x1.5966af3f36e75p-1 +-0x1.2758a5bde9501p-19 +0x1.350d386ffde67p+0 +0x1.26f096f56f2c4p+0 +-0x1.19ab9de03834ap-18 +0x1.125674fc197d3p+0 +0x1.05c0cd05bdaa6p+0 +-0x1.c7afae4eb8333p-19 +0x1.5591f2988844dp-1 +0x1.45ba4ef5fd684p-1 +-0x1.c1e7af1062d25p-20 +0x1.5f98f0ddb5835p-1 +0x1.4f4c2b1252331p-1 +-0x1.bfc9c0bb8d101p-20 +0x1.88c1bacfdd924p-1 +0x1.c27458f38093cp-1 +-0x1.0e3c83140846bp-18 +0x1.6021de32a8038p-1 +0x1.942971d16f74cp-1 +-0x1.bd9faa8e94deep-19 +0x1.c0e87d1f4d276p-2 +0x1.021058575aadbp-1 +-0x1.d9e0ab82e8595p-20 +0x1.cda1e9c7f46edp-2 +0x1.095c1d7fc1c61p-1 +-0x1.d8863b04e1804p-20 +-0x1.e36147cf50815p-18 +-0x1.9f11095530728p-15 +-0x1.68d59ee2714ddp-13 +-0x1.665bbac53b33cp-14 +-0x1.0418950682bf8p-14 +-0x1.2acd9c7e0bb78p-19 +-0x1.baccf0a6c2979p-13 +-0x1.3d5a22c855308p-15 +-0x1.642d112ba7126p-9 +-0x1.e19ceba157e85p-18 +-0x1.9d8c9b1ff6ec2p-15 +-0x1.6783f14e4df7dp-13 +-0x1.650c5e67330d1p-14 +-0x1.03252d7bc951p-14 +-0x1.29b5fbb3d89a7p-19 +-0x1.b92e8e2967aacp-13 +-0x1.3c312654717c6p-15 +-0x1.6da80b2264ebap-9 +-0x1.94b2461c60b03p-16 +-0x1.5b80bb1829951p-13 +-0x1.11b657aae57d3p-10 +-0x1.0fd580897d7c8p-11 +-0x1.8a97f2ebf592fp-12 +-0x1.f45445904a3f7p-18 +-0x1.72b8ed2d2e5efp-11 +-0x1.e175077a94858p-13 +-0x1.5e86770114393p-9 +-0x1.97f5425077906p-16 +-0x1.5e4db64d568a1p-13 +-0x1.13619730f57c5p-10 +-0x1.117dd17f9308ep-11 +-0x1.8cffe2a58059bp-12 +-0x1.f85c91f7ebd41p-18 +-0x1.75b5d0ad7c674p-11 +-0x1.e4648ded69f7bp-13 +-0x1.5f5a5e2633098p-9 +0x1.ef9d54fef756dp+0 +0x1.cbc1f6822227ap+0 +0x1.6b2cc1f59f175p+0 +0x1.73819598eaf2dp+0 +-0x1.9ce710d28d01p-12 +-0x1.de71b6fca610ep-10 +-0x1.c9b09b4c3081ep-12 +-0x1.02f704658adacp-9 +-0x1.0afa9f61e14e7p-11 +-0x1.1e62cac1b2a32p-9 +-0x1.08080361ff109p-11 +-0x1.1c646342b0739p-9 +-0x1.3298232a9d291p+1 +-0x1.2863e24a57699p+1 +-0x1.0ff75376f3027p+1 +-0x1.11d2cdea931abp+1 +0x1.1f2391231a3b4p+0 +0x1.32bba0e4559aep+0 +-0x1.48783c7e31bdp-18 +0x1.011cf16fb4339p+0 +0x1.124360ee4d92ap+0 +-0x1.0c5ce949d2c0ap-18 +0x1.403be76c8e138p-1 +0x1.547048cf64475p-1 +-0x1.1459eeecded79p-19 +0x1.51f68a5cae425p-1 +0x1.6760be5a49f7fp-1 +-0x1.1df1cba3264f9p-19 +0x1.0ef9c6e5cfc48p+0 +0x1.ff61eaf2a9de7p-1 +-0x1.a13cb6c254d6ep-18 +0x1.daf9cf44a8b03p-1 +0x1.c2906a2b71f59p-1 +-0x1.4dccf70bad3c5p-18 +0x1.18b63716c43c2p-1 +0x1.0dd78cdec423p-1 +-0x1.3e75d3da8e667p-19 +0x1.2972d460a1c47p-1 +0x1.1da227179e60bp-1 +-0x1.4a60878577e23p-19 +0x1.bcf9d5f2182dcp-1 +0x1.8e8d3bc6a0c7cp-1 +-0x1.5f2e218e4944dp-18 +0x1.8615780eb688cp-1 +0x1.5c09ffff36191p-1 +-0x1.19e1ffc4af9abp-18 +0x1.cd6089fb3a269p-2 +0x1.979eaa8c67efp-2 +-0x1.10dd7593f9a25p-19 +0x1.e8dc61fcff926p-2 +0x1.b03cd81d5643p-2 +-0x1.1ad7083b45032p-19 +0x1.23071dcdece03p+0 +0x1.4c1f02006774fp+0 +-0x1.140df608faedp-18 +0x1.009cb7ffc542ep+0 +0x1.1eb33d69091e7p+0 +-0x1.b9de887c61ef5p-19 +0x1.33f3d4685fa2p-1 +0x1.45cb1304e4875p-1 +-0x1.a5dfc5fa1670cp-20 +0x1.45ed1086b0e2dp-1 +0x1.5a4fbfce0abbbp-1 +-0x1.b5b1a96e4524cp-20 +0x1.365da3c8ef346p+0 +0x1.283252eae80acp+0 +-0x1.a116e4cda8b4p-19 +0x1.12d41b8e6310ep+0 +0x1.0638e29d4836bp+0 +-0x1.4e365a77b059bp-19 +0x1.4d46cff4a4421p-1 +0x1.3dd027469992ep-1 +-0x1.40534cb2f400ep-20 +0x1.607174b9291afp-1 +0x1.501acf4c21d8bp-1 +-0x1.4c55adbbc0d6fp-20 +0x1.8a44721af0a2ap-1 +0x1.c42c5e6e9adcap-1 +-0x1.94ed04ab2ef69p-19 +0x1.60b739604d16cp-1 +0x1.94d3daf074e1fp-1 +-0x1.4bd97bb9199fdp-19 +0x1.b65c3f60bad16p-2 +0x1.f8079819fdd24p-2 +-0x1.5bec274358aaep-20 +0x1.ceb44abeab4d9p-2 +0x1.09f96cc867a35p-1 +-0x1.675d390b685dcp-20 +-0x1.378bd913722d5p-18 +-0x1.0b8463d321ae5p-15 +-0x1.d120b2ed1278bp-14 +-0x1.cdef9790d3131p-15 +-0x1.4f45c32547d4cp-15 +-0x1.812ac1763d3e9p-20 +-0x1.1d6464b5869fbp-13 +-0x1.9913d75ccf5bdp-16 +-0x1.2e98bd634f1e8p-9 +-0x1.378bd913722d6p-18 +-0x1.0b8463d321ae6p-15 +-0x1.d120b2ed1278cp-14 +-0x1.cdef9790d3133p-15 +-0x1.4f45c32547d4dp-15 +-0x1.812ac1763d3ebp-20 +-0x1.1d6464b5869fdp-13 +-0x1.9913d75ccf5bep-16 +-0x1.3636d845662b5p-9 +-0x1.253cb786ac8c9p-16 +-0x1.f79754bbeada4p-14 +-0x1.acdc68b32391p-11 +-0x1.a9eb036408835p-12 +-0x1.35217a4459239p-12 +-0x1.6a880530bc0bep-18 +-0x1.0c9ebe7ea87e9p-11 +-0x1.792e5ad688d2ep-13 +-0x1.2aa5a8aa7ad26p-9 +-0x1.253cb786ac8c9p-16 +-0x1.f79754bbeada4p-14 +-0x1.acdc68b32391p-11 +-0x1.a9eb036408835p-12 +-0x1.35217a4459239p-12 +-0x1.6a880530bc0bep-18 +-0x1.0c9ebe7ea87e9p-11 +-0x1.792e5ad688d2ep-13 +-0x1.2c02fab1f735dp-9 +0x1.f27527a4acfb7p+0 +0x1.ccbee837aa24cp+0 +0x1.6a04a56819cf1p+0 +0x1.75d554abbe7a1p+0 +-0x1.43329d042d1cp-12 +-0x1.77541fae8c458p-10 +-0x1.65b71d6cfa719p-12 +-0x1.95257ed0ec8d2p-10 +-0x1.a409db04a5f06p-12 +-0x1.c26cc1e1a7e02p-10 +-0x1.a325b0d15d49ap-12 +-0x1.c4192ed4cb279p-10 +-0x1.33764bedb868ep+1 +-0x1.28a9fd21ef0e6p+1 +-0x1.0fb29d81144b9p+1 +-0x1.126abac55abc6p+1 +0x1.2175611a9472ap+0 +0x1.353fb2faad573p+0 +-0x1.b7fd897ef9b17p-19 +0x1.01fd2f9506564p+0 +0x1.1335497bd1609p+0 +-0x1.5f1cd87e9397cp-19 +0x1.3da0271b9b98cp-1 +0x1.51a7382136e3p-1 +-0x1.6b6a2cba964ccp-20 +0x1.5782eadcfc35ap-1 +0x1.6d4ec0a75f125p-1 +-0x1.8bc1db34253abp-20 +0x1.11a9318223eb1p+0 +0x1.021c4492cfe52p+0 +-0x1.11cffa388a3dcp-18 +0x1.dcdeb846e39fep-1 +0x1.c44bbb900074dp-1 +-0x1.a8fd5ac39c36ep-19 +0x1.164358d1f9bcap-1 +0x1.0b8747a3ec623p-1 +-0x1.90cf7288a9313p-20 +0x1.2eb87af8b4311p-1 +0x1.22998b951daf7p-1 +-0x1.b928674cfb4ecp-20 +0x1.c1603786c9c8ep-1 +0x1.929f5287fca6bp-1 +-0x1.ce0b3e2fa40fp-19 +0x1.87a30483af972p-1 +0x1.5d76230eac2ep-1 +-0x1.6828d17a01e7cp-19 +0x1.c95b14686423p-2 +0x1.940578cced91dp-2 +-0x1.59eebdbf57099p-20 +0x1.f184801af41aap-2 +0x1.b8002b1057bd2p-2 +-0x1.7bce54f897e2fp-20 +0x1.25c32da975c8cp+0 +0x1.4fd5738dff9cap+0 +-0x1.6a8498f8d704fp-19 +0x1.0197d6541ed5cp+0 +0x1.1ff6996583848p+0 +-0x1.197c40ccdcba2p-19 +0x1.315195008c567p-1 +0x1.42cd8d80428c2p-1 +0x1.412ffd5bf8288p+3 +0x1.497062ae923eep+3 +0x1.422aec47428bdp+3 +0x1.4378ff5881715p+3 +0x1.412ffd5bf8288p+3 +0x1.497062ae923eep+3 +0x1.422aec47428bdp+3 +0x1.4378ff5881715p+3 +-0x1.c4bd44b64b961p-4 +-0x1.c4bd44b64b961p-4 +-0x1.7979d430e86cap-3 +-0x1.c4bd44b64b961p-4 +0x1.f90a8003589e3p-3 +0x1.f90a8003589e3p-3 +0x1.67f4c06c9e0fbp-3 +0x1.f90a8003589e3p-3 +0x1.4f2558353976cp-3 +0x1.4f2558353976cp-3 +0x1.7958b256356e3p-4 +0x1.4f2558353976cp-3 +-0x1.1f127ce667d2ap-2 +-0x1.1f127ce667d2ap-2 +-0x1.6c141279d1283p-2 +-0x1.1f127ce667d2ap-2 +-0x1.5e3ecb3298dfp-3 +-0x1.c4bd44b64b961p-4 +-0x1.7979d430e86cap-3 +-0x1.e8ce662b6c807p-3 +-0x1.410d2cca47988p-2 +-0x1.e873ae43fc5cp-3 +-0x1.40df6f916dcccp-2 +-0x1.e873833a2f033p-3 +0x1.77636a8d7a1e5p-3 +0x1.f90a8003589e3p-3 +0x1.67f4c06c9e0fbp-3 +0x1.ef726a644fb28p-4 +0x1.9223013bd52c4p-5 +0x1.f0296b806839fp-4 +0x1.9394047a6510dp-5 +0x1.f029c096e6763p-4 +0x1.a31e535616cb5p-4 +0x1.4f2558353976cp-3 +0x1.7958b256356e3p-4 +0x1.33adfb7405653p-5 +-0x1.1eb2cae060e94p-5 +0x1.34944e05653cbp-5 +-0x1.1dca920f779dcp-5 +0x1.34e91a3e67f73p-5 +-0x1.940d90a083a6p-2 +-0x1.1f127ce667d2ap-2 +-0x1.6c141279d1283p-2 +-0x1.0f49e06574dfap-1 +-0x1.36df30884a86bp-1 +-0x1.0ec41047475dcp-1 +-0x1.36583cc5a2edap-1 +-0x1.0ebde4fac48d2p-1 +-0x1.3d4a06c0e244ep-2 +-0x1.e873833a2f033p-3 +-0x1.40df59de61ad6p-2 +-0x1.e97009e282b8fp-2 +-0x1.1c13816d70449p-1 +-0x1.d97b152a70749p-2 +-0x1.1407b218d61a4p-1 +-0x1.d9a62efb9f3e5p-2 +-0x1.141d6dccf12cfp-1 +-0x1.d9a5cd8c2073dp-2 +-0x1.d9a5cd8c2073dp-2 +-0x1.141d3cab6847ep-1 +-0x1.a4095fb21516bp-2 +-0x1.f229cd2d97617p-2 +-0x1.a4d44675cccdbp-2 +-0x1.f2f66b41f7136p-2 +-0x1.a4d2753f5d998p-2 +0x1.c5f1490c3bd0bp-10 +0x1.f029c096e6763p-4 +0x1.9394b00ceff45p-5 +-0x1.f8c9f85174816p-4 +-0x1.93b79b4ed3285p-3 +-0x1.f4862070b6791p-4 +-0x1.9191244b68f78p-3 +-0x1.f47216265eb4p-4 +-0x1.67fb4fc2464abp-5 +0x1.34e91a3e67f73p-5 +-0x1.1d7512d113a1p-5 +-0x1.98bb6769f87f3p-3 +-0x1.18adea04cc457p-2 +-0x1.153d5fb91ee2ep-3 +-0x1.acc4f29793373p-3 +-0x1.17c8530e44253p-3 +-0x1.af5551cd47091p-3 +-0x1.17c1710c9179fp-3 +-0x1.17c1710c9179fp-3 +-0x1.af4e611eb6bf7p-3 +0x1.022cc38fc3ae2p-6 +-0x1.d2c3aa604d14cp-5 +0x1.65464e254d5fap-7 +-0x1.fadc8bbc0db3p-5 +0x1.66f3b087b875cp-7 +-0x1.6384123ccc10cp-1 +-0x1.0ebde4fac48d2p-1 +-0x1.365204072dcedp-1 +-0x1.dee54ecbf8798p-1 +-0x1.042217515615bp+0 +-0x1.c7ee328532d06p-1 +-0x1.f119f526f49cap-1 +-0x1.c82cff6f2c891p-1 +-0x1.f1594dac82a69p-1 +-0x1.c82c8eb3ec496p-1 +-0x1.c82c8eb3ec496p-1 +-0x1.f158dbf6a661fp-1 +-0x1.601c4dec29b2fp-1 +-0x1.88628a7f882f5p-1 +-0x1.62a98b2a8a4ccp-1 +-0x1.8af56420a4acbp-1 +-0x1.62a4c33216506p-1 +-0x1.199aa1b9dba25p-1 +-0x1.d9a5cd8c2073dp-2 +-0x1.141d3cab6847ep-1 +-0x1.b7ae5f62e3b9ap-1 +-0x1.e0b60aa67261ep-1 +-0x1.98c3ee5864e52p-1 +-0x1.c1871ad282e7fp-1 +-0x1.99297727a7d6ap-1 +-0x1.c1ed843894a89p-1 +-0x1.9928b419970ddp-1 +-0x1.234ad14a68983p-2 +-0x1.f47216265eb4p-4 +-0x1.918709cd6a56cp-3 +-0x1.090f27323804p-1 +-0x1.3096e4bcd8036p-1 +-0x1.bd0464c0f7d69p-2 +-0x1.05ad78ce3bcadp-1 +-0x1.beac9b95ed0b5p-2 +-0x1.0683601a4d801p-1 +-0x1.bea8881ec21c4p-2 +-0x1.bea8881ec21c4p-2 +-0x1.068151f3787bep-1 +-0x1.009fa122f4782p-2 +-0x1.4d5fd1da71dd4p-2 +-0x1.06cfbca4e63a1p-2 +-0x1.539d35414ddf1p-2 +-0x1.06c06e4bb4c4dp-2 +-0x1.2b7a0ea11ca7p-2 +-0x1.17c1710c9179fp-3 +-0x1.af4e611eb6bf7p-3 +-0x1.f95b59fbc5eeap-2 +-0x1.241a77cbc1452p-1 +-0x1.b3efd71f3474fp-2 +-0x1.01195aba2ebe1p-1 +-0x1.b5278d75db0f7p-2 +-0x1.01b687a5739bp-1 +-0x1.b52494d1844ffp-2 +-0x1.260999c0b5b65p+0 +-0x1.c82c8eb3ec496p-1 +-0x1.f158dbf6a661fp-1 +-0x1.8264e7647718p+0 +-0x1.9860e22774fd2p+0 +-0x1.62aecc8bc3953p+0 +-0x1.7862278e6fd2dp+0 +-0x1.630fa948ef284p+0 +-0x1.78c3e16914a23p+0 +-0x1.630f2844a8341p+0 +-0x1.e726c7a8e2d38p-1 +-0x1.9928b419970ddp-1 +-0x1.c1ecbf7b0de13p-1 +-0x1.661aa1ca0db0fp+0 +-0x1.7bd5ccc2b036ap+0 +-0x1.4590054cea6dcp+0 +-0x1.5b011a7e3a2adp+0 +-0x1.4600b40aa9ff5p+0 +-0x1.5b72c8eb7112bp+0 +-0x1.46000e449ad48p+0 +-0x1.53a3a63007d6dp-1 +-0x1.bea8881ec21c4p-2 +-0x1.068151f3787bep-1 +-0x1.e0610095d8bedp-1 +-0x1.04e1974dc117cp+0 +-0x1.b7f4a7f8ed396p-1 +-0x1.e0fcef35e61fep-1 +-0x1.b894fea3d06e9p-1 +-0x1.e19ea9b883f4ep-1 +-0x1.b893b3240b9bbp-1 +-0x1.52d8530891ce5p-1 +-0x1.b52494d1844ffp-2 +-0x1.01b5081b13899p-1 +-0x1.abc669afdac3dp-1 +-0x1.d4b3ad3e60496p-1 +-0x1.b52b66878afefp-1 +-0x1.de2d7f1c6a322p-1 +-0x1.b51c4c6982797p-1 +-0x1.de1e437d130c4p-1 +-0x1.b51c6ba2b1b09p-1 +-0x1.bc3e04278687ap+0 +-0x1.630f2844a8341p+0 +-0x1.78c35f3e467fp+0 +-0x1.05b3fe20acd4cp+1 +-0x1.11519853b8f8fp+1 +-0x1.08b86881411d1p+1 +-0x1.145d24648d6c6p+1 +-0x1.08b68e7cc0268p+1 +-0x1.85969303bae6ap+0 +-0x1.46000e449ad48p+0 +-0x1.5b7221ad3652dp+0 +-0x1.e72cb18a079dcp+0 +-0x1.fe129f25e11a5p+0 +-0x1.ed7044b25d307p+0 +-0x1.0232729e3dcdfp+1 +-0x1.ed6bd566569bap+0 +-0x1.288904051982fp+0 +-0x1.b893b3240b9bbp-1 +-0x1.e19d5b5904fc8p-1 +-0x1.6d84a9e39b195p+0 +-0x1.8350c7d9eba03p+0 +-0x1.752ff5a0dcf77p+0 +-0x1.8b0da2c0e9d2fp+0 +-0x1.752836fe134ffp+0 +-0x1.8b05d25f1d48ep+0 +-0x1.752842d99f051p+0 +-0x1.1a1263418cc55p+0 +-0x1.b51c6ba2b1b09p-1 +-0x1.de1e62fb87c2fp-1 +-0x1.69b8eee786c75p+0 +-0x1.7f7c5e9dc61b8p+0 +-0x1.710c00a66ccacp+0 +-0x1.86e03204358ddp+0 +-0x1.7104846567932p+0 +-0x1.86d8a4a005afbp+0 +-0x1.71048fbc4e6abp+0 +-0x1.3d9978bb98af1p+1 +-0x1.08b68e7cc0268p+1 +-0x1.145b45fefbe08p+1 +-0x1.78ffa590dec13p+1 +-0x1.85b3dd60774bep+1 +-0x1.7bdf62b4198d5p+1 +-0x1.889ab571c3285p+1 +-0x1.7bdec28e0eea6p+1 +-0x1.273c0a67bd5bfp+1 +-0x1.ed6bd566569bap+0 +-0x1.023035c35b02ap+1 +-0x1.639e5856d43fdp+1 +-0x1.701df361d7112p+1 +-0x1.66eab54b86f2cp+1 +-0x1.737266f533b8p+1 +-0x1.66e9bf03737dbp+1 +-0x1.c58f43ad87c8fp+0 +-0x1.752842d99f051p+0 +-0x1.8b05de55d49e9p+0 +-0x1.1b8bf9085875bp+1 +-0x1.275d661ad1ad9p+1 +-0x1.20336f7feda56p+1 +-0x1.2c0ff62d159d6p+1 +-0x1.2030e992a5f7ap+1 +-0x1.80902453e86edp+0 +-0x1.71048fbc4e6abp+0 +-0x1.86d8b010e28e2p+0 +-0x1.1394fce1e5821p+1 +-0x1.1f53772965793p+1 +-0x1.17a8163c01b86p+1 +-0x1.23704028796d4p+1 +-0x1.17a59cf550cf3p+1 +-0x1.b192cf1fe3cbp+1 +-0x1.7bdec28e0eea6p+1 +-0x1.889a13bf939d3p+1 +-0x1.019289d67a87p+2 +-0x1.089bd21e6c2a5p+2 +-0x1.02138b00af19p+2 +-0x1.091e22ea99561p+2 +-0x1.02139b52faa5ep+2 +-0x1.a63dd1fa1775cp+1 +-0x1.66e9bf03737dbp+1 +-0x1.73716e50ca689p+1 +-0x1.ed3a5477e86bep+1 +-0x1.fb141c2ebf13ep+1 +-0x1.eec9c479de056p+1 +-0x1.fca79340d677ep+1 +-0x1.eec9dd18dad15p+1 +-0x1.424d898867e7fp+1 +-0x1.2030e992a5f7ap+1 +-0x1.2c0d6a39dfa0fp+1 +-0x1.963c7bbe32d78p+1 +-0x1.a33958ff8cd98p+1 +-0x1.999c33f5a73cfp+1 +-0x1.a6a180918b4fbp+1 +-0x1.999b77b24065cp+1 +-0x1.0d5c7628c5cd1p+1 +-0x1.17a59cf550cf3p+1 +-0x1.236dc0ff2702cp+1 +-0x1.84cf47aef4ccap+1 +-0x1.91a0bf69ed311p+1 +-0x1.87e661a2f5fcbp+1 +-0x1.94bf860f8081bp+1 +-0x1.87e584e98f2ap+1 +-0x1.13cc02822d798p+2 +-0x1.02139b52faa5ep+2 +-0x1.091e33675d988p+2 +-0x1.4ad753d412748p+2 +-0x1.52a4447116cddp+2 +-0x1.4a578b9166f23p+2 +-0x1.52231e2b36ddep+2 +-0x1.4a575753d5425p+2 +-0x1.18322fb3b7b28p+2 +-0x1.eec9dd18dad15p+1 +-0x1.fca7ac1f65ba7p+1 +-0x1.418aef1e601d3p+2 +-0x1.493e7b4e13421p+2 +-0x1.412c0d954ef48p+2 +-0x1.48de97887bbacp+2 +-0x1.412bea5598b56p+2 +-0x1.b9bb45e29fbc7p+1 +-0x1.999b77b24065cp+1 +-0x1.a6a0c2772c492p+1 +-0x1.0f1cf187c43dbp+2 +-0x1.16499f0e2be8fp+2 +-0x1.0f9d0a219c477p+2 +-0x1.16cb08331797bp+2 +-0x1.0f9d19404820fp+2 +-0x1.7d2480abccf98p+1 +-0x1.87e584e98f2ap+1 +-0x1.94bea7319cbb7p+1 +-0x1.01d80ea920a16p+2 +-0x1.08e20bcb60a2dp+2 +-0x1.0274dd02959cdp+2 +-0x1.098072345d1f2p+2 +-0x1.0274e509a79c6p+2 +-0x1.4698be761ef08p+2 +-0x1.4a575753d5425p+2 +-0x1.5222e95e9385bp+2 +-0x1.963b6650b94c8p+2 +-0x1.9edc4054a81c6p+2 +-0x1.952dc19c7a3cbp+2 +-0x1.9dcb92c1e4abp+2 +-0x1.952d23da600ap+2 +-0x1.4c5dc7718bcd3p+2 +-0x1.412bea5598b56p+2 +-0x1.48de73e8d8ec3p+2 +-0x1.8e7b34db33df3p+2 +-0x1.9705c6c73090cp+2 +-0x1.8d701874fb7dcp+2 +-0x1.95f7acb7b900bp+2 +-0x1.8d6f800e2822ap+2 +-0x1.1a9289769e8b8p+2 +-0x1.0f9d19404820fp+2 +-0x1.16cb17797e93bp+2 +-0x1.57ece71697d45p+2 +-0x1.5fddd99cace7fp+2 +-0x1.577671be1df23p+2 +-0x1.5f661cdc59529p+2 +-0x1.577641e9d316dp+2 +-0x1.f1cef1afd7d1dp+1 +-0x1.0274e509a79c6p+2 +-0x1.09807a5054462p+2 +-0x1.46e0e920d1735p+2 +-0x1.4ea302704815cp+2 +-0x1.469e852c82bcp+2 +-0x1.4e5fe91d312d7p+2 +-0x1.469e6e7b958cp+2 +-0x1.73374b108726fp+2 +-0x1.952d23da600ap+2 +-0x1.9dcaf3396e6d1p+2 +-0x1.e3626d1fe5ac7p+2 +-0x1.ece744848f856p+2 +-0x1.e215944c75caap+2 +-0x1.eb967c3a7df07p+2 +-0x1.e214b167cf195p+2 +-0x1.6e02187c4088bp+2 +-0x1.8d6f800e2822ap+2 +-0x1.95f7129c32063p+2 +-0x1.db6d1caa08e9ep+2 +-0x1.e4d9ea55ea466p+2 +-0x1.da25a2917b903p+2 +-0x1.e38e95f49c02fp+2 +-0x1.da24c63e04955p+2 +-0x1.45f16c63122abp+2 +-0x1.577641e9d316dp+2 +-0x1.5f65ec83e1fa3p+2 +-0x1.a263ffc648431p+2 +-0x1.ab2808604e8c2p+2 +-0x1.a163def33382fp+2 +-0x1.aa24ffb833262p+2 +-0x1.a1634a23a92e5p+2 +-0x1.3cd341469f1b1p+2 +-0x1.469e6e7b958cp+2 +-0x1.4e5fd22e482afp+2 +-0x1.91970fb0c3f15p+2 +-0x1.9a2a8e04669a7p+2 +-0x1.90ac9c44c9dd6p+2 +-0x1.993d792583eabp+2 +-0x1.90ac1bdd6a7a3p+2 +-0x1.9caff23cb71bep+2 +-0x1.e214b167cf195p+2 +-0x1.eb9596a75be45p+2 +-0x1.194e94944d13cp+3 +-0x1.1e8bed32e3bbfp+3 +-0x1.189afc7b40027p+3 +-0x1.1dd61a9538fdap+3 +-0x1.189a782c33d29p+3 +-0x1.873f80535d74cp+2 +-0x1.da24c63e04955p+2 +-0x1.e38db709d7633p+2 +-0x1.143d67866410fp+3 +-0x1.196ab21efe8e9p+3 +-0x1.139417edaa061p+3 +-0x1.18bf4be8f463fp+3 +-0x1.13939cfeea52ap+3 +-0x1.638b0cac3914fp+2 +-0x1.a1634a23a92e5p+2 +-0x1.aa246938a22aep+2 +-0x1.ed463a493be36p+2 +-0x1.f6e91bc29255dp+2 +-0x1.ec134c04f61bp+2 +-0x1.f5b286b308149p+2 +-0x1.ec127ce084a91p+2 +-0x1.7c84d1ef97a83p+2 +-0x1.90ac1bdd6a7a3p+2 +-0x1.993cf74d6b9bfp+2 +-0x1.e0b666ee63b17p+2 +-0x1.ea3328cda97a8p+2 +-0x1.df6509f3642b6p+2 +-0x1.e8ddd066b57a2p+2 +-0x1.df642792839e9p+2 +-0x1.c077f0a3958f1p+2 +-0x1.189a782c33d29p+3 +-0x1.1dd594a20b86fp+3 +-0x1.41f33a03f9ffap+3 +-0x1.47b4de2b06f98p+3 +-0x1.413bc6c4b9a8ap+3 +-0x1.46fb07e6f794ep+3 +-0x1.413b391fad3efp+3 +-0x1.97acd4781145dp+2 +-0x1.13939cfeea52ap+3 +-0x1.18becf76307e3p+3 +-0x1.3ac954cc8e24dp+3 +-0x1.4073333236d56p+3 +-0x1.3a24b87a8e4afp+3 +-0x1.3fcc770dc0595p+3 +-0x1.3a243bc06389cp+3 +-0x1.7cbed64a20abbp+2 +-0x1.ec127ce084a91p+2 +-0x1.f5b1b517f2884p+2 +-0x1.1c70e831964f4p+3 +-0x1.21b83b662b65ep+3 +-0x1.1bd0994a2b1dcp+3 +-0x1.2115ed5110002p+3 +-0x1.1bd024c4a7237p+3 +-0x1.99ec73e5f74ep+2 +-0x1.df642792839e9p+2 +-0x1.e8dceb5a0f39fp+2 +-0x1.184ba539a972fp+3 +-0x1.1d85c76fa0108p+3 +-0x1.1796e44cad4dap+3 +-0x1.1ccec900c7677p+3 +-0x1.17965fed5fbcp+3 +-0x1.d56ab845a270bp+2 +-0x1.413b391fad3efp+3 +-0x1.46fa786a55a78p+3 +-0x1.6b1f5002990a7p+3 +-0x1.716d5b56933e9p+3 +-0x1.6a6cc0036c708p+3 +-0x1.70b85cb5821bdp+3 +-0x1.6a6c31b536b6ep+3 +-0x1.9f87d86718c65p+2 +-0x1.3a243bc06389cp+3 +-0x1.3fcbf8b7ad522p+3 +-0x1.614793f45cf74p+3 +-0x1.677378e679715p+3 +-0x1.60abc4820b495p+3 +-0x1.66d58ff2f72b6p+3 +-0x1.60ab4ae985f47p+3 +-0x1.850cf4c619cb1p+2 +-0x1.1bd024c4a7237p+3 +-0x1.211577582172ep+3 +-0x1.4202f84e701cbp+3 +-0x1.47c4d0eb26a64p+3 +-0x1.4169669e99b43p+3 +-0x1.47293fab14e19p+3 +-0x1.4168f26cc46a8p+3 +-0x1.909e6029545e2p+2 +-0x1.17965fed5fbcp+3 +-0x1.1cce42fda75c3p+3 +-0x1.3efda813970cep+3 +-0x1.44b57434b8dfdp+3 +-0x1.3e58b65df4f62p+3 +-0x1.440e5ef1984c2p+3 +-0x1.3e583912453p+3 +-0x1.dd1daef192b1cp+2 +-0x1.6a6c31b536b6ep+3 +-0x1.70b7cc7747aacp+3 +-0x1.9479ed2869267p+3 +-0x1.9b5b781561c74p+3 +-0x1.93d0c97645f56p+3 +-0x1.9aafec0b92883p+3 +-0x1.93d03f37aec86p+3 +-0x1.9cfd51fc7d6fbp+2 +-0x1.60ab4ae985f47p+3 +-0x1.66d514b71cafbp+3 +-0x1.877c837cb547bp+3 +-0x1.8e2f067fa6f54p+3 +-0x1.86ec318a6f76p+3 +-0x1.8d9cadbe8df97p+3 +-0x1.86ebbe3a06f71p+3 +-0x1.7bb367dcafbafp+2 +-0x1.4168f26cc46a8p+3 +-0x1.4728c9f6515a5p+3 +-0x1.66bc0a704fecep+3 +-0x1.6cfad0e0a174fp+3 +-0x1.66312632beeap+3 +-0x1.6c6e0a9b02219p+3 +-0x1.6630ba742ebap+3 +-0x1.74b8d6e1887dbp+2 +-0x1.3e583912453p+3 +-0x1.440de0062095bp+3 +-0x1.63dff421f5c97p+3 +-0x1.6a14d109a57fap+3 +-0x1.6352c368d1b1dp+3 +-0x1.6985b7d6e75d5p+3 +-0x1.63525600a9c59p+3 +-0x1.db644f02df6bp+2 +-0x1.93d03f37aec86p+3 +-0x1.9aaf5fd564efbp+3 +-0x1.bdd8fc52ee037p+3 +-0x1.c55496a9a13bcp+3 +-0x1.bd3aa58912d3ap+3 +-0x1.c4b3e5fb8caeap+3 +-0x1.bd3a211a0f76p+3 +-0x1.942a33a8413c2p+2 +-0x1.86ebbe3a06f71p+3 +-0x1.8d9c38cfbbfbap+3 +-0x1.ad5d586bab842p+3 +-0x1.b49ac9f1ec761p+3 +-0x1.acd8705ca1addp+3 +-0x1.b413f0f915aecp+3 +-0x1.acd803d68827ap+3 +-0x1.688086e205e9cp+2 +-0x1.6630ba742ebap+3 +-0x1.6c6d9d669f7d4p+3 +-0x1.8a5d9c84b70bap+3 +-0x1.911a7e19249bp+3 +-0x1.89e3139984dcfp+3 +-0x1.909e3b539b1a8p+3 +-0x1.89e2b2a9033a5p+3 +-0x1.514cc08b209dfp+2 +-0x1.63525600a9c59p+3 +-0x1.698548f4593fcp+3 +-0x1.86cf32e34efcp+3 +-0x1.8d7f46e5b51f3p+3 +-0x1.86592fc63d5bbp+3 +-0x1.8d079bd43df1bp+3 +-0x1.8658d2e711bdep+3 +-0x1.d03649ce8d432p+2 +-0x1.bd3a211a0f76p+3 +-0x1.c4b35f9546575p+3 +-0x1.e701bdab6fce6p+3 +-0x1.ef1d123af11d7p+3 +-0x1.e66f65b9e0708p+3 +-0x1.ee88771209571p+3 +-0x1.e66ee8a3f61a3p+3 +-0x1.8de79e71271ffp+2 +-0x1.acd803d68827ap+3 +-0x1.b41382dd5768ap+3 +-0x1.d35662e0b8508p+3 +-0x1.db2494d605e36p+3 +-0x1.d2d90f741d606p+3 +-0x1.daa55abd896bbp+3 +-0x1.d2d8a6c1c3651p+3 +-0x1.567e206b54fbep+2 +-0x1.89e2b2a9033a5p+3 +-0x1.909dd905a1561p+3 +-0x1.ad362a4eaa468p+3 +-0x1.b47309512967fp+3 +-0x1.acc8807b7de38p+3 +-0x1.b403c586856cdp+3 +-0x1.acc82802f9fcp+3 +-0x1.35e322f6f9999p+2 +-0x1.8658d2e711bdep+3 +-0x1.8d073da783b5dp+3 +-0x1.a87f214d38206p+3 +-0x1.afaa69c020ad6p+3 +-0x1.a818d6f6da05ap+3 +-0x1.af42a2d643f14p+3 +-0x1.a818850b13395p+3 +-0x1.cc9a830fd7e03p+2 +-0x1.e66ee8a3f61a3p+3 +-0x1.ee87f80d2db8dp+3 +-0x1.0854a3a17bcb2p+4 +-0x1.0cb6691dedd67p+4 +-0x1.080e6cd145b4cp+4 +-0x1.0c6f1143a4af3p+4 +-0x1.080e2f547dc14p+4 +-0x1.92d32f6a0ebb9p+2 +-0x1.d2d8a6c1c3651p+3 +-0x1.daa4f074b84e7p+3 +-0x1.fa4af989dc2d3p+3 +-0x1.0159aeec352f1p+4 +-0x1.f9ce88353b27p+3 +-0x1.011a7b69ade1fp+4 +-0x1.f9ce1d888fe1cp+3 +-0x1.4771c987d6b9bp+2 +-0x1.acc82802f9fcp+3 +-0x1.b4036bc356943p+3 +-0x1.cf9ee29535e1dp+3 +-0x1.d75eab775936p+3 +-0x1.cf3a9ddd60d35p+3 +-0x1.d6f8e2c79dfa9p+3 +-0x1.cf3a4b50ce7c4p+3 +-0x1.288599db9cac6p+2 +-0x1.a818850b13395p+3 +-0x1.af424fb9c2a37p+3 +-0x1.c9fedfd2fd786p+3 +-0x1.d1a8f3354d7c8p+3 +-0x1.c99fd8b935c8p+3 +-0x1.d1487e72342d5p+3 +-0x1.c99f8b00913f5p+3 +-0x1.d0ada0184d33ap+2 +-0x1.080e2f547dc14p+4 +-0x1.0c6ed2c9cfa55p+4 +-0x1.1dbd11b004d9ep+4 +-0x1.2278bc50d0381p+4 +-0x1.1d773d5fb5b32p+4 +-0x1.2231bd274bc2dp+4 +-0x1.1d76fe974b46ep+4 +-0x1.9af929fa0ef28p+2 +-0x1.f9ce1d888fe1cp+3 +-0x1.011a453c5da54p+4 +-0x1.114b37b89392fp+4 +-0x1.15d233ad18535p+4 +-0x1.110c38b7cbedcp+4 +-0x1.15922d09ca122p+4 +-0x1.110c014127e5cp+4 +-0x1.345776da9eb35p+2 +-0x1.cf3a4b50ce7c4p+3 +-0x1.d6f88efbb33aap+3 +-0x1.f1782abe3a9bbp+3 +-0x1.f9bd2089db402p+3 +-0x1.f11d39585018fp+3 +-0x1.f960c38969764p+3 +-0x1.f11ced01491afp+3 +-0x1.1df6b80e51247p+2 +-0x1.c99f8b00913f5p+3 +-0x1.d1482f8e8c90fp+3 +-0x1.eb9d36fd6fcc7p+3 +-0x1.f3cad37023463p+3 +-0x1.eb42ecf7ced06p+3 +-0x1.f36f227024d1cp+3 +-0x1.eb42a18205fc7p+3 +-0x1.d170181d25f8ep+2 +-0x1.1d76fe974b46ep+4 +-0x1.22317d52410ap+4 +-0x1.3839f9290c0f8p+4 +-0x1.3d69b40e9df65p+4 +-0x1.37d16750d142ap+4 +-0x1.3cff4d9bdfdap+4 +-0x1.37d103da16212p+4 +-0x1.9df7143c6f92ep+2 +-0x1.110c014127e5cp+4 +-0x1.1591f4ab16f38p+4 +-0x1.2a6b28806c43dp+4 +-0x1.2f5db7baa8bd8p+4 +-0x1.2a0acaaa7d86fp+4 +-0x1.2efbb43151a0dp+4 +-0x1.2a0a70eec186fp+4 +-0x1.1e465c379b611p+2 +-0x1.f11ced01491afp+3 +-0x1.f960760137c3dp+3 +-0x1.0d5fdc69f63e6p+4 +-0x1.11d67f6cb5586p+4 +-0x1.0d1cf5be73866p+4 +-0x1.119282c79a1c2p+4 +-0x1.0d1cbaf24026ep+4 +-0x1.1500ae1ba7824p+2 +-0x1.eb42a18205fc7p+3 +-0x1.f36ed5ce63fb9p+3 +-0x1.0a9bbc9ddd38ap+4 +-0x1.0f06e81dc873ep+4 +-0x1.0a570d26609e1p+4 +-0x1.0ec11cb5b8e6ep+4 +-0x1.0a56d0e7f4d03p+4 +-0x1.d8b12c94c7a83p+2 +-0x1.37d103da16212p+4 +-0x1.3cfee86793901p+4 +-0x1.5e999d7d21dep+4 +-0x1.647afd8d5c34dp+4 +-0x1.5dbfec03b546bp+4 +-0x1.639d3d15e9c8cp+4 +-0x1.5dbf051f860fp+4 +-0x1.a30ab92cb1fe4p+2 +-0x1.2a0a70eec186fp+4 +-0x1.2efb58ed0a3adp+4 +-0x1.4ee47c2b54e8bp+4 +-0x1.547bc8cb9a4f2p+4 +-0x1.4e1a52d636d17p+4 +-0x1.53adf2d3270cap+4 +-0x1.4e19813f0d7b8p+4 +-0x1.10c93eaa6b7d5p+2 +-0x1.0d1cbaf24026ep+4 +-0x1.1192470727a1bp+4 +-0x1.2b233f11795e1p+4 +-0x1.3018f4a2e5088p+4 +-0x1.2a969139532cdp+4 +-0x1.2f89de8012308p+4 +-0x1.2a9609dbd1ca7p+4 +-0x1.178ae938546fep+2 +-0x1.0a56d0e7f4d03p+4 +-0x1.0ec0df7e51ebbp+4 +-0x1.293109167f47ep+4 +-0x1.2e1e3abb1e21ap+4 +-0x1.289abad14617fp+4 +-0x1.2d855c3fc3543p+4 +-0x1.289a297c6d163p+4 +-0x1.e949f1ed5dd4ep+2 +-0x1.5dbf051f860fp+4 +-0x1.639c51e47fd03p+4 +-0x1.93e2a5466e916p+4 +-0x1.9acd5fd5016b6p+4 +-0x1.92501200f7c76p+4 +-0x1.9932a813421b6p+4 +-0x1.924e2a45ec7cdp+4 +-0x1.9930b67dc1f1bp+4 +-0x1.924e28651824dp+4 +-0x1.a9d6c2f92ddbbp+2 +-0x1.4e19813f0d7b8p+4 +-0x1.53ad1d6d6be25p+4 +-0x1.80ff30159b357p+4 +-0x1.87895e0191087p+4 +-0x1.7f909013bce4fp+4 +-0x1.8613888387596p+4 +-0x1.7f8ee06117e9fp+4 +-0x1.8611d056382fap+4 +-0x1.7f8edec098423p+4 +-0x1.149c1fdd7d59ep+2 +-0x1.2a9609dbd1ca7p+4 +-0x1.2f8954d1d6766p+4 +-0x1.546553f1e45ap+4 +-0x1.5a165da851aa2p+4 +-0x1.535d5d72e8944p+4 +-0x1.5909901c16d6fp+4 +-0x1.535c40317549p+4 +-0x1.1ff63899abf9bp+2 +-0x1.289a297c6d163p+4 +-0x1.2d84c870bf633p+4 +-0x1.53bbaf72d3308p+4 +-0x1.59699c9d19424p+4 +-0x1.52a06be260e3dp+4 +-0x1.584928e9fe719p+4 +-0x1.529f367ad6141p+4 +-0x1.e873833a2f033p-3 +-0x1.40df59de61ad6p-2 +-0x1.e8738325d015bp-3 +-0x1.e8738325d015bp-3 +-0x1.40df59d41c5f2p-2 +-0x1.e8738325c66e9p-3 +0x1.f029c096e6763p-4 +0x1.9394b00ceff45p-5 +0x1.f029c0be5da8fp-4 +0x1.f029c0be5da8fp-4 +0x1.9394b05c8431ap-5 +0x1.f029c0be6ffbcp-4 +0x1.34e91a3e67f73p-5 +-0x1.1d7512d113a1p-5 +0x1.35084637cda23p-5 +0x1.35084637cda23p-5 +-0x1.1d55a508c26c4p-5 +0x1.3513b9ff763bdp-5 +-0x1.0ebde4fac48d2p-1 +-0x1.365204072dcedp-1 +-0x1.0ebda4a8d96c6p-1 +-0x1.0ebda4a8d96c6p-1 +-0x1.3651c32914abcp-1 +-0x1.0ebda20e5405ep-1 +-0x1.d9a5cd8c2073dp-2 +-0x1.141d3cab6847ep-1 +-0x1.d84f79a5eb439p-2 +-0x1.13709f103dea9p-1 +-0x1.d8528e5ec63bcp-2 +-0x1.d8528e5ec63bcp-2 +-0x1.13722cc4ef2bp-1 +-0x1.d8614c0553213p-2 +-0x1.f47216265eb4p-4 +-0x1.918709cd6a56cp-3 +-0x1.f471e5ba36bc1p-4 +-0x1.f471e5ba36bc1p-4 +-0x1.9186f163c1e27p-3 +-0x1.f471e5473e147p-4 +-0x1.17c1710c9179fp-3 +-0x1.af4e611eb6bf7p-3 +-0x1.0d67a4ac59b47p-3 +-0x1.a4de83c7d428ap-3 +-0x1.0d86100720497p-3 +-0x1.0d86100720497p-3 +-0x1.a4fd2ff9b4b6ap-3 +-0x1.0e117b2c9519bp-3 +-0x1.a589c44d2a2fbp-3 +-0x1.0e0ffbfc1f6adp-3 +-0x1.c82c8eb3ec496p-1 +-0x1.f158dbf6a661fp-1 +-0x1.c6196346233cdp-1 +-0x1.ef4113d6dd9a4p-1 +-0x1.c61d530ae53abp-1 +-0x1.c61d530ae53abp-1 +-0x1.ef450c5b7800fp-1 +-0x1.c62f97a08263ap-1 +-0x1.ef57798b35821p-1 +-0x1.c62f769c26baep-1 +-0x1.9928b419970ddp-1 +-0x1.c1ecbf7b0de13p-1 +-0x1.92a814359687p-1 +-0x1.bb5dbeb8756ecp-1 +-0x1.92b6b7e016e4p-1 +-0x1.bb6c82bf12775p-1 +-0x1.92b69b47d610ep-1 +-0x1.92b69b47d610ep-1 +-0x1.bb6c65e79c601p-1 +-0x1.92f475014f63ap-1 +-0x1.bbaac859a654ep-1 +-0x1.92f3fcc1557a1p-1 +-0x1.bea8881ec21c4p-2 +-0x1.068151f3787bep-1 +-0x1.b7b6d0c06e442p-2 +-0x1.0300ef5cb5708p-1 +-0x1.b7c9cc63836ffp-2 +-0x1.b7c9cc63836ffp-2 +-0x1.030a81c0bb77ep-1 +-0x1.b81dae7803f2bp-2 +-0x1.0334cdb31c701p-1 +-0x1.b81cdbf02605cp-2 +-0x1.b52494d1844ffp-2 +-0x1.01b5081b13899p-1 +-0x1.a3a49d382551bp-2 +-0x1.f1c4308c28587p-2 +-0x1.a3d9adfe54c1bp-2 +-0x1.f1f9b4368600fp-2 +-0x1.a3d92997c82ep-2 +-0x1.a3d92997c82ep-2 +-0x1.f1f92eb150768p-2 +-0x1.a4ac03c64523p-2 +-0x1.f2cdd1665feefp-2 +-0x1.a4a9f9eb2b45p-2 +-0x1.630f2844a8341p+0 +-0x1.78c35f3e467fp+0 +-0x1.5e9b0d51e9cdp+0 +-0x1.74451ac8380c5p+0 +-0x1.5ea258c797bfep+0 +-0x1.744c76e127d54p+0 +-0x1.5ea24ec43e384p+0 +-0x1.5ea24ec43e384p+0 +-0x1.744c6cc6f7dc2p+0 +-0x1.5ec0dc4345dacp+0 +-0x1.746b3ff559b45p+0 +-0x1.5ec0b2820474bp+0 +-0x1.46000e449ad48p+0 +-0x1.5b7221ad3652dp+0 +-0x1.3f05921c7bc42p+0 +-0x1.5467d29a01807p+0 +-0x1.3f1383e850a22p+0 +-0x1.5475e3fea7ff3p+0 +-0x1.3f136e93f3ad2p+0 +-0x1.3f136e93f3ad2p+0 +-0x1.5475ce79f64e9p+0 +-0x1.3f47ae54a1e3dp+0 +-0x1.54aa849fa399bp+0 +-0x1.3f475efe1213ep+0 +-0x1.b893b3240b9bbp-1 +-0x1.e19d5b5904fc8p-1 +-0x1.acf07d858e332p-1 +-0x1.d5e055c5a5e71p-1 +-0x1.ad0fe45a1f079p-1 +-0x1.d6000235a1a56p-1 +-0x1.ad0fa1ad17254p-1 +-0x1.ad0fa1ad17254p-1 +-0x1.d5ffbef4cd24ep-1 +-0x1.ad85176f13a02p-1 +-0x1.d676391781dfcp-1 +-0x1.ad84202270107p-1 +-0x1.b51c6ba2b1b09p-1 +-0x1.de1e62fb87c2fp-1 +-0x1.a3993df4c1fa7p-1 +-0x1.cc74644452f9fp-1 +-0x1.a3cd0a998bf1cp-1 +-0x1.cca8a39e84ce5p-1 +-0x1.a3cc9da70c44cp-1 +-0x1.a3cc9da70c44cp-1 +-0x1.cca835bac1923p-1 +-0x1.a47e999ba997fp-1 +-0x1.cd5bbbd88d17ep-1 +-0x1.a47d2805296c7p-1 +-0x1.08b68e7cc0268p+1 +-0x1.145b45fefbe08p+1 +-0x1.048da7977a24dp+1 +-0x1.10288aab476d2p+1 +-0x1.04924c661894p+1 +-0x1.102d3a70ce019p+1 +-0x1.0492487c9ab41p+1 +-0x1.0492487c9ab41p+1 +-0x1.102d367e137d1p+1 +-0x1.04a586e97f30bp+1 +-0x1.1040a25b07074p+1 +-0x1.04a576c8f95a8p+1 +-0x1.ed6bd566569bap+0 +-0x1.023035c35b02ap+1 +-0x1.e2132a439ec82p+0 +-0x1.f8ed23d4804fp+0 +-0x1.e2239a56163a5p+0 +-0x1.f8fdba6952b82p+0 +-0x1.e22389ebd8707p+0 +-0x1.e22389ebd8707p+0 +-0x1.f8fda9d8a02cp+0 +-0x1.e25e84516e32cp+0 +-0x1.f9392e6aa59a8p+0 +-0x1.e25e49e067e5bp+0 +-0x1.752842d99f051p+0 +-0x1.8b05de55d49e9p+0 +-0x1.6a10a9dda8a7dp+0 +-0x1.7fd4e22309c9fp+0 +-0x1.6a2a76930e5c6p+0 +-0x1.7feee9d40fc2ap+0 +-0x1.6a2a4ddcfdb0bp+0 +-0x1.6a2a4ddcfdb0bp+0 +-0x1.7feec0c0ec02dp+0 +-0x1.6a80d41081b3fp+0 +-0x1.80460cc650369p+0 +-0x1.6a804d1f3736ap+0 +-0x1.71048fbc4e6abp+0 +-0x1.86d8b010e28e2p+0 +-0x1.62d31e9930ca9p+0 +-0x1.7886cc84be6d5p+0 +-0x1.62f6fdaf8a164p+0 +-0x1.78aafd7e26418p+0 +-0x1.62f6c52fa3b31p+0 +-0x1.62f6c52fa3b31p+0 +-0x1.78aac47d455a5p+0 +-0x1.63657330073a1p+0 +-0x1.791a6f2a08cb5p+0 +-0x1.6364c76225e34p+0 +-0x1.7bdec28e0eea6p+1 +-0x1.889a13bf939d3p+1 +-0x1.75d8a8f32938ep+1 +-0x1.828517fb3dc2cp+1 +-0x1.75db28a0e4e09p+1 +-0x1.75db28a0e4e09p+1 +-0x1.82879dd3a757bp+1 +-0x1.75ead97adfa61p+1 +-0x1.829775670f201p+1 +-0x1.75ead4c6c4dfcp+1 +-0x1.66e9bf03737dbp+1 +-0x1.73716e50ca689p+1 +-0x1.5f04cc5583894p+1 +-0x1.6b792414a65efp+1 +-0x1.5f09eb86b5983p+1 +-0x1.6b7e4fcd8c924p+1 +-0x1.5f09e957741ddp+1 +-0x1.5f09e957741ddp+1 +-0x1.6b7e4d98f2ec5p+1 +-0x1.5f21b83ea968ap+1 +-0x1.6b9656bf1141cp+1 +-0x1.5f21ae27c0c43p+1 +-0x1.2030e992a5f7ap+1 +-0x1.2c0d6a39dfa0fp+1 +-0x1.17dde2ced3818p+1 +-0x1.23a68cbb21108p+1 +-0x1.17ea7fca8517ep+1 +-0x1.23b347b9a5029p+1 +-0x1.17ea740a8db7ap+1 +-0x1.17ea740a8db7ap+1 +-0x1.23b33bddb89d8p+1 +-0x1.1814646680503p+1 +-0x1.23dd90041a9c1p+1 +-0x1.18143dbfd687ap+1 +-0x1.17a59cf550cf3p+1 +-0x1.236dc0ff2702cp+1 +-0x1.0dd3f339b9b34p+1 +-0x1.1984c6a35ebc5p+1 +-0x1.0de4bc07c8eb3p+1 +-0x1.1995b73853849p+1 +-0x1.0de4ab8e888edp+1 +-0x1.0de4ab8e888edp+1 +-0x1.1995a69808a99p+1 +-0x1.0e1721b7619dfp+1 +-0x1.19c89458eb7eap+1 +-0x1.0e16f0cdf46fbp+1 +-0x1.02139b52faa5ep+2 +-0x1.091e33675d988p+2 +-0x1.fcafbe39c848ep+1 +-0x1.0558c38eb0f67p+2 +-0x1.fcae3e5b936b5p+1 +-0x1.fcae3e5b936b5p+1 +-0x1.055801ad7e27fp+2 +-0x1.fcb783fa92949p+1 +-0x1.055cb084f1ff4p+2 +-0x1.fcb785102ffcfp+1 +-0x1.eec9dd18dad15p+1 +-0x1.fca7ac1f65ba7p+1 +-0x1.e5137169367a9p+1 +-0x1.f2d837d5a0b22p+1 +-0x1.e512692f41236p+1 +-0x1.e512692f41236p+1 +-0x1.f2d72cf3da581p+1 +-0x1.e52091a30520cp+1 +-0x1.f2e579d4e6405p+1 +-0x1.e520923a61bcep+1 +-0x1.999b77b24065cp+1 +-0x1.a6a0c2772c492p+1 +-0x1.8f034bc24476bp+1 +-0x1.9bee232bcbf39p+1 +-0x1.8f091b1b8bd3ep+1 +-0x1.9bf400ff0e61cp+1 +-0x1.8f091924ec68cp+1 +-0x1.8f091924ec68cp+1 +-0x1.9bf3ff038a96ap+1 +-0x1.8f25a9f002d01p+1 +-0x1.9c10d6fc26eb5p+1 +-0x1.8f25a05c6874bp+1 +-0x1.87e584e98f2ap+1 +-0x1.94bea7319cbb7p+1 +-0x1.7bc4a1feb24cep+1 +-0x1.887fb28fb29f5p+1 +-0x1.7bcd96fdec022p+1 +-0x1.8888bdb6b412fp+1 +-0x1.7bcd9332eaaefp+1 +-0x1.7bcd9332eaaefp+1 +-0x1.8888b9e250ee1p+1 +-0x1.7bf149fd37ae5p+1 +-0x1.88acc90444c86p+1 +-0x1.7bf13b020857fp+1 +-0x1.4a575753d5425p+2 +-0x1.5222e95e9385bp+2 +-0x1.461c357723b9ap+2 +-0x1.4ddc35818f28bp+2 +-0x1.4619bb612b106p+2 +-0x1.4dd9b4a81df84p+2 +-0x1.4619ba75db85cp+2 +-0x1.4619ba75db85cp+2 +-0x1.4dd9b3ba4be0cp+2 +-0x1.461c01fb32fd5p+2 +-0x1.4ddc0179086bp+2 +-0x1.461c02d3382fcp+2 +-0x1.412bea5598b56p+2 +-0x1.48de73e8d8ec3p+2 +-0x1.3ba9d7d4752bcp+2 +-0x1.434d6b75b8e98p+2 +-0x1.3ba68df0f63e9p+2 +-0x1.434a18a7ef211p+2 +-0x1.3ba68cd632f83p+2 +-0x1.3ba68cd632f83p+2 +-0x1.434a178a2d4f7p+2 +-0x1.3ba9fd4a230fap+2 +-0x1.434d9150f3c5dp+2 +-0x1.3ba9fe70d292p+2 +-0x1.0f9d19404820fp+2 +-0x1.16cb17797e93bp+2 +-0x1.097457b4b463p+2 +-0x1.10922fc8e7819p+2 +-0x1.0973039c26426p+2 +-0x1.0973039c26426p+2 +-0x1.1090d8369ecd9p+2 +-0x1.0976f54f7744ep+2 +-0x1.1094d43b6f752p+2 +-0x1.0976f5ac05a87p+2 +-0x1.0274e509a79c6p+2 +-0x1.09807a5054462p+2 +-0x1.f6f8357207cabp+1 +-0x1.0275961a4b364p+2 +-0x1.f6f70952e2915p+1 +-0x1.f6f70952e2915p+1 +-0x1.0274fe861a25p+2 +-0x1.f701ddb6fbaabp+1 +-0x1.027a76be10d46p+2 +-0x1.f701ddd5f145dp+1 +-0x1.952d23da600ap+2 +-0x1.9dcaf3396e6d1p+2 +-0x1.9092693f7e707p+2 +-0x1.9922fae514cfap+2 +-0x1.908ebf734ea26p+2 +-0x1.991f46941f3cp+2 +-0x1.908ebd9179653p+2 +-0x1.908ebd9179653p+2 +-0x1.991f44ace27a2p+2 +-0x1.908fc1d40f12bp+2 +-0x1.8d6f800e2822ap+2 +-0x1.95f7129c32063p+2 +-0x1.876fe5cb12edp+2 +-0x1.8fe650d7d65ddp+2 +-0x1.876abddb3c529p+2 +-0x1.8fe11a30c3413p+2 +-0x1.876abb49e5784p+2 +-0x1.876abb49e5784p+2 +-0x1.8fe11798184cep+2 +-0x1.876c3d75740e7p+2 +-0x1.577641e9d316dp+2 +-0x1.5f65ec83e1fa3p+2 +-0x1.508e5ff2502f1p+2 +-0x1.586b00a0d4a7dp+2 +-0x1.50898c0f7aea7p+2 +-0x1.58661f76d6532p+2 +-0x1.50898a5315008p+2 +-0x1.50898a5315008p+2 +-0x1.58661db5aa276p+2 +-0x1.508b23fb5b0ap+2 +-0x1.469e6e7b958cp+2 +-0x1.4e5fd22e482afp+2 +-0x1.3ed8f5569ba17p+2 +-0x1.46852d242cf2p+2 +-0x1.3ed3f7ede547cp+2 +-0x1.4680222cd5caep+2 +-0x1.3ed3f66c980bep+2 +-0x1.3ed3f66c980bep+2 +-0x1.468020a771ba9p+2 +-0x1.3ed64dd9d41e7p+2 +-0x1.46827e7145a84p+2 +-0x1.3ed64e8df0c96p+2 +-0x1.e214b167cf195p+2 +-0x1.eb9596a75be45p+2 +-0x1.dd285e00e4ca7p+2 +-0x1.e69a63eb3e82p+2 +-0x1.dd23e56065318p+2 +-0x1.e695ddce47921p+2 +-0x1.dd23e2b6c572ep+2 +-0x1.dd23e2b6c572ep+2 +-0x1.e695db1c9fe5cp+2 +-0x1.dd245027b541ap+2 +-0x1.da24c63e04955p+2 +-0x1.e38db709d7633p+2 +-0x1.d3bb9ec195291p+2 +-0x1.dd114cba972edp+2 +-0x1.d3b54136bba6p+2 +-0x1.dd0adc19b9ff5p+2 +-0x1.d3b53d7a7eb5bp+2 +-0x1.d3b53d7a7eb5bp+2 +-0x1.dd0ad85249e68p+2 +-0x1.d3b5e01d87fb4p+2 +-0x1.a1634a23a92e5p+2 +-0x1.aa246938a22aep+2 +-0x1.99ca8ced54169p+2 +-0x1.a275ac07ff694p+2 +-0x1.99c3361bebd85p+2 +-0x1.a26e400310e82p+2 +-0x1.99c3325f0610ap+2 +-0x1.99c3325f0610ap+2 +-0x1.a26e3c3b5ede9p+2 +-0x1.99c3ca11caec6p+2 +-0x1.90ac1bdd6a7a3p+2 +-0x1.993cf74d6b9bfp+2 +-0x1.882691cb5184fp+2 +-0x1.909f0655cf7e9p+2 +-0x1.881e40bedb2d2p+2 +-0x1.90969d89f9d0fp+2 +-0x1.881e3cc39eb41p+2 +-0x1.881e3cc39eb41p+2 +-0x1.909699835f018p+2 +-0x1.881f1e7547283p+2 +-0x1.189a782c33d29p+3 +-0x1.1dd594a20b86fp+3 +-0x1.15fdbe2e8345cp+3 +-0x1.1b30927ee112fp+3 +-0x1.15fb336d00af2p+3 +-0x1.1b2dffb16dd22p+3 +-0x1.15fb31c7d7a1fp+3 +-0x1.15fb31c7d7a1fp+3 +-0x1.1b2dfe070f9cap+3 +-0x1.15fb47befd071p+3 +-0x1.13939cfeea52ap+3 +-0x1.18becf76307e3p+3 +-0x1.102e14ae62636p+3 +-0x1.154e943558847p+3 +-0x1.102a760752442p+3 +-0x1.154aea2d6823dp+3 +-0x1.102a73b59d583p+3 +-0x1.102a73b59d583p+3 +-0x1.154ae7d468f41p+3 +-0x1.102a9542f0d8fp+3 +-0x1.ec127ce084a91p+2 +-0x1.f5b1b517f2884p+2 +-0x1.e3c95cce79065p+2 +-0x1.ed4f6bef0626fp+2 +-0x1.e3c022fe4115fp+2 +-0x1.ed46162d6e631p+2 +-0x1.e3c01d83fffd3p+2 +-0x1.e3c01d83fffd3p+2 +-0x1.ed4610a2963ddp+2 +-0x1.e3c052c1611f4p+2 +-0x1.df642792839e9p+2 +-0x1.e8dceb5a0f39fp+2 +-0x1.d61ccfab3fbb9p+2 +-0x1.df79a19fb3c4fp+2 +-0x1.d612093d83bafp+2 +-0x1.df6ebad6bacd4p+2 +-0x1.d61202facf3dbp+2 +-0x1.d61202facf3dbp+2 +-0x1.df6eb48139a42p+2 +-0x1.d6124edf51722p+2 +-0x1.413b391fad3efp+3 +-0x1.46fa786a55a78p+3 +-0x1.3e780e1843ffcp+3 +-0x1.442e1eafba684p+3 +-0x1.3e753f73d0e31p+3 +-0x1.442b46ba36ffp+3 +-0x1.3e753d879cc21p+3 +-0x1.3e753d879cc21p+3 +-0x1.442b44c7a1543p+3 +-0x1.3e7546005cd8cp+3 +-0x1.3a243bc06389cp+3 +-0x1.3fcbf8b7ad522p+3 +-0x1.368efe37082f7p+3 +-0x1.3c2aec4234639p+3 +-0x1.368b02e9a7a5cp+3 +-0x1.3c26e3dc7eaeep+3 +-0x1.368b003610cb1p+3 +-0x1.368b003610cb1p+3 +-0x1.3c26e1200550dp+3 +-0x1.368b0de47416bp+3 +-0x1.1bd024c4a7237p+3 +-0x1.211577582172ep+3 +-0x1.1750353302e28p+3 +-0x1.1c8739c36b49dp+3 +-0x1.174acb19229adp+3 +-0x1.1c81be7efc9f7p+3 +-0x1.174ac7995dadbp+3 +-0x1.174ac7995dadbp+3 +-0x1.1c81baf41fbfp+3 +-0x1.174ad07c17754p+3 +-0x1.17965fed5fbcp+3 +-0x1.1cce42fda75c3p+3 +-0x1.128e6b3a101aep+3 +-0x1.17b665c811f43p+3 +-0x1.12880d5202d05p+3 +-0x1.17aff3cddec48p+3 +-0x1.1288093d1ed4ap+3 +-0x1.1288093d1ed4ap+3 +-0x1.17afefac1ce6ap+3 +-0x1.1288152504b95p+3 +-0x1.6a6c31b536b6ep+3 +-0x1.70b7cc7747aacp+3 +-0x1.6782384fa6dbbp+3 +-0x1.6dc3af09a48e2p+3 +-0x1.677f295a69e38p+3 +-0x1.6dc09574039d9p+3 +-0x1.677f2729a9a8bp+3 +-0x1.677f2729a9a8bp+3 +-0x1.6dc0933ba7113p+3 +-0x1.677f2a592af78p+3 +-0x1.60ab4ae985f47p+3 +-0x1.66d514b71cafbp+3 +-0x1.5ce698def759cp+3 +-0x1.63036abecb886p+3 +-0x1.5ce2486fa36bp+3 +-0x1.62ff0b7e90c9dp+3 +-0x1.5ce24560adfd9p+3 +-0x1.5ce24560adfd9p+3 +-0x1.62ff08651a834p+3 +-0x1.5ce24aeb53aa6p+3 +-0x1.4168f26cc46a8p+3 +-0x1.4728c9f6515a5p+3 +-0x1.3ca89dd6e25e5p+3 +-0x1.4258adee3847fp+3 +-0x1.3ca2ab93c97b8p+3 +-0x1.4252a7f9738cfp+3 +-0x1.3ca2a783d2b99p+3 +-0x1.3ca2a783d2b99p+3 +-0x1.4252a3dc08852p+3 +-0x1.3ca2b98854bfdp+3 +-0x1.3e583912453p+3 +-0x1.440de0062095bp+3 +-0x1.38e91774fb489p+3 +-0x1.3e8cc46a203f1p+3 +-0x1.38e1d9cee2e04p+3 +-0x1.3e856ee32cf7bp+3 +-0x1.38e1d4e17ee11p+3 +-0x1.38e1d4e17ee11p+3 +-0x1.3e8569e5894c6p+3 +-0x1.38e1d87f87ecep+3 +-0x1.93d03f37aec86p+3 +-0x1.9aaf5fd564efbp+3 +-0x1.90bf0a4880b42p+3 +-0x1.9793032dc242ep+3 +-0x1.90bbbb4f5afe9p+3 +-0x1.978fa83134e8fp+3 +-0x1.90bbb8d8c32d8p+3 +-0x1.90bbb8d8c32d8p+3 +-0x1.978fa5b1ab645p+3 +-0x1.90bbba06c1133p+3 +-0x1.86ebbe3a06f71p+3 +-0x1.8d9c38cfbbfbap+3 +-0x1.82f7b07e5389fp+3 +-0x1.8999fd978185p+3 +-0x1.82f30d61ffc64p+3 +-0x1.899549e2d7d61p+3 +-0x1.82f309f888856p+3 +-0x1.82f309f888856p+3 +-0x1.8995466d2ab95p+3 +-0x1.82f30c371db3ep+3 +-0x1.6630ba742ebap+3 +-0x1.6c6d9d669f7d4p+3 +-0x1.6134c1960b067p+3 +-0x1.6760659529126p+3 +-0x1.612e5a538cd38p+3 +-0x1.6759e83a4b987p+3 +-0x1.612e55c3cc63p+3 +-0x1.612e55c3cc63p+3 +-0x1.6759e39acdcfp+3 +-0x1.612e5d6430347p+3 +-0x1.63525600a9c59p+3 +-0x1.698548f4593fcp+3 +-0x1.5d97789f4aed8p+3 +-0x1.63b6aa29bd2fap+3 +-0x1.5d8f9e7a7a92fp+3 +-0x1.63aeb508612cbp+3 +-0x1.5d8f98e6a23ecp+3 +-0x1.5d8f98e6a23ecp+3 +-0x1.63aeaf615da7p+3 +-0x1.5d8fa26d2bbd7p+3 +-0x1.bd3a211a0f76p+3 +-0x1.c4b35f9546575p+3 +-0x1.ba01463656cbep+3 +-0x1.c16e4b36ba039p+3 +-0x1.b9fdb61839e67p+3 +-0x1.c16aad99ac161p+3 +-0x1.b9fdb3589edf3p+3 +-0x1.b9fdb3589edf3p+3 +-0x1.c16aaacfa7f13p+3 +-0x1.b9fdb3c6ca125p+3 +-0x1.acd803d68827ap+3 +-0x1.b41382dd5768ap+3 +-0x1.a8b498673b2b8p+3 +-0x1.afe0a7d576e6p+3 +-0x1.a8afa2b361355p+3 +-0x1.afdb9fabb34b7p+3 +-0x1.a8af9eed5b243p+3 +-0x1.a8af9eed5b243p+3 +-0x1.afdb9bd7a1a9ap+3 +-0x1.a8af9fd5faa54p+3 +-0x1.89e2b2a9033a5p+3 +-0x1.909dd905a1561p+3 +-0x1.84ac84659fae9p+3 +-0x1.8b54ee35923cbp+3 +-0x1.84a5ae7cc8a53p+3 +-0x1.8b4dffcafcc74p+3 +-0x1.84a5a97211af3p+3 +-0x1.84a5a97211af3p+3 +-0x1.8b4dfaae326f9p+3 +-0x1.84a5acbf9b69cp+3 +-0x1.8658d2e711bdep+3 +-0x1.8d073da783b5dp+3 +-0x1.805c14fc29fe1p+3 +-0x1.86f5102f9d58ap+3 +-0x1.8053b72bc72bp+3 +-0x1.86ec94838b444p+3 +-0x1.8053b104ebabfp+3 +-0x1.8053b104ebabfp+3 +-0x1.86ec8e46bb886p+3 +-0x1.8053b53a2947dp+3 +-0x1.e66ee8a3f61a3p+3 +-0x1.ee87f80d2db8dp+3 +-0x1.e30e27cd2f67dp+3 +-0x1.eb19df175f6ffp+3 +-0x1.e30a551367a03p+3 +-0x1.eb15fd498d5bp+3 +-0x1.e30a52070837cp+3 +-0x1.e30a52070837cp+3 +-0x1.eb15fa3128391p+3 +-0x1.e30a522e24897p+3 +-0x1.d2d8a6c1c3651p+3 +-0x1.daa4f074b84e7p+3 +-0x1.ce85489ad4783p+3 +-0x1.d640d0448573ap+3 +-0x1.ce7ffe6d7eebap+3 +-0x1.d63b71a42ef41p+3 +-0x1.ce7ffa46673a7p+3 +-0x1.ce7ffa46673a7p+3 +-0x1.d63b6d6d09946p+3 +-0x1.ce7ffaa2c0279p+3 +-0x1.acc82802f9fcp+3 +-0x1.b4036bc356943p+3 +-0x1.a75898cad6499p+3 +-0x1.ae7f99d6333ccp+3 +-0x1.a751566867a2dp+3 +-0x1.ae783c7860173p+3 +-0x1.a75150e2a17dp+3 +-0x1.a75150e2a17dp+3 +-0x1.ae7836de1330dp+3 +-0x1.a75152563c42p+3 +-0x1.a818850b13395p+3 +-0x1.af424fb9c2a37p+3 +-0x1.a1dbc8a2cbb53p+3 +-0x1.a8ee72ba90be3p+3 +-0x1.a1d2ebfe20f3ap+3 +-0x1.a8e57554f42a9p+3 +-0x1.a1d2e546dfe4dp+3 +-0x1.a1d2e546dfe4dp+3 +-0x1.a8e56e84e0d43p+3 +-0x1.a1d2e7314d0adp+3 +-0x1.080e2f547dc14p+4 +-0x1.0c6ed2c9cfa55p+4 +-0x1.064964cb341c7p+4 +-0x1.0aa2c3d836627p+4 +-0x1.064758b17fbacp+4 +-0x1.0aa0af58a790ap+4 +-0x1.064757022624ep+4 +-0x1.064757022624ep+4 +-0x1.0aa0ada26499dp+4 +-0x1.06475708542bfp+4 +-0x1.f9ce1d888fe1cp+3 +-0x1.011a453c5da54p+4 +-0x1.f54910a1de093p+3 +-0x1.fd9d4ff7ba62cp+3 +-0x1.f5436d95710cap+3 +-0x1.fd97964be7029p+3 +-0x1.f5436905924aap+3 +-0x1.f5436905924aap+3 +-0x1.fd9791a9b946fp+3 +-0x1.f54369279adecp+3 +-0x1.cf3a4b50ce7c4p+3 +-0x1.d6f88efbb33aap+3 +-0x1.c991930a84624p+3 +-0x1.d13a01db4fe25p+3 +-0x1.c989e3eeef949p+3 +-0x1.d132353054084p+3 +-0x1.c989ddeb100efp+3 +-0x1.c989ddeb100efp+3 +-0x1.d1322f1550c11p+3 +-0x1.c989de8e43cdep+3 +-0x1.c99f8b00913f5p+3 +-0x1.d1482f8e8c90fp+3 +-0x1.c322abd5cd8dp+3 +-0x1.cab26f1d8db86p+3 +-0x1.c3194f94fcfdap+3 +-0x1.caa8ef1513331p+3 +-0x1.c31948495753ap+3 +-0x1.c31948495753ap+3 +-0x1.caa8e7ad8a986p+3 +-0x1.c3194927d9392p+3 +-0x1.1d76fe974b46ep+4 +-0x1.22317d52410ap+4 +-0x1.1b9cfa5949e5dp+4 +-0x1.204f904628e18p+4 +-0x1.1b9ac9659573ep+4 +-0x1.204d55fa466b7p+4 +-0x1.1b9ac789593e1p+4 +-0x1.1b9ac789593e1p+4 +-0x1.204d54161b51ep+4 +-0x1.1b9ac78a6f0e6p+4 +-0x1.110c014127e5cp+4 +-0x1.1591f4ab16f38p+4 +-0x1.0eaf80ba613d2p+4 +-0x1.132b9858c929ep+4 +-0x1.0eac7feca7dbdp+4 +-0x1.13288b084242p+4 +-0x1.0eac7d6b839abp+4 +-0x1.0eac7d6b839abp+4 +-0x1.1328887caf105p+4 +-0x1.0eac7d7093d33p+4 +-0x1.f11ced01491afp+3 +-0x1.f960760137c3dp+3 +-0x1.eb3b7087d2c31p+3 +-0x1.f367883e0b5a9p+3 +-0x1.eb335440b8aa5p+3 +-0x1.f35f4bb9ae134p+3 +-0x1.eb334dbb6042cp+3 +-0x1.eb334dbb6042cp+3 +-0x1.f35f451a6a13cp+3 +-0x1.eb334e0212f16p+3 +-0x1.eb42a18205fc7p+3 +-0x1.f36ed5ce63fb9p+3 +-0x1.e484d24f32d54p+3 +-0x1.ec965050b427ap+3 +-0x1.e47af3a0cd251p+3 +-0x1.ec8c4aa742133p+3 +-0x1.e47aebba24d27p+3 +-0x1.e47aebba24d27p+3 +-0x1.ec8c42a1657a7p+3 +-0x1.e47aec1c5a7e6p+3 +-0x1.37d103da16212p+4 +-0x1.3cfee86793901p+4 +-0x1.35dc8502cc67cp+4 +-0x1.3b01ab3c73b37p+4 +-0x1.35da250bc1101p+4 +-0x1.3aff40ab029a5p+4 +-0x1.35da22f486823p+4 +-0x1.35da22f486823p+4 +-0x1.3aff3e8a726aep+4 +-0x1.35da22f36e0b1p+4 +-0x1.2a0a70eec186fp+4 +-0x1.2efb58ed0a3adp+4 +-0x1.278d4bd0172c5p+4 +-0x1.2c73569fcdc2ap+4 +-0x1.278a0e64d3e64p+4 +-0x1.2c700b17fbb49p+4 +-0x1.278a0b9838385p+4 +-0x1.278a0b9838385p+4 +-0x1.2c70083f2eda8p+4 +-0x1.278a0b97f6acp+4 +-0x1.0d1cbaf24026ep+4 +-0x1.1192470727a1bp+4 +-0x1.0a092f7f2909ep+4 +-0x1.0e71fd55ec9cep+4 +-0x1.0a04dd7461e5cp+4 +-0x1.0e6d9972a025ap+4 +-0x1.0a04d9df32ab1p+4 +-0x1.0a04d9df32ab1p+4 +-0x1.0e6d95cea488fp+4 +-0x1.0a04d9eae8a43p+4 +-0x1.0a56d0e7f4d03p+4 +-0x1.0ec0df7e51ebbp+4 +-0x1.06cf83bb1bf9dp+4 +-0x1.0b2b0937268a9p+4 +-0x1.06ca4229c7d91p+4 +-0x1.0b25b21103d14p+4 +-0x1.06ca3dd25359bp+4 +-0x1.06ca3dd25359bp+4 +-0x1.0b25ada7bbd9bp+4 +-0x1.06ca3de2df138p+4 +-0x1.5dbf051f860fp+4 +-0x1.639c51e47fd03p+4 +-0x1.5ba3b977e6dd9p+4 +-0x1.6176fe6f1e891p+4 +-0x1.5ba1129a15a46p+4 +-0x1.61744af670461p+4 +-0x1.5ba1102672514p+4 +-0x1.5ba1102672514p+4 +-0x1.61744877259d9p+4 +-0x1.5ba110244dc94p+4 +-0x1.4e19813f0d7b8p+4 +-0x1.53ad1d6d6be25p+4 +-0x1.4b6c74dfb1725p+4 +-0x1.50f3a6ad4beb6p+4 +-0x1.4b68dc200f1dfp+4 +-0x1.50effd472e8fp+4 +-0x1.4b68d8dd7eb39p+4 +-0x1.4b68d8dd7eb39p+4 +-0x1.50eff9f586afbp+4 +-0x1.4b68d8daef727p+4 +-0x1.2a9609dbd1ca7p+4 +-0x1.2f8954d1d6766p+4 +-0x1.274fe4e121e5cp+4 +-0x1.2c34e44e35c42p+4 +-0x1.274b2e153c578p+4 +-0x1.2c3018fc4fd13p+4 +-0x1.274b2a01b3d18p+4 +-0x1.274b2a01b3d18p+4 +-0x1.2c3014d708291p+4 +-0x1.274b2a01fa537p+4 +-0x1.289a297c6d163p+4 +-0x1.2d84c870bf633p+4 +-0x1.24d6fe3725db7p+4 +-0x1.29b1401e3a059p+4 +-0x1.24d1406132ddap+4 +-0x1.29ab6964d3c34p+4 +-0x1.24d13b6d7d713p+4 +-0x1.24d13b6d7d713p+4 +-0x1.29ab645ba72ddp+4 +-0x1.24d13b6e3d4d5p+4 +-0x1.924e28651824dp+4 +-0x1.9930b49336d97p+4 +-0x1.8ffbc308fa847p+4 +-0x1.96d25268f5266p+4 +-0x1.8ff8b39c652e5p+4 +-0x1.96cf3336a4314p+4 +-0x1.8ff8b09992d2cp+4 +-0x1.8ff8b09992d2cp+4 +-0x1.96cf30244d16fp+4 +-0x1.8ff8b096a038ap+4 +-0x1.7f8edec098423p+4 +-0x1.8611cead8a4d2p+4 +-0x1.7c9e9071a2e01p+4 +-0x1.8312c21af1311p+4 +-0x1.7c9a72f060aeap+4 +-0x1.830e90003e33ep+4 +-0x1.7c9a6ef9f6875p+4 +-0x1.7c9a6ef9f6875p+4 +-0x1.830e8bf5fe578p+4 +-0x1.7c9a6ef631a21p+4 +-0x1.535c40317549p+4 +-0x1.59086da0c443ap+4 +-0x1.4fcebee7e8713p+4 +-0x1.556a4f0ce97dep+4 +-0x1.4fc975f9a48fep+4 +-0x1.5564ed7a2756ep+4 +-0x1.4fc9712706332p+4 +-0x1.4fc9712706332p+4 +-0x1.5564e8910c406p+4 +-0x1.4fc971233611fp+4 +-0x1.529f367ad6141p+4 +-0x1.5847edd910badp+4 +-0x1.4e874175088bdp+4 +-0x1.541cdc24f6c6p+4 +-0x1.4e80ceb494b34p+4 +-0x1.54164b637e162p+4 +-0x1.4e80c8d36790dp+4 +-0x1.4e80c8d36790dp+4 +-0x1.54164566f5728p+4 +-0x1.4e80c8cec763cp+4 +-0x1.4e401fed87954p+2 +-0x1.45af0919bd016p+2 +-0x1.ba20dfdee7519p+1 +-0x1.f20991d921956p+1 +-0x1.b21acfd8034d2p+2 +-0x1.792da65b08d12p+2 +-0x1.ed0f2881c3685p+1 +-0x1.14fb226b96fbbp+2 +-0x1.f1e984baded37p+2 +-0x1.a17ae476b7b3ap+2 +-0x1.02250eb7ca45bp+2 +-0x1.28d495483ae98p+2 +-0x1.f30ec3a437d46p+2 +-0x1.ad5206a9e5453p+2 +-0x1.169b1317496c5p+2 +-0x1.27a394a5babep+2 +-0x1.f14db2e583b2ap+2 +-0x1.ab32fd7065facp+2 +-0x1.1a7ff15be7de3p+2 +-0x1.224d672ba3f94p+2 +-0x1.e15a4aa8c57f3p+2 +-0x1.a87b240768095p+2 +-0x1.0ec4d2278c8fcp+2 +-0x1.1da102706fdf3p+2 +-0x1.d01fbfd01210dp+2 +-0x1.9da402b87908fp+2 +-0x1.12cf2844a199cp+2 +-0x1.1182250498bfdp+2 +-0x1.d2c0fe627c5e7p+2 +-0x1.9e4a2eb04fad6p+2 +-0x1.29edd6e56adbbp+2 +-0x1.1883ad9a3b927p+2 +-0x1.ce9ba2cf417fep+2 +-0x1.97abc847bdbc8p+2 +-0x1.3ee839f3715dbp+2 +-0x1.237492f3ae22ap+2 +-0x1.ca9aad5d45c01p+2 +-0x1.8e0260f4a5f47p+2 +-0x1.50153da143996p+2 +-0x1.2d9fe6bc9fd0ap+2 +-0x1.d5dc10b2f1ff2p+2 +-0x1.8dccdcdd7277p+2 +-0x1.5cf56a2d312f3p+2 +-0x1.3e3eea2467a76p+2 +-0x1.e0f66009a2c25p+2 +-0x1.9a952a38f2625p+2 +-0x1.743a1a9777a5cp+2 +-0x1.64dc929df2efp+2 +-0x1.d949ae1a56b9dp+2 +-0x1.9f676719e5ab1p+2 +-0x1.833fd4594ddefp+2 +-0x1.84ec9c173308p+2 +-0x1.d19087cebc2a5p+2 +-0x1.9fa84b10d501bp+2 +-0x1.86db2da9b55f8p+2 +-0x1.9c7e9226339f4p+2 +-0x1.afbc17b90b5bcp+2 +-0x1.8fc65a42dd4acp+2 +-0x1.72c4a9e3534b9p+2 +-0x1.975c85fa23e41p+2 +-0x1.8a193e57a07a1p+2 +-0x1.7ed0d5c8bf3ecp+2 +-0x1.549fad56bfd36p+2 +-0x1.6298d41833817p+2 +-0x1.5d028b238116ep+2 +-0x1.5d91dbf7ef552p+2 +-0x1.378d6b21a3fbdp+2 +-0x1.18ed3b3d94812p+2 +-0x1.30da26f179dbap+2 +-0x1.3b8ee0ac1ce57p+2 +-0x1.fd77c7ff82f43p+1 +-0x1.b49ab187225aep+1 +-0x1.efc9e6b7ac0bap+1 +-0x1.ed0b222a565c6p+1 +-0x1.793a3cd2288ffp+1 +-0x1.47ea36089cf24p+1 +-0x1.761a8c011e657p+1 +-0x1.62fcd96ba9c89p+1 +-0x1.0d9e3014a4e92p+1 +-0x1.aacb260f786afp+0 +-0x1.07778c3a3e6cap+1 +-0x1.dc4c79af98ffap+0 +-0x1.72bc240a1349ap+0 +-0x1.570c078fa07bfp+0 +-0x1.6c36fa4ef9e85p+0 +-0x1.31d57e218875ep+0 +-0x1.c11a7c82ab243p-1 +-0x1.bd3620ff605a7p-1 +-0x1.c3b19e1f40d3fp-1 +-0x1.6dcdfc725bd85p-1 +-0x1.d1570077175bfp-2 +-0x1.d5ac053b1d55fp-2 +-0x1.05442146bbbf1p-1 +-0x1.8dcafdf3bfd81p-2 +-0x1.e1ea35822e695p-4 +-0x1.08bf7ea3df0ddp-3 +-0x1.1f127ce667d2ap-2 +-0x1.daf772a1b031dp-3 +0x1.e994837f155d6p-4 +0x1.4c5bd39f03469p-5 +-0x1.442189cfbfa13p-3 +-0x1.c4bd44b64b961p-4 +0x1.f90a8003589e3p-3 +0x1.4f2558353976cp-3 +0x1.1656f5e444ea9p-6 +0x1.1656f5e444ea9p-6 +0x1.8bc824de72df6p-5 +0x1.8bc824de72df6p-5 +0x1.8b1c67ea3e0ecp-5 +0x1.8b1c67ea3e0ecp-5 +0x1.6b99478000488p-4 +0x1.6b99478000488p-4 +0x1.8ff59b00c5d82p-5 +0x1.8ff59b00c5d82p-5 +0x1.1bb2b2f16b4ccp-3 +0x1.1bb2b2f16b4ccp-3 +0x1.1bcbbaf4eae08p-3 +0x1.1bcbbaf4eae08p-3 +0x1.bc74f7b30c27fp-3 +0x1.bc74f7b30c27fp-3 +0x1.84c918dbf2d1p-4 +0x1.84c918dbf2d1p-4 +0x1.136dcf64b310ap-2 +0x1.136dcf64b310ap-2 +0x1.13bdd39765c85p-2 +0x1.13bdd39765c85p-2 +0x1.87482fbba2b8ep-2 +0x1.87482fbba2b8ep-2 +0x1.3c359aecde5cp-3 +0x1.3c359aecde5cp-3 +0x1.c017ae316edd7p-2 +0x1.c017ae316edd7p-2 +0x1.c0e2a6bdbc1dfp-2 +0x1.c0d0f9990b9b3p-7 +0x1.29b24da8f2a0bp-1 +0x1.29b24da8f2a0bp-1 +0x1.cf07c6c271f5p-3 +0x1.cf07c6c271f5p-3 +0x1.486609099ca76p-1 +0x0p+0 +0x1.498f60f3c668ep-6 +0x0p+0 +0x1.9e823bb929b8p-1 +0x0p+0 +0x1.3b51c858f73afp-2 +0x1.3b51c858f73afp-2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8b7d3a6379e1dp-2 +0x1.8b7d3a6379e1dp-2 +0x1.d862ab157e756p-2 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.4f3793def901cp-3 +0x1.3a6df5c51019dp-2 +0x1.521b67c43949cp-2 +0x1.b43f0443f50d6p-2 +0x1.2c61dddba2a6cp-1 +0x1.095314f8de7fep-1 +0x1.0b28ebd7fad49p-2 +0x1.87482fbba2b8ep-1 +0x1.29ec58fab2ec4p-1 +0x1.c3e99591c9698p-2 +0x1.720941f4b6b9bp-3 +0x1.3b51c858f73afp-1 +0x1.136dcf64b310ap-1 +0x1.1bcbbaf4eae08p-2 +-0x1.287329d5245aep-2 +0x1.224bbb0bd91dcp-4 +-0x1.b035f81dcd337p-7 +-0x1.53a0314bf0c25p-1 +-0x1.3de66e628f07p-1 +-0x1.035244bae36fbp-2 +-0x1.3f6bbe1f1524dp-3 +-0x1.0d0d532c4ad41p-2 +-0x1.353f61ea40aa6p-4 +-0x1.650811e95f329p-2 +-0x1.086350168b226p-1 +-0x1.f5402d328ce6cp-3 +-0x1.9ef7c860fabbbp-2 +-0x1.4cb45b812948fp-7 +-0x1.186eda938a70ep-1 +-0x1.6c7ccf653274ep-3 +-0x1.600889207e844p-5 +-0x1.d6cd59d63ed9ep-3 +-0x1.36e5f9052ef0ap-5 +-0x1.4f3dd0435573ap-5 +-0x1.e9a543a495fe9p-3 +-0x1.ff80a69d541fep-4 +-0x1.3f4b5cfeb5a55p-3 +-0x1.1b259eddb89ecp-2 +-0x1.c5fddc91ba213p-2 +-0x1.4c5366ae69e6cp-5 +-0x1.ba90101653accp-1 +-0x1.37313a3a16529p-3 +-0x1.05a25cb01456dp-2 +-0x1.b79eb07d6194dp-2 +-0x1.b754e18cc668dp-6 +-0x1.b6f83de3a845ep-5 +-0x1.ea01c1b780874p-3 +-0x1.40ae1e4552763p-4 +-0x1.f0c349f347aeap-3 +-0x1.3e034edca954dp-3 +-0x1.fc3d8aea73fc7p+4 +-0x1.0903f9856412ep+5 +-0x1.9f78a3ea12fa4p+4 +-0x1.90fdcd25d5b0ep+4 +-0x1.b7b742de076b7p+4 +-0x1.cbc50e5d7707cp+4 +-0x1.67b5cf04ae2dep+4 +-0x1.5c078f931209fp+4 +-0x1.7f0941b7615a6p+4 +-0x1.90144a970665ep+4 +-0x1.37af7213655d7p+4 +-0x1.2e780f4c9b857p+4 +-0x1.500df7b4e29dp+4 +-0x1.5e0836722d793p+4 +-0x1.0ecbf7bf9e9b6p+4 +-0x1.07dd9f0ba5c54p+4 +-0x1.28e4e98fc31bcp+4 +-0x1.349020640c5e5p+4 +-0x1.da4025d967be2p+3 +-0x1.cf4ae73df4677p+3 +-0x1.097f8d4db1d4p+4 +-0x1.134ecc652feb3p+4 +-0x1.a470382955771p+3 +-0x1.9b826cf7a7accp+3 +-0x1.e042f0a7262b6p+3 +-0x1.f13eb369c17bfp+3 +-0x1.79022e3bde406p+3 +-0x1.71e6608aa903cp+3 +-0x1.b9c2c746a80f4p+3 +-0x1.c8df4e41912fdp+3 +-0x1.586eff46a0b49p+3 +-0x1.5260bae0b2edbp+3 +-0x1.9f0e922caf739p+3 +-0x1.ad132d561c2e5p+3 +-0x1.4329633f2b39ap+3 +-0x1.3d1eea122108ep+3 +-0x1.8470822d413dp+3 +-0x1.914a83aebe768p+3 +-0x1.2e1eaf893f16dp+3 +-0x1.280a18e5da054p+3 +-0x1.69e3477659109p+3 +-0x1.75748068a0a52p+3 +-0x1.1942a06e4d38cp+3 +-0x1.131dcecf559d7p+3 +-0x1.4f99396a2e765p+3 +-0x1.59b2ef4db47b1p+3 +-0x1.0487fe3bfd6f5p+3 +-0x1.fcd9bcf478b84p+2 +-0x1.358cd45a032a8p+3 +-0x1.3e35d255a01e5p+3 +-0x1.e01d2adf15da1p+2 +-0x1.d46fdf506dbbcp+2 +-0x1.1b780772a8e97p+3 +-0x1.22da9c187027cp+3 +-0x1.b77a21c881f4p+2 +-0x1.acca9c01901ddp+2 +-0x1.01579a86fa6c6p+3 +-0x1.078d1f7b6db7dp+3 +-0x1.8ee42ea0be806p+2 +-0x1.85b19b09087b8p+2 +-0x1.cd92b3a8e40e5p+2 +-0x1.d818c008fc59ap+2 +-0x1.65cfdc87dc526p+2 +-0x1.5e81fd02f566ap+2 +-0x1.976eb20b837aep+2 +-0x1.a0a274609c513p+2 +-0x1.3bfc0be2fafcep+2 +-0x1.3625dd583d83p+2 +-0x1.5ff48944d3d9cp+2 +-0x1.682a0dfa733cap+2 +-0x1.1168a77e16b1p+2 +-0x1.0bfd4e6ee79a9p+2 +-0x1.27136e71dfd29p+2 +-0x1.2e9a43a04a381p+2 +-0x1.ca9b0629079cdp+1 +-0x1.c04a593824617p+1 +-0x1.d8715fec7b635p+1 +-0x1.e52ab954ee64ep+1 +-0x1.6e820ea13a007p+1 +-0x1.65680d937109ep+1 +-0x1.5e1a4931c6fdap+1 +-0x1.67b2ec8cf010ep+1 +-0x1.0ef10eab62cf9p+1 +-0x1.06d9b66bbb35ep+1 +-0x1.e65538ddcf43cp+0 +-0x1.f393cdf6941a3p+0 +-0x1.78016503accf9p+0 +-0x1.6c0d8a9b13fa5p+0 +-0x1.3542c574881aep+0 +-0x1.3d308152f7a7ep+0 +-0x1.dd82173fef7c9p-1 +-0x1.cdfb152ecd2d3p-1 +-0x1.576ac7fc70954p-1 +-0x1.5fb112e53f491p-1 +-0x1.091a9e8331a38p-1 +-0x1.0040b1b2a2678p-1 +-0x1.31fdf4edfcd55p-2 +-0x1.38eac4398914ap-2 +-0x1.d8e2197f230fcp-3 +-0x1.c83b170c6a7fap-3 +-0x1.98cc4ac61dc9ep-4 +-0x1.a22ea7c908a49p-4 +-0x1.3cdd7de507f5p-4 +-0x1.312e51e7f254ap-4 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.dd1a560aee2a8p-17 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.03a2ba086a9ap-3 +-0x1.dc6d30eb6c57dp-3 +-0x0p+0 +-0x1.b1a01eeed875bp-3 +-0x0p+0 +-0x1.485dc03e67913p-1 +-0x0p+0 +-0x1.81b3170e668d3p-2 +-0x1.77ac4880b042p-9 +-0x1.2a5d2084fb273p-1 +-0x0p+0 +-0x1.c38a3ea6385a1p+0 +-0x1.576e10e952cc3p-3 +-0x1.798b271ecba01p-1 +-0x1.360859f80ebe6p+1 +-0x0p+0 +-0x1.4c91305e54f23p+5 +-0x1.e98d91dfd1fc1p-15 +-0x1.1200e42f92904p+7 +-0x1.3ec6e1213a6d2p+7 +-0x1.61619b200bdc9p+3 +-0x0p+0 +-0x1.de09737c189edp-5 +-0x1.df7b6775e37fcp+4 +-0x1.a33734be689e2p-12 +-0x0p+0 +-0x1.9f48653d3418p+0 +-0x1.7706065634046p+2 +-0x1.92a43e5724443p-16 +-0x0p+0 +-0x0p+0 +-0x1.d9d83178e3aa5p-14 +-0x1.667e6d99abda8p-16 +-0x0p+0 +-0x0p+0 +-0x1.3f8429b906accp+1 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.f252b08f1a1efp+0 +-0x1.9p+4 +-0x1.713b84ea397f9p+1 +-0x1.2f4462e785496p+1 +-0x1.32bf4534a4ac2p+1 +-0x1.9p+4 +-0x1.c6916a51f8187p+1 +-0x1.755b9bb59313ap+1 +-0x1.01309ddea97p+2 +-0x1.9p+4 +-0x1.64aee239e67ecp+2 +-0x1.25119eb723bc9p+2 +-0x1.5a930d37ac32fp+2 +-0x1.9p+4 +-0x1.0bc2a90e8e0f1p+3 +-0x1.b81c12a7342a8p+2 +-0x1.b63050a2b84cp+2 +-0x1.9p+4 +-0x1.48f13e93325p+3 +-0x1.0e768e217972fp+3 +-0x1.ece0e2f2ea721p+2 +-0x1.9p+4 +-0x1.2742f984d780fp+3 +-0x1.e626b4b10f32ep+2 +-0x1.b5d687788eb96p+2 +-0x1.9p+4 +-0x1.ca7fb013bcf9p+2 +-0x1.7a433979371a3p+2 +-0x1.32f1c7815a697p+2 +-0x1.9p+4 +-0x1.337e2229172f3p+2 +-0x1.fcfa6704cd295p+1 +-0x1.7a19a211b1324p+1 +-0x1.9p+4 +-0x1.662c5fc1e22acp+1 +-0x1.29a8df586c9c8p+1 +-0x1.551df9e212197p+1 +-0x1.9p+4 +-0x1.33d5ffad41e33p+1 +-0x1.012495f15c38p+1 +-0x1.39721367a2983p+1 +-0x1.9p+4 +-0x1.099990b2ad656p+1 +-0x1.bed0f11576373p+0 +-0x1.29e317e85e759p+1 +-0x1.9p+4 +-0x1.d3eab038a894dp+0 +-0x1.8d0de1212013bp+0 +-0x1.152261f3afd5ep+1 +-0x1.9p+4 +-0x1.aa56ee1988807p+0 +-0x1.6d7ca6dbd160ap+0 +-0x1.d4b392d935cb7p+0 +-0x1.9p+4 +-0x1.86dbf85ba9374p+0 +-0x1.536aa625d72f7p+0 +-0x1.5a00463fcd6ap+0 +-0x1.9p+4 +-0x1.5f117fba1726fp+0 +-0x1.3674f3aa40977p+0 +-0x1.ed5bf9085f6dbp-1 +-0x1.9p+4 +-0x1.2fae8574fcbf5p+0 +-0x1.1425db522071ap+0 +-0x1.7517db925465dp-1 +-0x1.9p+4 +-0x1.7517b221ce113p-1 +-0x1.9p+4 +-0x1.0371a2b82ca67p+0 +-0x1.eb43031892b4dp-1 +-0x1.47587c835ad5dp-1 +-0x1.9p+4 +-0x1.3c2f23cdeff92p-1 +-0x1.9p+4 +-0x1.eab050345fc19p-1 +-0x1.0e9ff0c24b4c9p+0 +-0x1.d669df8c5f7e9p-1 +-0x1.d147bf38ddb9ep-1 +-0x1.28f066d9c7a42p-1 +-0x1.9p+4 +-0x1.f6fc0cfa341c9p-1 +-0x1.2f528f4bc9fb1p+0 +-0x1.d7900e28d8e32p-1 +-0x1.e27204569debp-1 +-0x1.27fa639fcf24bp-1 +-0x1.9p+4 +-0x1.27c478e23bd5cp-1 +-0x1.9p+4 +-0x1.28177e558de79p+0 +-0x1.bb9b81954b879p+0 +-0x1.fe1563d7c16c1p-1 +-0x1.0a52fa149a28ep+0 +-0x1.422a3395b2c5cp-1 +-0x1.9p+4 +-0x1.3a0eb3e2c4c33p-1 +-0x1.9p+4 +-0x1.1e1ee947b5bd9p+0 +-0x1.2e4f54310488ep+0 +-0x1.d9a5517a17e35p+0 +-0x1.9p+4 +-0x1.31c69a4473283p-1 +-0x1.9p+4 +-0x1.4096bf31e0419p+2 +-0x1.9p+4 +-0x1.0e3f42094ca24p+0 +-0x1.20ab49bdaa86ep+0 +-0x1.f65e8499c325bp-1 +-0x1.9p+4 +-0x1.16cd7b24a2f2ap-1 +-0x1.9p+4 +-0x1.17a1929f48f99p+1 +-0x1.3916dfecc4fe8p+3 +-0x1.e0d32a81ceb8ep-1 +-0x1.074a1a8e2f933p+0 +-0x1.d05f644a0fbdbp-2 +-0x1.9p+4 +-0x1.195df064a1a81p+0 +-0x1.49dcb0bb58a18p+1 +-0x1.8a935c0ffd6eap-1 +-0x1.bc32a79715bf4p-1 +-0x1.528cf0c4546c9p-2 +-0x1.9p+4 +-0x1.16b7cd2df76cfp-1 +-0x1.3292ae839bce2p-1 +-0x1.761e84bd105dep-3 +-0x1.9p+4 +-0x1.be02b34977976p-2 +-0x1.1040ef616203ap+0 +-0x1.31a356a9ccb0dp-2 +-0x1.574f62abbc619p-2 +-0x1.7d6efe2e41329p-4 +-0x1.9p+4 +-0x1.3572514b03262p-3 +-0x1.57ce967081994p-3 +-0x1.2e8965cfa80dfp+2 +-0x1.9p+4 +-0x1.c0c48943c732cp+2 +-0x1.6ffe8bf55401ep+2 +-0x1.74750bf35218ap+2 +-0x1.9p+4 +-0x1.143df2d10d39fp+3 +-0x1.c50b0c190bf2p+2 +-0x1.38306c506a078p+3 +-0x1.9p+4 +-0x1.b15bdddb01ec3p+3 +-0x1.63637ac4021bdp+3 +-0x1.a463580315fcdp+3 +-0x1.9p+4 +-0x1.453fee3bb5a42p+4 +-0x1.0abe730e8cebap+4 +-0x1.099b47d006285p+4 +-0x1.9p+4 +-0x1.8f62e52a777cp+4 +-0x1.47944958a5937p+4 +-0x1.2a9930faeb588p+4 +-0x1.9p+4 +-0x1.660e8b34afacep+4 +-0x1.25c36789acb9cp+4 +-0x1.08db39ed3d98cp+4 +-0x1.9p+4 +-0x1.156fc6af345c7p+4 +-0x1.c774b4576f214p+3 +-0x1.7252ecc725dedp+3 +-0x1.9p+4 +-0x1.72fd791b8f26ap+3 +-0x1.30bcd479673f6p+3 +-0x1.c689e71cb155bp+2 +-0x1.9p+4 +-0x1.ae6dd46d6a31p+2 +-0x1.61e49cfa1675ap+2 +-0x1.9878bb1129228p+2 +-0x1.9p+4 +-0x1.70213138f1bb2p+2 +-0x1.2f06c5766da3cp+2 +-0x1.7592a28587903p+2 +-0x1.9p+4 +-0x1.3b896c3cd69c8p+2 +-0x1.04269eb6bfad6p+2 +-0x1.6139178c40589p+2 +-0x1.9p+4 +-0x1.13a9c7d2976efp+2 +-0x1.c77bed5913fccp+1 +-0x1.46530febf41f5p+2 +-0x1.9p+4 +-0x1.f19636b806318p+1 +-0x1.9c14dea697a7ep+1 +-0x1.1062e8c64c16fp+2 +-0x1.9p+4 +-0x1.c2ce8a813d70bp+1 +-0x1.76802b0c3e071p+1 +-0x1.8771d4abac328p+1 +-0x1.9p+4 +-0x1.8e50843079d12p+1 +-0x1.4c6108aa18666p+1 +-0x1.0a9e1b883b726p+1 +-0x1.9p+4 +-0x1.502f4257f9821p+1 +-0x1.1a8920129123bp+1 +-0x1.7b66199a0b78bp+0 +-0x1.9p+4 +-0x1.7b6600c9d7b87p+0 +-0x1.9p+4 +-0x1.1592ec9313531p+1 +-0x1.d7a80c5be56a6p+0 +-0x1.3594d22f5d649p+0 +-0x1.9p+4 +-0x1.2e6f6c2409af3p+0 +-0x1.9p+4 +-0x1.f1b0eb074aa9dp+0 +-0x1.c7bb355a1c0e4p+0 +-0x1.e5a0757da96a2p+0 +-0x1.a1bf24343f9eap+0 +-0x1.0e03526376599p+0 +-0x1.9p+4 +-0x1.ed79979ee81b8p+0 +-0x1.da3f6bbfbf106p+0 +-0x1.da3680c4507eep+0 +-0x1.9c25de9f440adp+0 +-0x1.02259ea2b9454p+0 +-0x1.9p+4 +-0x1.01fffba449a02p+0 +-0x1.9p+4 +-0x1.1684042a662dcp+1 +-0x1.35a05ae6e53f4p+1 +-0x1.f92e280125595p+0 +-0x1.b9f82e4d19202p+0 +-0x1.107b6d1c1c8fap+0 +-0x1.9p+4 +-0x1.0aa8288b0f6ffp+0 +-0x1.9p+4 +-0x1.18d6383220dd1p+1 +-0x1.ed384df701fb7p+0 +-0x1.75057a097c9c9p+1 +-0x1.9p+4 +-0x1.03647683c8fap+0 +-0x1.9p+4 +-0x1.fa43d4245df0ep+2 +-0x1.9p+4 +-0x1.07690029fe7dep+1 +-0x1.d0832041d6567p+0 +-0x1.92cda7ae1c129p+0 +-0x1.9p+4 +-0x1.d8ee2a27fe701p-1 +-0x1.9p+4 +-0x1.c966373c44f99p+1 +-0x1.4c1d90d414e87p+3 +-0x1.d1046b3bc6a1p+0 +-0x1.9f7fa1c8aee21p+0 +-0x1.89f04c04ddd61p-1 +-0x1.9p+4 +-0x1.eb5fb116ecda3p+0 +-0x1.86aa1db3baa3cp+1 +-0x1.7acb0a7d01adfp+0 +-0x1.57b42dbc4ee3dp+0 +-0x1.1f33c86182e44p-1 +-0x1.9p+4 +-0x1.0b6654de9f0a1p+0 +-0x1.dd885b94c4d01p-1 +-0x1.3d5f943b9be7fp-2 +-0x1.9p+4 +-0x1.82801e0646f25p-1 +-0x1.3e5e9443f410cp+0 +-0x1.23d92cc79faf2p-1 +-0x1.07e2fb1b024aep-1 +-0x1.43946557d450bp-3 +-0x1.9p+4 +-0x1.279c11b6c16ebp-2 +-0x1.0945dc3e1a877p-2 +-0x1.ade104215d335p+1 +-0x1.9p+4 +-0x1.3ed25719ef617p+2 +-0x1.0572f5c6151p+2 +-0x1.089d7d930889dp+2 +-0x1.9p+4 +-0x1.88817ab5b9b76p+2 +-0x1.41dfbd988525dp+2 +-0x1.bb992e09d43b4p+2 +-0x1.9p+4 +-0x1.33e0bb1afec7ep+3 +-0x1.f8fee94852b12p+2 +-0x1.2aad399a5d6dap+3 +-0x1.9p+4 +-0x1.ce25b3809ee31p+3 +-0x1.7b09ec1d8c69fp+3 +-0x1.796beaf7ac449p+3 +-0x1.9p+4 +-0x1.1bbf637ae2d3bp+4 +-0x1.d17ed987dc838p+3 +-0x1.a84f04bc6cf05p+3 +-0x1.9p+4 +-0x1.fcc976b7582d9p+3 +-0x1.a177eccc5530cp+3 +-0x1.7860919647492p+3 +-0x1.9p+4 +-0x1.8a4058de9313ap+3 +-0x1.43a8c973d0997p+3 +-0x1.0725bece2cefdp+3 +-0x1.9p+4 +-0x1.079ef5a2b6d98p+3 +-0x1.b12d9c6c7ecebp+2 +-0x1.4305cf841cd51p+2 +-0x1.9p+4 +-0x1.31e47c4652257p+2 +-0x1.f727c999ef1fep+1 +-0x1.22515316c7b65p+2 +-0x1.9p+4 +-0x1.05a7df6c25ccap+2 +-0x1.aef225d2c5106p+1 +-0x1.098cd91099049p+2 +-0x1.9p+4 +-0x1.c0a2cd5b32feep+1 +-0x1.7219cab9bff22p+1 +-0x1.f63ec49bc915cp+1 +-0x1.9p+4 +-0x1.880a3f2f9dbe6p+1 +-0x1.4423ba05e64eap+1 +-0x1.d01867caf31c2p+1 +-0x1.9p+4 +-0x1.61edeef34bbefp+1 +-0x1.25681b02d8716p+1 +-0x1.8389c319042d8p+1 +-0x1.9p+4 +-0x1.40c61182f6919p+1 +-0x1.0ad3b26ecc3bp+1 +-0x1.16b38e46a6f05p+1 +-0x1.9p+4 +-0x1.1b923a11938f4p+1 +-0x1.da150c9b21e05p+0 +-0x1.7c3d75cd8341ap+0 +-0x1.9p+4 +-0x1.df1187c171e43p+0 +-0x1.939673fdeb3e2p+0 +-0x1.0f294a3d78259p+0 +-0x1.9p+4 +-0x1.0f29319392128p+0 +-0x1.9p+4 +-0x1.8c07655e3bfb6p+0 +-0x1.51a1a2f309691p+0 +-0x1.bf89883139761p-1 +-0x1.9p+4 +-0x1.b16e1d87de693p-1 +-0x1.9p+4 +-0x1.66d734e061c18p+0 +-0x1.51c1770a78873p+0 +-0x1.5ae6109598398p+0 +-0x1.2bc565e49c178p+0 +-0x1.83e78f31aa196p-1 +-0x1.9p+4 +-0x1.661c940c0c598p+0 +-0x1.66789f2df722bp+0 +-0x1.531e4da8661ffp+0 +-0x1.285f120d7c1d2p+0 +-0x1.73c390ad3b466p-1 +-0x1.9p+4 +-0x1.73794b1717e48p-1 +-0x1.9p+4 +-0x1.9c1a7783b9aeep+0 +-0x1.ef8c381a33cb1p+0 +-0x1.69859ded6e524p+0 +-0x1.3e43b099826c7p+0 +-0x1.8bf63dee5e0aap-1 +-0x1.9p+4 +-0x1.8087037d1db7ep-1 +-0x1.9p+4 +-0x1.921b3c3ef7961p+0 +-0x1.6368eec69c8b1p+0 +-0x1.3546cefeb7d07p+1 +-0x1.9p+4 +-0x1.7609375851afp-1 +-0x1.9p+4 +-0x1.a6bab928b1aa2p+2 +-0x1.9p+4 +-0x1.7954292bd9644p+0 +-0x1.4f1c38ae06826p+0 +-0x1.437d56905f051p+0 +-0x1.9p+4 +-0x1.553217cd7a994p-1 +-0x1.9p+4 +-0x1.7398a2c2b36bcp+1 +-0x1.3de8cab2dfddap+3 +-0x1.4dbc00a0e9e86p+0 +-0x1.2dd970bf068c5p+0 +-0x1.1c028b4268062p-1 +-0x1.9p+4 +-0x1.7b528df360bfbp+0 +-0x1.58c5d9418b659p+1 +-0x1.108c2609a9dbap+0 +-0x1.f7d749afe0cf7p-1 +-0x1.9e1c73926f38cp-2 +-0x1.9p+4 +-0x1.7f9c6b3a98a1dp-1 +-0x1.59fcfb73036e5p-1 +-0x1.c9a01926ca3acp-3 +-0x1.9p+4 +-0x1.2b4f4f270fb92p-1 +-0x1.1a9431e08e75p+0 +-0x1.a35dc777820a1p-2 +-0x1.809c6ca86e26dp-2 +-0x1.d2917d1269f02p-4 +-0x1.6731f9cfa53cap+4 +-0x1.a857aeabbeccap-3 +-0x1.81292f10056dp-3 +-0x1.a3719755148a5p+0 +-0x1.9p+4 +-0x1.3702a8208620cp+1 +-0x1.fe4854afc9aafp+0 +-0x1.02313b8348193p+1 +-0x1.9p+4 +-0x1.7ee3cdc8270bap+1 +-0x1.3a1bfa1095e1p+1 +-0x1.b0dcbecdd1a1fp+1 +-0x1.9p+4 +-0x1.2c5c595b82cb7p+2 +-0x1.ece39089650b6p+1 +-0x1.237f55dcc4a36p+2 +-0x1.9p+4 +-0x1.c2e3042f2d2bep+2 +-0x1.71fc6acea7f7cp+2 +-0x1.70662df101f7fp+2 +-0x1.9p+4 +-0x1.14dd1f5534d13p+3 +-0x1.c6774cf126f38p+2 +-0x1.9e37af7d3ce99p+2 +-0x1.9p+4 +-0x1.f0964869d723bp+2 +-0x1.97ca03113b108p+2 +-0x1.6f8e9e452ce1dp+2 +-0x1.9p+4 +-0x1.80fc4d06abd61p+2 +-0x1.3c6ed3bb7d531p+2 +-0x1.0126af7fb14cap+2 +-0x1.9p+4 +-0x1.019d1635eb352p+2 +-0x1.a810ab977e47dp+1 +-0x1.3bef0bae26cccp+1 +-0x1.9p+4 +-0x1.2b34e8aebc4f2p+1 +-0x1.ed6a9cb92957ep+0 +-0x1.1c372e17dbd6ap+1 +-0x1.9p+4 +-0x1.003d8bce77f8bp+1 +-0x1.a78270170811p+0 +-0x1.0444120330212p+1 +-0x1.9p+4 +-0x1.b80eb63652231p+0 +-0x1.6cc57c09d44fp+0 +-0x1.ecdd6ef21e17ap+0 +-0x1.9p+4 +-0x1.8153ba0734eb1p+0 +-0x1.40a6494022592p+0 +-0x1.c836abd38826bp+0 +-0x1.9p+4 +-0x1.5cb2313ba6a1p+0 +-0x1.237f833ef6d59p+0 +-0x1.7e31afb3d25f8p+0 +-0x1.9p+4 +-0x1.3cfb10b17f4a3p+0 +-0x1.0a89f52928b72p+0 +-0x1.14c486ce3e9bp+0 +-0x1.9p+4 +-0x1.196882ae70f36p+0 +-0x1.dd3c98e219753p-1 +-0x1.7e45c7adc91c2p-1 +-0x1.9p+4 +-0x1.de856ddb80ca1p-1 +-0x1.9b23e089dfcfap-1 +-0x1.1572e85e27e9bp-1 +-0x1.9p+4 +-0x1.1572b95c41e48p-1 +-0x1.9p+4 +-0x1.8f5643a864c87p-1 +-0x1.5e06d843078e3p-1 +-0x1.de14be5e8e181p-2 +-0x1.9p+4 +-0x1.c4060262041aap-2 +-0x1.9p+4 +-0x1.77f3d67d0482ep-1 +-0x1.88b25a9219748p-1 +-0x1.616a2c7a3c6b6p-1 +-0x1.3cba384660953p-1 +-0x1.9b7639948521ep-2 +-0x1.9p+4 +-0x1.7f910c24da6c3p-1 +-0x1.ba1842146046dp-1 +-0x1.5c44c4d81e8dbp-1 +-0x1.3de527d36a3bdp-1 +-0x1.906dcacda4bedp-2 +-0x1.9p+4 +-0x1.8fe7482e2ecb7p-2 +-0x1.9p+4 +-0x1.d04666d6f682p-1 +-0x1.5d9764941a455p+0 +-0x1.751b496a5efb7p-1 +-0x1.589dba26d1cd8p-1 +-0x1.b6685aef90297p-2 +-0x1.9p+4 +-0x1.a2165341054abp-2 +-0x1.9p+4 +-0x1.a0298f6031d3ap-1 +-0x1.82cfb2d386002p-1 +-0x1.a82094fb92526p+0 +-0x1.9p+4 +-0x1.96ba4e63db355p-2 +-0x1.9p+4 +-0x1.23fe99923d455p+2 +-0x1.9p+4 +-0x1.878c98508d199p-1 +-0x1.6edb1011c0d1fp-1 +-0x1.aa69ba1b06d66p-1 +-0x1.9p+4 +-0x1.737e90076d605p-2 +-0x1.9p+4 +-0x1.ef710f1bc49ebp+0 +-0x1.2d3edf872d18dp+3 +-0x1.5c741c94369a2p-1 +-0x1.51142ec2e0ca9p-1 +-0x1.34cbc46c49d17p-2 +-0x1.9p+4 +-0x1.d2c68ca2c408p-1 +-0x1.22b5679795cap+1 +-0x1.1e7c57fcbff82p-1 +-0x1.1f9583080a615p-1 +-0x1.c23cbf63b2397p-3 +-0x1.9p+4 +-0x1.90ebecab94865p-2 +-0x1.81a4a6f4427d5p-2 +-0x1.f193299a4b4d2p-4 +-0x1.9p+4 +-0x1.72dc960cad1cdp-2 +-0x1.e1f243c58e6c7p-1 +-0x1.b8945eeda419p-3 +-0x1.b4605962a2569p-3 +-0x1.fb48bedf519a7p-5 +-0x1.adbe753c816dbp+3 +-0x1.bc9978c18552p-4 +-0x1.b05cddf68c394p-4 +-0x1.2bf5d4ec3edc3p-1 +-0x1.9p+4 +-0x1.bc7e227a6beb6p-1 +-0x1.6d1b69194e6c5p-1 +-0x1.714a1a7ab68p-1 +-0x1.9p+4 +-0x1.119cd440fe246p+0 +-0x1.c17eaca6b8e11p-1 +-0x1.35a1da632ea32p+0 +-0x1.9p+4 +-0x1.ad65193f2dd3bp+0 +-0x1.60d7dff252ac8p+0 +-0x1.a1418c6cbf101p+0 +-0x1.9p+4 +-0x1.425914f795e68p+1 +-0x1.08f12869c5026p+1 +-0x1.07c8af839a57p+1 +-0x1.9p+4 +-0x1.8c02d8764230dp+1 +-0x1.45a5108fde577p+1 +-0x1.28b6a10b0c278p+1 +-0x1.9p+4 +-0x1.637b9a5a96c73p+1 +-0x1.24b2df840347ep+1 +-0x1.0798b834322e2p+1 +-0x1.9p+4 +-0x1.140866428ec26p+1 +-0x1.c78fa101b5ac1p+0 +-0x1.71a1cccda3685p+0 +-0x1.9p+4 +-0x1.724bce8c06627p+0 +-0x1.3292a6643da3p+0 +-0x1.c7645d4f7a5d9p-1 +-0x1.9p+4 +-0x1.af6868da488bap-1 +-0x1.66b2ce0319239p-1 +-0x1.9aeb6a75a026ep-1 +-0x1.9p+4 +-0x1.72dcfeeb687bdp-1 +-0x1.360062b7942afp-1 +-0x1.79a9c550da82ap-1 +-0x1.9p+4 +-0x1.4013ee834ccep-1 +-0x1.0d7b33791654ep-1 +-0x1.66ff283a665c9p-1 +-0x1.9p+4 +-0x1.1a0ddbe7b3007p-1 +-0x1.df44d11121aeap-2 +-0x1.4e165840a687p-1 +-0x1.9p+4 +-0x1.011ac8e4869f2p-1 +-0x1.b983ac6d27396p-2 +-0x1.1aa9c3ae5d9b6p-1 +-0x1.9p+4 +-0x1.d7aaad5f3f593p-2 +-0x1.9a6a6cdbaf73p-2 +-0x1.a1c3f0e8a3f83p-2 +-0x1.9p+4 +-0x1.a7f03325b58adp-2 +-0x1.77de306accc8cp-2 +-0x1.2a52faf4d4a06p-2 +-0x1.9p+4 +-0x1.6f11717b5ee7ep-2 +-0x1.4eef3d184954ap-2 +-0x1.c41554c5c3f58p-3 +-0x1.9p+4 +-0x1.c414b0174a085p-3 +-0x1.9p+4 +-0x1.3a11238a44d9p-2 +-0x1.2ae30e9123b6ap-2 +-0x1.aa81d1e63c353p-3 +-0x1.9p+4 +-0x1.7fd28b9dd90b2p-3 +-0x1.9p+4 +-0x1.43a354ba0aa7bp-2 +-0x1.b3983b8da9bc4p-2 +-0x1.1d13b33dc919ap-2 +-0x1.1ba7f6f637fdbp-2 +-0x1.691496aca1107p-3 +-0x1.9p+4 +-0x1.58b164d3979ddp-2 +-0x1.0fbf4cdaeb349p-1 +-0x1.1e33ca474b4bp-2 +-0x1.27186533ea531p-2 +-0x1.691b45a1e6fdep-3 +-0x1.9p+4 +-0x1.68464975e52e4p-3 +-0x1.9p+4 +-0x1.c500f25a0013ep-2 +-0x1.0301ad88f7d44p+0 +-0x1.36025a189b38ep-2 +-0x1.46e4982119d69p-2 +-0x1.9e14575d6caaep-3 +-0x1.9p+4 +-0x1.7ee9a25a05412p-3 +-0x1.9p+4 +-0x1.5bea6088c54d1p-2 +-0x1.73196fb03dc53p-2 +-0x1.f4f206df5aab3p-1 +-0x1.9p+4 +-0x1.748fe287d1955p-3 +-0x1.9p+4 +-0x1.5aec6a82da52dp+1 +-0x1.9p+4 +-0x1.49381f8287377p-2 +-0x1.649bd16aa63b6p-2 +-0x1.e944e478f008ep-2 +-0x1.9p+4 +-0x1.551ada9db43fap-3 +-0x1.9p+4 +-0x1.1f14fd27c5364p+0 +-0x1.22e47913e2a4fp+3 +-0x1.29085b15acb97p-2 +-0x1.56db8f1c7314bp-2 +-0x1.1acbe426720fbp-3 +-0x1.9p+4 +-0x1.f98a5645494a6p-2 +-0x1.012c820bffa1fp+1 +-0x1.efa81ae8ad5c2p-3 +-0x1.32e3d9b363809p-2 +-0x1.9c4e5c0ae0c6bp-4 +-0x1.9p+4 +-0x1.564759b8381f1p-3 +-0x1.861675d0668bep-3 +-0x1.c7b323a1df111p-5 +-0x1.e4ffff6361aa1p+3 +-0x1.943cfa38c839bp-3 +-0x1.ae21a136f42bep-1 +-0x1.7c41d448bbe13p-4 +-0x1.ca3b9e5072a8p-4 +-0x1.d0919ea5f0cb5p-6 +-0x1.ee43f0476eec2p+2 +-0x1.7d940be7e14a4p-5 +-0x1.bc2286957878cp-5 +-0x1.4c8ecc3b5cd84p-3 +-0x1.9p+4 +-0x1.eb7198adfbae3p-3 +-0x1.958c4752c6579p-3 +-0x1.996f331a83266p-3 +-0x1.9p+4 +-0x1.2e854bdc2025dp-2 +-0x1.f34d8d56b80bp-3 +-0x1.5795a5d7104d8p-2 +-0x1.9p+4 +-0x1.db3e5a354e0c4p-2 +-0x1.88a8c221bb5adp-2 +-0x1.cfef2c41bd2a7p-2 +-0x1.9p+4 +-0x1.64fc5b6c5f435p-1 +-0x1.272a6fced475fp-1 +-0x1.25c18e6c195dep-1 +-0x1.9p+4 +-0x1.b72011c9be94cp-1 +-0x1.6ba1a71ba6247p-1 +-0x1.4ae9676082702p-1 +-0x1.9p+4 +-0x1.8b873b4d16251p-1 +-0x1.48dbaa4497bedp-1 +-0x1.2730c7a58d566p-1 +-0x1.9p+4 +-0x1.34df0093971e2p-1 +-0x1.028dfa5d3edd5p-1 +-0x1.a10d31195b39p-2 +-0x1.9p+4 +-0x1.a1ccc23b2480ep-2 +-0x1.6144c91e09a74p-2 +-0x1.0359e58b9541cp-2 +-0x1.9p+4 +-0x1.ebdf5bf92056ep-3 +-0x1.a54892d97f499p-3 +-0x1.d8ca7ffc31402p-3 +-0x1.9p+4 +-0x1.ac2d990249775p-3 +-0x1.7487afaf53dfep-3 +-0x1.b7a6cbb959f4ep-3 +-0x1.9p+4 +-0x1.779311f978045p-3 +-0x1.4d9ba2ef96bc8p-3 +-0x1.a7151aac1d27ep-3 +-0x1.9p+4 +-0x1.516616ae5f0fbp-3 +-0x1.33698a789d88bp-3 +-0x1.9022b7d46a593p-3 +-0x1.9p+4 +-0x1.3a1064d8a103bp-3 +-0x1.2671ed70f72aap-3 +-0x1.5c2c54dc8aeb1p-3 +-0x1.9p+4 +-0x1.2730a458e9c3ep-3 +-0x1.1e800934ebde5p-3 +-0x1.0ee3e50a64ce6p-3 +-0x1.9p+4 +-0x1.11aa65a408602p-3 +-0x1.163a712538612p-3 +-0x1.9f718cdd4a05p-4 +-0x1.7ef6259fd6873p+4 +-0x1.edd9b936449dcp-4 +-0x1.0c551eacca0acp-3 +-0x1.52c72725fac06p-4 +-0x1.6a9fb95693c3cp+4 +-0x1.52c6357715451p-4 +-0x1.6a9bdcb2641dcp+4 +-0x1.bbfd83ba4a8d7p-4 +-0x1.07de605eebac9p-3 +-0x1.699c3763b2bb9p-4 +-0x1.9p+4 +-0x1.307eee998d8c3p-4 +-0x1.77ffb624178dcp+4 +-0x1.08eb87af4017ep-3 +-0x1.204f0923c021bp-2 +-0x1.a4fda052ae708p-4 +-0x1.10bd89189cc6p-3 +-0x1.29aa94bbbc389p-4 +-0x1.9p+4 +-0x1.28c422d785436p-3 +-0x1.8eb32e5dbce4fp-2 +-0x1.b3192bc7c903fp-4 +-0x1.2c99f3b7a19d9p-3 +-0x1.323d741a2477fp-4 +-0x1.9p+4 +-0x1.312900463686dp-4 +-0x1.9p+4 +-0x1.a5f9f84251f3p-3 +-0x1.b8930d52b0a32p-1 +-0x1.df10921adef1fp-4 +-0x1.5807f94537978p-3 +-0x1.7092a3e9e2defp-4 +-0x1.9p+4 +-0x1.496c47aba0734p-4 +-0x1.9p+4 +-0x1.0f353f686ca8fp-3 +-0x1.8ce8aeca48a5p-3 +-0x1.05db89ce16934p-1 +-0x1.9p+4 +-0x1.408178d8e0127p-4 +-0x1.9p+4 +-0x1.6d2c9e6561612p+0 +-0x1.9p+4 +-0x1.02b547e39a113p-3 +-0x1.84d556039fa51p-3 +-0x1.f7218909f183ep-3 +-0x1.9p+4 +-0x1.26480d81910ep-4 +-0x1.9p+4 +-0x1.2a02454265573p-1 +-0x1.1e6d09ec16dbfp+3 +-0x1.dc13206a4a851p-4 +-0x1.8fdb5445f3f01p-3 +-0x1.e67232b2c6edcp-5 +-0x1.8cc72f77fa0bep+4 +-0x1.fa07e03bccb0ap-3 +-0x1.e54646902c8adp+0 +-0x1.95182b4dc90cap-4 +-0x1.7d31c728313afp-3 +-0x1.62962502f276cp-5 +-0x1.210d52e2eab87p+4 +-0x1.1288c994e4364p-4 +-0x1.c21efbd212401p-4 +-0x1.87f3326709086p-6 +-0x1.3fd7fe45a3945p+3 +-0x1.962511594c74bp-4 +-0x1.97ae636e5ed27p-1 +-0x1.35ab7771f4ddap-5 +-0x1.16a1b00bc7df3p-4 +-0x1.8f8e156f0262p-7 +-0x1.45e01f4a322ebp+2 +-0x1.342e421c38b3fp-6 +-0x1.05afe9cd99c11p-5 +-0x1.f5cd085a64864p-8 +-0x1.7c081c5494622p+0 +-0x1.61a591b19b0aap-7 +-0x1.4198391ef355fp-7 +-0x1.3525d4a3b1ce1p-7 +-0x1.d4812c76e3188p+0 +-0x1.b3a6d0bc05c5bp-7 +-0x1.8c55ac7af1e6fp-7 +-0x1.0704c557c0149p-6 +-0x1.93c013f763afbp+1 +-0x1.5c69cf6f601f2p-6 +-0x1.42389f7dff448p-6 +-0x1.6e3939b8968a3p-6 +-0x1.215c5dd13429ap+2 +-0x1.088005cbb2869p-5 +-0x1.ee037fce14ff5p-6 +-0x1.da87a8e318dfap-6 +-0x1.7f41a6046cc8p+2 +-0x1.4c5daa237d795p-5 +-0x1.3c923e15a5b43p-5 +-0x1.10c4e17bdc5afp-5 +-0x1.c15edcfbb0df6p+2 +-0x1.3b7d7508f45fbp-5 +-0x1.3bbdfd81c603ap-5 +-0x1.0086a3f901a7fp-5 +-0x1.bd2f1869031d7p+2 +-0x1.09d9149332f25p-5 +-0x1.1e7fa03028d79p-5 +-0x1.89d39e6b199c9p-6 +-0x1.73e3887c9d055p+2 +-0x1.8ab03a5945e3ap-6 +-0x1.d350c5cdaf691p-6 +-0x1.0b33147feb895p-6 +-0x1.14c3707094b49p+2 +-0x1.ff621c5050d41p-7 +-0x1.4ef482bd33214p-6 +-0x1.07212c73d3a09p-6 +-0x1.28ede02e2ac8ep+2 +-0x1.e8bac36659173p-7 +-0x1.62dce85034bedp-6 +-0x1.07ea77ffde568p-6 +-0x1.450be2fca05bdp+2 +-0x1.d8929086e3d7ap-7 +-0x1.802e46e86ea42p-6 +-0x1.0fa33fc356e66p-6 +-0x1.6ae1ba2b82ed3p+2 +-0x1.d22fc8e44a7a9p-7 +-0x1.a8f4e7178054cp-6 +-0x1.14da80cc6bab9p-6 +-0x1.96cc7d3e74fafp+2 +-0x1.d798a60394aefp-7 +-0x1.deab3fc0cd756p-6 +-0x1.0b46bd1aa8273p-6 +-0x1.c53efe1d99d8ap+2 +-0x1.e01898daab218p-7 +-0x1.100e33a614022p-5 +-0x1.dd7be7a96c38fp-7 +-0x1.f8696498aa198p+2 +-0x1.e310623f8b704p-7 +-0x1.367fad7c677fcp-5 +-0x1.a0aff137fc791p-7 +-0x1.1d64f37772f75p+3 +-0x1.db270c604338ep-7 +-0x1.63af3a97c48e4p-5 +-0x1.74c73c14894dap-7 +-0x1.48b55b3ff7a53p+3 +-0x1.74c502c606a2dp-7 +-0x1.48ada1f798593p+3 +-0x1.d08c4385afcd5p-7 +-0x1.9cc8bbf051bb9p-5 +-0x1.d9a1d43bc3c1p-7 +-0x1.9p+4 +-0x1.6205030374d87p-7 +-0x1.7f41b88d4d542p+3 +-0x1.6497db64b464cp-6 +-0x1.a7555a0a9ad96p-3 +-0x1.d6cb0431d60adp-7 +-0x1.ddd3436edd704p-5 +-0x1.656a3c9150465p-7 +-0x1.c38857b87b408p+3 +-0x1.acb292f0f5d38p-6 +-0x1.3ee4513b3ac53p-2 +-0x1.0060b68f3ee96p-6 +-0x1.19f872e53abc2p-4 +-0x1.78813db0bbe67p-7 +-0x1.11f891c976a23p+4 +-0x1.7634a80e70844p-7 +-0x1.0b84ef33eaa22p+4 +-0x1.50b328d25408cp-5 +-0x1.8c706871d5054p-1 +-0x1.25b776d6a38bap-6 +-0x1.4efacb8392412p-4 +-0x1.e7ca29baed8f7p-7 +-0x1.9p+4 +-0x1.9801e95fd6e03p-7 +-0x1.3b82bd25bd9adp+4 +-0x1.54d2142ed1611p-6 +-0x1.8853375066702p-4 +-0x1.c5db4510d1725p-4 +-0x1.9p+4 +-0x1.8b9c13cc63714p-7 +-0x1.31841be52a315p+4 +-0x1.5e45edc62c8b6p-2 +-0x1.9p+4 +-0x1.4a1d0932376c6p-6 +-0x1.8ad730074b81fp-4 +-0x1.93a4c256b7e08p-5 +-0x1.9p+4 +-0x1.6d8a190a54dbep-7 +-0x1.26c3ceb3e83a6p+4 +-0x1.096300ba7aeebp-3 +-0x1.1bc49ce92471ap+3 +-0x1.38c66df38f3d8p-6 +-0x1.cb802712b2bd6p-4 +-0x1.2c0f349426b88p-7 +-0x1.cdb0ec9f9b577p+3 +-0x1.b1475b18ab754p-5 +-0x1.d3e0fc19cab56p+0 +-0x1.128f2bddd43cap-6 +-0x1.e40ee6ea451c4p-4 +-0x1.b562733edf1b6p-8 +-0x1.502628ba2824cp+3 +-0x1.668f1925076c3p-7 +-0x1.f2214cc9ac818p-5 +-0x1.e396c69379abbp-9 +-0x1.745474707d6a2p+2 +-0x1.5d3d7a471fa32p-6 +-0x1.89f7d4422b561p-1 +-0x1.9ee3746fe7132p-8 +-0x1.51da6d5457f76p-5 +-0x1.ece8f7d8f9f51p-10 +-0x1.7b28409b6854fp+1 +-0x1.959a068da4337p-9 +-0x1.2b497747cc8eap-6 +-0x1.264bdc75304b2p-10 +-0x1.dd2470ba37571p-3 +-0x1.971ada75040ccp-10 +-0x1.85837ded565e5p-10 +-0x1.6ba77d51094bfp-10 +-0x1.2765568ab74f6p-2 +-0x1.f697f661f7d6dp-10 +-0x1.e1b750dc7c1b5p-10 +-0x1.36fb8cd256756p-9 +-0x1.0113e52384c72p-1 +-0x1.951129d97bafdp-9 +-0x1.8d606bcc5f89bp-9 +-0x1.b5c093a2af79ep-9 +-0x1.7845ae76447b1p-1 +-0x1.34da3684b44ebp-8 +-0x1.3324099743ac1p-8 +-0x1.1dc377cac247fp-8 +-0x1.f9b68dbadad1dp-1 +-0x1.876038e4376c8p-8 +-0x1.8ff92a33efe6fp-8 +-0x1.4a9c7285bae47p-8 +-0x1.2c24aeb8f2fb9p+0 +-0x1.7a96ebc7f75ebp-8 +-0x1.9d91640135b99p-8 +-0x1.3bad876289b37p-8 +-0x1.323b93f78fb62p+0 +-0x1.46b0cb056c347p-8 +-0x1.88ad587daff33p-8 +-0x1.eeac3045de429p-9 +-0x1.0a3037fe2dcc2p+0 +-0x1.f124720e5dda7p-9 +-0x1.4f7042af8d023p-8 +-0x1.55b319d4c37c8p-9 +-0x1.9a1c577cd237cp-1 +-0x1.4922fad476394p-9 +-0x1.f40551dcc986fp-9 +-0x1.551b94bd3732cp-9 +-0x1.c3648eaa4ad0fp-1 +-0x1.408b06678dc3bp-9 +-0x1.114ece07acd83p-8 +-0x1.5a3159221e5edp-9 +-0x1.f8cdfd2f6aa7ep-1 +-0x1.3ba493f62edfap-9 +-0x1.2ff1d9d6ef6e3p-8 +-0x1.67d129a42d6f9p-9 +-0x1.1e8fce206d937p+0 +-0x1.3cddd440330edp-9 +-0x1.5776e08ef54d1p-8 +-0x1.7261e0320cc28p-9 +-0x1.46b52e977a0cap+0 +-0x1.45f2590853a95p-9 +-0x1.8939ce0a3bc32p-8 +-0x1.69893a70f276bp-9 +-0x1.72d303240b588p+0 +-0x1.514f5898bb566p-9 +-0x1.c4ec7178fdddap-8 +-0x1.462b6d1d8f46dp-9 +-0x1.a3a6dc7154ab5p+0 +-0x1.580b8a35981f2p-9 +-0x1.050fa8c768c6ep-7 +-0x1.1e4e61239d7c6p-9 +-0x1.e0114fc595282p+0 +-0x1.56c92a5d18e51p-9 +-0x1.2de27de859163p-7 +-0x1.00fc253517b12p-9 +-0x1.16a6fa1ac6362p+1 +-0x1.00f4e303b263dp-9 +-0x1.168814f949064p+1 +-0x1.5766b04cd79bp-9 +-0x1.6a197da800421p-7 +-0x1.0b71058e50988p-8 +-0x1.529d80d4d97f9p+4 +-0x1.ea1ff6eef69bap-10 +-0x1.47be213ee8afp+1 +-0x1.dcbe3f9d47c61p-8 +-0x1.49d8984715388p-3 +-0x1.660150b9bc637p-9 +-0x1.9f80f1831bb41p-7 +-0x1.f39390e1832c6p-10 +-0x1.8b042c775b6bap+1 +-0x1.3a8a1f128ddeap-7 +-0x1.0840239fbca71p-2 +-0x1.9c0690237648p-9 +-0x1.fb3de3ba121dap-7 +-0x1.0ff44092d3515p-9 +-0x1.0b3a2219fde22p+2 +-0x1.0896744ee301ap-9 +-0x1.e2d72f879bc38p+1 +-0x1.19bd6c5b5657fp-6 +-0x1.6c60bbe079899p-1 +-0x1.f2d19435e8cfp-9 +-0x1.39f59be2d98d5p-6 +-0x1.f242740827029p-9 +-0x1.539cc5acb5628p+4 +-0x1.20e17290b3e58p-9 +-0x1.2009c0ace12b3p+2 +-0x1.28b4bf19bf34ep-8 +-0x1.6bd0c4e116b68p-6 +-0x1.d6c2008520fdp-5 +-0x1.9p+4 +-0x1.13acfe5bc21ccp-9 +-0x1.0ff0b308db37p+2 +-0x1.940ce93afe0a4p-3 +-0x1.9p+4 +-0x1.2948f5b45e667p-8 +-0x1.92f423093d463p-6 +-0x1.430b68c298e6bp-6 +-0x1.9p+4 +-0x1.0d314b799c57cp-9 +-0x1.3fc0a4838bc28p+2 +-0x1.0072e876bedfap-4 +-0x1.19b8e47cccbc5p+3 +-0x1.4d1809d8b0e12p-8 +-0x1.8b47e1cdb02adp-5 +-0x1.a05b2caa567ap-10 +-0x1.93fed47f38f98p+1 +-0x1.85c2059786ae4p-6 +-0x1.c68d6600ae18fp+0 +-0x1.48445935118fbp-8 +-0x1.0ed585587b56cp-4 +-0x1.2f1b4fe044c25p-10 +-0x1.24d2a6cd02a49p+1 +-0x1.62c6c7077b621p-9 +-0x1.61d5c84551695p-6 +-0x1.4fcb6eb731af1p-11 +-0x1.46ea512705073p+0 +-0x1.3b72f3d1a972fp-7 +-0x1.7f334f3d9b87bp-1 +-0x1.d1f0cf8851ee7p-10 +-0x1.4b243a16b622p-6 +-0x1.55e9db9c1fc98p-12 +-0x1.4b8efc72a7b36p-1 +-0x1.a14f3d3dac481p-11 +-0x1.dd7080a21b1dep-8 +-0x1.c79b22ec99624p-11 +-0x1.3ef3d92440188p-3 +-0x1.4b4b5e6b9d0f6p-10 +-0x1.1ca2021fb9513p-10 +-0x1.196d26a7bddaap-10 +-0x1.8b07e81dc125fp-3 +-0x1.98e029ae010ebp-10 +-0x1.5ff11bcf4f195p-10 +-0x1.db936184e20c6p-10 +-0x1.4ffeec24f0a5p-2 +-0x1.444c2f9f9dbf7p-9 +-0x1.196be35e1248ep-9 +-0x1.462e69bdcff8fp-9 +-0x1.d4055efb9b72dp-2 +-0x1.ea08261f3048bp-9 +-0x1.ab512d05886f3p-9 +-0x1.a214a28b24ff1p-9 +-0x1.2f859872034d5p-1 +-0x1.30fd3115eca75p-8 +-0x1.0ca0014ed0a61p-8 +-0x1.dc1e1b7a423a2p-9 +-0x1.5d6add2853f53p-1 +-0x1.1b33ae2b698b6p-8 +-0x1.ffe3742547055p-9 +-0x1.b56888df612f3p-9 +-0x1.4a9e3b6770ff6p-1 +-0x1.cfdd01519a2dep-9 +-0x1.b491109db6775p-9 +-0x1.449b48696fa13p-9 +-0x1.0218a77c34db2p-1 +-0x1.4e6f49b6469e6p-9 +-0x1.4c82ac049c127p-9 +-0x1.aac8762a91156p-10 +-0x1.67f8736e82ba8p-2 +-0x1.a74296b738d43p-10 +-0x1.bff968b8660ep-10 +-0x1.99fce94c6ae22p-10 +-0x1.6e67378bd67c8p-2 +-0x1.8dff11b2b98f1p-10 +-0x1.c250a821a863ep-10 +-0x1.9292315422378p-10 +-0x1.7edfc2ac33856p-2 +-0x1.7d160ac65abdcp-10 +-0x1.d0fb78937745dp-10 +-0x1.97c0f50bdc393p-10 +-0x1.9c464240fe84cp-2 +-0x1.77573400d684bp-10 +-0x1.ef0c32c768e34p-10 +-0x1.996497ce82ffap-10 +-0x1.bebc16cf28c36p-2 +-0x1.7e07271537a5ap-10 +-0x1.0f4a0c5b45ec3p-9 +-0x1.83eaa938659ffp-10 +-0x1.dc52a6c475c5fp-2 +-0x1.89b001bf72ff2p-10 +-0x1.2da10daa6e49dp-9 +-0x1.52fdaa60a78acp-10 +-0x1.f4b6582f522b8p-2 +-0x1.930be048238bcp-10 +-0x1.4ff078af16157p-9 +-0x1.239842fe00eaep-10 +-0x1.0e33befc530b5p-1 +-0x1.9894aa128c5dfp-10 +-0x1.7912b65c6d077p-9 +-0x1.04c0d5a058794p-10 +-0x1.306fbd9370738p-1 +-0x1.04a57bce1b786p-10 +-0x1.2ff4290d7bb42p-1 +-0x1.ad955f5b81dc4p-10 +-0x1.d8524d6c6feap-9 +-0x1.e7242032ac33ap-9 +-0x1.34cfd66243ffdp+4 +-0x1.f5d7925e7611dp-11 +-0x1.654336a8f2c85p-1 +-0x1.0792c599460fap-7 +-0x1.37f3923d0c4c8p-3 +-0x1.c68dfeb57701p-10 +-0x1.026121c519e65p-8 +-0x1.06018bc77aaf6p-10 +-0x1.c4a613ec426d1p-1 +-0x1.60902a502fde9p-7 +-0x1.fb690a3513732p-3 +-0x1.0aff450ebb92p-9 +-0x1.5394262768e59p-8 +-0x1.39936afc7c3f6p-10 +-0x1.90726500adbaep+0 +-0x1.1e85c38903bap-10 +-0x1.29383ba7edb94p+0 +-0x1.3d35822865933p-6 +-0x1.6628829c75cfdp-1 +-0x1.46cc234e2203dp-9 +-0x1.cbb9cd898948cp-8 +-0x1.bd75bf73d893cp-9 +-0x1.224848770fa78p+4 +-0x1.3e862c7b897edp-10 +-0x1.6adf2f5928fe1p+0 +-0x1.7d087d46c9aa1p-9 +-0x1.0391824e3a0f3p-7 +-0x1.dcfe91c28dddbp-5 +-0x1.9p+4 +-0x1.2bfe43346dd55p-10 +-0x1.425d9007f02f6p+0 +-0x1.b302979b37de5p-3 +-0x1.9p+4 +-0x1.97add08c29cedp-9 +-0x1.5bce63b325664p-7 +-0x1.4a48864baf767p-6 +-0x1.9p+4 +-0x1.5442186d42ba5p-10 +-0x1.262c793355ffep+1 +-0x1.22e15f2abc05p-4 +-0x1.1958f4f978b0dp+3 +-0x1.3110135cd8d7cp-8 +-0x1.2b585e79a4bbbp-5 +-0x1.bf33756023d3ep-11 +-0x1.c8bf291bf1ea2p-1 +-0x1.c2fda059ee9fep-6 +-0x1.c44945b875795p+0 +-0x1.4e0c46a9badf2p-8 +-0x1.d52701a9e2c06p-5 +-0x1.44749fcd7273dp-11 +-0x1.46e15bd3de8bfp-1 +-0x1.2e7c19d890836p-9 +-0x1.d0bf07506d6f3p-7 +-0x1.699c04bdcec2dp-12 +-0x1.75271d3c808ap-2 +-0x1.6fdbd6b50ceffp-7 +-0x1.7d5c45d9688c3p-1 +-0x1.cb3db7e4a6cc4p-10 +-0x1.10430d9056b7ap-6 +-0x1.6f10b25a31ec2p-13 +-0x1.762a15f58e118p-3 +-0x1.7b7d593197592p-11 +-0x1.58fa55be5ec43p-8 +-0x1.4dd35262c9c5p-16 +-0x1.15f48744c2e73p-6 +-0x1.7786e92080fabp-14 +-0x1.fdaaae1c6576ep-14 +-0x1.e7eea8a252766p-16 +-0x1.618e6c2c01dd7p-6 +-0x1.d886891de90ep-14 +-0x1.411095634e917p-13 +-0x1.c09859f01fff5p-15 +-0x1.462162f891588p-5 +-0x1.b44ecf2481263p-13 +-0x1.2876841bcb0fdp-12 +-0x1.6e3b7fc09a2f3p-14 +-0x1.0afee5ea57989p-4 +-0x1.655fa03642461p-12 +-0x1.e5ab19df5aaf2p-12 +-0x1.076a0f7296d9p-13 +-0x1.81035e564de69p-4 +-0x1.01c8b8348fbc1p-11 +-0x1.5e55bb368011cp-11 +-0x1.4937b8e1a39d1p-13 +-0x1.e2c9768ef4e18p-4 +-0x1.439530f46909fp-11 +-0x1.b7c76ba6a6b2bp-11 +-0x1.791039d935844p-13 +-0x1.151af366106cfp-3 +-0x1.746291cfc0071p-11 +-0x1.fa35feb79d258p-11 +-0x1.76ed8c41e3ed1p-13 +-0x1.13ccf10b018eep-3 +-0x1.73fede5d99ca4p-11 +-0x1.f9fd8e27ddf94p-11 +-0x1.3f28ae2e8afb9p-13 +-0x1.d5f84ff5928ecp-4 +-0x1.356c697ac777ap-11 +-0x1.a55786d9791bfp-11 +-0x1.773184fe31b85p-13 +-0x1.147fa8e95e26ap-3 +-0x1.6d367b1f7b80fp-11 +-0x1.f2061948ea26fp-11 +-0x1.b96fbf5a3aad5p-13 +-0x1.4597da6452034p-3 +-0x1.aee6d3ed765c3p-11 +-0x1.2647fe6c67127p-10 +-0x1.04283b71e7262p-12 +-0x1.80474fef48ed9p-3 +-0x1.fc67f0d8d5d7ep-11 +-0x1.5bdb706b517f7p-10 +-0x1.31a924fc3311bp-12 +-0x1.c728d2c30a3b9p-3 +-0x1.2c026f56a5d23p-10 +-0x1.9bb7ed4f57a06p-10 +-0x1.61f243850f356p-12 +-0x1.0ce93f0338881p-2 +-0x1.61ae28b45e359p-10 +-0x1.e7665bfdadf5dp-10 +-0x1.916ca1c0a0e7ep-12 +-0x1.3abdb8a104da5p-2 +-0x1.9f2d1183c8ed5p-10 +-0x1.1f2f4e1cb3777p-9 +-0x1.c7c0bf3a21701p-12 +-0x1.6f8c092fbc319p-2 +-0x1.e700ddbfadc0dp-10 +-0x1.5347a9109b9ccp-9 +-0x1.075163e32f4a7p-11 +-0x1.b1d68c809eaf1p-2 +-0x1.072910cdde74dp-11 +-0x1.b0e5940d4371ap-2 +-0x1.25bd572abba9dp-9 +-0x1.b72c3216a8038p-9 +-0x1.1020bf5b0a9bap-8 +-0x1.2a59f8a83df5bp+4 +-0x1.36c97d2324275p-11 +-0x1.046055de58da7p-1 +-0x1.b86a3b8075504p-7 +-0x1.3011a2793fae6p-3 +-0x1.56b256cc9f5ddp-9 +-0x1.efd3379215dfp-9 +-0x1.7bcb0e925b41dp-11 +-0x1.4de57a514ca39p-1 +-0x1.4200d428f6dacp-6 +-0x1.f0e1aef5d5dacp-3 +-0x1.a5de4728cb5d3p-9 +-0x1.47428d51200d5p-8 +-0x1.110786ac26d06p-10 +-0x1.4149be547ec17p+0 +-0x1.e0a090020adaap-11 +-0x1.b93d5f8fbe9fdp-1 +-0x1.5d35f23ec9bap-5 +-0x1.71c96dc99ed3ep-1 +-0x1.0833be3a3ac01p-8 +-0x1.bae93d45ef195p-8 +-0x1.4f86be9e4fffdp-8 +-0x1.1e176301b364p+4 +-0x1.3808c541afeb8p-10 +-0x1.0ee4bcc45c81cp+0 +-0x1.39350d925f0d6p-8 +-0x1.f898721fcff1ep-8 +-0x1.0b80088238073p-1 +-0x1.9p+4 +-0x1.621de4885965cp-10 +-0x1.ebbc1b580b4c3p-1 +-0x1.b9acd3f9914d3p+0 +-0x1.9p+4 +-0x1.621b111c20c0ep-8 +-0x1.53912bf2ae30dp-7 +-0x1.d0464fdf88112p-4 +-0x1.9p+4 +-0x1.1487b4546322dp-9 +-0x1.f41b1afc6d7fdp+0 +-0x1.56c83f4719d4ap-2 +-0x1.316a6dd945d1p+3 +-0x1.4fb48c5682fbep-7 +-0x1.358af772f36d8p-5 +-0x1.8645716bb5628p-10 +-0x1.71a29863cbf5p-1 +-0x1.84a9edfcf75cbp-4 +-0x1.eb2951bcb7c23p+0 +-0x1.cd2acecd1ccb7p-7 +-0x1.f6e3dff92c0b9p-5 +-0x1.3dfb239ae6b94p-10 +-0x1.0fe93292a0e5dp-1 +-0x1.4f6789049bbcdp-8 +-0x1.d73b81f782a54p-7 +-0x1.b737485679f2bp-11 +-0x1.48849ba0e1babp-2 +-0x1.36469752e4b4bp-5 +-0x1.9df171e704c44p-1 +-0x1.2653271b9dc7ep-8 +-0x1.1bc5b1c780e3fp-6 +-0x1.c933599833247p-12 +-0x1.4cc0c3b4b9561p-3 +-0x1.cd150fd7f6772p-10 +-0x1.61c95f5c8046p-8 +-0x1.4142bd0182188p-20 +-0x1.f66db1e52d6f9p-8 +-0x1.2ebf98c31cf58p-18 +-0x1.3d9c1e78bab24p-15 +-0x1.57b31ab9e8699p-17 +-0x1.4a5de0e7d6e37p-7 +-0x1.8c599918a6eccp-17 +-0x1.a24089e2ceb22p-15 +-0x1.38f826fcfbb62p-16 +-0x1.30821b4f3c3e5p-6 +-0x1.6f78f66998da3p-16 +-0x1.82610fc2cda07p-14 +-0x1.fb59f328b0827p-16 +-0x1.f26436650f76dp-6 +-0x1.2d7f2449c6f3ep-15 +-0x1.3c8b88f42e5dcp-13 +-0x1.6adc8a30ede6ep-15 +-0x1.673da467ae138p-5 +-0x1.b3cefc77ba141p-15 +-0x1.c8c7625574fdep-13 +-0x1.c1dff1216c195p-15 +-0x1.c246ff2f92de7p-5 +-0x1.13fcccbe59ba6p-14 +-0x1.1effa769829fdp-12 +-0x1.00554ce4b5fa4p-14 +-0x1.02576e1715de4p-4 +-0x1.4784f4b7acabp-14 +-0x1.4ba5ce6709d49p-12 +-0x1.fd7cf5ab0c438p-15 +-0x1.011937a9895dcp-4 +-0x1.57b979db7e791p-14 +-0x1.4df18273c21a3p-12 +-0x1.b1b400e58e14bp-15 +-0x1.b6323d822622dp-5 +-0x1.2b63ffd445392p-14 +-0x1.1870b59f9c58dp-12 +-0x1.fe19809a983b3p-15 +-0x1.01e39e21f3b8fp-4 +-0x1.6ee1ec35f7794p-14 +-0x1.4e53f72609c0ap-12 +-0x1.2dfcdf063ab34p-14 +-0x1.3011e77113aa6p-4 +-0x1.bf157ebf2d026p-14 +-0x1.8e74b25970142p-12 +-0x1.6c1cfa6dddfc3p-14 +-0x1.68620241011b4p-4 +-0x1.1082173d2f5b2p-13 +-0x1.db4eba3f71e5bp-12 +-0x1.b623f26b10507p-14 +-0x1.ae6ea8288ac28p-4 +-0x1.547c8ca1b78a4p-13 +-0x1.1d51d9298ca04p-11 +-0x1.f489f316564e9p-14 +-0x1.ffa2d0dc7fbd2p-4 +-0x1.a4bda87b9e41ap-13 +-0x1.57177c5d2eb5dp-11 +-0x1.057592e4928e9p-13 +-0x1.2a4a6e7ca99bdp-3 +-0x1.ea153d8cfe7adp-13 +-0x1.96df2c45d652p-11 +-0x1.29ec952a535a6p-13 +-0x1.5b58674522023p-3 +-0x1.28e891de5d19dp-12 +-0x1.e8d3cf847c6afp-11 +-0x1.96185c11248ep-13 +-0x1.9ed46546ea289p-3 +-0x1.91355497ef0c2p-13 +-0x1.9d03369dca901p-3 +-0x1.da8b461ed6d99p-12 +-0x1.7799ce634cfc2p-10 +-0x1.e0ff5386d629p-6 +-0x1.1ce23cabeb16cp+4 +-0x1.47a7415aafa06p-12 +-0x1.02b8fe4dc87e3p-2 +-0x1.9d5bb23a67ab9p-5 +-0x1.2334b5915900cp-3 +-0x1.87c4029e848ecp-11 +-0x1.ae36302234d78p-10 +-0x1.295ce0b267af5p-11 +-0x1.71ca2b814p-2 +-0x1.68c9adad64dadp-4 +-0x1.e42d8a5c558f9p-3 +-0x1.a2182971c7927p-10 +-0x1.720fe139e4f2ep-9 +-0x1.e970facdf8cedp-10 +-0x1.e196eee6f069bp-1 +-0x1.32d105a5836bp-10 +-0x1.1d81d82f60fd7p-1 +-0x1.fc2a2173d31d6p-3 +-0x1.87eaaffddb9f9p-1 +-0x1.bd0f14d488dbcp-9 +-0x1.4d87b15afa272p-8 +-0x1.061d626004f3p-5 +-0x1.2106a12f0b5a7p+4 +-0x1.4f7b06f46078cp-9 +-0x1.aec5b416437c6p-1 +-0x1.6abfc085e2011p-8 +-0x1.c43266795bad8p-8 +-0x1.1d7dd899723ebp+2 +-0x1.9p+4 +-0x1.414ec8eb7cf5ap-8 +-0x1.1f6975dbd1791p+0 +-0x1.c61d854f0b68cp+3 +-0x1.9p+4 +-0x1.5c70b8162a2f4p-7 +-0x1.a8e9adb7767e4p-7 +-0x1.ccdffd0426448p-1 +-0x1.9p+4 +-0x1.5409c2cfbe8cfp-7 +-0x1.6575ba8e5fe25p+1 +-0x1.3e93858dc4852p+1 +-0x1.5727ad5b0fccdp+3 +-0x1.a2741666374dcp-6 +-0x1.7c5f344a6830ep-5 +-0x1.48cbbf6cd3edep-7 +-0x1.db3c1915b24fbp+0 +-0x1.07698daf27d7ep-1 +-0x1.148da0d54270ep+1 +-0x1.31bf90e18cb42p-5 +-0x1.32a9adc9848c5p-4 +-0x1.322ec2663c51cp-7 +-0x1.af5ced26d37c3p+0 +-0x1.62a9a45c1b4b3p-6 +-0x1.abac355be9e5ap-6 +-0x1.02b0211499d52p-7 +-0x1.64b9762c26352p+0 +-0x1.ca632ffb2867fp-3 +-0x1.d454d0fad7601p-1 +-0x1.229937fc58f3fp-6 +-0x1.ad6eec8e32f74p-6 +-0x1.13ffacf5a8821p-8 +-0x1.7ad68cd7aeb6fp-1 +-0x1.1269b4a65188fp-7 +-0x1.4cfc3b8b480dp-7 +-0x1.069ad7892776bp-19 +-0x1.91da310ef058bp-9 +-0x1.0555c35bd6af5p-17 +-0x1.1dfae2ed2833bp-16 +-0x1.bd853b88d5c0fp-18 +-0x1.19afe5a50c9fp-8 +-0x1.9246fc228d05p-17 +-0x1.8c654eab85972p-16 +-0x1.97b85e089287cp-17 +-0x1.036301d896f71p-7 +-0x1.74c1809bc4b7ep-16 +-0x1.6e8c391ac6fecp-15 +-0x1.4d23e62c4b835p-16 +-0x1.a891972563e62p-7 +-0x1.3297b68712626p-15 +-0x1.2ca55714bd719p-14 +-0x1.e1f90367328e8p-16 +-0x1.3238edd6e88eap-6 +-0x1.bc0c964ce56edp-15 +-0x1.b250cf83cdb97p-14 +-0x1.2f1afdefdf9e2p-15 +-0x1.801372e97d9e8p-6 +-0x1.183a5a9597b4fp-14 +-0x1.11521ef8f4c79p-13 +-0x1.5ec0823f1aeccp-15 +-0x1.b918f768f11fdp-6 +-0x1.451d4af2eca7fp-14 +-0x1.3cb62650308e6p-13 +-0x1.61edd7143e0bdp-15 +-0x1.b7a6285c5da2fp-6 +-0x1.4abcacb311b25p-14 +-0x1.410a12b7e14fcp-13 +-0x1.310cbac5712ffp-15 +-0x1.775e2b92ab91fp-6 +-0x1.1b49408a48316p-14 +-0x1.109b11e2cc138p-13 +-0x1.6bf79ba0e9dd5p-15 +-0x1.badee49246dc6p-6 +-0x1.55e1981c81ac3p-14 +-0x1.48456becc629cp-13 +-0x1.bcec03a2c1aa4p-15 +-0x1.06d1fda61713dp-5 +-0x1.9f956cba0289dp-14 +-0x1.8c487baf56903p-13 +-0x1.22f565075ff5bp-14 +-0x1.3dc41687955cap-5 +-0x1.ff304255987cep-14 +-0x1.e0ec08bf9396fp-13 +-0x1.87c5bc01d1afep-14 +-0x1.88cca5a99170dp-5 +-0x1.5e22e9c6c751bp-13 +-0x1.30d518f2ef5cbp-12 +-0x1.f371e3afec8c4p-14 +-0x1.e024ab20ba60cp-5 +-0x1.e0570bebf2579p-13 +-0x1.869b6827dde02p-12 +-0x1.26a17fe804d5p-13 +-0x1.198680e26c8e9p-4 +-0x1.2ea1cf68e639p-12 +-0x1.e047c9b186336p-12 +-0x1.a85effacfe1a4p-13 +-0x1.570a14fe91d8ep-4 +-0x1.b5f115d4f6112p-12 +-0x1.3eb2b3d16348bp-11 +-0x1.587cbc20c15a5p-12 +-0x1.c7aa0db50ce51p-4 +-0x1.5701010018eb1p-12 +-0x1.c407b062cdb42p-4 +-0x1.db3e86631df0fp-11 +-0x1.49edf2e575536p-10 +-0x1.e4b155a2c5e25p-6 +-0x1.1b98182d5aa36p+4 +-0x1.488bcd1d2fce5p-11 +-0x1.605fbd535752dp-3 +-0x1.a9ca4b0cf3271p-5 +-0x1.24207ab76aa0dp-3 +-0x1.04c5f4c28f0dcp-9 +-0x1.120c6195826dep-9 +-0x1.6330c3fa53c63p-10 +-0x1.56bc7da50ee7cp-2 +-0x1.7d13830ad574fp-4 +-0x1.e99476c5bea9fp-3 +-0x1.6ef0fcc2a679p-8 +-0x1.65e57dca15c58p-8 +-0x1.19d84eba41f9cp-8 +-0x1.26f0f26bd5c96p+0 +-0x1.cf3a260bec0fap-9 +-0x1.89ccce201c264p-1 +-0x1.0d5bf7b05589ep-2 +-0x1.8c37653684c02p-1 +-0x1.dc9503ee1dd99p-7 +-0x1.b9f126d7c536ap-7 +-0x1.52db3d86e0daep-5 +-0x1.328834870c17ep+4 +-0x1.4f1c8edef974bp-7 +-0x1.ef7c0f8b2d945p+0 +-0x1.ba285a7693c3ep-6 +-0x1.84b9f3e561097p-6 +-0x1.1f6c5914f80b2p+2 +-0x1.9p+4 +-0x1.9ee97cd77ba94p-6 +-0x1.199d34cef1061p+2 +-0x1.c8733c08e4614p+3 +-0x1.9p+4 +-0x1.cce5a7d6c4832p-5 +-0x1.959ddc874bde1p-5 +-0x1.f2177de28a3cfp-1 +-0x1.9p+4 +-0x1.bd23276d4e219p-5 +-0x1.3ea4128db3da3p+3 +-0x1.50afcb6b3c987p+1 +-0x1.596179384515ap+3 +-0x1.d015a5157e2bap-4 +-0x1.db1588bfd88a7p-4 +-0x1.f630a9568dbafp-5 +-0x1.4b1fe62b7120bp+3 +-0x1.5f54fe7e89c0ap-1 +-0x1.2073583251cf1p+1 +-0x1.3d72beb841e9bp-3 +-0x1.57b04cb5b82a4p-3 +-0x1.ddb1483b2192cp-5 +-0x1.3a231147bab69p+3 +-0x1.f25285f8699f5p-4 +-0x1.b775e93aa29eep-4 +-0x1.9cf891f98aaeap-5 +-0x1.0f2389b3fd9a9p+3 +-0x1.4f801bac46a1bp-2 +-0x1.f26d591ccc02dp-1 +-0x1.72c88cfe71c6bp-4 +-0x1.5c1ffc3331d0fp-4 +-0x1.b9e38dd1bede9p-6 +-0x1.21f79aa59d3fcp+2 +-0x1.8289e99b6689cp-5 +-0x1.55a4f004b115dp-5 +-0x1.b3fada9bb1d7ap-19 +-0x1.822c0b497e819p-10 +-0x1.42ded49daa42cp-16 +-0x1.3e41bdba8fac7p-16 +-0x1.82d1b32a63d65p-18 +-0x1.19c60daa55ea4p-9 +-0x1.a512b66020222p-16 +-0x1.a440df4e55b7ep-16 +-0x1.68e4c6a97f77dp-17 +-0x1.04a634453513cp-8 +-0x1.86657dd5ff52bp-15 +-0x1.8566f38828f04p-15 +-0x1.2f8e664c53605p-16 +-0x1.aea321e3a7ab8p-8 +-0x1.423508f076fa8p-14 +-0x1.40eef3ced513bp-14 +-0x1.c83d018242d15p-16 +-0x1.3afd243a81728p-7 +-0x1.d406dc06aa03p-14 +-0x1.d19a85d30db2cp-14 +-0x1.2bfd38e46a39p-15 +-0x1.91da8d79f10a5p-7 +-0x1.26f17e8c0bc5dp-13 +-0x1.255646cc6c8fcp-13 +-0x1.6a9d37c44aebep-15 +-0x1.d6452b509d218p-7 +-0x1.4fe7e6ef037aep-13 +-0x1.4f7c623e58cc7p-13 +-0x1.7ce65d6f952bfp-15 +-0x1.de3e29172a3abp-7 +-0x1.4ca0f07bdb88ep-13 +-0x1.4e579148f5712p-13 +-0x1.5296fff43a246p-15 +-0x1.9f2c56618c35dp-7 +-0x1.1950b85efbbe5p-13 +-0x1.1b85e4c900a8ap-13 +-0x1.a1c747513ff6bp-15 +-0x1.f362210574e5dp-7 +-0x1.4e5e328626ec3p-13 +-0x1.52dbab6cae46cp-13 +-0x1.11aafb3cc18c5p-14 +-0x1.361f960620888p-6 +-0x1.9699f772a910ap-13 +-0x1.9c8d83dceb83fp-13 +-0x1.a10cf716652d6p-14 +-0x1.a76a4fc5de68ap-6 +-0x1.fc55a7d78bp-13 +-0x1.01132cae52798p-12 +-0x1.4cfbea4962db4p-13 +-0x1.33a2cf551daf8p-5 +-0x1.8d052ef23d989p-12 +-0x1.81dbfbeac240bp-12 +-0x1.dfe3420076215p-13 +-0x1.a768b214defe9p-5 +-0x1.34cb5fb876d22p-11 +-0x1.2391cac062c54p-11 +-0x1.34712466bb2a4p-12 +-0x1.09f8a34eb533bp-4 +-0x1.a252f92b1eeeep-11 +-0x1.86f8ded544b23p-11 +-0x1.0cc164f5c006fp-11 +-0x1.a6c63cda4006ap-4 +-0x1.60d77a1245b6dp-10 +-0x1.40234235ed97bp-10 +-0x1.069c39a30a496p-10 +-0x1.8258938c2e8c1p-3 +-0x1.06254d341310dp-10 +-0x1.808764e30ef39p-3 +-0x1.cf66acf51c2d9p-9 +-0x1.a34035b69a29bp-9 +-0x1.04fca165ea12ap-5 +-0x1.1f8d98d95c34bp+4 +-0x1.32aea9385423ap-9 +-0x1.ad9009aa0ffebp-2 +-0x1.f6046a039df1bp-5 +-0x1.30469c94dbca4p-3 +-0x1.35cf0c07515ffp-7 +-0x1.06e5363c7331ep-7 +-0x1.7fd21af782f19p-8 +-0x1.08df2ddf95d03p+0 +-0x1.ef109cadf9697p-4 +-0x1.08338d818d704p-2 +-0x1.dc1d598dcef37p-6 +-0x1.900e815d6726fp-6 +-0x1.2a0a405f0ff47p-6 +-0x1.b16390dbe0675p+1 +-0x1.1c189e1e9c536p-6 +-0x1.805e4b2dfc8c2p+1 +-0x1.5f87cac7b7fe5p-2 +-0x1.a6fe9f89f201ap-1 +-0x1.4300f116e2c73p-4 +-0x1.0d77f77662b28p-4 +-0x1.704c0535df83dp-4 +-0x1.9p+4 +-0x1.c3979dd742cf3p-5 +-0x1.2b63da60cb692p+3 +-0x1.340400f790472p-3 +-0x1.fdbe81d23f268p-4 +-0x1.2a4d3aee0c003p+2 +-0x1.9p+4 +-0x1.259067949a939p-3 +-0x1.81388904f3cf7p+4 +-0x1.d58ac40c089c6p+3 +-0x1.9p+4 +-0x1.438cd6328f7d5p-2 +-0x1.0bed46718bb5p-2 +-0x1.569ef8c5f6ap+0 +-0x1.9p+4 +-0x1.377b69885e5dp-2 +-0x1.9p+4 +-0x1.add0c98d4100ap+1 +-0x1.6603e744142c2p+3 +-0x1.32bcd0abe835p-1 +-0x1.058991d4ec78bp-1 +-0x1.69ccdf3a12f28p-2 +-0x1.9p+4 +-0x1.7411d31fe6f87p+0 +-0x1.6329572b8f9efp+1 +-0x1.98388d3148b5bp-1 +-0x1.60c40f12654a3p-1 +-0x1.58c3eda0c9122p-2 +-0x1.9p+4 +-0x1.5f5f0713bc0bep-1 +-0x1.234007fe358f4p-1 +-0x1.2a88b4cf0c366p-2 +-0x1.9p+4 +-0x1.9501723e546cfp-1 +-0x1.4e5dc900cb0f4p+0 +-0x1.fe269d3c8f2c2p-2 +-0x1.aba470d660ac2p-2 +-0x1.3f86343e532acp-3 +-0x1.9p+4 +-0x1.10709cfa3bc2p-2 +-0x1.c3dce191b86e2p-3 +-0x1.bf8c28ff974f3p-18 +-0x1.761030c5e5773p-10 +-0x1.2f8dca2e7021dp-14 +-0x1.fc9ecbca90d0cp-15 +-0x1.466bc7145f8cfp-17 +-0x1.15ba8f6a1cdb2p-9 +-0x1.7c532b2703c79p-14 +-0x1.40bc05c3892f9p-14 +-0x1.37328e7d9d42fp-16 +-0x1.064882e2d241ep-8 +-0x1.60cbb5ead7657p-13 +-0x1.2980302c8e243p-13 +-0x1.0e51147c0e066p-15 +-0x1.c10ce0e1d24cep-8 +-0x1.23a912ef517cbp-12 +-0x1.ebc7766173b43p-13 +-0x1.a7f13e67064d8p-15 +-0x1.596d94fbc754dp-7 +-0x1.a843724c0498p-12 +-0x1.659cbfb3e807ap-12 +-0x1.24227454c469fp-14 +-0x1.d2ae1b83063e5p-7 +-0x1.0b5401ef57954p-11 +-0x1.c2b10e423be51p-12 +-0x1.71cc89ff6c57p-14 +-0x1.21cb85d5ef37ap-6 +-0x1.2e692aa17f69dp-11 +-0x1.fe751416d9ad1p-12 +-0x1.955d5bbce8c93p-14 +-0x1.385b3f693dd89p-6 +-0x1.288a0ed36366fp-11 +-0x1.f5993b7970b86p-12 +-0x1.737b29a86e421p-14 +-0x1.1b1c2ce19cce6p-6 +-0x1.f3b5234fbc18dp-12 +-0x1.a74dc9bc14cfcp-12 +-0x1.d9ab78041f4c6p-14 +-0x1.64fd1a580da26p-6 +-0x1.273d62ca4c5ecp-11 +-0x1.f5538bc2b0599p-12 +-0x1.4b743fe5dd42fp-13 +-0x1.e9629bcab39d3p-6 +-0x1.6756ecd6b6c6ap-11 +-0x1.3180a3f3ac0b6p-11 +-0x1.1fc27038281b9p-12 +-0x1.9a52e3119c082p-5 +-0x1.c4b5a8c8fb868p-11 +-0x1.8114f8c92ed8dp-11 +-0x1.019c9b26970bap-11 +-0x1.672361ef2210bp-4 +-0x1.757605d12d139p-10 +-0x1.3b63370c557fp-10 +-0x1.8c036479949b4p-11 +-0x1.117c95b83b481p-3 +-0x1.2ecf23b048cd4p-9 +-0x1.fd0350ed6a8c8p-10 +-0x1.08a7d9600134ep-10 +-0x1.6b6a816fff59ap-3 +-0x1.a1cb297f0f6e3p-9 +-0x1.5ea361d6e87dbp-9 +-0x1.fdf1806ae5c71p-10 +-0x1.573299ae2b46bp-2 +-0x1.6d998866eebc3p-8 +-0x1.3139fd5e0ff78p-8 +-0x1.0b5e1873e06edp-8 +-0x1.63e32aa3d3967p-1 +-0x1.0b3e5dbee9a5ap-8 +-0x1.636edef98bb06p-1 +-0x1.e8a91d7fffc79p-7 +-0x1.992167d66a64fp-7 +-0x1.51fd1966ded6dp-5 +-0x1.33f2ed407af38p+4 +-0x1.4831349e8ad51p-7 +-0x1.b1b948dc6febcp+0 +-0x1.91916553d001fp-4 +-0x1.66d13caa20511p-3 +-0x1.5808c61a63bcfp-5 +-0x1.1be3cde42ee7cp-5 +-0x1.a2c62d2d506d3p-6 +-0x1.147e17fac3514p+2 +-0x1.d6b159e0935ap-3 +-0x1.5d21833355dap-2 +-0x1.0adcc4c125106p-3 +-0x1.b7bb771e7b70bp-4 +-0x1.3f5b452c46f82p-4 +-0x1.abe50c34aed2p+3 +-0x1.3bcf85c6e2ed4p-4 +-0x1.9fa3bac935db3p+3 +-0x1.4c40a76686ee3p-1 +-0x1.0d8eeddae1cb7p+0 +-0x1.6c28adf8a418cp-2 +-0x1.2b9c76353bd79p-2 +-0x1.24e3f5b7ad79cp-2 +-0x1.9p+4 +-0x1.fddd8089cf48ap-3 +-0x1.9p+4 +-0x1.5d5121d7fca47p-1 +-0x1.1ee3afbb8c436p-1 +-0x1.57198c5456b31p+2 +-0x1.9p+4 +-0x1.4df4464a8ce68p-1 +-0x1.9p+4 +-0x1.05c57ff7fbe16p+4 +-0x1.9p+4 +-0x1.6ebea3341b58ap+0 +-0x1.2d4572cc0cbe4p+0 +-0x1.4e8dccecfececp+1 +-0x1.9p+4 +-0x1.607b8a8d364e9p+0 +-0x1.9p+4 +-0x1.7a6401b4955a7p+2 +-0x1.9c07df92f1be9p+3 +-0x1.544540a5201f2p+1 +-0x1.197245b0b1687p+1 +-0x1.9c8ea0e48c159p+0 +-0x1.9p+4 +-0x1.0fe06366a9d19p+2 +-0x1.3f547221e9d91p+2 +-0x1.bfe3ce9941739p+1 +-0x1.73b090dcdd65ep+1 +-0x1.89370bd706ad8p+0 +-0x1.9p+4 +-0x1.8e0c81b1af46bp+1 +-0x1.471303c0cf5f1p+1 +-0x1.5486f18517d3fp+0 +-0x1.9p+4 +-0x1.485fca85ed90dp+1 +-0x1.5de5e8171126dp+1 +-0x1.1ead7e44178b7p+1 +-0x1.d8572362ef694p+0 +-0x1.6c7c722cf83bp-1 +-0x1.9p+4 +-0x1.3484bad9b8e62p+0 +-0x1.fb1285bc630e3p-1 +-0x1.72333323a8484p-16 +-0x1.f392d5bc0adb8p-9 +-0x1.3b2a60cfa8938p-12 +-0x1.02ebc0ddb7403p-12 +-0x1.e7e87936a435cp-16 +-0x1.4a0e77f79f15bp-8 +-0x1.860e247bbb6ecp-12 +-0x1.40904c5726af3p-12 +-0x1.d872317771c87p-15 +-0x1.3f0cece8e19b7p-7 +-0x1.69d7b3c1e2d0cp-11 +-0x1.295fecceadecap-11 +-0x1.a3ce077ccdc6bp-14 +-0x1.1ac620c71fa9ep-6 +-0x1.2b3c05c19cbe8p-10 +-0x1.ebd4a012791cap-11 +-0x1.529d18635b504p-13 +-0x1.c6b686f40a272p-6 +-0x1.b365a1151a17ap-10 +-0x1.65ceefcba1b11p-10 +-0x1.e063c2249d656p-13 +-0x1.418a73e894354p-5 +-0x1.124ec26bb1131p-9 +-0x1.c2d9e110a828cp-10 +-0x1.382202016773cp-12 +-0x1.a0aa48cd8e2d9p-5 +-0x1.35c2b4e2bbbf8p-9 +-0x1.fd2b399a09bf6p-10 +-0x1.5de7fb3656dd4p-12 +-0x1.d1fa7803c9283p-5 +-0x1.2ee5feaa9ca04p-9 +-0x1.f1f74c558c1acp-10 +-0x1.459190d78bacp-12 +-0x1.b0e85ee3c396bp-5 +-0x1.fd94167dc4e79p-10 +-0x1.a2ea14f8dcc0ep-10 +-0x1.a58843a367e74p-12 +-0x1.17d59104d6948p-4 +-0x1.2c6f32fc7ea73p-9 +-0x1.ee0a9d9d04174p-10 +-0x1.2f6599fed2343p-11 +-0x1.91bc2d7b6754dp-4 +-0x1.6d6f9c01070cfp-9 +-0x1.2c7f271d15602p-9 +-0x1.14242356ed297p-10 +-0x1.6c19dc91fdbfcp-3 +-0x1.cccac429dc12p-9 +-0x1.7af087f641ecbp-9 +-0x1.ff68d8279d029p-10 +-0x1.504ac074d9442p-2 +-0x1.80458bba70fb3p-8 +-0x1.3bd63bf2831bcp-8 +-0x1.8f7de648e2deep-9 +-0x1.06763bb766c8dp-1 +-0x1.3a08e2a1a9da6p-7 +-0x1.020824d7f3938p-7 +-0x1.0d629284dfdabp-8 +-0x1.61d85ee4522bp-1 +-0x1.b2e92fbed71f4p-7 +-0x1.65583aac5159fp-7 +-0x1.0885142bddf7dp-7 +-0x1.5ac93010c7571p+0 +-0x1.7f53dcba2b0c5p-6 +-0x1.3acd875b6e81dp-6 +-0x1.1882f0f7344c8p-6 +-0x1.6f4bce0356b4cp+1 +-0x1.1865cc1fbdc18p-6 +-0x1.6f2362a4c60ffp+1 +-0x1.016d163436e63p-4 +-0x1.a6dd21859be77p-5 +-0x1.719ed7c02607ap-3 +-0x1.9p+4 +-0x1.5a96f88d1667cp-5 +-0x1.c57a3228acbaep+2 +-0x1.9f59d2ffe8132p-2 +-0x1.5ff67ea25b0a4p-2 +-0x1.6caceff99977ap-3 +-0x1.2b1d191545ef7p-3 +-0x1.bb5715b3b1e98p-4 +-0x1.21fc63978cc9ep+4 +-0x1.dde6301668fd6p-1 +-0x1.92f74c3318be3p-1 +-0x1.1b46cbd7ecb95p-1 +-0x1.d09a72203acd5p-2 +-0x1.522a2bd572cb9p-2 +-0x1.9p+4 +-0x1.4f09d09fce6e1p-2 +-0x1.9p+4 +-0x1.582f7c8739078p+1 +-0x1.328e370477e42p+1 +-0x1.82d9b509a5e4cp+0 +-0x1.3d306456fb60dp+0 +-0x1.313b2dd1998dep+0 +-0x1.9p+4 +-0x1.0ee5a29fd8219p+0 +-0x1.9p+4 +-0x1.734ad0f9fc8f4p+1 +-0x1.30638ab875acp+1 +-0x1.9p+4 +-0x1.9p+4 +-0x1.6325a44e80bdap+1 +-0x1.9p+4 +-0x1.9p+4 +-0x1.9p+4 +-0x1.85dc501a71395p+2 +-0x1.3f9b3554dc28fp+2 +-0x1.7258a6e6248cap+3 +-0x1.9p+4 +-0x1.76af0f1b05831p+2 +-0x1.9p+4 +-0x1.9p+4 +-0x1.9p+4 +-0x1.6915426457958p+3 +-0x1.28265ac979f12p+3 +-0x1.b6d7c697c3a5ep+2 +-0x1.9p+4 +-0x1.1e13e08ded5cbp+4 +-0x1.ee73f03dae8d2p+3 +0x1.9c9f1a0696507p-1 +0x1.b748b31994d3fp-1 +-0x1.6653147570c59p-25 +0x1.90de5484df9abp-1 +0x1.aaafeafce4b6bp-1 +-0x1.621a6e4507439p-25 +0x1.cd90a33f85d24p-2 +0x1.ea1cb140988p-2 +-0x1.1cb0ab955659p-25 +0x1.18399ef902541p-1 +0x1.29be214515957p-1 +-0x1.2f69229577166p-25 +0x1.71e6a46bb6d1p-1 +0x1.6189bf40df1a1p-1 +-0x1.adad0707e8044p-26 +0x1.6643b4b933683p-1 +0x1.56af0ef9d3166p-1 +-0x1.a6304eab64085p-26 +0x1.8d1aca0807a99p-2 +0x1.7f975d270026p-2 +-0x1.3ea8bf559284dp-26 +0x1.e7093b6dd9633p-2 +0x1.d53b7838df5ddp-2 +-0x1.58489c287aab2p-26 +0x1.2fe6309dff816p-1 +0x1.0da4f0eebf1bdp-1 +-0x1.a1f7d65033cd9p-26 +0x1.2659a37c7bcc2p-1 +0x1.05052ee94ebeap-1 +-0x1.9bdd18cd1df0cp-26 +0x1.466ae9b7432c7p-2 +0x1.1f54b0dd27fc8p-2 +-0x1.43988dcf24a0fp-26 +0x1.904a1ce5a1fc2p-2 +0x1.610d7d93500a4p-2 +-0x1.59c5f7ff8c57ep-26 +0x1.93239df639e33p-1 +0x1.b4cf0c641d395p-1 +-0x1.22f2e15050089p-26 +0x1.86ce399228c0cp-1 +0x1.a61562e9b916dp-1 +-0x1.1dd163dbfb31ap-26 +0x1.b6117fc803dd2p-2 +0x1.c605ff784f793p-2 +-0x1.acff21b3b661ep-27 +0x1.0bd643b55a5bp-1 +0x1.18af616d0084fp-1 +-0x1.d081c0f13068dp-27 +0x1.b255d8d9aff55p-1 +0x1.9e4803806160fp-1 +-0x1.d488207926025p-27 +0x1.a54e362363b52p-1 +0x1.91d70c6f8c282p-1 +-0x1.cc59fb221258p-27 +0x1.dbe10eb388563p-2 +0x1.c5b58a803cd47p-2 +-0x1.5911019a0c489p-27 +0x1.225e43bca08f1p-1 +0x1.14dec04cc32bep-1 +-0x1.760b9d2a5ff38p-27 +0x1.1aabd0ab77358p-1 +0x1.44c550800290fp-1 +-0x1.cc23f85f526f6p-26 +0x1.1295c78cbeb36p-1 +0x1.3b836e7e99dd6p-1 +-0x1.c82ed2af2fa78p-26 +0x1.3bad581b70041p-2 +0x1.6b315d6dea292p-2 +-0x1.810a7a6a92688p-26 +0x1.7f75ba76e3131p-2 +0x1.b90842267fc3cp-2 +-0x1.947b32a4a3f03p-26 +-0x1.93a0ebb0fcc8p-29 +-0x1.5a960257a6af6p-26 +-0x1.2d4e34d3b77d3p-24 +-0x1.2b3ce45946e3bp-25 +-0x1.b25f78b4707bdp-26 +-0x1.f30252b76568cp-31 +-0x1.71be8567056c7p-24 +-0x1.08ff25c071d3fp-26 +-0x1.1566bfd1f7948p-13 +-0x1.93a0ebb0fcc87p-29 +-0x1.5a960257a6afcp-26 +-0x1.2d4e34d3b77d8p-24 +-0x1.2b3ce45946e4p-25 +-0x1.b25f78b4707c5p-26 +-0x1.f30252b765695p-31 +-0x1.71be8567056cep-24 +-0x1.08ff25c071d43p-26 +-0x1.167dcbe42e081p-13 +-0x1.d7bc37fb95f51p-25 +-0x1.95114594eb937p-22 +-0x1.3221b25411097p-17 +-0x1.3007e76b54db2p-18 +-0x1.b954995d03ae8p-19 +-0x1.239adb50ce2eap-26 +-0x1.b02222f3d943ap-20 +-0x1.0d3dc143627dfp-19 +-0x1.15ac52c11a64fp-13 +-0x1.d7bc37fb95f51p-25 +-0x1.95114594eb937p-22 +-0x1.3221b25411097p-17 +-0x1.3007e76b54db2p-18 +-0x1.b954995d03ae8p-19 +-0x1.239adb50ce2eap-26 +-0x1.b02222f3d943ap-20 +-0x1.0d3dc143627dfp-19 +-0x1.16ce74149540bp-13 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.37c443532a173p-5 +-0x1.19f67abb07d4cp-3 +-0x1.6158c663913d8p-5 +-0x1.3b090c802dbd1p-3 +-0x1.78cbda6d99979p-5 +-0x1.4d2932fbac6f1p-3 +-0x1.82e4fb240322fp-5 +-0x1.554e8f71773edp-3 +-0x1.c3b5d187da0acp+0 +-0x1.c32a0ab19db54p+0 +-0x1.bbf39460d4faep+0 +-0x1.bcd4feede96fep+0 +0x1.27f10ec52fea3p-1 +0x1.3a81fcd30d94fp-1 +-0x1.20b39e8249af4p-9 +0x1.2bde4d9490c23p-1 +0x1.3eb2a70800f44p-1 +-0x1.887a225482bc3p-9 +0x1.5f3b76a9d9c72p-1 +0x1.758fb5db0c749p-1 +-0x1.9d8758377db4fp-9 +0x1.5903f1e0e506bp-1 +0x1.6eea4d5611cdp-1 +-0x1.baa6e8b64802ap-9 +0x1.02098f048254cp-1 +0x1.f0c6ff52c4576p-2 +-0x1.0bb8677734052p-9 +0x1.05aedc9101ee9p-1 +0x1.f7af68b8b80e7p-2 +-0x1.6097e11d5e875p-9 +0x1.3615c99cedb09p-1 +0x1.2987e34497a51p-1 +-0x1.6b14e74d7f9a3p-9 +0x1.3027130c08ba2p-1 +0x1.23f2b699042d8p-1 +-0x1.85149a24d27ffp-9 +0x1.a82355cd6d216p-2 +0x1.7654d49e1d7fap-2 +-0x1.be3ef965fb22dp-10 +0x1.ae203af9c6b92p-2 +0x1.7badc86d156a9p-2 +-0x1.25cec67c3df55p-9 +0x1.fd9c067760a75p-2 +0x1.c2d9f966af4fp-2 +-0x1.2e912da132cc5p-9 +0x1.f3de6e6a51a9dp-2 +0x1.ba1c25afa0aafp-2 +-0x1.4436af9424ec5p-9 +0x1.1b8655c3e5e9ep-1 +0x1.2a3713e3e127cp-1 +-0x1.61afee039ebb4p-10 +0x1.1f7552a138384p-1 +0x1.2ea1ef2ceda5fp-1 +-0x1.d1d650ca2de35p-10 +0x1.53769b663d4b4p-1 +0x1.69e5854248d1ap-1 +-0x1.dfbb3a725140ap-10 +0x1.4d1c8f303ead9p-1 +0x1.6291dacb439cp-1 +-0x1.0109d4e433b7bp-9 +0x1.332b499507564p-1 +0x1.24e67e7475ea6p-1 +-0x1.098847fb52745p-10 +0x1.3760a8e4eabb6p-1 +0x1.28ea80d9ad8a5p-1 +-0x1.5db3fba9fcd82p-10 +0x1.6edaa8a72d524p-1 +0x1.5ddbed2e9b2b6p-1 +-0x1.682773f5b4035p-10 +0x1.68185c39750aep-1 +0x1.57686d8312df4p-1 +-0x1.81ed55008ab7bp-10 +0x1.95053e246e249p-2 +0x1.d1c736ef0823dp-2 +-0x1.d9d2a2d052c73p-11 +0x1.9a6891f8e92e1p-2 +0x1.d7f60b1348941p-2 +-0x1.376c53f27213dp-10 +0x1.e0ee681643281p-2 +0x1.146c43096f423p-1 +-0x1.40caf8c57150fp-10 +0x1.d8640e50116f3p-2 +0x1.0f8708e19e3dep-1 +-0x1.5797ff8a2f9aap-10 +-0x1.fe529d719658p-19 +-0x1.b6339bbedf8a2p-16 +-0x1.7cf1bb6c88881p-14 +-0x1.7a54836f306ffp-15 +-0x1.12976f2f2a014p-15 +-0x1.3b75397fd011p-20 +-0x1.d37b3f5f3cdfp-14 +-0x1.4f09dfc42c6p-16 +-0x1.8910eb7c65cb3p-4 +-0x1.fa0c375e4433dp-19 +-0x1.b287e00293dc9p-16 +-0x1.79c0c9d6d9cedp-14 +-0x1.77292d012469ep-15 +-0x1.104a91048f637p-15 +-0x1.38d0b7c8c9327p-20 +-0x1.cf90b9111faadp-14 +-0x1.4c3b604f565e2p-16 +-0x1.aecac34f27a04p-4 +-0x1.e71f0b314124ep-19 +-0x1.a24771b90dac6p-16 +-0x1.6b9ffa4663583p-14 +-0x1.69212f394c1ddp-15 +-0x1.061b80ecf50f1p-15 +-0x1.2d1da7ff1d035p-20 +-0x1.be3a4cb41721cp-14 +-0x1.3fce68c55599p-16 +-0x1.babcd9cfd09bdp-4 +-0x1.f33b9c2ea3d8dp-19 +-0x1.acadd3127abc5p-16 +-0x1.74aa7acdea082p-14 +-0x1.721bcdc86aa33p-15 +-0x1.0c9fd6b5a5cbp-15 +-0x1.349a4873b8d12p-20 +-0x1.c9529349adfcp-14 +-0x1.47c2009147ebcp-16 +-0x1.c541c7940350ep-4 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.32daa296efe6bp-5 +-0x1.1615a29e26227p-3 +-0x1.5c9d037d7ca58p-5 +-0x1.374edcd8948ddp-3 +-0x1.743d03a739c46p-5 +-0x1.49918db07c9dbp-3 +-0x1.7ce98810146a6p-5 +-0x1.50a8664318ca6p-3 +-0x1.c60846ff0d9cfp+0 +-0x1.c4e83be3b2da7p+0 +-0x1.bd58c43ac1b54p+0 +-0x1.bf1afcb06c527p+0 +0x1.172f9d679bd3ep-1 +0x1.28a274c0db609p-1 +-0x1.1d70cafe1e157p-9 +0x1.1f50e25605b54p-1 +0x1.314e3802355cdp-1 +-0x1.8410aef28318bp-9 +0x1.555fbe552be1p-1 +0x1.6b05edcc5e651p-1 +-0x1.98e38233598ep-9 +0x1.48e4a2cde6195p-1 +0x1.5dafef6870a24p-1 +-0x1.b5aa12938a56bp-9 +0x1.e51fcca0ef71fp-2 +0x1.d36ab9f490dc9p-2 +-0x1.08b68b517d91bp-9 +0x1.f41bee6ac7633p-2 +0x1.e1a3bf2c3ddb8p-2 +-0x1.5ca40524c07fdp-9 +0x1.2cb00bea834bbp-1 +0x1.20af67802a796p-1 +-0x1.6703b4dcca1f9p-9 +0x1.20dd9fdd43f64p-1 +0x1.158a4476e0af6p-1 +-0x1.80b69cf0de8edp-9 +0x1.8eb822f444f7dp-2 +0x1.5fa71aa979f45p-2 +-0x1.b93c1e700cd1bp-10 +0x1.9b06b9cc5d3eap-2 +0x1.6aa0f34359c4cp-2 +-0x1.2283e6d4a606p-9 +0x1.ee2df61046c75p-2 +0x1.b501b88a2485cp-2 +-0x1.2b2de12f6016ap-9 +0x1.dac469b9dee0ep-2 +0x1.a39bb92664d94p-2 +-0x1.40935717bcb17p-9 +0x1.0acd89e5d23a7p-1 +0x1.1788cf4257bfcp-1 +-0x1.5db628ca6b10dp-10 +0x1.12e765793dd9ep-1 +0x1.2090918312adcp-1 +-0x1.cc9ceb0bc1f49p-10 +0x1.496616a7b1e83p-1 +0x1.5e4c77be69f31p-1 +-0x1.da5b169084778p-10 +0x1.3cb712b2f8ff5p-1 +0x1.4fc5a5d6d81fep-1 +-0x1.fc4db7d4a3cd5p-10 +0x1.2142852126ffp-1 +0x1.13d0088fa6f5ep-1 +-0x1.068b4f1aba474p-10 +0x1.29f0980985d7dp-1 +0x1.1c182163a10ffp-1 +-0x1.59c75751686b2p-10 +0x1.6424626a9efb6p-1 +0x1.53a2914db152ep-1 +-0x1.641dd45a1c562p-10 +0x1.56a023d4cac8p-1 +0x1.46bc2a5a07563p-1 +-0x1.7d96cc62530adp-10 +0x1.7e08dff02119dp-2 +0x1.b76570c713ad9p-2 +-0x1.d47a6a8933f01p-11 +0x1.892fc095af7c1p-2 +0x1.c4325effe71d1p-2 +-0x1.33ed631dfb54p-10 +0x1.d3639a1b0df29p-2 +0x1.0ca8ff12c0bc8p-1 +-0x1.3d331ec545d0bp-10 +0x1.c23fbbb01c57ep-2 +0x1.02d52c81445bp-1 +-0x1.53b9c91ad167ep-10 +-0x1.fe529d719658p-19 +-0x1.b6339bbedf8a2p-16 +-0x1.7cf1bb6c88881p-14 +-0x1.7a54836f306ffp-15 +-0x1.12976f2f2a014p-15 +-0x1.3b75397fd011p-20 +-0x1.d37b3f5f3cdfp-14 +-0x1.4f09dfc42c6p-16 +-0x1.86dc821718c4dp-4 +-0x1.fa0c375e444d2p-19 +-0x1.b287e00293f24p-16 +-0x1.79c0c9d6d9e1cp-14 +-0x1.77292d01247cbp-15 +-0x1.104a91048f712p-15 +-0x1.38d0b7c8c9421p-20 +-0x1.cf90b9111fc2p-14 +-0x1.4c3b604f566edp-16 +-0x1.ac602e0484f15p-4 +-0x1.e71f0b314124ep-19 +-0x1.a24771b90dac6p-16 +-0x1.6b9ffa4663583p-14 +-0x1.69212f394c1ddp-15 +-0x1.061b80ecf50f1p-15 +-0x1.2d1da7ff1d035p-20 +-0x1.be3a4cb41721cp-14 +-0x1.3fce68c55599p-16 +-0x1.b8411d594b579p-4 +-0x1.f33b9c2ea3c8p-19 +-0x1.acadd3127aaddp-16 +-0x1.74aa7acde9fb8p-14 +-0x1.721bcdc86a96ap-15 +-0x1.0c9fd6b5a5c1ep-15 +-0x1.349a4873b8c6bp-20 +-0x1.c9529349adecap-14 +-0x1.47c2009147e0bp-16 +-0x1.c2b6f04885c65p-4 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.29e1a7ead3e56p-4 +-0x1.00e438315f0ddp-2 +-0x1.57045d6eccafbp-4 +-0x1.21ba34b969f6ep-2 +-0x1.6e76ef2dfea0cp-4 +-0x1.32b0c253600a9p-2 +-0x1.78d763e8dc564p-4 +-0x1.3a4d3494af0c7p-2 +-0x1.c4de492f6c7aap+0 +-0x1.c408b52f826a2p+0 +-0x1.bca5e4925f18cp+0 +-0x1.bdf73fef15cafp+0 +0x1.1f98ab8c9db25p-1 +0x1.319acad1287e3p-1 +-0x1.abf21326873b3p-8 +0x1.259c52cf47909p-1 +0x1.38054cbefbfdcp-1 +-0x1.2321e739e5037p-7 +0x1.5a50d75070a44p-1 +0x1.704e262c14325p-1 +-0x1.32b8d43855784p-7 +0x1.50fcc8d296074p-1 +0x1.6655da9589eefp-1 +-0x1.48609be4c53ddp-7 +0x1.f4a085d0598ccp-2 +0x1.e221875941439p-2 +-0x1.8dc0a97a01e11p-8 +0x1.ffc0d62ef163cp-2 +0x1.ecae7f2e5faf1p-2 +-0x1.0603fbf6f68c7p-7 +0x1.31644a0c3ebcap-1 +0x1.251d5459dc4eep-1 +-0x1.0dc9c799588fdp-7 +0x1.2885f3150a7d9p-1 +0x1.1cc2e83705c4cp-1 +-0x1.21219417cdd64p-7 +0x1.9b739e94a0ad5p-2 +0x1.6b021aa01882fp-2 +-0x1.4b49f573e7298p-8 +0x1.a496d13c5de55p-2 +0x1.7329b6dfdc9f2p-2 +-0x1.b470007b633abp-8 +0x1.f5e74766932f7p-2 +0x1.bbef745e9699p-2 +-0x1.c1696c9eb1e86p-8 +0x1.e7576b3b74066p-2 +0x1.aee026c3ac698p-2 +-0x1.e19db6a42a94ap-8 +0x1.132f08b83b024p-1 +0x1.20e097a731918p-1 +-0x1.06b7dad3af4dap-8 +0x1.193140a4e9363p-1 +0x1.27999e9a1bb5ep-1 +-0x1.5a25cc5f1a37p-8 +0x1.4e7053f4a2dadp-1 +0x1.64193f052c91ep-1 +-0x1.6470bfbf0f084p-8 +0x1.44ef02ebaef2dp-1 +0x1.592c69969495ep-1 +-0x1.7dfe274b579dcp-8 +0x1.2a3d51cab1d84p-1 +0x1.1c615625aade2p-1 +-0x1.8a60892f3c5dap-9 +0x1.30ac44a2606dp-1 +0x1.2284c3758140dp-1 +-0x1.03cc7cb11ece9p-8 +0x1.698203985a43cp-1 +0x1.58c19b320913dp-1 +-0x1.0b88cfd73db87p-8 +0x1.5f62ca0adab46p-1 +0x1.4f187c76260c6p-1 +-0x1.1eb53194de4a7p-8 +0x1.89923ad7ed868p-2 +0x1.c4a3661b16e8fp-2 +-0x1.5e35226f83586p-9 +0x1.91d2805defc9ap-2 +0x1.ce1ba035c2a55p-2 +-0x1.cce5e1fd68d73p-9 +0x1.da2d5815aa86p-2 +0x1.108d2b09a3b78p-1 +-0x1.daaccaefd4809p-9 +0x1.cd5d47c9c94c7p-2 +0x1.0934c3fca3721p-1 +-0x1.fc8e42ee19e47p-9 +-0x1.7ebdf61530c42p-17 +-0x1.48a6b4cf27a97p-14 +-0x1.1db54c916667bp-12 +-0x1.1bbf629364558p-13 +-0x1.9be326c6bf042p-14 +-0x1.d92fd63fb81c3p-19 +-0x1.5e9c6f876da93p-12 +-0x1.f68ecfa64292dp-15 +-0x1.53222dec27395p-3 +-0x1.7b892986b335ap-17 +-0x1.45e5e801eef21p-14 +-0x1.1b50976123663p-12 +-0x1.195ee1c0db5a6p-13 +-0x1.986fd986d7252p-14 +-0x1.d53913ad2dddep-19 +-0x1.5bac8accd7cdap-12 +-0x1.f259107701a0bp-15 +-0x1.73aedec91bcfcp-3 +-0x1.6d574864f0dbbp-17 +-0x1.39b5954aca415p-14 +-0x1.10b7fbb4ca822p-12 +-0x1.0ed8e36af9166p-13 +-0x1.892941636f969p-14 +-0x1.c3ac7bfeab84fp-19 +-0x1.4eabb98711595p-12 +-0x1.dfb59d2800658p-15 +-0x1.7dfd5ba9e3c2ep-3 +-0x1.766cb522fada3p-17 +-0x1.41825e4ddc06p-14 +-0x1.177fdc1a6f7fdp-12 +-0x1.1594da564ff42p-13 +-0x1.92efc21078a77p-14 +-0x1.cee76cad952f4p-19 +-0x1.56fdee7742755p-12 +-0x1.eba300d9ebd6ap-15 +-0x1.8710ca4afa3b4p-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.2aa735d482b22p-4 +-0x1.01799157cf587p-2 +-0x1.57ea71f9c9fe5p-4 +-0x1.2264175d637c4p-2 +-0x1.6f69452a1c532p-4 +-0x1.3362d66a17af9p-2 +-0x1.79dfca99c8ed2p-4 +-0x1.3b0b4a9fe3aa5p-2 +-0x1.c4de492f6c7aap+0 +-0x1.c408b52f826a2p+0 +-0x1.bca5e4925f18cp+0 +-0x1.bdf73fef15cafp+0 +0x1.1f98ab8c9db25p-1 +0x1.319acad1287e3p-1 +-0x1.ad8c6f16a535ep-8 +0x1.259c52cf47909p-1 +0x1.38054cbefbfdcp-1 +-0x1.24393acf1a009p-7 +0x1.5a50d75070a44p-1 +0x1.704e262c14325p-1 +-0x1.33df17f7b51e4p-7 +0x1.50fcc8d296074p-1 +0x1.6655da9589eefp-1 +-0x1.499bb0c3cb0ddp-7 +0x1.f4a085d0598ccp-2 +0x1.e221875941439p-2 +-0x1.8f3ea95d6e14ep-8 +0x1.ffc0d62ef163cp-2 +0x1.ecae7f2e5faf1p-2 +-0x1.06ffae7854b2p-7 +0x1.31644a0c3ebcap-1 +0x1.251d5459dc4eep-1 +-0x1.0eccedc446e72p-7 +0x1.2885f3150a7d9p-1 +0x1.1cc2e83705c4cp-1 +-0x1.22375380c412cp-7 +0x1.9b739e94a0ad5p-2 +0x1.6b021aa01882fp-2 +-0x1.4c87fd8010dffp-8 +0x1.a496d13c5de55p-2 +0x1.7329b6dfdc9f2p-2 +-0x1.b6131a2b4b0b6p-8 +0x1.f5e74766932f7p-2 +0x1.bbef745e9699p-2 +-0x1.c318f52dfc1aep-8 +0x1.e7576b3b74066p-2 +0x1.aee026c3ac698p-2 +-0x1.e36c355a88ef4p-8 +0x1.132f08b83b024p-1 +0x1.20e097a731918p-1 +-0x1.07b427f50da3p-8 +0x1.193140a4e9363p-1 +0x1.27999e9a1bb5ep-1 +-0x1.5b724d1f27ed9p-8 +0x1.4e7053f4a2dadp-1 +0x1.64193f052c91ep-1 +-0x1.65c71e056dfep-8 +0x1.44ef02ebaef2dp-1 +0x1.592c69969495ep-1 +-0x1.7f6d17419d108p-8 +0x1.2a3d51cab1d84p-1 +0x1.1c615625aade2p-1 +-0x1.8bdb35369ae2ap-9 +0x1.30ac44a2606dp-1 +0x1.2284c3758140dp-1 +-0x1.04c601e081c0fp-8 +0x1.698203985a43cp-1 +0x1.58c19b320913dp-1 +-0x1.0c89bdfcf604fp-8 +0x1.5f62ca0adab46p-1 +0x1.4f187c76260c6p-1 +-0x1.1fc88f234631bp-8 +0x1.89923ad7ed868p-2 +0x1.c4a3661b16e8fp-2 +-0x1.5f844e1dfa014p-9 +0x1.91d2805defc9ap-2 +0x1.ce1ba035c2a55p-2 +-0x1.ce9f58b3b71e7p-9 +0x1.da2d5815aa86p-2 +0x1.108d2b09a3b78p-1 +-0x1.dc7363b098c48p-9 +0x1.cd5d47c9c94c7p-2 +0x1.0934c3fca3721p-1 +-0x1.fe7568f69490cp-9 +-0x1.7ebdf61530c42p-17 +-0x1.48a6b4cf27a97p-14 +-0x1.1db54c916667bp-12 +-0x1.1bbf629364558p-13 +-0x1.9be326c6bf042p-14 +-0x1.d92fd63fb81c3p-19 +-0x1.5e9c6f876da93p-12 +-0x1.f68ecfa64292dp-15 +-0x1.53c51c4587641p-3 +-0x1.7b892986b32d3p-17 +-0x1.45e5e801eeeadp-14 +-0x1.1b509761235fep-12 +-0x1.195ee1c0db542p-13 +-0x1.986fd986d71c1p-14 +-0x1.d53913ad2dd37p-19 +-0x1.5bac8accd7c5ep-12 +-0x1.f259107701959p-15 +-0x1.7461706ff4c4ep-3 +-0x1.6d574864f0dbbp-17 +-0x1.39b5954aca415p-14 +-0x1.10b7fbb4ca822p-12 +-0x1.0ed8e36af9166p-13 +-0x1.892941636f969p-14 +-0x1.c3ac7bfeab84fp-19 +-0x1.4eabb98711595p-12 +-0x1.dfb59d2800658p-15 +-0x1.7eb4e0eed43bp-3 +-0x1.766cb522fade6p-17 +-0x1.41825e4ddc099p-14 +-0x1.177fdc1a6f82fp-12 +-0x1.1594da564ff74p-13 +-0x1.92efc21078abfp-14 +-0x1.cee76cad95347p-19 +-0x1.56fdee7742792p-12 +-0x1.eba300d9ebdc2p-15 +-0x1.87ccabd1046fbp-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.be44fda27297ep-5 +-0x1.8a408f4d76ff2p-3 +-0x1.ed4842fcc1266p-5 +-0x1.adfd9addf8a4cp-3 +-0x1.0c42b22de21ep-4 +-0x1.ce35be4e62389p-3 +-0x1.187ed457cd35cp-4 +-0x1.e0c2f84ab9258p-3 +-0x1.c768908dc7a47p+0 +-0x1.c634c07db940dp+0 +-0x1.bed7c2cf5b5fbp+0 +-0x1.c0907f4a811c8p+0 +0x1.0d3724479f4d1p-1 +0x1.1e00ef5c6f3a5p-1 +-0x1.133dfdaf3734ap-8 +0x1.15edcc359f8e7p-1 +0x1.274b46ed8b881p-1 +-0x1.573d6dbab5efcp-8 +0x1.4ac2b21a78ebbp-1 +0x1.5faea4639ab34p-1 +-0x1.7b216e655b229p-8 +0x1.3e7e779c47f1p-1 +0x1.52949cd181e81p-1 +-0x1.a7f74ec163557p-8 +0x1.d2d40d31c68b4p-2 +0x1.c20842ca59faap-2 +-0x1.01131688524bdp-8 +0x1.e2d003403a08ap-2 +0x1.d138b69d9f7d2p-2 +-0x1.38ba59d5e08f1p-8 +0x1.22a119aa2d792p-1 +0x1.173433c8313b6p-1 +-0x1.5006aaacddde4p-8 +0x1.1713f3c2c7949p-1 +0x1.0c4c6504ad994p-1 +-0x1.76cc9115ff5eap-8 +0x1.7fb1335423767p-2 +0x1.5243050352ce9p-2 +-0x1.ac50056f6768cp-9 +0x1.8cd217b68a997p-2 +0x1.5df5cfb0525cp-2 +-0x1.04804545abd33p-8 +0x1.dda9c94ccaa55p-2 +0x1.a633d5aa13f88p-2 +-0x1.17ebcdd247badp-8 +0x1.cab1a8962c74ep-2 +0x1.9537ff3ba46dp-2 +-0x1.3833c1fcfea85p-8 +0x1.00e63b2f3b4cep-1 +0x1.0c8b5768ef8f6p-1 +-0x1.539975f102312p-9 +0x1.098d66574e039p-1 +0x1.1624c815cc82ap-1 +-0x1.9d2371eaaa53bp-9 +0x1.3e9bdc14821bfp-1 +0x1.51ef46a34c757p-1 +-0x1.bbf3d2dbaadefp-9 +0x1.3231fbcad3765p-1 +0x1.43cc36e41ba6ap-1 +-0x1.ef2d2f29b64dp-9 +0x1.16a39d312520fp-1 +0x1.09ae0706b9304p-1 +-0x1.fdd14b386e857p-10 +0x1.1feb57c2fc3b5p-1 +0x1.12889d144febdp-1 +-0x1.361964ac9cdf5p-9 +0x1.58a510c6196d5p-1 +0x1.48a97ed50a7ap-1 +-0x1.4d3d87fb99fefp-9 +0x1.4b6699aa3b1b2p-1 +0x1.3c05e38b4f8e2p-1 +-0x1.73ad9bd1e310fp-9 +0x1.705c4d75945ebp-2 +0x1.a7b2bb75ab1fap-2 +-0x1.c55cea8eb57e6p-10 +0x1.7c4f7b362878bp-2 +0x1.b56ac086a6d24p-2 +-0x1.13801ef670cd4p-9 +0x1.c4d02c1e26366p-2 +0x1.044d96d56da21p-1 +-0x1.280a225b4bdffp-9 +0x1.b3f8c146467d3p-2 +0x1.f54a2a80b9712p-2 +-0x1.4a038c7c95937p-9 +-0x1.f484d193cf6d8p-18 +-0x1.adc88200f9ef1p-15 +-0x1.75a039f51d906p-13 +-0x1.730fdd394bfa4p-14 +-0x1.0d50fa35ded9bp-14 +-0x1.3565c8d7630fap-19 +-0x1.ca8025a5b75bep-13 +-0x1.489a229c6c112p-15 +-0x1.0d65102859e6p-3 +-0x1.effa09977265p-18 +-0x1.a9e20e5f60eep-15 +-0x1.723c3c9c2bbfap-13 +-0x1.6fb1d4b49a9d5p-14 +-0x1.0adf50903fe4bp-14 +-0x1.329701c830dbfp-19 +-0x1.c656fb0ad545bp-13 +-0x1.459ebe1f745a3p-15 +-0x1.200a0719071b6p-3 +-0x1.dbde1e711eee4p-18 +-0x1.989daa2ee109bp-15 +-0x1.63396ed7f5758p-13 +-0x1.60c965bb99aa2p-14 +-0x1.000d5a1cc958dp-14 +-0x1.2628cd3d2bce1p-19 +-0x1.b3eb3a083d20cp-13 +-0x1.386b041a71577p-15 +-0x1.2b96bf025ff81p-3 +-0x1.e8bc6bd4c8716p-18 +-0x1.a3aa66be7237ap-15 +-0x1.6cd48df434662p-13 +-0x1.6a53a4d084cacp-14 +-0x1.06f9ee71d1e1ap-14 +-0x1.2e1d2fe549055p-19 +-0x1.bfb4f96dbe8e2p-13 +-0x1.40ddcd12fa388p-15 +-0x1.36d4e5bedb702p-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.b539ee9d99c38p-5 +-0x1.831d95db991e8p-3 +-0x1.e3d42625d436p-5 +-0x1.a69aa9661bbb8p-3 +-0x1.06b699654ee6fp-4 +-0x1.c5a91c4ee5c19p-3 +-0x1.12a950eb78c4p-4 +-0x1.d7d3c219a1436p-3 +-0x1.c9341746f93afp+0 +-0x1.c7b138e2ca7bbp+0 +-0x1.c0bd4565ea8c4p+0 +-0x1.c27c8bfce0b9dp+0 +0x1.002a85ebdb44ap-1 +0x1.10185dc2a3364p-1 +-0x1.0d18ceca96f3ep-8 +0x1.0b27c55dfe734p-1 +0x1.1bcebeb4b9073p-1 +-0x1.4f964a1765edp-8 +0x1.3d3eaa9f4b319p-1 +0x1.513f1f8856223p-1 +-0x1.72b2ef16bc113p-8 +0x1.30bc37d20bb68p-1 +0x1.43e454704be96p-1 +-0x1.9e8461c99531ep-8 +0x1.bb03e18fa2131p-2 +0x1.ab5fb0aa59b7fp-2 +-0x1.f6acb192d13eap-9 +0x1.cf0f26ce3b7dfp-2 +0x1.be72c019de81ep-2 +-0x1.31c163fdb3ff6p-8 +0x1.15e7e72da1e52p-1 +0x1.0b30dda0c8511p-1 +-0x1.488e4988aa463p-8 +0x1.0a363dc6ab0f8p-1 +0x1.00217a07862fdp-1 +-0x1.6e72f875a2474p-8 +0x1.6c21dadcbdd4dp-2 +0x1.40d96a916ce54p-2 +-0x1.a2c1e9c30b5fdp-9 +0x1.7c98aa1acb651p-2 +0x1.4f81272df2ea3p-2 +-0x1.fd63e824748ccp-9 +0x1.c8c4e81f2cb81p-2 +0x1.937f1c8ac96fap-2 +-0x1.11b346d4eac81p-8 +0x1.b590645b3ac25p-2 +0x1.8252fe82e73f8p-2 +-0x1.313fbc38b6a8fp-8 +0x1.e7fa4c161245cp-2 +0x1.fc9871072e683p-2 +-0x1.4c04ed92207a9p-9 +0x1.fdb6fdf20b4bep-2 +0x1.0a48f80cc3e0cp-1 +-0x1.93ed1f8ab99c8p-9 +0x1.30ef3451c1811p-1 +0x1.425df22514681p-1 +-0x1.b214dde79a52ap-9 +0x1.24576e75de626p-1 +0x1.3420fe5efdd9bp-1 +-0x1.e424aa31dc5f4p-9 +0x1.08c749715fa77p-1 +0x1.f8e9ccdd35e7ap-2 +-0x1.f26f91c7dc63dp-10 +0x1.1472b2f3e17eep-1 +0x1.0796e5637ee2dp-1 +-0x1.2f2f12445a77cp-9 +0x1.4a0dfa4110d9fp-1 +0x1.3abd04fe394c5p-1 +-0x1.45d4685861611p-9 +0x1.3c998b4d8485fp-1 +0x1.2de62a45e41ep-1 +-0x1.6b652cc636df1p-9 +0x1.5e77e51b10b15p-2 +0x1.932757e1d55eap-2 +-0x1.bb42480c5d3ebp-10 +0x1.6d8921c557d49p-2 +0x1.a4746ff0d428bp-2 +-0x1.0d5e3dad08d33p-9 +0x1.b241bff924e8cp-2 +0x1.f352945f2f82dp-2 +-0x1.21774b0141bd7p-9 +0x1.a1164afd7667ep-2 +0x1.df9fdad9e3444p-2 +-0x1.42ab51b9fd937p-9 +-0x1.f484d193cf695p-18 +-0x1.adc88200f9eb7p-15 +-0x1.75a039f51d8d3p-13 +-0x1.730fdd394bf71p-14 +-0x1.0d50fa35ded76p-14 +-0x1.3565c8d7630d1p-19 +-0x1.ca8025a5b758p-13 +-0x1.489a229c6c0e5p-15 +-0x1.0a5f3218d752p-3 +-0x1.effa0997725c7p-18 +-0x1.a9e20e5f60e6bp-15 +-0x1.723c3c9c2bb95p-13 +-0x1.6fb1d4b49a97p-14 +-0x1.0adf50903fe01p-14 +-0x1.329701c830d6ap-19 +-0x1.c656fb0ad53dep-13 +-0x1.459ebe1f74549p-15 +-0x1.1ccf3099f7eb9p-3 +-0x1.dbde1e711ef27p-18 +-0x1.989daa2ee10d5p-15 +-0x1.63396ed7f578ap-13 +-0x1.60c965bb99ad4p-14 +-0x1.000d5a1cc95b2p-14 +-0x1.2628cd3d2bd0bp-19 +-0x1.b3eb3a083d24ap-13 +-0x1.386b041a715a3p-15 +-0x1.283d96cdffcf2p-3 +-0x1.e8bc6bd4c8716p-18 +-0x1.a3aa66be7237ap-15 +-0x1.6cd48df434662p-13 +-0x1.6a53a4d084cacp-14 +-0x1.06f9ee71d1e1ap-14 +-0x1.2e1d2fe549055p-19 +-0x1.bfb4f96dbe8e2p-13 +-0x1.40ddcd12fa388p-15 +-0x1.3359aa62a3412p-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.b2d6747cb447fp-4 +-0x1.69d562487a524p-2 +-0x1.e65d7b05021d3p-4 +-0x1.8d5241ed38c28p-2 +-0x1.0947035cc77d2p-3 +-0x1.ab8b252ad0975p-2 +-0x1.16ffbee80926p-3 +-0x1.be2abeb67111dp-2 +-0x1.c84de03924771p+0 +-0x1.c6f2ad2477b74p+0 +-0x1.bfca0080a1555p+0 +-0x1.c185fefd856b7p+0 +0x1.06b5a9ffcd84ep-1 +0x1.17119e92ca5f4p-1 +-0x1.957c2f536a42cp-7 +0x1.108e22dde5e4cp-1 +0x1.2190754154518p-1 +-0x1.f9dfeaff0c91cp-7 +0x1.44067f271418cp-1 +0x1.587cdd03fb5cap-1 +-0x1.176770c65687ap-6 +0x1.37a3396b02279p-1 +0x1.4b42851379f97p-1 +-0x1.3880fc4a199b3p-6 +0x1.c6f00fdd9cb66p-2 +0x1.b6b9000cc2d6bp-2 +-0x1.7b532c1d681fdp-7 +0x1.d8f26c6658c36p-2 +0x1.c7d937b93252p-2 +-0x1.cd869af4148adp-7 +0x1.1c46f76d25d41p-1 +0x1.11358ed811223p-1 +-0x1.efec1b92de24cp-7 +0x1.10a796f108c1bp-1 +0x1.0639fe750194dp-1 +-0x1.1497bd383476bp-6 +0x1.75ecf05554d92p-2 +0x1.49909dbfd99d4p-2 +-0x1.3bdbc7636192bp-7 +0x1.84b7beb419492p-2 +0x1.56bd255bb1ae6p-2 +-0x1.804cf409a3d47p-7 +0x1.d33b73c8039d9p-2 +0x1.9cdc5c17debb8p-2 +-0x1.9cf6c97f1b9cfp-7 +0x1.c0252d7b6bc7ap-2 +0x1.8bc86a41d1185p-2 +-0x1.cca240ad76d8ep-7 +0x1.f4e94a466a08ap-2 +0x1.056c283f71ce4p-1 +-0x1.f5122123a34bep-8 +0x1.04367f7ba5a7cp-1 +0x1.103722dd40d3fp-1 +-0x1.30d7eb46c8e59p-7 +0x1.37c916c99a59bp-1 +0x1.4a2710491c6bdp-1 +-0x1.47963b34e4f53p-7 +0x1.2b484e0ef5aa2p-1 +0x1.3bf70fd782ebcp-1 +-0x1.6d69a8edb42e4p-7 +0x1.0fb92b89ce46ap-1 +0x1.0314fc0c7fa73p-1 +-0x1.780c3ccadd1d2p-8 +0x1.1a3199f1ec3b9p-1 +0x1.0d1232828c359p-1 +-0x1.c98ec27c927a5p-8 +0x1.515dffa6f2a05p-1 +0x1.41b77ec89d8d2p-1 +-0x1.ebb541675ff8ap-8 +0x1.440499a466932p-1 +0x1.34fa501a91f83p-1 +-0x1.123cc08d1f3fap-7 +0x1.67709349331b1p-2 +0x1.9d749db2888f2p-2 +-0x1.4d4c007f7a0fp-8 +0x1.74f0ccb44ccb5p-2 +0x1.acf4da186b6aep-2 +-0x1.9550e4bdded3bp-8 +0x1.bb90c1b269dabp-2 +0x1.fe0000209aee7p-2 +-0x1.b38bd6d137d41p-8 +0x1.aa8f687452d13p-2 +0x1.ea7e3c4fc6121p-2 +-0x1.e5ae3ce08c4d6p-8 +-0x1.77639d2edb911p-16 +-0x1.42566180bb726p-13 +-0x1.18382b77d62b7p-11 +-0x1.164be5eaf8fadp-12 +-0x1.93f97750ce455p-13 +-0x1.d018ad4314963p-18 +-0x1.57e01c3c4983fp-11 +-0x1.ece733eaa2183p-14 +-0x1.cf1f17863ac22p-3 +-0x1.73fb873195c77p-16 +-0x1.3f698ac788aedp-13 +-0x1.15ad2d7520cc9p-11 +-0x1.13c55f8773f2dp-12 +-0x1.904ef8d85fd27p-13 +-0x1.cbe282ac49449p-18 +-0x1.54c13c481ff05p-11 +-0x1.e86e1d2f2e81ap-14 +-0x1.ef2d0edc9c447p-3 +-0x1.64e696d4d733bp-16 +-0x1.32763fa328c82p-13 +-0x1.0a6b1321f818ep-11 +-0x1.08970c4cb3405p-12 +-0x1.8014072b2e066p-13 +-0x1.b93d33dbc1b66p-18 +-0x1.46f06b862dd98p-11 +-0x1.d4a08627aa048p-14 +-0x1.0185a5b95b866p-2 +-0x1.6e8d50df9653fp-16 +-0x1.3abfcd0ed5a8cp-13 +-0x1.119f6a77274bdp-11 +-0x1.0fbebb9c63974p-12 +-0x1.8a76e5aabad14p-13 +-0x1.c52bc7d7ed869p-18 +-0x1.4fc7bb124ee99p-11 +-0x1.e14cb39c77536p-14 +-0x1.0b2e90beb42bp-2 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.b50a4c23a13c4p-4 +-0x1.6b71d50f319c8p-2 +-0x1.e8dbe9d5b2692p-4 +-0x1.8f1ac550c346dp-2 +-0x1.0aaa7c162ff19p-3 +-0x1.ad7cd18d53629p-2 +-0x1.187afd16bfa98p-3 +-0x1.c037ac7d514dp-2 +-0x1.c84de03924771p+0 +-0x1.c6f2ad2477b74p+0 +-0x1.bfca0080a1555p+0 +-0x1.c185fefd856b7p+0 +0x1.06b5a9ffcd84ep-1 +0x1.17119e92ca5f4p-1 +-0x1.988a61be783f3p-7 +0x1.108e22dde5e4cp-1 +0x1.2190754154518p-1 +-0x1.fdaf58be63633p-7 +0x1.44067f271418cp-1 +0x1.587cdd03fb5cap-1 +-0x1.198067b3f6a1cp-6 +0x1.37a3396b02279p-1 +0x1.4b42851379f97p-1 +-0x1.3adaf3f2e47a5p-6 +0x1.c6f00fdd9cb66p-2 +0x1.b6b9000cc2d6bp-2 +-0x1.7e2fb54e7a543p-7 +0x1.d8f26c6658c36p-2 +0x1.c7d937b93252p-2 +-0x1.d10158a6b01c4p-7 +0x1.1c46f76d25d41p-1 +0x1.11358ed811223p-1 +-0x1.f3a6097187215p-7 +0x1.10a796f108c1bp-1 +0x1.0639fe750194dp-1 +-0x1.16acf7f7adbcdp-6 +0x1.75ecf05554d92p-2 +0x1.49909dbfd99d4p-2 +-0x1.3e3d906edcfcap-7 +0x1.84b7beb419492p-2 +0x1.56bd255bb1ae6p-2 +-0x1.8332733426823p-7 +0x1.d33b73c8039d9p-2 +0x1.9cdc5c17debb8p-2 +-0x1.a010eeb883b93p-7 +0x1.c0252d7b6bc7ap-2 +0x1.8bc86a41d1185p-2 +-0x1.d01a117a2b7fep-7 +0x1.f4e94a466a08ap-2 +0x1.056c283f71ce4p-1 +-0x1.f8d9bee12aa8dp-8 +0x1.04367f7ba5a7cp-1 +0x1.103722dd40d3fp-1 +-0x1.33243f6a346f6p-7 +0x1.37c916c99a59bp-1 +0x1.4a2710491c6bdp-1 +-0x1.4a0c56dd09253p-7 +0x1.2b484e0ef5aa2p-1 +0x1.3bf70fd782ebcp-1 +-0x1.702a19ce6ae17p-7 +0x1.0fb92b89ce46ap-1 +0x1.0314fc0c7fa73p-1 +-0x1.7ae2551d5ee3cp-8 +0x1.1a3199f1ec3b9p-1 +0x1.0d1232828c359p-1 +-0x1.cd01b84af74a4p-8 +0x1.515dffa6f2a05p-1 +0x1.41b77ec89d8d2p-1 +-0x1.ef66f03c4f21p-8 +0x1.440499a466932p-1 +0x1.34fa501a91f83p-1 +-0x1.144d5ea355777p-7 +0x1.67709349331b1p-2 +0x1.9d749db2888f2p-2 +-0x1.4fce11ae415c1p-8 +0x1.74f0ccb44ccb5p-2 +0x1.acf4da186b6aep-2 +-0x1.985d7348e2b22p-8 +0x1.bb90c1b269dabp-2 +0x1.fe0000209aee7p-2 +-0x1.b6cfd14b8390fp-8 +0x1.aa8f687452d13p-2 +0x1.ea7e3c4fc6121p-2 +-0x1.e954af05423bp-8 +-0x1.77639d2edb911p-16 +-0x1.42566180bb726p-13 +-0x1.18382b77d62b7p-11 +-0x1.164be5eaf8fadp-12 +-0x1.93f97750ce455p-13 +-0x1.d018ad4314963p-18 +-0x1.57e01c3c4983fp-11 +-0x1.ece733eaa2183p-14 +-0x1.d0dde0cd8774bp-3 +-0x1.73fb873195c99p-16 +-0x1.3f698ac788b0ap-13 +-0x1.15ad2d7520ce2p-11 +-0x1.13c55f8773f46p-12 +-0x1.904ef8d85fd4ap-13 +-0x1.cbe282ac49473p-18 +-0x1.54c13c481ff24p-11 +-0x1.e86e1d2f2e846p-14 +-0x1.f10a6d2737e1bp-3 +-0x1.64e696d4d733bp-16 +-0x1.32763fa328c82p-13 +-0x1.0a6b1321f818ep-11 +-0x1.08970c4cb3405p-12 +-0x1.8014072b2e066p-13 +-0x1.b93d33dbc1b66p-18 +-0x1.46f06b862dd98p-11 +-0x1.d4a08627aa048p-14 +-0x1.027d1574caad6p-2 +-0x1.6e8d50df9653fp-16 +-0x1.3abfcd0ed5a8cp-13 +-0x1.119f6a77274bdp-11 +-0x1.0fbebb9c63974p-12 +-0x1.8a76e5aabad14p-13 +-0x1.c52bc7d7ed869p-18 +-0x1.4fc7bb124ee99p-11 +-0x1.e14cb39c77536p-14 +-0x1.0c2fd6988c94ap-2 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.d2bbaf71a299ep-5 +-0x1.a023a33aec00ap-3 +-0x1.85ca5e2e63cfbp-5 +-0x1.6207b35e01372p-3 +-0x1.648b92b2488ecp-4 +-0x1.2bca9ade2ae75p-2 +-0x1.7a8cf7791ecap-4 +-0x1.3b9772a1895p-2 +-0x1.cbb7779038141p+0 +-0x1.c976eb749cccbp+0 +-0x1.c3511a9c262b8p+0 +-0x1.c5353cdfc2544p+0 +0x1.dba270705f64dp-2 +0x1.f9185dcb0feffp-2 +-0x1.09fc611a126efp-8 +0x1.fc875b2399df6p-2 +0x1.0e11962e9f9b3p-1 +-0x1.4ccf1612994b1p-9 +0x1.2ac581d0ee1c2p-1 +0x1.3d87027685451p-1 +-0x1.370e8b22dd309p-7 +0x1.1d250117f0b91p-1 +0x1.2efd4a77ae742p-1 +-0x1.66952eedd5036p-7 +0x1.99c6786c5a174p-2 +0x1.8baff67e0c586p-2 +-0x1.0ac469373bb53p-8 +0x1.b78e95ea199d6p-2 +0x1.a8149311d919ep-2 +-0x1.5c74830f2fec6p-9 +0x1.04a9f8bbad18fp-1 +0x1.f5c12ab3c6587p-2 +-0x1.17ace6c8ab518p-7 +0x1.f019d4acd9a42p-2 +0x1.ddd631d431deep-2 +-0x1.40d08f13c8d26p-7 +0x1.50d3abe48efbap-2 +0x1.28931e3ec0fdap-2 +-0x1.bc6835e89d376p-9 +0x1.694aa630a510cp-2 +0x1.3e5278b7e2286p-2 +-0x1.225270aa78859p-9 +0x1.ac73bcd56c27dp-2 +0x1.7a2f1123a545ap-2 +-0x1.d1d7a7cd4ee29p-8 +0x1.97bc02e44cc44p-2 +0x1.67b12c7a03efp-2 +-0x1.0b2b71e69d0c9p-7 +0x1.c3dbf67eec9ddp-2 +0x1.d5099fc123c8p-2 +-0x1.605867b220c7ap-9 +0x1.e439626d961f4p-2 +0x1.f877e90f41c7ep-2 +-0x1.cc36dca942333p-10 +0x1.1e5be4b6c88c4p-1 +0x1.2d65a85074fa7p-1 +-0x1.717a70dddd1ddp-8 +0x1.10bce899007e2p-1 +0x1.1e258d0991ba4p-1 +-0x1.a7d40ed91c2fep-8 +0x1.eab93ff50f36ep-2 +0x1.d3de727e332dbp-2 +-0x1.087712a14fb74p-9 +0x1.06c31b9386418p-1 +0x1.f510f5dfa7fd9p-2 +-0x1.5978e59c8c961p-10 +0x1.36339a5ccb70ep-1 +0x1.27cb3cf6bd3ccp-1 +-0x1.154eb39a10963p-8 +0x1.279ea6feae311p-1 +0x1.19e170018982cp-1 +-0x1.3e17211277774p-8 +0x1.455143b43640ep-2 +0x1.764466a213789p-2 +-0x1.d677e286c42c5p-10 +0x1.5bdc77a6aabb6p-2 +0x1.9028e293d8c07p-2 +-0x1.34212d9efcccp-10 +0x1.98e7450aca27ap-2 +0x1.d63be881087b1p-2 +-0x1.ebdd5c6a33432p-9 +0x1.8635343d06184p-2 +0x1.c0c722f29d555p-2 +-0x1.19f5ff266a986p-8 +-0x1.c4f714b7ed282p-17 +-0x1.84f337c88d5d7p-14 +-0x1.5220cf11da875p-12 +-0x1.4fcece88d14d7p-13 +-0x1.e775342de7878p-14 +-0x1.18008aee5edc1p-18 +-0x1.9ef0631c5e482p-12 +-0x1.2961cc0d48f26p-14 +-0x1.22d87153f4cbp-3 +-0x1.c0dac61dd4489p-17 +-0x1.816ba0aec145bp-14 +-0x1.4f0f4921579b7p-12 +-0x1.4cc2ac8d6057dp-13 +-0x1.e308c3db7a83p-14 +-0x1.15760e1da12cdp-18 +-0x1.9b2c6baf4fcc9p-12 +-0x1.26aeeef0ebc91p-14 +-0x1.f742e69f73c3cp-4 +-0x1.aea7f39d40b6bp-17 +-0x1.71cb361641ccp-14 +-0x1.417994c359808p-12 +-0x1.3f44d59882b34p-13 +-0x1.cf732e1138f7ap-14 +-0x1.0a362fc510c42p-18 +-0x1.8a80b42206bc7p-12 +-0x1.1abc4f456fc02p-14 +-0x1.7dce2fa5c55afp-3 +-0x1.ba4d445c58104p-17 +-0x1.7bcb31952a36fp-14 +-0x1.4a2b10a7ba56ap-12 +-0x1.47e70be61d14ep-13 +-0x1.dbfb84b5617adp-14 +-0x1.11691913a09d8p-18 +-0x1.952bbd4d1d6e1p-12 +-0x1.22619c9363e3cp-14 +-0x1.8f47604d644c2p-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.c118e7d18d73fp-5 +-0x1.92252a0c9c2b6p-3 +-0x1.783052218b1f7p-5 +-0x1.56ebbb80784e8p-3 +-0x1.57136c0908f84p-4 +-0x1.21b635d7a156bp-2 +-0x1.6c69ea2ab0577p-4 +-0x1.311c054872fa6p-2 +-0x1.cf125e719db97p+0 +-0x1.cc1f4cc9e33f2p+0 +-0x1.c69df12b865b9p+0 +-0x1.c85b6720db64cp+0 +0x1.aa6076c1df614p-2 +0x1.c4a6f626bbe8bp-2 +-0x1.fdbecfc5cd69fp-9 +0x1.d5b20c4d074e9p-2 +0x1.f2c5285d9a447p-2 +-0x1.3eedd2265b19p-9 +0x1.12f42840a6788p-1 +0x1.241f22b08c8c9p-1 +-0x1.2a1e168c03505p-7 +0x1.0653523ebfd76p-1 +0x1.16a8cd61162ffp-1 +-0x1.57a2aa0427499p-7 +0x1.6d9625534e7cfp-2 +0x1.6175f8faaeb51p-2 +-0x1.ff40d60ab901bp-9 +0x1.946c012c0af8cp-2 +0x1.8693f0db3bb6p-2 +-0x1.4deba9d995d98p-9 +0x1.dd58e44d4733p-2 +0x1.cc07a3c9d06b7p-2 +-0x1.0c0b3cbb8a6dep-7 +0x1.c63c9dc213268p-2 +0x1.b60e407402ac6p-2 +-0x1.337189d2eae04p-7 +0x1.2c85e53e65a84p-2 +0x1.085bd3f99b54bp-2 +-0x1.a9dafa5370c2dp-9 +0x1.4c6dd09c934f6p-2 +0x1.24ab22bbd0a17p-2 +-0x1.16381e8528741p-9 +0x1.8854f52d7fdd5p-2 +0x1.59f596aca3014p-2 +-0x1.be793259ea383p-8 +0x1.75598b191c024p-2 +0x1.490d67b490ddp-2 +-0x1.00097d12e75fcp-7 +0x1.93b5a78a515ddp-2 +0x1.a0d40acba98d4p-2 +-0x1.51a0e4f431bb6p-9 +0x1.be08b90c3dcb7p-2 +0x1.ceb09268b5469p-2 +-0x1.b903e055a75fbp-10 +0x1.06984af66313dp-1 +0x1.12dbae9c117e9p-1 +-0x1.621c476982ce1p-8 +0x1.f426b59f29d0ep-2 +0x1.0500cef6273c6p-1 +-0x1.962987e098e32p-8 +0x1.b6daf2f4f845dp-2 +0x1.a26522a63b7c4p-2 +-0x1.fad56c36b4f83p-10 +0x1.e4745e98b6b82p-2 +0x1.cde39409edfdep-2 +-0x1.4b0ed355ca139p-10 +0x1.1cbf959bd5046p-1 +0x1.0f8222f0c95cap-1 +-0x1.09c5a115b8709p-8 +0x1.0f50b7b147f75p-1 +0x1.02b15615e56dfp-1 +-0x1.30d494e95ac88p-8 +0x1.239267dabb59ap-2 +0x1.4f7f26e427ec8p-2 +-0x1.c2d900081f889p-10 +0x1.413f77c095cd7p-2 +0x1.7197ab450c72ap-2 +-0x1.274fa017a02c7p-10 +0x1.783ae30544392p-2 +0x1.b0bb967fc4879p-2 +-0x1.d76da82bd693dp-9 +0x1.66e9bc4bf4b72p-2 +0x1.9cd9c9a019074p-2 +-0x1.0e3862fa88eaep-8 +-0x1.c4f714b7ed282p-17 +-0x1.84f337c88d5d7p-14 +-0x1.5220cf11da875p-12 +-0x1.4fcece88d14d7p-13 +-0x1.e775342de7878p-14 +-0x1.18008aee5edc1p-18 +-0x1.9ef0631c5e482p-12 +-0x1.2961cc0d48f26p-14 +-0x1.1cb5300e6c6cbp-3 +-0x1.c0dac61dd4489p-17 +-0x1.816ba0aec145bp-14 +-0x1.4f0f4921579b7p-12 +-0x1.4cc2ac8d6057dp-13 +-0x1.e308c3db7a83p-14 +-0x1.15760e1da12cdp-18 +-0x1.9b2c6baf4fcc9p-12 +-0x1.26aeeef0ebc91p-14 +-0x1.eca61a7ba6894p-4 +-0x1.aea7f39d40b6bp-17 +-0x1.71cb361641ccp-14 +-0x1.417994c359808p-12 +-0x1.3f44d59882b34p-13 +-0x1.cf732e1138f7ap-14 +-0x1.0a362fc510c42p-18 +-0x1.8a80b42206bc7p-12 +-0x1.1abc4f456fc02p-14 +-0x1.75c81d1dfd18p-3 +-0x1.ba4d445c58104p-17 +-0x1.7bcb31952a36fp-14 +-0x1.4a2b10a7ba56ap-12 +-0x1.47e70be61d14ep-13 +-0x1.dbfb84b5617adp-14 +-0x1.11691913a09d8p-18 +-0x1.952bbd4d1d6e1p-12 +-0x1.22619c9363e3cp-14 +-0x1.86de829f526abp-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.bd9358b14f16cp-4 +-0x1.77547eef06d4p-2 +-0x1.6da7b729604dfp-4 +-0x1.3caf64c9936f1p-2 +-0x1.62ac6b0cb78efp-3 +-0x1.1446a6fb071a7p-1 +-0x1.7b9a139f2b71ep-3 +-0x1.243834e56f81bp-1 +-0x1.cd635b48cfbc3p+0 +-0x1.caca1fdffdb62p+0 +-0x1.c4f5fbf568426p+0 +-0x1.c6c6ecbdc9e3cp+0 +0x1.c321bf1b902c4p-2 +0x1.df00e02fa9fd7p-2 +-0x1.8298858df3188p-7 +0x1.e9316e33a3effp-2 +0x1.03c4bdbede08p-1 +-0x1.e3175968172e9p-8 +0x1.1eeda692750e6p-1 +0x1.30e45e57cd349p-1 +-0x1.c4c293679cd2fp-6 +0x1.11cb3bcf58d3fp-1 +0x1.22e28b978438p-1 +-0x1.050184130a894p-5 +0x1.83bbfef44f04bp-2 +0x1.76a3c2aa2183ap-2 +-0x1.847113561fcd2p-7 +0x1.a60614a0fb44bp-2 +0x1.975f093870bb9p-2 +-0x1.fb2587118ea3ep-8 +0x1.f364ac9485e64p-2 +0x1.e0f5e4d230bb2p-2 +-0x1.977ca86a6eb2cp-6 +0x1.db37ffaa5c9f1p-2 +0x1.ca01e5715e5ap-2 +-0x1.d3715cec86227p-6 +0x1.3eb82ef4fc989p-2 +0x1.187f7cfaeffebp-2 +-0x1.43680fdcb48d5p-7 +0x1.5ae38c8fd3271p-2 +0x1.3183f2b6cbd44p-2 +-0x1.a64953993172p-8 +0x1.9a7038abe48dep-2 +0x1.6a1aad0b78135p-2 +-0x1.5344e52d214d7p-6 +0x1.86956acd897fbp-2 +0x1.5866c527972fdp-2 +-0x1.852da55bf9fd1p-6 +0x1.abdc8fabb7c5bp-2 +0x1.baf158db19102p-2 +-0x1.0083d19d13fc2p-7 +0x1.d12dbb56b6406p-2 +0x1.e395dad0af4a9p-2 +-0x1.4ee17392d00e6p-8 +0x1.1284613b6cfe4p-1 +0x1.2021fa9ff0773p-1 +-0x1.0d27e13f7d5d1p-6 +0x1.05715974f6d2p-1 +0x1.11945a55b65bep-1 +-0x1.34c2a4cdf698dp-6 +0x1.d0e2f6297e4ddp-2 +0x1.bb39530c95f5cp-2 +-0x1.8101d7f7e999cp-8 +0x1.f90d400bad71p-2 +0x1.e1895fc0dee1bp-2 +-0x1.f6a8f4218af41p-9 +0x1.29868a959f51cp-1 +0x1.1bb2f15e491bep-1 +-0x1.93f9962b4a5cap-7 +0x1.1b834984103aep-1 +0x1.0e545e72560fep-1 +-0x1.cf690eb8c01abp-7 +0x1.34877ae12061bp-2 +0x1.62fb1a6477a5dp-2 +-0x1.554b9a47daf32p-8 +0x1.4e9bdc3e7252cp-2 +0x1.80f0886d36e54p-2 +-0x1.be503822815b1p-9 +0x1.88a79f6600acep-2 +0x1.c396209110252p-2 +-0x1.657c46ba89b15p-7 +0x1.76a3abeb92f1p-2 +0x1.aee819a082e84p-2 +-0x1.99f6378c490b1p-7 +-0x1.53b94f89f1debp-15 +-0x1.23b669d66a069p-12 +-0x1.fb31369ac7cbcp-11 +-0x1.f7b635cd39f4ep-12 +-0x1.6d97e7226da63p-12 +-0x1.a400d0658e4adp-17 +-0x1.37344a5546b6ap-10 +-0x1.be12b213ed6c4p-13 +-0x1.f0b27c23cf999p-3 +-0x1.50a414965f37p-15 +-0x1.2110b88310f4cp-12 +-0x1.f696edb20369fp-11 +-0x1.f32402d410847p-12 +-0x1.6a4692e49be2dp-12 +-0x1.a031152c71c3fp-17 +-0x1.346150c37bd9fp-10 +-0x1.ba06666961ae5p-13 +-0x1.adbb583456f92p-3 +-0x1.42fdf6b5f089ap-15 +-0x1.15586890b1598p-12 +-0x1.e2365f250641bp-11 +-0x1.dee74064c40ddp-12 +-0x1.5b96628ceaba6p-12 +-0x1.8f5147a79926fp-17 +-0x1.27e08719850dep-10 +-0x1.a81a76e827a0fp-13 +-0x1.4609827506d7bp-2 +-0x1.4bb9f345420c3p-15 +-0x1.1cd8652fdfa93p-12 +-0x1.ef4098fb9781fp-11 +-0x1.ebda91d92b9f5p-12 +-0x1.64fca388091c2p-12 +-0x1.9a1da59d70ec5p-17 +-0x1.2fe0cdf9d6129p-10 +-0x1.b3926add15d59p-13 +-0x1.54f294769b2a3p-2 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.c1bdb37c679f3p-4 +-0x1.7a6bd3018a83dp-2 +-0x1.70e94c8bf36f6p-4 +-0x1.3f382e4d4cc62p-2 +-0x1.6645e4f1ed1e7p-3 +-0x1.16ad4b635ba4ap-1 +-0x1.7f81aa402706fp-3 +-0x1.26c96c0dc3618p-1 +-0x1.cd635b48cfbc3p+0 +-0x1.caca1fdffdb62p+0 +-0x1.c4f5fbf568426p+0 +-0x1.c6c6ecbdc9e3cp+0 +0x1.c321bf1b902c4p-2 +0x1.df00e02fa9fd7p-2 +-0x1.881e695feb581p-7 +0x1.e9316e33a3effp-2 +0x1.03c4bdbede08p-1 +-0x1.e9fb2b0085945p-8 +0x1.1eeda692750e6p-1 +0x1.30e45e57cd349p-1 +-0x1.cb34f5ea5300bp-6 +0x1.11cb3bcf58d3fp-1 +0x1.22e28b978438p-1 +-0x1.08bb380f5592dp-5 +0x1.83bbfef44f04bp-2 +0x1.76a3c2aa2183ap-2 +-0x1.89ff83431b6d4p-7 +0x1.a60614a0fb44bp-2 +0x1.975f093870bb9p-2 +-0x1.01324cc9cc5a8p-7 +0x1.f364ac9485e64p-2 +0x1.e0f5e4d230bb2p-2 +-0x1.9d4b0834be6aap-6 +0x1.db37ffaa5c9f1p-2 +0x1.ca01e5715e5ap-2 +-0x1.da1e6aeafc065p-6 +0x1.3eb82ef4fc989p-2 +0x1.187f7cfaeffebp-2 +-0x1.4807f7dc05411p-7 +0x1.5ae38c8fd3271p-2 +0x1.3183f2b6cbd44p-2 +-0x1.ac5155f8b33b2p-8 +0x1.9a7038abe48dep-2 +0x1.6a1aad0b78135p-2 +-0x1.581a2efb99dbbp-6 +0x1.86956acd897fbp-2 +0x1.5866c527972fdp-2 +-0x1.8abc4a2d631dbp-6 +0x1.abdc8fabb7c5bp-2 +0x1.baf158db19102p-2 +-0x1.042f2014e50eep-7 +0x1.d12dbb56b6406p-2 +0x1.e395dad0af4a9p-2 +-0x1.53aa592f40bbbp-8 +0x1.1284613b6cfe4p-1 +0x1.2021fa9ff0773p-1 +-0x1.10fda5ab888acp-6 +0x1.05715974f6d2p-1 +0x1.11945a55b65bep-1 +-0x1.392b8146820fep-6 +0x1.d0e2f6297e4ddp-2 +0x1.bb39530c95f5cp-2 +-0x1.86837dcfd1cap-8 +0x1.f90d400bad71p-2 +0x1.e1895fc0dee1bp-2 +-0x1.fdd73b80e4ef4p-9 +0x1.29868a959f51cp-1 +0x1.1bb2f15e491bep-1 +-0x1.99bafe4e639a5p-7 +0x1.1b834984103aep-1 +0x1.0e545e72560fep-1 +-0x1.d607356844871p-7 +0x1.34877ae12061bp-2 +0x1.62fb1a6477a5dp-2 +-0x1.5a2a3dd141723p-8 +0x1.4e9bdc3e7252cp-2 +0x1.80f0886d36e54p-2 +-0x1.c4ab436d4e362p-9 +0x1.88a79f6600acep-2 +0x1.c396209110252p-2 +-0x1.6a9220101442cp-7 +0x1.76a3abeb92f1p-2 +0x1.aee819a082e84p-2 +-0x1.9fcee34323c9ep-7 +-0x1.53b94f89f1debp-15 +-0x1.23b669d66a069p-12 +-0x1.fb31369ac7cbcp-11 +-0x1.f7b635cd39f4ep-12 +-0x1.6d97e7226da63p-12 +-0x1.a400d0658e4adp-17 +-0x1.37344a5546b6ap-10 +-0x1.be12b213ed6c4p-13 +-0x1.f43d9a826128cp-3 +-0x1.50a414965f37p-15 +-0x1.2110b88310f4cp-12 +-0x1.f696edb20369fp-11 +-0x1.f32402d410847p-12 +-0x1.6a4692e49be2dp-12 +-0x1.a031152c71c3fp-17 +-0x1.346150c37bd9fp-10 +-0x1.ba06666961ae5p-13 +-0x1.b0cb93ab45c45p-3 +-0x1.42fdf6b5f089ap-15 +-0x1.15586890b1598p-12 +-0x1.e2365f250641bp-11 +-0x1.dee74064c40ddp-12 +-0x1.5b96628ceaba6p-12 +-0x1.8f5147a79926fp-17 +-0x1.27e08719850dep-10 +-0x1.a81a76e827a0fp-13 +-0x1.485a708350786p-2 +-0x1.4bb9f345420c3p-15 +-0x1.1cd8652fdfa93p-12 +-0x1.ef4098fb9781fp-11 +-0x1.ebda91d92b9f5p-12 +-0x1.64fca388091c2p-12 +-0x1.9a1da59d70ec5p-17 +-0x1.2fe0cdf9d6129p-10 +-0x1.b3926add15d59p-13 +-0x1.5760070b13607p-2 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.d1508da4288bdp-5 +-0x1.a189cd7d4b27ap-3 +-0x1.bd91c4c649ee6p-5 +-0x1.918c104ed7ffdp-3 +-0x1.8b3c7df7111dcp-4 +-0x1.48d0e73ad5cf9p-2 +-0x1.48b4b0f2a2daap-4 +-0x1.19db35669af1fp-2 +-0x1.d342cfda68f4cp+0 +-0x1.cfcb2e26dcba3p+0 +-0x1.ca907dcc062bfp+0 +-0x1.cbb1e401d099fp+0 +0x1.6c7bf5d0111fap-2 +0x1.82ceb1eb7a382p-2 +-0x1.19a4075508e65p-8 +0x1.9fbd9400fa924p-2 +0x1.b955363a55fc1p-2 +-0x1.dd95c32c425bcp-9 +0x1.ec7b5b2421818p-2 +0x1.05852f3129afep-1 +-0x1.8ea1118791655p-7 +0x1.dbf40f6183e2ap-2 +0x1.f96f4bd0228fp-2 +-0x1.0b6c080db7fc8p-7 +0x1.36b78271c2a38p-2 +0x1.2cde6f62669c9p-2 +-0x1.259b32d2e32d2p-8 +0x1.641b487512456p-2 +0x1.586308b3b70ap-2 +-0x1.f6087a07d7d26p-9 +0x1.a9001d55fcedbp-2 +0x1.9a359789113c2p-2 +-0x1.6b6cc2f710d67p-7 +0x1.9a101829b107ep-2 +0x1.8bf63840e74ddp-2 +-0x1.fe37bcc803e0ep-8 +0x1.fee00a708f78dp-3 +0x1.c0e12b92b2c56p-3 +-0x1.e909d1940c6bfp-9 +0x1.24bbead2941f7p-2 +0x1.01748c4fce3ebp-2 +-0x1.a225623da561ap-9 +0x1.5d5589fc50252p-2 +0x1.33b060fcf78eep-2 +-0x1.2ea070dd0ceb3p-7 +0x1.5110276ffb632p-2 +0x1.28c8d87ed8bb6p-2 +-0x1.a8e24aaa163a1p-8 +0x1.57b6f7c10f851p-2 +0x1.60956a87cff62p-2 +-0x1.83c0d9c91cca3p-9 +0x1.895c406648a7bp-2 +0x1.95aed3764ccap-2 +-0x1.4b81d19578e93p-9 +0x1.d469ef573dfd7p-2 +0x1.e7203bb1e7c45p-2 +-0x1.e017e913c076ep-8 +0x1.c42c0f0c11157p-2 +0x1.d560f88b93c12p-2 +-0x1.50f95b76c19aap-8 +0x1.7612d349b22f6p-2 +0x1.649c9904bb222p-2 +-0x1.2304cfc4a254bp-9 +0x1.abb1375b75a09p-2 +0x1.97bf843d28528p-2 +-0x1.f1a2f920f778fp-10 +0x1.fc87d5c94cbd9p-2 +0x1.e4daece6e7fc7p-2 +-0x1.684d8d3cf4dd3p-8 +0x1.eb0f6ff7c6731p-2 +0x1.d430a925946b5p-2 +-0x1.f9cdbab57a06ep-9 +0x1.f261c5447fc96p-3 +0x1.1ec908eaff3e4p-2 +-0x1.02ab1569ba3c5p-9 +0x1.1c4981089c4a4p-2 +0x1.472013ec070a6p-2 +-0x1.bac39fbb0cd93p-10 +0x1.50dcdc10d8afbp-2 +0x1.83873fca97cbep-2 +-0x1.3f3fdbaf42e88p-8 +0x1.458931ac39b0dp-2 +0x1.7684a58fd93a9p-2 +-0x1.c0b42e03cd58ep-9 +-0x1.36a4524207a23p-16 +-0x1.0abd956d6b056p-13 +-0x1.cfc62f0d8a166p-12 +-0x1.cc97746da7432p-13 +-0x1.4e4bfce69a9aep-13 +-0x1.800c8480c3dbdp-18 +-0x1.1c904da3d0bb7p-11 +-0x1.97e3153bb1584p-14 +-0x1.2b4e276b950e3p-3 +-0x1.33d2a727c07dfp-16 +-0x1.0851e79f75011p-13 +-0x1.cb90c40e8effcp-12 +-0x1.c8696e2bfabe8p-13 +-0x1.4b435d901f571p-13 +-0x1.7c905044a15b6p-18 +-0x1.19fb37f17c48bp-11 +-0x1.942f7fcf62d86p-14 +-0x1.1f105dc38bd7ap-3 +-0x1.2757a6422970dp-16 +-0x1.fb34de07d5155p-14 +-0x1.b8eec578c56eep-12 +-0x1.b5e82b35d27b1p-13 +-0x1.3dd5112055913p-13 +-0x1.6d224e8045237p-18 +-0x1.0e8c6f0127048p-11 +-0x1.83cc5024380e4p-14 +-0x1.a48dc7f0d424p-3 +-0x1.2f54398c84c37p-16 +-0x1.04760f73027f6p-13 +-0x1.c4db3aa672a28p-12 +-0x1.c1bfae0650102p-13 +-0x1.466d557593384p-13 +-0x1.770207d2a72a2p-18 +-0x1.15dd5e3ce66c9p-11 +-0x1.8e48ef2eddd4p-14 +-0x1.77eca0a13261ep-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.b76da10794219p-5 +-0x1.8cf12360a1c79p-3 +-0x1.a5c76e498bd32p-5 +-0x1.7e6f193bdb255p-3 +-0x1.760ccb35b18f7p-4 +-0x1.392cac36d1ca2p-2 +-0x1.3783e1f2c2ea3p-4 +-0x1.0cbeccbb190f4p-2 +-0x1.d86069f75c1bep+0 +-0x1.d451a0a204c12p+0 +-0x1.cef8860b02dc9p+0 +-0x1.cfc237ef9e3d5p+0 +0x1.206402c48a069p-2 +0x1.31ed060ce2b1bp-2 +-0x1.087fe78b67955p-8 +0x1.5ccaded8bb5f8p-2 +0x1.721f3f9bb3c7cp-2 +-0x1.c08df5a595b02p-9 +0x1.abdcfd54623bap-2 +0x1.c63bf54dfb06p-2 +-0x1.767d2f16a8e93p-7 +0x1.a041b0acca34cp-2 +0x1.b9e1cc61badd5p-2 +-0x1.f662995e00a62p-8 +0x1.e85e5a775bfdcp-3 +0x1.d9bda728b9d21p-3 +-0x1.13bf55785e09dp-8 +0x1.28ea6211a1202p-2 +0x1.1f9d0e48d145ep-2 +-0x1.d786a4d88118p-9 +0x1.6ee9bda0613d6p-2 +0x1.62baeafeb90dbp-2 +-0x1.556b38775860ap-7 +0x1.6490e7dc08e83p-2 +0x1.58d3a69508c9fp-2 +-0x1.df410c5af2dbdp-8 +0x1.9184d87dee0d5p-3 +0x1.60500f6c8a1a8p-3 +-0x1.cb4d7a2485caap-9 +0x1.e8313f95281cdp-3 +0x1.acd3a1f9633ffp-3 +-0x1.88bf42e7ae433p-9 +0x1.2d9ce96489fb4p-2 +0x1.09532ee4f575cp-2 +-0x1.1c4e5fb958273p-7 +0x1.251c8f8569a9p-2 +0x1.01ca2fb8b749ep-2 +-0x1.8f1b36f88a968p-8 +0x1.0eabb653b423bp-2 +0x1.13857e18d71fep-2 +-0x1.6c2a070de5996p-9 +0x1.4896cee3616c1p-2 +0x1.508613a1b71fbp-2 +-0x1.375bf9b7a5023p-9 +0x1.95284000d12a9p-2 +0x1.a263b12a3a7dp-2 +-0x1.c30550a49c0ecp-8 +0x1.89dcb34cd076ap-2 +0x1.9638ffb844298p-2 +-0x1.3c85b9c84d0dep-8 +0x1.26fb7ec435187p-2 +0x1.19313bc356a3p-2 +-0x1.114fb133dd71ep-9 +0x1.65b70ef531473p-2 +0x1.5502feb0469efp-2 +-0x1.d3631ebe72e58p-10 +0x1.b86a950bda7cfp-2 +0x1.a3e24c6d7b423p-2 +-0x1.527b9075bcb1bp-8 +0x1.ac3bcb907a061p-2 +0x1.9843affb8c63ap-2 +-0x1.db1a5622a84c7p-9 +0x1.8a3ae1cd4cb74p-3 +0x1.c5ce4a4661488p-3 +-0x1.e5e6fedb27d83p-10 +0x1.dce6228ead5f8p-3 +0x1.126fa1760bfd2p-2 +-0x1.9fe6c2d13e015p-10 +0x1.24970a8519e64p-2 +0x1.50aaa6abdf7cbp-2 +-0x1.2bef7975e72bep-8 +0x1.1ca3fbc2676f5p-2 +0x1.47880e9e667fbp-2 +-0x1.a581e6ec9efdep-9 +-0x1.36a4524207a45p-16 +-0x1.0abd956d6b073p-13 +-0x1.cfc62f0d8a199p-12 +-0x1.cc97746da7464p-13 +-0x1.4e4bfce69a9d3p-13 +-0x1.800c8480c3de8p-18 +-0x1.1c904da3d0bd7p-11 +-0x1.97e3153bb15b1p-14 +-0x1.220f6bfec7d2ap-3 +-0x1.33d2a727c07bdp-16 +-0x1.0851e79f74ff4p-13 +-0x1.cb90c40e8efc9p-12 +-0x1.c8696e2bfabb5p-13 +-0x1.4b435d901f54cp-13 +-0x1.7c905044a158cp-18 +-0x1.19fb37f17c46cp-11 +-0x1.942f7fcf62d59p-14 +-0x1.1634383ba511fp-3 +-0x1.2757a6422972ep-16 +-0x1.fb34de07d518fp-14 +-0x1.b8eec578c572p-12 +-0x1.b5e82b35d27e2p-13 +-0x1.3dd5112055937p-13 +-0x1.6d224e804526p-18 +-0x1.0e8c6f0127067p-11 +-0x1.83cc50243810fp-14 +-0x1.979f0c7e201ap-3 +-0x1.2f54398c84c26p-16 +-0x1.04760f73027e8p-13 +-0x1.c4db3aa672a0fp-12 +-0x1.c1bfae06500e9p-13 +-0x1.466d557593372p-13 +-0x1.770207d2a728ep-18 +-0x1.15dd5e3ce66bap-11 +-0x1.8e48ef2eddd29p-14 +-0x1.6c56315095e78p-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.b722add97ca68p-4 +-0x1.74b6572d57185p-2 +-0x1.a1f57949ffdd1p-4 +-0x1.655e508f686cep-2 +-0x1.8985be00ff9cp-3 +-0x1.2e00a906ef4fbp-1 +-0x1.4008d2e0279e3p-3 +-0x1.fef8aed121eb9p-2 +-0x1.d5ce0c4b14befp+0 +-0x1.d20b9785b155p+0 +-0x1.ccc1cf8500154p+0 +-0x1.cdb7c3f97bba6p+0 +0x1.46b5d3779d843p-2 +0x1.5aa5aebad83aap-2 +-0x1.941ab3e521bf5p-7 +0x1.7e7ca8a4bda3fp-2 +0x1.95f4444669a18p-2 +-0x1.56792c309d0ddp-7 +0x1.cc642e9afd8cfp-2 +0x1.e8dcc343564aep-2 +-0x1.1e71d0918254ap-5 +0x1.be4a1e5ae5731p-2 +0x1.d9d921c47da91p-2 +-0x1.80175e0dd4b37p-6 +0x1.1590f1b40449fp-2 +0x1.0d02f245e2583p-2 +-0x1.a6007a0dc7281p-7 +0x1.469ac088f3e1bp-2 +0x1.3c1d63bd264f7p-2 +-0x1.68bb48dfa395cp-7 +0x1.8c0caa9e7ddcep-2 +0x1.7e9560e97e3e8p-2 +-0x1.055c5c8423a42p-5 +0x1.7f64860a2ae07p-2 +0x1.727d8035d09eap-2 +-0x1.6ed1406735abap-6 +0x1.c863bffb7fedcp-3 +0x1.90bb482d9f316p-3 +-0x1.5f4db1dea8859p-7 +0x1.0c7e3119f137p-2 +0x1.d7fa60756716ep-3 +-0x1.2c50b6eaa43c3p-7 +0x1.458cff0f887b6p-2 +0x1.1e8fae81b51c3p-2 +-0x1.b32bb84cce7dp-6 +0x1.3b2708b7100a3p-2 +0x1.15553dbc91bddp-2 +-0x1.315ffd71b280fp-6 +0x1.335c0e78ff351p-2 +0x1.3a12e41c62fc6p-2 +-0x1.16a67aee25af5p-7 +0x1.691c0bfd20cefp-2 +0x1.731ed82f42f58p-2 +-0x1.dc620738fd9ccp-8 +0x1.b4eb59712d298p-2 +0x1.c4c652982b6b9p-2 +-0x1.594178804195ep-6 +0x1.a721466bbca26p-2 +0x1.b5d0a99c41e45p-2 +-0x1.e483fb69cfbdfp-7 +0x1.4ebced3b280b8p-2 +0x1.3f19ced355907p-2 +-0x1.a235193454db7p-8 +0x1.88df95489311ap-2 +0x1.768a610db3a92p-2 +-0x1.657f23cfa1bacp-8 +0x1.daa453bef68bdp-2 +0x1.c4876cf00828p-2 +-0x1.0315c82d9cce4p-6 +0x1.cbc9fc87872ccp-2 +0x1.b65c999e61be4p-2 +-0x1.6b9733d8d4c89p-7 +0x1.beabf1b7057f1p-3 +0x1.010edc6ade118p-2 +-0x1.729448b62b364p-8 +0x1.05841c0ee18ap-2 +0x1.2cf41ca2c3525p-2 +-0x1.3cf9043a3561p-8 +0x1.3adf7d3dedf01p-2 +0x1.6a44dfd0441edp-2 +-0x1.ca4dcd8827c02p-7 +0x1.313640a62ba5cp-2 +0x1.5f2b66d38c449p-2 +-0x1.41cfc46d88514p-7 +-0x1.d1f67b630b756p-15 +-0x1.901c60242089ep-12 +-0x1.5bd4a34a27926p-10 +-0x1.597197523d73fp-11 +-0x1.f571fb59e7eaap-12 +-0x1.2009636092e63p-16 +-0x1.aad87475b91b2p-10 +-0x1.31ea4fecc5039p-12 +-0x1.fbcaf5f68276p-3 +-0x1.cdbbfabba0bb4p-15 +-0x1.8c7adb6f2f804p-12 +-0x1.58ac930aeb3eap-10 +-0x1.564f12a0fc0dbp-11 +-0x1.f0e50c582f00ep-12 +-0x1.1d6c3c3379039p-16 +-0x1.a6f8d3ea3a6b9p-10 +-0x1.2f239fdb8a214p-12 +-0x1.e7084f0090102p-3 +-0x1.bb0379633e2adp-15 +-0x1.7c67a685dfd16p-12 +-0x1.4ab3141a94146p-10 +-0x1.486e20685ddd8p-11 +-0x1.dcbf99b0805b8p-12 +-0x1.11d9bae033db9p-16 +-0x1.95d2a681ba884p-10 +-0x1.22d93c1b2a0bcp-12 +-0x1.64c862e5cbf8ep-2 +-0x1.c6fe5652c7242p-15 +-0x1.86b1172c83be3p-12 +-0x1.53a46bfcd5f92p-10 +-0x1.514fc284bc0b5p-11 +-0x1.e9a400305cd34p-12 +-0x1.194185ddfd5efp-16 +-0x1.a0cc0d5b59a1ep-10 +-0x1.2ab6b363265e5p-12 +-0x1.3ee7accc8145fp-2 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.bd2d87b7fddbap-4 +-0x1.7939c7d12e2b8p-2 +-0x1.a797443c44f41p-4 +-0x1.69a34a5171fcbp-2 +-0x1.8f7b51230fd06p-3 +-0x1.31e647febafc9p-1 +-0x1.44a72e91ee0dep-3 +-0x1.02a9df8909badp-1 +-0x1.d5ce0c4b14befp+0 +-0x1.d20b9785b155p+0 +-0x1.ccc1cf8500154p+0 +-0x1.cdb7c3f97bba6p+0 +0x1.46b5d3779d843p-2 +0x1.5aa5aebad83aap-2 +-0x1.9ca022111691ep-7 +0x1.7e7ca8a4bda3fp-2 +0x1.95f4444669a18p-2 +-0x1.5dafc7b8a0ab5p-7 +0x1.cc642e9afd8cfp-2 +0x1.e8dcc343564aep-2 +-0x1.2476947438aabp-5 +0x1.be4a1e5ae5731p-2 +0x1.d9d921c47da91p-2 +-0x1.882da9ac3ca51p-6 +0x1.1590f1b40449fp-2 +0x1.0d02f245e2583p-2 +-0x1.aee93e3714305p-7 +0x1.469ac088f3e1bp-2 +0x1.3c1d63bd264f7p-2 +-0x1.7057116215c26p-7 +0x1.8c0caa9e7ddcep-2 +0x1.7e9560e97e3e8p-2 +-0x1.0adaff8f9e645p-5 +0x1.7f64860a2ae07p-2 +0x1.727d8035d09eap-2 +-0x1.768bfbdd8aa39p-6 +0x1.c863bffb7fedcp-3 +0x1.90bb482d9f316p-3 +-0x1.66b7cc71610e7p-7 +0x1.0c7e3119f137p-2 +0x1.d7fa60756716ep-3 +-0x1.32a5bbfc5fb2cp-7 +0x1.458cff0f887b6p-2 +0x1.1e8fae81b51c3p-2 +-0x1.bc5165c1d0207p-6 +0x1.3b2708b7100a3p-2 +0x1.15553dbc91bddp-2 +-0x1.37ceec8171e45p-6 +0x1.335c0e78ff351p-2 +0x1.3a12e41c62fc6p-2 +-0x1.1c8873a01d6a7p-7 +0x1.691c0bfd20cefp-2 +0x1.731ed82f42f58p-2 +-0x1.e66e34c07f31fp-8 +0x1.b4eb59712d298p-2 +0x1.c4c652982b6b9p-2 +-0x1.6083995d48c62p-6 +0x1.a721466bbca26p-2 +0x1.b5d0a99c41e45p-2 +-0x1.eeb990d5f73d7p-7 +0x1.4ebced3b280b8p-2 +0x1.3f19ced355907p-2 +-0x1.ab09134543307p-8 +0x1.88df95489311ap-2 +0x1.768a610db3a92p-2 +-0x1.6d092b4de0a47p-8 +0x1.daa453bef68bdp-2 +0x1.c4876cf00828p-2 +-0x1.08880ec9ee50dp-6 +0x1.cbc9fc87872ccp-2 +0x1.b65c999e61be4p-2 +-0x1.734054110460fp-7 +0x1.beabf1b7057f1p-3 +0x1.010edc6ade118p-2 +-0x1.7a628935c77f3p-8 +0x1.05841c0ee18ap-2 +0x1.2cf41ca2c3525p-2 +-0x1.43a40c2ce8258p-8 +0x1.3adf7d3dedf01p-2 +0x1.6a44dfd0441edp-2 +-0x1.d3ed09cdb6f73p-7 +0x1.313640a62ba5cp-2 +0x1.5f2b66d38c449p-2 +-0x1.4894bd804fd21p-7 +-0x1.d1f67b630b746p-15 +-0x1.901c60242089p-12 +-0x1.5bd4a34a27919p-10 +-0x1.597197523d732p-11 +-0x1.f571fb59e7e98p-12 +-0x1.2009636092e59p-16 +-0x1.aad87475b91a3p-10 +-0x1.31ea4fecc502ep-12 +-0x1.00909f55e6d0bp-2 +-0x1.cdbbfabba0bb4p-15 +-0x1.8c7adb6f2f804p-12 +-0x1.58ac930aeb3eap-10 +-0x1.564f12a0fc0dbp-11 +-0x1.f0e50c582f00ep-12 +-0x1.1d6c3c3379039p-16 +-0x1.a6f8d3ea3a6b9p-10 +-0x1.2f239fdb8a214p-12 +-0x1.ec25ae41e04a5p-3 +-0x1.bb0379633e2adp-15 +-0x1.7c67a685dfd16p-12 +-0x1.4ab3141a94146p-10 +-0x1.486e20685ddd8p-11 +-0x1.dcbf99b0805b8p-12 +-0x1.11d9bae033db9p-16 +-0x1.95d2a681ba884p-10 +-0x1.22d93c1b2a0bcp-12 +-0x1.688402422b258p-2 +-0x1.c6fe5652c7254p-15 +-0x1.86b1172c83bf3p-12 +-0x1.53a46bfcd5f9ep-10 +-0x1.514fc284bc0c2p-11 +-0x1.e9a400305cd47p-12 +-0x1.194185ddfd5fap-16 +-0x1.a0cc0d5b59a2ep-10 +-0x1.2ab6b363265fp-12 +-0x1.423feaefe7fd7p-2 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.946daa655dce5p-5 +-0x1.71b9789b5c1cbp-3 +-0x1.65994472e2a3cp-5 +-0x1.4a8c57c720e66p-3 +-0x1.2d938b9293e9bp-4 +-0x1.05911e8d59de1p-2 +-0x1.ebd292aee26c4p-5 +-0x1.b6f3232fb7186p-3 +-0x1.de67bef882207p+0 +-0x1.d9b280b7a1adap+0 +-0x1.d3af600d38126p+0 +-0x1.d48795c062546p+0 +0x1.8c34fda97241p-3 +0x1.a41a145fdd422p-3 +-0x1.f7a373942972ap-9 +0x1.0caa1c52d658ep-2 +0x1.1cf8746dd958p-2 +-0x1.5cfeb3c4adcf3p-9 +0x1.6632589b28faap-2 +0x1.7c1f0f6d35107p-2 +-0x1.f8fa9742243bp-8 +0x1.59a9c653a1ff2p-2 +0x1.6ecb878c1aaaap-2 +-0x1.42131bf68d72dp-8 +0x1.4ceaddec913eep-3 +0x1.439a902430d44p-3 +-0x1.134a8e96ed41dp-8 +0x1.c62ffee74ec9p-3 +0x1.b8c88870384aap-3 +-0x1.87cdc50dc9151p-9 +0x1.312e7c1243c52p-2 +0x1.278dc9c04d4f2p-2 +-0x1.eee4b24acec09p-8 +0x1.262b1e8f53c54p-2 +0x1.1cf9481dfeed7p-2 +-0x1.4db09a2a656a7p-8 +0x1.11bd73b1c0ddbp-3 +0x1.dfa46523ebce2p-4 +-0x1.ca799f4076238p-9 +0x1.756cbf88696a4p-3 +0x1.478c6e595818fp-3 +-0x1.4653b65dc6f9dp-9 +0x1.f5c725e942591p-3 +0x1.b8d5ec210bab9p-3 +-0x1.9c17250c93c14p-8 +0x1.e3ad633562c85p-3 +0x1.a8d627c337671p-3 +-0x1.15e1fd9490b89p-8 +0x1.71e2d47b6dbfdp-3 +0x1.7538c0b8a9261p-3 +-0x1.6b856f9eb75d9p-9 +0x1.f7b6911dd2f02p-3 +0x1.ffbd81ce8a221p-3 +-0x1.02ae43b2d04eep-9 +0x1.51a665a93357ep-2 +0x1.5a23467c7630bp-2 +-0x1.46d4268cbe9a9p-8 +0x1.4593a26d4f1dep-2 +0x1.4d54ec46eefb3p-2 +-0x1.b8b131f8963cfp-9 +0x1.93bbcb8d533aap-3 +0x1.80d40aac02758p-3 +-0x1.10cfd94053001p-9 +0x1.1292b8b084aa8p-2 +0x1.05bb7faca9fd8p-2 +-0x1.844c5eaac65c2p-10 +0x1.6f8406ae2649ap-2 +0x1.5e5b9e8e9f295p-2 +-0x1.ea8dd22aa71c9p-9 +0x1.6274b7148340cp-2 +0x1.51e759f460113p-2 +-0x1.4abddd100e172p-9 +0x1.0eba2ab83f538p-3 +0x1.37b75c346b2b2p-3 +-0x1.e4cc47a1a7d4p-10 +0x1.6f3d6e6e3c9e4p-3 +0x1.a6c2aa26ab536p-3 +-0x1.59b2df13df419p-10 +0x1.e9c6077e13f58p-3 +0x1.19d64759c0d1ap-2 +-0x1.b315999683cc9p-9 +0x1.d89d784939873p-3 +0x1.0ff92f7537d7fp-2 +-0x1.25cb911d58e6dp-9 +-0x1.745afa154622bp-16 +-0x1.3fbb806b63b39p-13 +-0x1.15f46d8b8c6ep-11 +-0x1.140c2272d85aap-12 +-0x1.90b5b06ae13edp-13 +-0x1.cc5883b5fb35cp-18 +-0x1.5518abe08d485p-11 +-0x1.e8eb7150b894bp-14 +-0x1.15accfe14d203p-3 +-0x1.70f9f05148a7dp-16 +-0x1.3cd4b6f05119cp-13 +-0x1.136eb258ae8c3p-11 +-0x1.118ad5a12c70bp-12 +-0x1.8d12c78f5949bp-13 +-0x1.c82b0fb27f152p-18 +-0x1.520040af05759p-11 +-0x1.e47b9b9c9654bp-14 +-0x1.f1f395d7ad59bp-4 +-0x1.620433b2a9d85p-16 +-0x1.2ffc36ace15e2p-13 +-0x1.0843e2b0746c1p-11 +-0x1.0673a42684413p-12 +-0x1.7cf969e1b0194p-13 +-0x1.b5ac54306ac3bp-18 +-0x1.444c051a47115p-11 +-0x1.d0d6fcdade7bep-14 +-0x1.681d6cf7b58ep-3 +-0x1.6b96f626dd199p-16 +-0x1.38349ee690ec4p-13 +-0x1.0f6952568f987p-11 +-0x1.0d8c85f6474d9p-12 +-0x1.8746cb8d2ac9ap-13 +-0x1.c18238ade8782p-18 +-0x1.4d110a2d3852fp-11 +-0x1.dd68f28fc0368p-14 +-0x1.398b3f83926b8p-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.776dd6906fb08p-5 +-0x1.5a37473154f8fp-3 +-0x1.4c43fa95f2ce6p-5 +-0x1.35b24669786b6p-3 +-0x1.18c20a5e364dp-4 +-0x1.eb0d2832dc444p-3 +-0x1.cb11f41b51c4fp-5 +-0x1.9cd6400465724p-3 +-0x1.e4f99b478d29ap+0 +-0x1.e01720044e063p+0 +-0x1.d94efa7b2bfc9p+0 +-0x1.d99092b2b1f0fp+0 +0x1.8c6b2d5c89e58p-4 +0x1.a41fe83eb1c99p-4 +-0x1.cf91e862365f1p-9 +0x1.59880abed63dep-3 +0x1.6e52f20ce7ad5p-3 +-0x1.41408f31e4e61p-9 +0x1.12797fa6acb76p-2 +0x1.232465aeeb5d9p-2 +-0x1.d1049043fac95p-8 +0x1.0ea54441c0056p-2 +0x1.1f132842306b4p-2 +-0x1.2887f75617a2bp-8 +0x1.4a76e3da207b4p-4 +0x1.41e6d3b3c65a9p-4 +-0x1.facdd02f3ef51p-9 +0x1.21bc46dc31bd2p-3 +0x1.19c927aea7b1cp-3 +-0x1.68ad81db8fbb9p-9 +0x1.d03dfb8906efep-3 +0x1.c27b371bc0d66p-3 +-0x1.c7bc3bddaf808p-8 +0x1.c99d571414623p-3 +0x1.bc16d59567b35p-3 +-0x1.333954d33e97ap-8 +0x1.0fc05f5f1c025p-4 +0x1.db62d95a84dd6p-5 +-0x1.a6084a66b616bp-9 +0x1.dc7b0ad913651p-4 +0x1.a1438bf32466dp-4 +-0x1.2c69efe2f439cp-9 +0x1.7db0653360817p-3 +0x1.4ed4d7247424fp-3 +-0x1.7b7e22aca316p-8 +0x1.783ddedf0f90cp-3 +0x1.4a07dfd888e81p-3 +-0x1.ffb3a64f68e45p-9 +0x1.700cba03573ep-4 +0x1.6ff62ab1557bep-4 +-0x1.4e9cb9867653p-9 +0x1.421cb4e9b1fd3p-3 +0x1.443cff6f07c48p-3 +-0x1.dc40d19c70215p-10 +0x1.01649e84283ebp-2 +0x1.05a50bc44f94p-2 +-0x1.2cf7607657481p-8 +0x1.fb7cde17d876ap-3 +0x1.01d67c867d2e3p-2 +-0x1.95bc705ef3a54p-9 +0x1.92600b359aed9p-4 +0x1.7f8051f6bdf2ap-4 +-0x1.f639d8e59dc88p-10 +0x1.5fbc4fba044d3p-3 +0x1.4f41ff4212a07p-3 +-0x1.65705f3d4d8e8p-10 +0x1.18949f0183741p-2 +0x1.0b75d72276b8bp-2 +-0x1.c3bb7a4604cbfp-9 +0x1.149f01f6a747dp-2 +0x1.07af6360ab46fp-2 +-0x1.3081336c26cf1p-9 +0x1.0eca0d17c5e18p-4 +0x1.37ddea09410c5p-4 +-0x1.be49ad155a3fbp-10 +0x1.d829e7e8483cap-4 +0x1.0fd7f2a727e1p-3 +-0x1.3e45efa53fdc6p-10 +0x1.77306c646b10bp-3 +0x1.afe785e4671cp-3 +-0x1.90b1f9387975ap-9 +0x1.71f34b6e6dfbcp-3 +0x1.a9e0d3ca23bep-3 +-0x1.0e87c8285f189p-9 +-0x1.745afa154622bp-16 +-0x1.3fbb806b63b39p-13 +-0x1.15f46d8b8c6ep-11 +-0x1.140c2272d85aap-12 +-0x1.90b5b06ae13edp-13 +-0x1.cc5883b5fb35cp-18 +-0x1.5518abe08d485p-11 +-0x1.e8eb7150b894bp-14 +-0x1.0a6825e8a2e6ep-3 +-0x1.70f9f05148a8dp-16 +-0x1.3cd4b6f0511aap-13 +-0x1.136eb258ae8dp-11 +-0x1.118ad5a12c718p-12 +-0x1.8d12c78f594adp-13 +-0x1.c82b0fb27f166p-18 +-0x1.520040af05768p-11 +-0x1.e47b9b9c96561p-14 +-0x1.ddc3044a0d4c1p-4 +-0x1.620433b2a9d74p-16 +-0x1.2ffc36ace15d4p-13 +-0x1.0843e2b0746b5p-11 +-0x1.0673a42684407p-12 +-0x1.7cf969e1b0181p-13 +-0x1.b5ac54306ac27p-18 +-0x1.444c051a47106p-11 +-0x1.d0d6fcdade7a7p-14 +-0x1.599285b6a9887p-3 +-0x1.6b96f626dd1aap-16 +-0x1.38349ee690ed2p-13 +-0x1.0f6952568f994p-11 +-0x1.0d8c85f6474e6p-12 +-0x1.8746cb8d2acadp-13 +-0x1.c18238ade8796p-18 +-0x1.4d110a2d3853ep-11 +-0x1.dd68f28fc037fp-14 +-0x1.2cd9594d684b8p-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.77a9c32fe04eap-4 +-0x1.468b4cf1d0bb3p-2 +-0x1.476c509ede081p-4 +-0x1.21d3891eb9981p-2 +-0x1.222494bcd3368p-3 +-0x1.d612af55f48dap-2 +-0x1.cef030542e9c8p-4 +-0x1.8604014a755dbp-2 +-0x1.e1aaf1096040ap+0 +-0x1.dcdf5436221e6p+0 +-0x1.d67ae00f31517p+0 +-0x1.d708a26b0638dp+0 +0x1.2a05c9ecf5064p-3 +0x1.3beb6f464a0a3p-3 +-0x1.64abefd406d96p-7 +0x1.ba3ba0bd48744p-3 +0x1.d4f541f2491afp-3 +-0x1.edd940dc8791ap-8 +0x1.3ca9d52377f7p-2 +0x1.4ff805625fa37p-2 +-0x1.6607f5b0fb9bp-6 +0x1.346a7a08eceecp-2 +0x1.47343340253a6p-2 +-0x1.c8505251de6fep-7 +0x1.f2d70d229e49dp-4 +0x1.e566ce80845eap-4 +-0x1.86946ffbb067cp-7 +0x1.744d3bb73f0d8p-3 +0x1.69b3b29a03612p-3 +-0x1.15db8eb2c78fep-7 +0x1.0cca4d602497cp-2 +0x1.04915451f22d9p-2 +-0x1.5f43b2a39842bp-6 +0x1.059945f024a2bp-2 +0x1.fb4a548d1e608p-3 +-0x1.d980774afcc5cp-7 +0x1.9a30d61e47aa4p-4 +0x1.6712670278d2ap-4 +-0x1.451c201388401p-7 +0x1.321dac7f119f1p-3 +0x1.0c4a1a6e1857ap-3 +-0x1.ce9cbb117bf77p-8 +0x1.b9f702ee0d2ebp-3 +0x1.83ff0827e1328p-3 +-0x1.24683a3ea4e1bp-6 +0x1.ae24e63ad10ebp-3 +0x1.79903ff2a122dp-3 +-0x1.8a29e61a726c1p-7 +0x1.15741eee246b8p-3 +0x1.16aa260c1a452p-3 +-0x1.01df9bf352042p-7 +0x1.9d675308bd2ecp-3 +0x1.a20d3fcb2eaa7p-3 +-0x1.6ee305562dd1fp-8 +0x1.29b8d4820a8c5p-2 +0x1.2feab14e8b2f2p-2 +-0x1.cff0b847b0019p-7 +0x1.21d1fc855a92cp-2 +0x1.279aeab71a5f8p-2 +-0x1.38a8a94ab2d76p-7 +0x1.2f166ba99b64fp-3 +0x1.20e20860550fp-3 +-0x1.8301227766d63p-8 +0x1.c30f13d91e676p-3 +0x1.adf23db2c11f4p-3 +-0x1.1350de7ab8fbdp-8 +0x1.444cebe6e389ep-2 +0x1.3525dfe96e07dp-2 +-0x1.5c23b30dcd0ddp-7 +0x1.3bbd683ee78aap-2 +0x1.2cfc290254894p-2 +-0x1.d53df6c7710d1p-8 +0x1.9736ace85230dp-4 +0x1.d4ed56f99395dp-4 +-0x1.56ddb289395fap-8 +0x1.2e32ebcd7371cp-3 +0x1.5bee766e7826ap-3 +-0x1.e86871b356264p-9 +0x1.b0ebb4350205fp-3 +0x1.f24da6688183ap-3 +-0x1.341a4fae4e20dp-7 +0x1.a5a222341f35bp-3 +0x1.e5529ded8b786p-3 +-0x1.9fa995d177704p-8 +-0x1.17443b8ff49ap-14 +-0x1.df9940a1158d5p-12 +-0x1.a0eea45152a51p-10 +-0x1.9e1233ac4487fp-11 +-0x1.2c88445028ef2p-11 +-0x1.594262c87c685p-16 +-0x1.ffa501d0d3ec8p-10 +-0x1.6eb094fc8a6f8p-12 +-0x1.d406bc58d0f84p-3 +-0x1.14bb743cf67e6p-14 +-0x1.db3f126879a78p-12 +-0x1.9d260b8505d31p-10 +-0x1.9a504071c2a9dp-11 +-0x1.29ce15ab82f7dp-11 +-0x1.56204bc5df508p-16 +-0x1.fb00610688315p-10 +-0x1.6b5cb4b570c03p-12 +-0x1.a3a9be82215b4p-3 +-0x1.098326c5ff617p-14 +-0x1.c7fa5203520bep-12 +-0x1.8c65d408aea0ep-10 +-0x1.89ad7639c660ap-11 +-0x1.1dbb0f6944121p-11 +-0x1.48413f245011dp-16 +-0x1.e67207a76a98ap-10 +-0x1.5ca13da426dbdp-12 +-0x1.2f87d4b5b85fbp-2 +-0x1.10b1389d25d37p-14 +-0x1.d44eee59d962dp-12 +-0x1.971dfb81d7651p-10 +-0x1.9452c8f16af4cp-11 +-0x1.257518a9e0179p-11 +-0x1.5121aa826e5a7p-16 +-0x1.f3998f43d47cdp-10 +-0x1.660eb5ebd0294p-12 +-0x1.084228488a966p-2 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.7e68cebfcd47cp-4 +-0x1.4bbeff4b9256ap-2 +-0x1.4d1cf6082abccp-4 +-0x1.265b1617d2e44p-2 +-0x1.27a9c5eeb5677p-3 +-0x1.ddccb4cc4f565p-2 +-0x1.d7540d18af4d2p-4 +-0x1.8c3b5361625fdp-2 +-0x1.e1aaf1096040ap+0 +-0x1.dcdf5436221e6p+0 +-0x1.d67ae00f31517p+0 +-0x1.d708a26b0638dp+0 +0x1.2a05c9ecf5064p-3 +0x1.3beb6f464a0a3p-3 +-0x1.6ea25be00e191p-7 +0x1.ba3ba0bd48744p-3 +0x1.d4f541f2491afp-3 +-0x1.fb9efda5d1c39p-8 +0x1.3ca9d52377f7p-2 +0x1.4ff805625fa37p-2 +-0x1.6ffcc333a4c9p-6 +0x1.346a7a08eceecp-2 +0x1.47343340253a6p-2 +-0x1.d507e3be8dfbp-7 +0x1.f2d70d229e49dp-4 +0x1.e566ce80845eap-4 +-0x1.91809bc376235p-7 +0x1.744d3bb73f0d8p-3 +0x1.69b3b29a03612p-3 +-0x1.1d9e78d6483a2p-7 +0x1.0cca4d602497cp-2 +0x1.04915451f22d9p-2 +-0x1.690a3cc2461aap-6 +0x1.059945f024a2bp-2 +0x1.fb4a548d1e608p-3 +-0x1.e6b65558c59fep-7 +0x1.9a30d61e47aa4p-4 +0x1.6712670278d2ap-4 +-0x1.4e32ebae0dd45p-7 +0x1.321dac7f119f1p-3 +0x1.0c4a1a6e1857ap-3 +-0x1.db879378de2ddp-8 +0x1.b9f702ee0d2ebp-3 +0x1.83ff0827e1328p-3 +-0x1.2c8b005a2b936p-6 +0x1.ae24e63ad10ebp-3 +0x1.79903ff2a122dp-3 +-0x1.952856b7d1e07p-7 +0x1.15741eee246b8p-3 +0x1.16aa260c1a452p-3 +-0x1.0915b53073edap-7 +0x1.9d675308bd2ecp-3 +0x1.a20d3fcb2eaa7p-3 +-0x1.792283a7e44dbp-8 +0x1.29b8d4820a8c5p-2 +0x1.2feab14e8b2f2p-2 +-0x1.dcd9f49c82c7ep-7 +0x1.21d1fc855a92cp-2 +0x1.279aeab71a5f8p-2 +-0x1.4161b4c06ad77p-7 +0x1.2f166ba99b64fp-3 +0x1.20e20860550fp-3 +-0x1.8dd36d914c6cap-8 +0x1.c30f13d91e676p-3 +0x1.adf23db2c11f4p-3 +-0x1.1b01556555e06p-8 +0x1.444cebe6e389ep-2 +0x1.3525dfe96e07dp-2 +-0x1.65d3c16b9bd9bp-7 +0x1.3bbd683ee78aap-2 +0x1.2cfc290254894p-2 +-0x1.e25506c77439bp-8 +0x1.9736ace85230dp-4 +0x1.d4ed56f99395dp-4 +-0x1.606ef5294bc6fp-8 +0x1.2e32ebcd7371cp-3 +0x1.5bee766e7826ap-3 +-0x1.f60338a27e7e4p-9 +0x1.b0ebb4350205fp-3 +0x1.f24da6688183ap-3 +-0x1.3ca9bc47b3c03p-7 +0x1.a5a222341f35bp-3 +0x1.e5529ded8b786p-3 +-0x1.ab3c0dfa44471p-8 +-0x1.17443b8ff49ap-14 +-0x1.df9940a1158d5p-12 +-0x1.a0eea45152a51p-10 +-0x1.9e1233ac4487fp-11 +-0x1.2c88445028ef2p-11 +-0x1.594262c87c685p-16 +-0x1.ffa501d0d3ec8p-10 +-0x1.6eb094fc8a6f8p-12 +-0x1.da87e13bf814p-3 +-0x1.14bb743cf67ddp-14 +-0x1.db3f126879a6ap-12 +-0x1.9d260b8505d24p-10 +-0x1.9a504071c2a91p-11 +-0x1.29ce15ab82f74p-11 +-0x1.56204bc5df4fep-16 +-0x1.fb00610688306p-10 +-0x1.6b5cb4b570bf8p-12 +-0x1.a97d7f5e873dap-3 +-0x1.098326c5ff61fp-14 +-0x1.c7fa5203520ccp-12 +-0x1.8c65d408aea1bp-10 +-0x1.89ad7639c6616p-11 +-0x1.1dbb0f694412ap-11 +-0x1.48413f2450127p-16 +-0x1.e67207a76a999p-10 +-0x1.5ca13da426dc8p-12 +-0x1.33ba5674df319p-2 +-0x1.10b1389d25d37p-14 +-0x1.d44eee59d962dp-12 +-0x1.971dfb81d7651p-10 +-0x1.9452c8f16af4cp-11 +-0x1.257518a9e0179p-11 +-0x1.5121aa826e5a7p-16 +-0x1.f3998f43d47cdp-10 +-0x1.660eb5ebd0294p-12 +-0x1.0bec24fd3208fp-2 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.e80aa2f93f9c4p-6 +-0x1.d4903611ff94dp-4 +-0x1.f3516802193fdp-6 +-0x1.dd6f8541b7033p-4 +-0x1.7052c232382a3p-5 +-0x1.53462e13ee371p-3 +-0x1.3e90d153a0574p-5 +-0x1.29bd1e173702p-3 +-0x1.ebef50ee132a8p+0 +-0x1.e7806c58d13fdp+0 +-0x1.dfd84b8728289p+0 +-0x1.deb4d3a0fcb32p+0 +0x1.920ffc6bed887p-8 +0x1.a9ecf1a64e6e4p-8 +-0x1.c1fce342e6eebp-10 +0x1.e728d7b71de7dp-5 +0x1.0219a583ac844p-4 +-0x1.b0e6f309d5289p-10 +0x1.60ead29bff3c7p-3 +0x1.76293fba78b26p-3 +-0x1.b5839f8dbad5dp-9 +0x1.832876152b309p-3 +0x1.9a7f770c0bfccp-3 +-0x1.2efca26e559f5p-9 +0x1.4cd0f7eb9a555p-8 +0x1.44cec43347f03p-8 +-0x1.113d3ca5cb6fap-9 +0x1.94ea28e59005fp-5 +0x1.8abc1f75dc03p-5 +-0x1.056245e87a31dp-9 +0x1.28047bf7001efp-3 +0x1.1fdf533812e0fp-3 +-0x1.e11f6e4e40e58p-9 +0x1.45315d3cf79f2p-3 +0x1.3c206d059e296p-3 +-0x1.5aba25c00299ap-9 +0x1.11b609518a87bp-8 +0x1.de1e5df967ab3p-9 +-0x1.c72050bac92b3p-10 +0x1.4cfcbeb3990ep-5 +0x1.2313ed348ce8p-5 +-0x1.b36a9f7d2bcd3p-10 +0x1.e6cf4e789f1abp-4 +0x1.aa55de644a05p-4 +-0x1.90a7704156f54p-9 +0x1.0b63cb070b134p-3 +0x1.d47ad996ae20fp-4 +-0x1.20c8e65c5bca6p-9 +0x1.73787662abae5p-8 +0x1.70514b0299bdp-8 +-0x1.68bbb181ea2a9p-10 +0x1.c35fc7bd908f1p-5 +0x1.c1b635a6112d6p-5 +-0x1.5916d3718d4e4p-10 +0x1.4910ebc8c5296p-3 +0x1.4b5a7702a5bc2p-3 +-0x1.3da81e9a54b58p-9 +0x1.6958379791275p-3 +0x1.6c7242034a6f6p-3 +-0x1.c9d147d21bc46p-10 +0x1.96b22b591fff6p-8 +0x1.8397268fb294cp-8 +-0x1.0eb7ed2219fecp-10 +0x1.edc3efd7f472cp-5 +0x1.d6970a2e46fffp-5 +-0x1.02fd004e84969p-10 +0x1.674ea6eee0f3dp-3 +0x1.5679cfaa0284ap-3 +-0x1.dcc9fb1b99119p-10 +0x1.8a70b4539f74p-3 +0x1.77f7f97bd4873p-3 +-0x1.579a29082fffcp-10 +0x1.129213a85bcp-8 +0x1.3c4aea228c15cp-8 +-0x1.e232740ee40fp-11 +0x1.4cbc6414a0d19p-5 +0x1.7f3f1803f947bp-5 +-0x1.cd94ed778a2b9p-11 +0x1.e2430efcc47fep-4 +0x1.15a7a3a7723fdp-3 +-0x1.a7ce85854adaap-10 +0x1.088a509229707p-3 +0x1.3098a3f4a8c56p-3 +-0x1.31f8a462788fep-10 +-0x1.99095f6a9a8b6p-16 +-0x1.5f3acddd78092p-13 +-0x1.315624ea833d2p-11 +-0x1.2f3dbf9849329p-12 +-0x1.b82f268b0f4c8p-13 +-0x1.f9b1ee7e2243fp-18 +-0x1.76b2bfcf0bc62p-11 +-0x1.0c8abb4bea6fcp-13 +-0x1.7fe91bf1649a6p-4 +-0x1.95531e4dc8667p-16 +-0x1.5c0ad814c340ep-13 +-0x1.2e90cd0ef6693p-11 +-0x1.2c7d45ddc948bp-12 +-0x1.b43089215b703p-13 +-0x1.f51b200051df9p-18 +-0x1.734c44a73f5cbp-11 +-0x1.0a1ade2b3dc05p-13 +-0x1.81b99bc79e803p-4 +-0x1.84e41bc602d0fp-16 +-0x1.4dee634ce8741p-13 +-0x1.224c5d353ecb2p-11 +-0x1.204e62efa7e37p-12 +-0x1.a2812af67f7bdp-13 +-0x1.e0c9f78c994dbp-18 +-0x1.643e6f275c333p-11 +-0x1.fea1bd19bd61dp-14 +-0x1.01e8c14ca1f6bp-3 +-0x1.8f684bcaa8a33p-16 +-0x1.56f61a728d0d9p-13 +-0x1.2a26054cfe55dp-11 +-0x1.281a40977bb5ap-12 +-0x1.add25c9ad512p-13 +-0x1.edca56b9614e9p-18 +-0x1.6de09d40b446cp-11 +-0x1.06385a2cab614p-13 +-0x1.cb73b29929f7ep-4 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.bd7ecb7e070a6p-6 +-0x1.b031578a7c672p-4 +-0x1.c6e73c4b8b75ep-6 +-0x1.b7add1f83ca8dp-4 +-0x1.5231014980803p-5 +-0x1.3a6c03bf1ccfbp-3 +-0x1.25b5ca421d3e5p-5 +-0x1.14c26617c1539p-3 +-0x1.f437efcec361ep+0 +-0x1.f03d11b807e36p+0 +-0x1.e657a771876a5p+0 +-0x1.e446e350bcb91p+0 +0x1.fc858dff48acbp-4 +0x1.0d8062e8700f7p-3 +-0x1.966acabdda5f6p-10 +0x1.189555f9ff727p-4 +0x1.2952807e3d8cp-4 +-0x1.86d12d2a92b3cp-10 +0x1.39bcdb2f1dc7cp-4 +0x1.4c77a0a81e8f3p-4 +-0x1.8af11478fd48p-9 +0x1.b6999de772c21p-4 +0x1.d0da01fee4872p-4 +-0x1.1170c9aed94a1p-9 +0x1.a8d97fd22d0b1p-4 +0x1.9d98e4af67551p-4 +-0x1.ed32f275efcb9p-10 +0x1.d2c1e48f61b38p-5 +0x1.c6efb2659c2c2p-5 +-0x1.d7c51d8f76678p-10 +0x1.051f1423af8a8p-4 +0x1.fcedf047c9174p-5 +-0x1.b24f8a7eae498p-9 +0x1.6dedd7c97ffc1p-4 +0x1.645e6056403fcp-4 +-0x1.38e7862b393e2p-9 +0x1.5d5b755c75aeep-4 +0x1.31b5e679b7abap-4 +-0x1.9aca793d8a4bp-10 +0x1.7fd7458084217p-5 +0x1.4f9478b0df2c4p-5 +-0x1.88f8446ed1069p-10 +0x1.ad774f8b11e98p-5 +0x1.77848fa43859cp-5 +-0x1.69afa71d69151p-9 +0x1.2ce972575f174p-4 +0x1.073e4dc29c573p-4 +-0x1.04a0c98940069p-9 +0x1.d8da13ca318b9p-4 +0x1.d9f43cbe4ffcap-4 +-0x1.459263e826f7dp-10 +0x1.04199729603e7p-4 +0x1.035b73a19c608p-4 +-0x1.376d094e81765p-10 +0x1.22f660f7e31c9p-4 +0x1.22592689cbb8p-4 +-0x1.1ebee7197512bp-9 +0x1.977201e1ebe31p-4 +0x1.97bd716046306p-4 +-0x1.9d27078da54b2p-10 +0x1.025c4bda2b244p-3 +0x1.ec7ebe0cdadb8p-4 +-0x1.e8b16a3a58957p-11 +0x1.1c7c9862e7a77p-4 +0x1.0f22d4d59cacbp-4 +-0x1.d375b2846526dp-11 +0x1.3e33a329c3b45p-4 +0x1.2f455a2d46d1ap-4 +-0x1.ae634cba015c4p-10 +0x1.bd5edf444046fp-4 +0x1.a87bcecfd6f6ep-4 +-0x1.3613c1481e7d8p-10 +0x1.5b651981e378fp-4 +0x1.9010af52aad66p-4 +-0x1.b392131847811p-11 +0x1.7f4b460548512p-5 +0x1.b978367a5dc57p-5 +-0x1.a0ca6db8947dap-11 +0x1.ac986a984c052p-5 +0x1.eda2fc124bcf8p-5 +-0x1.7ea2b14bea98fp-10 +0x1.2b9cc48c2b23p-4 +0x1.590da15d30474p-4 +-0x1.143198869f2fap-10 +-0x1.99095f6a9a883p-16 +-0x1.5f3acddd78066p-13 +-0x1.315624ea833adp-11 +-0x1.2f3dbf9849304p-12 +-0x1.b82f268b0f492p-13 +-0x1.f9b1ee7e224p-18 +-0x1.76b2bfcf0bc33p-11 +-0x1.0c8abb4bea6dbp-13 +-0x1.6ca4fe6db0514p-4 +-0x1.95531e4dc8645p-16 +-0x1.5c0ad814c33f1p-13 +-0x1.2e90cd0ef6679p-11 +-0x1.2c7d45ddc9471p-12 +-0x1.b43089215b6dfp-13 +-0x1.f51b200051dcep-18 +-0x1.734c44a73f5acp-11 +-0x1.0a1ade2b3dbefp-13 +-0x1.6e630008f8103p-4 +-0x1.84e41bc602d0fp-16 +-0x1.4dee634ce8741p-13 +-0x1.224c5d353ecb2p-11 +-0x1.204e62efa7e37p-12 +-0x1.a2812af67f7bdp-13 +-0x1.e0c9f78c994dbp-18 +-0x1.643e6f275c333p-11 +-0x1.fea1bd19bd61dp-14 +-0x1.ea130b744e5a6p-4 +-0x1.8f684bcaa8a33p-16 +-0x1.56f61a728d0d9p-13 +-0x1.2a26054cfe55dp-11 +-0x1.281a40977bb5ap-12 +-0x1.add25c9ad512p-13 +-0x1.edca56b9614e9p-18 +-0x1.6de09d40b446cp-11 +-0x1.06385a2cab614p-13 +-0x1.b4742e544b85bp-4 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.b2558996b29p-5 +-0x1.9431cf33aaf53p-3 +-0x1.bbab334f3b5b4p-5 +-0x1.9b4c11882b9dfp-3 +-0x1.520dcd180f9a4p-4 +-0x1.292a107567b16p-2 +-0x1.2088689931772p-4 +-0x1.0325e2a9a9834p-2 +-0x1.f00ac611ed88bp+0 +-0x1.ebd4d065c5ac5p+0 +-0x1.e31261b0f3f2ap+0 +-0x1.e179bb8f71766p+0 +0x1.0d20a16fa74bp-4 +0x1.1d2de026b4fdcp-4 +-0x1.3a4d4832640bfp-8 +0x1.2ddc18848f425p-8 +0x1.3fc60035522fcp-8 +-0x1.2e32a0f177026p-8 +0x1.ff5c678e5d1aap-4 +0x1.0f01d4aba45c8p-3 +-0x1.31ea2277de8e1p-7 +0x1.2fd0c72241916p-3 +0x1.4210a3ce9858ap-3 +-0x1.a73ed45f2abf9p-8 +0x1.bf9a23e0f28eap-5 +0x1.b44ab80c6fc44p-5 +-0x1.7e93ddff8784dp-8 +0x1.f3af41953d287p-9 +0x1.e7ad04d56ca64p-9 +-0x1.6dec28e806889p-8 +0x1.ab3ee52cb1782p-4 +0x1.9fec70ea08078p-4 +-0x1.5102026932fa2p-7 +0x1.fca78ee29d592p-4 +0x1.eeebc1a21f54cp-4 +-0x1.e57f1810f8d0ap-8 +0x1.7016e9d633209p-5 +0x1.41cb62f32ad45p-5 +-0x1.3e74f0fd47726p-8 +0x1.9af219832443fp-9 +0x1.66e9544cdab01p-9 +-0x1.309b2a1545e3ap-8 +0x1.5f53caca947c4p-4 +0x1.3370219a2d46dp-4 +-0x1.18867359aa52p-7 +0x1.a242840eafafap-4 +0x1.6e271a711ad79p-4 +-0x1.9427a9874eaa3p-8 +0x1.f2e289d6db5cdp-5 +0x1.f15512f700c21p-5 +-0x1.f9148b12ff877p-9 +0x1.16dea180ac231p-8 +0x1.1476fae2b56a1p-8 +-0x1.e317f36a8efc4p-9 +0x1.db82b0ee615f5p-4 +0x1.dca66c69c4619p-4 +-0x1.bd006b84a7406p-8 +0x1.1ae4713c32e66p-3 +0x1.1c342d6ed2269p-3 +-0x1.4083a73ddf9dep-8 +0x1.10d7934ca9d1cp-4 +0x1.04098d7d250ebp-4 +-0x1.7b005cecad5cp-9 +0x1.315239612eb89p-8 +0x1.22fa4533983d9p-8 +-0x1.6a80c8d47248fp-9 +0x1.03cf6b1db55e7p-3 +0x1.ef4243401e452p-4 +-0x1.4debb9d377456p-8 +0x1.3503a83c71bbcp-3 +0x1.268858f22c6cfp-3 +-0x1.e1077ddad7f5dp-9 +0x1.6fa43ad744a01p-5 +0x1.a771beb2dcae1p-5 +-0x1.504eac8739208p-9 +0x1.9c480f62e1d04p-9 +0x1.daee5143937e5p-9 +-0x1.41ba357a5e8d3p-9 +0x1.5d55d66648671p-4 +0x1.924c8cfddf935p-4 +-0x1.27ea469aee61p-8 +0x1.9f21f5499b49cp-4 +0x1.de0af2f1ec741p-4 +-0x1.aabe7524cb86dp-9 +-0x1.32c7078ff3e6fp-14 +-0x1.076c1a661a057p-11 +-0x1.ca01375fc4d95p-10 +-0x1.c6dc9f646dc97p-11 +-0x1.4a235ce84b77bp-11 +-0x1.7b4572de99b0fp-16 +-0x1.19060fdb48d32p-9 +-0x1.92d018f1dfa58p-12 +-0x1.417304473cb12p-3 +-0x1.2ffe56ba564b7p-14 +-0x1.0508220f926f8p-11 +-0x1.c5d93396719bcp-10 +-0x1.c2bbe8ccadebp-11 +-0x1.472466d90492bp-11 +-0x1.77d458003d65fp-16 +-0x1.1679337d6f844p-9 +-0x1.8f284d40dc9ecp-12 +-0x1.42faacecab5c6p-3 +-0x1.23ab14d4821cbp-14 +-0x1.f4e594f35cae1p-12 +-0x1.b3728bcfde30ap-10 +-0x1.b07594677bd53p-11 +-0x1.39e0e038df9cep-11 +-0x1.689779a972fa4p-16 +-0x1.0b2ed35d85266p-9 +-0x1.7ef94dd34e096p-12 +-0x1.aff9f56600aa8p-3 +-0x1.2b8e38d7fe7a7p-14 +-0x1.013893d5e9ca3p-11 +-0x1.bf3907f37d80bp-10 +-0x1.bc2760e339907p-11 +-0x1.425dc5741fcd8p-11 +-0x1.7257c10b08faep-16 +-0x1.126875f087351p-9 +-0x1.895487430111ep-12 +-0x1.80bbd1b7c577fp-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.bb68b85ff6792p-5 +-0x1.9bf4a82b7bba7p-3 +-0x1.c4ede9b778c91p-5 +-0x1.a32ecdb98bdddp-3 +-0x1.5973107610b2cp-4 +-0x1.2efaf97ad511ap-2 +-0x1.26a5986c5cebep-4 +-0x1.0822e6b407b11p-2 +-0x1.f00ac611ed88bp+0 +-0x1.ebd4d065c5ac5p+0 +-0x1.e31261b0f3f2ap+0 +-0x1.e179bb8f71766p+0 +0x1.0d20a16fa74bp-4 +0x1.1d2de026b4fdcp-4 +-0x1.453c4b8af988ep-8 +0x1.2ddc18848f425p-8 +0x1.3fc60035522fcp-8 +-0x1.38b302fa29901p-8 +0x1.ff5c678e5d1aap-4 +0x1.0f01d4aba45c8p-3 +-0x1.3c814989543cep-7 +0x1.2fd0c72241916p-3 +0x1.4210a3ce9858ap-3 +-0x1.b5eed78d70cc3p-8 +0x1.bf9a23e0f28eap-5 +0x1.b44ab80c6fc44p-5 +-0x1.8be9558c43c19p-8 +0x1.f3af41953d287p-9 +0x1.e7ad04d56ca64p-9 +-0x1.7aa9a0a1fc424p-8 +0x1.ab3ee52cb1782p-4 +0x1.9fec70ea08078p-4 +-0x1.5cb07bca0068bp-7 +0x1.fca78ee29d592p-4 +0x1.eeebc1a21f54cp-4 +-0x1.f65f6a03a8ea4p-8 +0x1.7016e9d633209p-5 +0x1.41cb62f32ad45p-5 +-0x1.498d28c9bacadp-8 +0x1.9af219832443fp-9 +0x1.66e9544cdab01p-9 +-0x1.3b34fabc016c7p-8 +0x1.5f53caca947c4p-4 +0x1.3370219a2d46dp-4 +-0x1.223ef301aac73p-7 +0x1.a242840eafafap-4 +0x1.6e271a711ad79p-4 +-0x1.a232c30438c5dp-8 +0x1.f2e289d6db5cdp-5 +0x1.f15512f700c21p-5 +-0x1.055779dad3be9p-8 +0x1.16dea180ac231p-8 +0x1.1476fae2b56a1p-8 +-0x1.f3e9b7f349b63p-9 +0x1.db82b0ee615f5p-4 +0x1.dca66c69c4619p-4 +-0x1.cc6d22fa1272ep-8 +0x1.1ae4713c32e66p-3 +0x1.1c342d6ed2269p-3 +-0x1.4ba7c8f32115cp-8 +0x1.10d7934ca9d1cp-4 +0x1.04098d7d250ebp-4 +-0x1.88357c5395375p-9 +0x1.315239612eb89p-8 +0x1.22fa4533983d9p-8 +-0x1.771f5ef4776f1p-9 +0x1.03cf6b1db55e7p-3 +0x1.ef4243401e452p-4 +-0x1.597e7e21071e7p-8 +0x1.3503a83c71bbcp-3 +0x1.268858f22c6cfp-3 +-0x1.f1bf7b26198d7p-9 +0x1.6fa43ad744a01p-5 +0x1.a771beb2dcae1p-5 +-0x1.5bfe65959884ap-9 +0x1.9c480f62e1d04p-9 +0x1.daee5143937e5p-9 +-0x1.4ce4fea8ff7d4p-9 +0x1.5d55d66648671p-4 +0x1.924c8cfddf935p-4 +-0x1.32260baf5c9f7p-8 +0x1.9f21f5499b49cp-4 +0x1.de0af2f1ec741p-4 +-0x1.b9890b1bda31fp-9 +-0x1.32c7078ff3e7fp-14 +-0x1.076c1a661a065p-11 +-0x1.ca01375fc4dafp-10 +-0x1.c6dc9f646dcbp-11 +-0x1.4a235ce84b78dp-11 +-0x1.7b4572de99b24p-16 +-0x1.19060fdb48d41p-9 +-0x1.92d018f1dfa6fp-12 +-0x1.47026071947cbp-3 +-0x1.2ffe56ba564c9p-14 +-0x1.0508220f92707p-11 +-0x1.c5d93396719d5p-10 +-0x1.c2bbe8ccadecap-11 +-0x1.472466d90493ep-11 +-0x1.77d458003d675p-16 +-0x1.1679337d6f854p-9 +-0x1.8f284d40dca02p-12 +-0x1.488f5f8e88a7bp-3 +-0x1.23ab14d4821cbp-14 +-0x1.f4e594f35cae1p-12 +-0x1.b3728bcfde30ap-10 +-0x1.b07594677bd53p-11 +-0x1.39e0e038df9cep-11 +-0x1.689779a972fa4p-16 +-0x1.0b2ed35d85266p-9 +-0x1.7ef94dd34e096p-12 +-0x1.b767e88ec0fccp-3 +-0x1.2b8e38d7fe7a7p-14 +-0x1.013893d5e9ca3p-11 +-0x1.bf3907f37d80bp-10 +-0x1.bc2760e339907p-11 +-0x1.425dc5741fcd8p-11 +-0x1.7257c10b08faep-16 +-0x1.126875f087351p-9 +-0x1.895487430111ep-12 +-0x1.875ee6bbc8ac3p-3 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.0870622b0008p-6 +-0x1.092bceb8dd5bbp-4 +-0x1.3436a60f5036ep-6 +-0x1.3230ea6adc2fbp-4 +-0x1.d5b18df4368adp-6 +-0x1.c31dbf62fb3fep-4 +-0x1.fcc1c6db7c5f8p-6 +-0x1.e58c6cafd891ep-4 +-0x1.fdd726f11222fp+0 +-0x1.fa4d8d7747962p+0 +-0x1.ec8e011d6e527p+0 +-0x1.ea2b8ac801a28p+0 +0x1.0119b06d48ddap-2 +0x1.10b0218b938bfp-2 +-0x1.80f1b3277ff94p-11 +0x1.a51ec146ff18fp-3 +0x1.be8ba4082b831p-3 +-0x1.e9c205efbad41p-11 +0x1.f416cf529ee7ap-7 +0x1.08e56978672p-6 +-0x1.b477c114bf108p-10 +0x1.478ff17ea012bp-6 +0x1.5b068db7231afp-6 +-0x1.e6d813812b248p-10 +0x1.b2350980fde2dp-3 +0x1.a580f425cbea9p-3 +-0x1.f7da78cf2fcedp-11 +0x1.6237435e3598fp-3 +0x1.583632c702b87p-3 +-0x1.3b06880684c5bp-10 +0x1.9e3f46dfbecf7p-7 +0x1.943418fee79cbp-7 +-0x1.04b0fb03f3d14p-9 +0x1.0f6edd0321c63p-6 +0x1.08d384c834aaap-6 +-0x1.1fd9c77af8e93p-9 +0x1.650081214baabp-3 +0x1.39149d78185c3p-3 +-0x1.a3c8c59edd3b6p-11 +0x1.233fa78d723fp-3 +0x1.fe6d6c6c95addp-4 +-0x1.066c6a0e5f637p-10 +0x1.54ad6bb97d6d6p-7 +0x1.29972894691bap-7 +-0x1.b23ee58ff578fp-10 +0x1.be73a0aaaaf8fp-7 +0x1.86041f6d2a877p-7 +-0x1.df78bb6834b35p-10 +0x1.e1b2e667cc29ep-3 +0x1.e8d1d5435dd8bp-3 +-0x1.4c93e649efc6dp-11 +0x1.896d1e2e46123p-3 +0x1.8d725aef1d1aep-3 +-0x1.9fe1605241c01p-11 +0x1.ce42b5a1ab21p-7 +0x1.cab6720aa3351p-7 +-0x1.582da28f59dfcp-10 +0x1.2edc291787759p-6 +0x1.2ca9e0bf8d50ep-6 +-0x1.7c0ade58b506fp-10 +0x1.06a0359aee041p-2 +0x1.f4aeb20a2f1afp-3 +-0x1.f34656a89963bp-12 +0x1.ad5699fe03296p-3 +0x1.993d0e7792debp-3 +-0x1.3825578b79355p-11 +0x1.fa062c0be10c6p-7 +0x1.e2418496f1398p-7 +-0x1.024c875bd0217p-10 +0x1.4b822288e8113p-6 +0x1.3bf03e637f21fp-6 +-0x1.1d3664df5c50dp-10 +0x1.5f6b57ddd6c02p-3 +0x1.948f96b0347ecp-3 +-0x1.be71fd83fd4dbp-12 +0x1.1fc302338601ep-3 +0x1.4b51a34f9d797p-3 +-0x1.16bac99d0b37ep-11 +0x1.5585c643fe8b3p-7 +0x1.8968d7115cb23p-7 +-0x1.cc214f490ec66p-11 +0x1.bf67f2af2c943p-7 +0x1.01afd9d86df1dp-6 +-0x1.fbe5eb31f1329p-11 +-0x1.a27b754322abep-16 +-0x1.6757279b50ea5p-13 +-0x1.3863309366921p-11 +-0x1.363e6843df9f8p-12 +-0x1.c2595ea6d4801p-13 +-0x1.02afb6e0a13f9p-17 +-0x1.7f59d67a79096p-11 +-0x1.12be4297bc505p-13 +-0x1.db35c8d939a41p-5 +-0x1.9eaf42978ac08p-16 +-0x1.64145a29e90aap-13 +-0x1.358d7756e7f3cp-11 +-0x1.336da9ef17463p-12 +-0x1.be4323e96fa8bp-13 +-0x1.0056bf1e0597ep-17 +-0x1.7bdf415b139b8p-11 +-0x1.103ffd68d944p-13 +-0x1.0d4f7e88a8d9ep-4 +-0x1.8ddf19c03dcb9p-16 +-0x1.55a479db802bap-13 +-0x1.2900825e91884p-11 +-0x1.26f6c1485d2fbp-12 +-0x1.ac2b39981c413p-13 +-0x1.ebe43a6e18ebfp-18 +-0x1.6c786d64943dp-11 +-0x1.053635dc836d1p-13 +-0x1.7266f0d79ed5bp-4 +-0x1.98a175007546ap-16 +-0x1.5ee1930639f1bp-13 +-0x1.310892d202668p-11 +-0x1.2ef0b5c53991cp-12 +-0x1.b7bf526443cbfp-13 +-0x1.f93175ba21bep-18 +-0x1.76538ea68a481p-11 +-0x1.0c46823374df8p-13 +-0x1.89a64dbfcd72ep-4 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.daaab065bf5f5p-7 +-0x1.e1dfb5fd9ee9p-5 +-0x1.1375ce8728ccdp-6 +-0x1.1555eb5330f99p-4 +-0x1.a89bfe5845543p-6 +-0x1.9c322d9981af3p-4 +-0x1.ce490ac88221cp-6 +-0x1.bd6967098c9f8p-4 +-0x1.0421d0fbf7d3cp+1 +-0x1.02d2c1c9dc532p+1 +-0x1.f4ae6cefdbdaap+0 +-0x1.f0de490e90586p+0 +0x1.82539c2f4675bp-2 +0x1.9a09d4ab93ceap-2 +-0x1.5552717ac3366p-11 +0x1.62f2c0149702dp-2 +0x1.78aacf4d4f3d9p-2 +-0x1.b2408f8d35e54p-11 +0x1.0b4351fe3c365p-3 +0x1.1b4ab418f72a1p-3 +-0x1.82f9a8ac631f4p-10 +0x1.3d2c535bec90fp-4 +0x1.501bf1367c1e5p-4 +-0x1.af4e13a8a5867p-10 +0x1.4a00277e26bd8p-2 +0x1.3f5f3253e8dbep-2 +-0x1.be1f4f8d6b10ep-11 +0x1.2e531669671e8p-2 +0x1.24cf51430d299p-2 +-0x1.16f535264c6cdp-10 +0x1.bece23e7d253dp-4 +0x1.b2e94d6744d6cp-4 +-0x1.cde5d987d94ap-10 +0x1.07ff85b128131p-4 +0x1.014378142716bp-4 +-0x1.fdbeef4a46c07p-10 +0x1.0f4895c03c63dp-2 +0x1.dceadf43ec37fp-3 +-0x1.73bd52ea7e4dcp-11 +0x1.f1151382187ccp-3 +0x1.b4af399d92ff4p-3 +-0x1.d0d1a5e70ee0cp-11 +0x1.6f68b794ca8b2p-4 +0x1.418a7e677ba0ep-4 +-0x1.80be331c69107p-10 +0x1.b23270efbaab5p-5 +0x1.7ba8e03b3e43cp-5 +-0x1.a8945a8bc2388p-10 +0x1.6cd34d5bc442p-2 +0x1.7716f85bd2b1ep-2 +-0x1.267c4bdc8118p-11 +0x1.4e84d00abd277p-2 +0x1.56d03120193b9p-2 +-0x1.70486c7e4bea3p-11 +0x1.f135c06e8819cp-4 +0x1.f2ab0ba46ce84p-4 +-0x1.30eb46cac9ffep-10 +0x1.262975774135dp-4 +0x1.259053a4a8bf5p-4 +-0x1.5081e357fbb1ep-10 +0x1.8ce336a416f67p-2 +0x1.7a5e6c1186355p-2 +-0x1.ba23c1c25bb7ap-12 +0x1.6c211ab94eb99p-2 +0x1.5b20e46af1a1ap-2 +-0x1.1473528d37788p-11 +0x1.0fa421caf827bp-3 +0x1.02e82bbb79667p-3 +-0x1.c9b3c69cda7d2p-11 +0x1.41b24b293c4efp-4 +0x1.329a1584b080cp-4 +-0x1.f91a546fe2b0cp-11 +0x1.08251f40f607ep-2 +0x1.2ff9b68281971p-2 +-0x1.8bdd3519ab2e2p-12 +0x1.e55386934d3bbp-3 +0x1.1747d28223c0ep-2 +-0x1.ee4e6b7519cc5p-12 +0x1.6d2ab710c5525p-4 +0x1.a486512606dcap-4 +-0x1.98095b273398ep-11 +0x1.b14a22a06b9ffp-5 +0x1.f30acd01e44a8p-5 +-0x1.c20ea64eb8956p-11 +-0x1.a27b754322aadp-16 +-0x1.6757279b50e97p-13 +-0x1.3863309366914p-11 +-0x1.363e6843df9ecp-12 +-0x1.c2595ea6d47efp-13 +-0x1.02afb6e0a13eep-17 +-0x1.7f59d67a79087p-11 +-0x1.12be4297bc4f9p-13 +-0x1.bf018b9592888p-5 +-0x1.9eaf42978ac2ap-16 +-0x1.64145a29e90c7p-13 +-0x1.358d7756e7f56p-11 +-0x1.336da9ef1747cp-12 +-0x1.be4323e96fabp-13 +-0x1.0056bf1e05993p-17 +-0x1.7bdf415b139d7p-11 +-0x1.103ffd68d9456p-13 +-0x1.fab07e8eb835fp-5 +-0x1.8ddf19c03dcb9p-16 +-0x1.55a479db802bap-13 +-0x1.2900825e91884p-11 +-0x1.26f6c1485d2fbp-12 +-0x1.ac2b39981c413p-13 +-0x1.ebe43a6e18ebfp-18 +-0x1.6c786d64943dp-11 +-0x1.053635dc836d1p-13 +-0x1.5c8eb8f129ff8p-4 +-0x1.98a175007546ap-16 +-0x1.5ee1930639f1bp-13 +-0x1.310892d202668p-11 +-0x1.2ef0b5c53991cp-12 +-0x1.b7bf526443cbfp-13 +-0x1.f93175ba21bep-18 +-0x1.76538ea68a481p-11 +-0x1.0c46823374df8p-13 +-0x1.725af09e26c09p-4 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x0p+0 +-0x1.c4b389f24aa66p-6 +-0x1.bf06e51fc688ep-4 +-0x1.092c828b8c1eep-5 +-0x1.02aa039b28ed8p-3 +-0x1.9f866208b4527p-5 +-0x1.82f59674f7fcap-3 +-0x1.c4f1a534a574dp-5 +-0x1.a201bbad53879p-3 +-0x1.017ff20e6d3a9p+1 +-0x1.ffe972a588daap+0 +-0x1.f095b4366253p+0 +-0x1.ed7f1870d920dp+0 +0x1.427f6fdf1d8fdp-2 +0x1.562b77e688a07p-2 +-0x1.08f0e276d6335p-9 +0x1.1bb4a192296b3p-2 +-0x0p+0 +-0x1.0c8b57f2636a4p-4 +-0x0p+0 +-0x1.1f091e27068e5p-4 +-0x0p+0 +-0x1.faa585438d205p-5 +-0x0p+0 +-0x1.6c174b032b3e4p-4 +-0x0p+0 +-0x1.140ba9d29167p-2 +-0x0p+0 +-0x1.1367ee36623ffp-2 +-0x0p+0 +-0x1.0a5f14d297535p-1 +-0x0p+0 +-0x1.c4ce1a7143d63p-2 +-0x0p+0 +-0x1.48ffdff037fafp-1 +-0x0p+0 +-0x1.141ff1901c0d4p+0 +-0x0p+0 +-0x1.ac0b2af50ff22p-2 +-0x0p+0 +-0x1.9462822a62a04p-1 +-0x0p+0 +-0x1.2f608e820e0a6p+0 +-0x0p+0 +-0x1.839ddea053ecdp+0 +-0x0p+0 +-0x1.0d809d0775723p+0 +-0x0p+0 +-0x1.f91a3f27fe172p-3 +-0x0p+0 +-0x1.018e9f2406a1cp-1 +-0x0p+0 +-0x1.ff8e7be1d8b93p-2 +-0x0p+0 +-0x1.74d9157927575p-1 +-0x0p+0 +-0x1.9f861c2337d45p-1 +-0x0p+0 +-0x1.247103a7540c3p+0 +-0x0p+0 +-0x1.2c47cab37fc21p+0 +-0x0p+0 +-0x1.e4cec4c8ee11bp+0 +-0x0p+0 +-0x1.fdfd9f2471fc7p+0 +-0x0p+0 +-0x1.1327fd99dc02ep+0 +-0x0p+0 +-0x1.58962e221a6dap+0 +-0x0p+0 +-0x1.162499f79df5ep+0 +-0x0p+0 +-0x1.c3eca00e52c35p+0 +-0x0p+0 +-0x1.6468b7edb332ap+1 +-0x0p+0 +-0x1.5f2e41eb27053p+1 +-0x0p+0 +-0x1.087df774d1be3p+1 +-0x0p+0 +-0x1.2ed19db6c9bb3p+1 +-0x0p+0 +-0x1.e1549a9452852p+1 +-0x0p+0 +-0x1.2d84e15d5420dp+1 +-0x0p+0 +-0x1.f772a3b0af6e5p+0 +-0x0p+0 +-0x1.9f99e64ec5b7dp+1 +-0x0p+0 +-0x1.88233b15be065p+1 +-0x0p+0 +-0x1.62425bf341ec8p+0 +-0x0p+0 +-0x1.f6848ef08fcf4p+0 +-0x0p+0 +-0x1.ecf0b69778ff7p+0 +-0x0p+0 +-0x1.259a769221eb3p+1 +-0x0p+0 +-0x1.40f27bfa80657p+1 +-0x0p+0 +-0x1.d3d61afe16567p+1 +-0x0p+0 +-0x1.a08538b928d9bp+1 +-0x0p+0 +-0x1.16335932255a6p+2 +-0x0p+0 +-0x1.5381cd330a4a4p+2 +-0x0p+0 +-0x1.bfa605dec1cep+1 +-0x0p+0 +-0x1.c4c3d5b2af45cp+1 +-0x0p+0 +-0x1.62e3d79b13e0cp+2 +-0x0p+0 +-0x1.185d898a8ff92p+2 +-0x0p+0 +-0x1.a2f33459d65d9p+2 +-0x0p+0 +-0x1.4111a5d5fcb87p+2 +-0x0p+0 +-0x1.b006fd729c098p+1 +-0x0p+0 +-0x1.1b828cbc655a1p+2 +-0x0p+0 +-0x1.2313626804fe5p+2 +-0x0p+0 +-0x1.93b72f39760fep+2 +-0x0p+0 +-0x1.4b776ae8a3be5p+2 +-0x0p+0 +-0x1.c3dd1fe28ed66p+2 +-0x0p+0 +-0x1.e4d7849ab2972p+2 +-0x0p+0 +-0x1.48f4a3e330629p+3 +-0x0p+0 +-0x1.614791c184c36p+3 +-0x0p+0 +-0x1.1d55c8362f5e9p+3 +-0x0p+0 +-0x1.1e5604635fc09p+4 +-0x0p+0 +-0x1.79381198c0338p+2 +-0x0p+0 +-0x1.e185f1f89380cp+2 +-0x0p+0 +-0x1.d2bb6c8f0cae6p+2 +-0x0p+0 +-0x1.3fa692f60c71p+3 +-0x0p+0 +-0x1.c07b539550991p+2 +-0x0p+0 +-0x1.23bcbc0774dfbp+3 +-0x0p+0 +-0x1.3dd8c8cc70c04p+3 +-0x0p+0 +-0x1.9ebc7cbc84636p+3 +-0x0p+0 +-0x1.b36f8211b24e8p+3 +-0x0p+0 +-0x1.887451310a315p+3 +-0x0p+0 +-0x1.b3ad199f4d6ddp+4 +-0x0p+0 +-0x1.ca062a0ba3f64p+2 +-0x0p+0 +-0x1.49885de592b0cp+3 +-0x0p+0 +-0x1.e026a52cec405p+2 +-0x0p+0 +-0x1.2d2ab2c32dffbp+3 +-0x0p+0 +-0x1.e7108fd789b0ap+2 +-0x0p+0 +-0x1.6950828c01fbap+3 +-0x0p+0 +-0x1.1150e02cdc494p+3 +-0x0p+0 +-0x1.9cb9d2479ba9cp+3 +-0x0p+0 +-0x1.54a78726c976fp+3 +-0x0p+0 +-0x1.fa9783065cd9ep+2 +-0x0p+0 +-0x1.4345891a09baep+3 +-0x0p+0 +-0x1.c396fe4b83a6ap+3 +-0x0p+0 +-0x1.7b6ea1490a13fp+3 +-0x0p+0 +-0x1.330b972564418p+4 +-0x0p+0 +-0x1.5d1d6832b50fep+3 +-0x0p+0 +-0x1.f358a5ec47ed7p+3 +-0x0p+0 +-0x1.27f573cae019dp+3 +-0x0p+0 +-0x1.7eb8dd1f36b09p+3 +-0x0p+0 +-0x1.07be94db43c2fp+3 +-0x0p+0 +-0x1.3e281064310ffp+3 +-0x0p+0 +-0x1.1836ebd25c13p+3 +-0x0p+0 +-0x1.87b32eba24e7ap+3 +-0x0p+0 +-0x1.2cf2bc34ace96p+3 +-0x0p+0 +-0x1.641b4700ad8ffp+3 +-0x0p+0 +-0x1.39fc02bb861e3p+3 +-0x0p+0 +-0x1.e54e419c4e155p+3 +-0x0p+0 +-0x1.68d23d98f6d71p+3 +-0x0p+0 +-0x1.080ba03a0ca4ap+4 +-0x0p+0 +-0x1.add6de16d59b9p+3 +-0x0p+0 +-0x1.cda64816d4578p+3 +-0x0p+0 +-0x1.1678e453694b3p+4 +-0x0p+0 +-0x1.256a1efa7936p+4 +-0x0p+0 +-0x1.662f7d60ee1a6p+3 +-0x0p+0 +-0x1.013599f40e6d6p+4 +-0x0p+0 +-0x1.6caaafd109cbep+3 +-0x0p+0 +-0x1.a8c49598c90dp+3 +-0x0p+0 +-0x1.7d099327b5a03p+3 +-0x0p+0 +-0x1.38196a771c236p+4 +-0x0p+0 +-0x1.a4588cdecd6f5p+3 +-0x0p+0 +-0x1.db33c4ccbe64ap+3 +-0x0p+0 +-0x1.3a726bc50a63bp+4 +-0x0p+0 +-0x1.eeb25b7d288d4p+3 +-0x0p+0 +-0x1.79435a9e751d5p+4 +-0x0p+0 +-0x1.3ada05204c0adp+4 +-0x0p+0 +-0x1.00c0037c02d0ep+4 +-0x0p+0 +-0x1.18322aee65597p+4 +-0x0p+0 +-0x1.4edbd56db5a15p+4 +-0x0p+0 +-0x1.875fc621aa2cbp+3 +-0x0p+0 +-0x1.1d0b9224b62f8p+4 +-0x0p+0 +-0x1.6339f94962b34p+3 +-0x0p+0 +-0x1.91de10a1cdfccp+3 +-0x0p+0 +-0x1.51c90acb1464bp+3 +-0x0p+0 +-0x1.074940e9c93acp+4 +-0x0p+0 +-0x1.483d7620b682cp+3 +-0x0p+0 +-0x1.9d7130cca52bp+3 +-0x0p+0 +-0x1.b25cf451d9eb4p+3 +-0x0p+0 +-0x1.610c878c09a68p+3 +-0x0p+0 +-0x1.0570dc982e932p+4 +-0x0p+0 +-0x1.fbd3a85ea409dp+3 +-0x0p+0 +-0x1.34afe800362dp+3 +-0x0p+0 +-0x1.8a8a1f5c4ce2bp+3 +-0x0p+0 +-0x1.8a0c81c8fa57p+3 +-0x0p+0 +-0x1.526fbf47466a9p+3 +-0x0p+0 +-0x1.e911da5e48a8bp+3 +-0x0p+0 +-0x1.ec2c1d14c22d3p+3 +-0x0p+0 +-0x1.55cae171a7fb7p+3 +-0x0p+0 +-0x1.61f686d979988p+3 +-0x0p+0 +-0x1.8b7577ac0a786p+3 +-0x0p+0 +-0x1.770cdb94f1838p+3 +-0x0p+0 +-0x1.8743b6a20c82fp+3 +-0x0p+0 +-0x1.0a0e70ed77036p+4 +-0x0p+0 +-0x1.90c088fce8076p+3 +-0x0p+0 +-0x1.b6fd21631352p+3 +-0x0p+0 +-0x1.0a6f788425bdcp+4 +-0x0p+0 +-0x1.ee44a010a8fbdp+3 +-0x0p+0 +-0x1.1c3e8de97c04p+4 +-0x0p+0 +-0x1.dd8fa8563fa69p+3 +-0x0p+0 +-0x1.2bc2d8e413d4fp+4 +-0x0p+0 +-0x1.8f195a7ab187cp+4 +-0x0p+0 +-0x1.074fb11a07c08p+4 +-0x0p+0 +-0x1.5810ebbe538d2p+4 +-0x0p+0 +-0x1.31ee7633629bfp+4 +-0x0p+0 +-0x1.391d38fc4d349p+4 +-0x0p+0 +-0x1.7b9794d72c1fbp+4 +-0x0p+0 +-0x1.58b009492ff05p+4 +-0x0p+0 +-0x1.7215dfd3dd734p+3 +-0x0p+0 +-0x1.dd22fa0e22304p+3 +-0x0p+0 +-0x1.144700e0a0cdfp+4 +-0x0p+0 +-0x1.20944f1a19d58p+4 +-0x0p+0 +-0x1.7428f7ba9e589p+3 +-0x0p+0 +-0x1.005e8b59dc638p+4 +-0x0p+0 +-0x1.e482ae43711d1p+3 +-0x0p+0 +-0x1.8a1bdb24e92dfp+3 +-0x0p+0 +-0x1.cdc4cee9c8247p+3 +-0x0p+0 +-0x1.d25bfc48b2912p+3 +-0x0p+0 +-0x1.fa66e00df32f8p+3 +-0x0p+0 +-0x1.827bcb29956d4p+3 +-0x0p+0 +-0x1.d7cc2308d16a9p+3 +-0x0p+0 +-0x1.985d0fa2c53fap+3 +-0x0p+0 +-0x1.176379db79a1p+4 +-0x0p+0 +-0x1.3f09d1a4ce72fp+3 +-0x0p+0 +-0x1.90654994fbc35p+3 +-0x0p+0 +-0x1.5615a67f7a898p+3 +-0x0p+0 +-0x1.00f68d8040fc8p+4 +-0x0p+0 +-0x1.ae9b3f4c3b23bp+3 +-0x0p+0 +-0x1.2d8ccb05466b3p+3 +-0x0p+0 +-0x1.219aa28cbb9dbp+3 +-0x0p+0 +-0x1.6cca41f915794p+3 +-0x0p+0 +-0x1.27cf7a53af645p+3 +-0x0p+0 +-0x1.79598520660c1p+3 +-0x0p+0 +-0x1.4b94b23fcf2fp+3 +-0x0p+0 +-0x1.c69b4c16e39ep+3 +-0x0p+0 +-0x1.7958e84039abcp+3 +-0x0p+0 +-0x1.222110b6db4b2p+4 +-0x0p+0 +-0x1.782e5172068d7p+3 +-0x0p+0 +-0x1.296aa7e93aafap+4 +-0x0p+0 +-0x1.73eec55f3390ep+3 +-0x0p+0 +-0x1.0f9af1be32293p+4 +-0x0p+0 +-0x1.710d6941ca2ebp+3 +-0x0p+0 +-0x1.a897459f0197ep+3 +-0x0p+0 +-0x1.54fc921daec27p+3 +-0x0p+0 +-0x1.eda893ce3fee7p+3 +-0x0p+0 +-0x1.8a8a2080223fdp+3 +-0x0p+0 +-0x1.2225429e41971p+4 +-0x0p+0 +-0x1.135d3a03d7bf8p+4 +-0x0p+0 +-0x1.50b0e6078c11fp+3 +-0x0p+0 +-0x1.708d449fa4e15p+3 +-0x0p+0 +-0x1.06cbf67e9ec06p+4 +-0x0p+0 +-0x1.70bc7dec6eaaep+3 +-0x0p+0 +-0x1.04835f0e0938cp+4 +-0x0p+0 +-0x1.648ebd2c4d027p+3 +-0x0p+0 +-0x1.c4d462edf9f49p+3 +-0x0p+0 +-0x1.7da83ad2aa9dbp+4 +-0x0p+0 +-0x1.8454b3ba5f09bp+3 +-0x0p+0 +-0x1.1fc84ba057c1p+4 +-0x0p+0 +-0x1.864befed41c11p+3 +-0x0p+0 +-0x1.289c61631746fp+4 +-0x0p+0 +-0x1.4fe0382195e15p+3 +-0x0p+0 +-0x1.71c68f615000cp+3 +-0x0p+0 +-0x1.8aa714a761fdfp+3 +-0x0p+0 +-0x1.06bf192a9d9ddp+4 +-0x0p+0 +-0x1.7c42b5df98099p+3 +-0x0p+0 +-0x1.94192d95df415p+3 +-0x0p+0 +-0x1.15e079227068cp+4 +-0x0p+0 +-0x1.8a0ed47c4ca1ep+3 +-0x0p+0 +-0x1.8a4e0b61d0b3fp+3 +-0x0p+0 +-0x1.cf80658a5575dp+3 +-0x0p+0 +-0x1.8b6f7795c2665p+3 +-0x0p+0 +-0x1.e60b133d13d67p+3 +-0x0p+0 +-0x1.2d31427f227fbp+4 +-0x0p+0 +-0x1.a35024a20b4e1p+3 +-0x0p+0 +-0x1.ff9f78eb321bep+3 +-0x0p+0 +-0x1.dd2266a493a54p+3 +-0x0p+0 +-0x1.aa27e4653ac04p+3 +-0x0p+0 +-0x1.1d2a00539d38p+4 +-0x0p+0 +-0x1.e7e8ddbfe39d1p+3 +-0x0p+0 +-0x1.0f053b610bc2p+4 +-0x0p+0 +-0x1.e4ffa33d06084p+3 +-0x0p+0 +-0x1.12f77a57f2ceap+4 +-0x0p+0 +-0x1.316ec40c7dc63p+4 +-0x0p+0 +-0x1.72ae898c127c5p+4 +-0x0p+0 +-0x1.6612f69353137p+4 +-0x0p+0 +-0x1.5c356710358a5p+4 +-0x0p+0 +-0x1.430d9f506b9e4p+4 +-0x0p+0 +-0x1.04decb4894b89p+4 +-0x0p+0 +-0x1.355ccb6c1c34ep+4 +-0x0p+0 +-0x1.2596927f3ad52p+4 +-0x0p+0 +-0x1.514a5aadc710ap+4 +-0x0p+0 +-0x1.8372dba1711c4p+4 +-0x0p+0 +-0x1.3d3ce5fdc1aa1p+4 +-0x0p+0 +-0x1.bb673e0cae09bp+3 +-0x0p+0 +-0x1.e7dd46357d397p+3 +-0x0p+0 +-0x1.c2028472d13a7p+3 +-0x0p+0 +-0x1.be5cdf8540117p+3 +-0x0p+0 +-0x1.1aa341abd76bep+4 +-0x0p+0 +-0x1.f4009fbd72365p+3 +-0x0p+0 +-0x1.ec0dcb9ae35bdp+3 +-0x0p+0 +-0x1.e298f5f679519p+3 +-0x0p+0 +-0x1.84e7f5e44adcdp+3 +-0x0p+0 +-0x1.e7fd92026b017p+3 +-0x0p+0 +-0x1.02c85b60c437fp+4 +-0x0p+0 +-0x1.3efb341763b15p+4 +-0x0p+0 +-0x1.3c0624c1d9b43p+4 +-0x0p+0 +-0x1.73f91f29e05a9p+3 +-0x0p+0 +-0x1.f04c61bcf4bcp+3 +-0x0p+0 +-0x1.62efac441c4fcp+3 +-0x0p+0 +-0x1.ca9e3552b2747p+3 +-0x0p+0 +-0x1.12b867099900fp+3 +-0x0p+0 +-0x1.81f6673bbd58dp+3 +-0x0p+0 +-0x1.3dcc7445c6991p+3 +-0x0p+0 +-0x1.99f2e5b4b831bp+3 +-0x0p+0 +-0x1.51ac730a9fe62p+3 +-0x0p+0 +-0x1.b382e6d68b211p+3 +-0x0p+0 +-0x1.01934560d5fedp+3 +-0x0p+0 +-0x1.51791a0277959p+3 +-0x0p+0 +-0x1.e0cc96cc9ff9dp+2 +-0x0p+0 +-0x1.3c8c3ec7dd63fp+3 +-0x0p+0 +-0x1.6c6e034599bb7p+2 +-0x0p+0 +-0x1.19500d3262beep+3 +-0x0p+0 +-0x1.95d9095f04cd6p+2 +-0x0p+0 +-0x1.3c0258cf41532p+3 +-0x0p+0 +-0x1.d3e7d0e0c1f97p+2 +-0x0p+0 +-0x1.9daa5e5369096p+2 +-0x0p+0 +-0x1.9630ab5095e54p+2 +-0x0p+0 +-0x1.177f63758243ap+3 +-0x0p+0 +-0x1.35d7484a5915dp+2 +-0x0p+0 +-0x1.5cf99d881eaaap+2 +-0x0p+0 +-0x1.29044f458cd67p+2 +-0x0p+0 +-0x1.a1a136a07b4ffp+2 +-0x0p+0 +-0x1.128149d7d0c96p+3 +-0x0p+0 +-0x1.3db1423d17fb1p+3 +-0x0p+0 +-0x1.c59c487c10bfep+2 +-0x0p+0 +-0x1.0acd7be80b4e8p+3 +-0x0p+0 +-0x1.85b0680f3624cp+3 +-0x0p+0 +-0x1.b6286106bf587p+2 +-0x0p+0 +-0x1.35fdd65ebf95ep+3 +-0x0p+0 +-0x1.575540f4c0196p+3 +-0x0p+0 +-0x1.3829a3cf0ebf6p+2 +-0x0p+0 +-0x1.f65803f649a9dp+2 +-0x0p+0 +-0x1.15d4d5916d744p+2 +-0x0p+0 +-0x1.6ed65799fc29ep+2 +-0x0p+0 +-0x1.ff380bc8bb104p+1 +-0x0p+0 +-0x1.5177fa45ee98dp+2 +-0x0p+0 +-0x1.8f10660f12996p+1 +-0x0p+0 +-0x1.398a286e72de9p+2 +-0x0p+0 +-0x1.c7d5788afbd14p+1 +-0x0p+0 +-0x1.48cbe9b8d7a45p+2 +-0x0p+0 +-0x1.3bac9c7474a9p+2 +-0x0p+0 +-0x1.c25c4d48f068p+1 +-0x0p+0 +-0x1.cd209279b74e3p+1 +-0x0p+0 +-0x1.465751b9e579p+2 +-0x0p+0 +-0x1.198039cf0522p+2 +-0x0p+0 +-0x1.651934def7f99p+2 +-0x0p+0 +-0x1.868fc39bb3186p+2 +-0x0p+0 +-0x1.3dd8747e4aa31p+1 +-0x0p+0 +-0x1.3ed857dedf201p+1 +-0x0p+0 +-0x1.4d75de6e8956fp+1 +-0x0p+0 +-0x1.e979d69110575p+1 +-0x0p+0 +-0x1.f2bb6c01e25cep+0 +-0x0p+0 +-0x1.0d5bd89020272p+1 +-0x0p+0 +-0x1.2fbdb1826ea4dp+1 +-0x0p+0 +-0x1.7373207680bbdp+1 +-0x0p+0 +-0x1.86cfa7d9ff3ebp+1 +-0x0p+0 +-0x1.b4d0ba658b30fp+1 +-0x0p+0 +-0x1.15c087fac6e07p+2 +-0x0p+0 +-0x1.394fec1684f28p+2 +-0x0p+0 +-0x1.1e20831921af7p+2 +-0x0p+0 +-0x1.3f8525ee2f131p+2 +-0x0p+0 +-0x1.b62f06ee723fcp+2 +-0x0p+0 +-0x1.20d0fa32382a5p+1 +-0x0p+0 +-0x1.53b7512ba3043p+1 +-0x0p+0 +-0x1.7b34fa118f8ap+1 +-0x0p+0 +-0x1.05ae9d9916155p+2 +-0x0p+0 +-0x1.9843925ece04dp+1 +-0x0p+0 +-0x1.0cc8630d7540ap+2 +-0x0p+0 +-0x1.263b34ffc6a61p+2 +-0x0p+0 +-0x1.ac9284216bd45p+2 +-0x0p+0 +-0x1.bdb7f48127131p+2 +-0x0p+0 +-0x1.1c6d2ace866bcp+2 +-0x0p+0 +-0x1.4f5138dd7e7c6p+2 +-0x0p+0 +-0x1.df8788147b1b9p+2 +-0x0p+0 +-0x1.816152d2f54b7p+2 +-0x0p+0 +-0x1.23d57b1df5262p+3 +-0x0p+0 +-0x1.97ee27992e39cp+2 +-0x0p+0 +-0x1.2f92e770d35edp+3 +-0x0p+0 +-0x1.0e3bb633fe927p+4 +-0x0p+0 +-0x1.82682df4814eap+2 +-0x0p+0 +-0x1.1fa0fd74aca2ap+3 +-0x0p+0 +-0x1.4f107c1f1452dp+2 +-0x0p+0 +-0x1.c82f1ffdbf5e1p+2 +-0x0p+0 +-0x1.d979cdc900cfep+1 +-0x0p+0 +-0x1.3ebb49567413fp+2 +-0x0p+0 +-0x1.20911b4b7f598p+2 +-0x0p+0 +-0x1.953b68714df92p+2 +-0x0p+0 +-0x1.1fd9aa5dcadc7p+2 +-0x0p+0 +-0x1.81f5473e4b2bbp+2 +-0x0p+0 +-0x1.5b559327960b6p+2 +-0x0p+0 +-0x1.9364c88c4e0bbp+2 +-0x0p+0 +-0x1.fd1fc90202ccbp+2 +-0x0p+0 +-0x1.b1fcde6829d13p+2 +-0x0p+0 +-0x1.0e1be2d6d1d9bp+3 +-0x0p+0 +-0x1.28ab275e4cf44p+3 +-0x0p+0 +-0x1.62517373771d3p+2 +-0x0p+0 +-0x1.f8cab4b04bd99p+2 +-0x0p+0 +-0x1.9161239a2a54cp+2 +-0x0p+0 +-0x1.061e5a8d1ac6fp+3 +-0x0p+0 +-0x1.9d17307bba386p+2 +-0x0p+0 +-0x1.26b181a4d3e96p+3 +-0x0p+0 +-0x1.e093484132dc9p+2 +-0x0p+0 +-0x1.4289bbea2edfap+3 +-0x0p+0 +-0x1.7eacd62512f76p+3 +-0x0p+0 +-0x1.cefe33308bb22p+2 +-0x0p+0 +-0x1.66d7e2a683034p+3 +-0x0p+0 +-0x1.46fe746d72af4p+3 +-0x0p+0 +-0x1.89e2cebb34951p+3 +-0x0p+0 +-0x1.be6552a972604p+3 +-0x0p+0 +-0x1.bb7e758b7e6acp+3 +-0x0p+0 +-0x1.ebd899b2c82a9p+2 +-0x0p+0 +-0x1.1f03d100aef46p+3 +-0x0p+0 +-0x1.4c1971ad94121p+3 +-0x0p+0 +-0x1.233012f2e02c8p+3 +-0x0p+0 +-0x1.fc9be2b8ee6bcp+2 +-0x0p+0 +-0x1.75733535e354cp+3 +-0x0p+0 +-0x1.0998236c83077p+3 +-0x0p+0 +-0x1.3570c281cff26p+3 +-0x0p+0 +-0x1.2ec2d95c90942p+3 +-0x0p+0 +-0x1.d8bcf7d8642cp+3 +-0x0p+0 +-0x1.810f7ae015f4ap+3 +-0x0p+0 +-0x1.afec45334e852p+3 +-0x0p+0 +-0x1.1c2d74c5966c3p+4 +-0x0p+0 +-0x1.d4f4fc72e6af5p+3 +-0x0p+0 +-0x1.47a1469a673c3p+3 +-0x0p+0 +-0x1.01239a77e875p+4 +-0x0p+0 +-0x1.2eb5e0ae3a663p+3 +-0x0p+0 +-0x1.451f2fba95751p+3 +-0x0p+0 +-0x1.374343037e4c5p+3 +-0x0p+0 +-0x1.0215df2aff036p+4 +-0x0p+0 +-0x1.3b7e6dc215d81p+3 +-0x0p+0 +-0x1.738bc4e94046p+3 +-0x0p+0 +-0x1.c220366475a3cp+3 +-0x0p+0 +-0x1.491911b47e14fp+3 +-0x0p+0 +-0x1.c7c996441ace2p+3 +-0x0p+0 +-0x1.55503a181f35bp+3 +-0x0p+0 +-0x1.586d1866240c8p+3 +-0x0p+0 +-0x1.dde6d323d0875p+3 +-0x0p+0 +-0x1.615546a6b2aep+3 +-0x0p+0 +-0x1.948a622ce1403p+3 +-0x0p+0 +-0x1.6b6da52141f07p+3 +-0x0p+0 +-0x1.0b4eace1373c7p+4 +-0x0p+0 +-0x1.8f08e0539a7afp+3 +-0x0p+0 +-0x1.1654f56195e7ep+4 +-0x0p+0 +-0x1.5db44cb7d72bp+3 +-0x0p+0 +-0x1.aa9047a802503p+3 +-0x0p+0 +-0x1.e4a44441d4d3cp+3 +-0x0p+0 +-0x1.19c9464db8bbbp+4 +-0x0p+0 +-0x1.360ed6c13b80ep+4 +-0x0p+0 +-0x1.cb2bd7800cdefp+3 +-0x0p+0 +-0x1.0bfa26d35e615p+4 +-0x0p+0 +-0x1.1918ecc106e4cp+4 +-0x0p+0 +-0x1.23bdec98a505p+4 +-0x0p+0 +-0x1.41dcb004b9b11p+4 +-0x0p+0 +-0x1.7dcd1ea26aba4p+4 +-0x0p+0 +-0x1.468c92e631882p+5 +-0x0p+0 +-0x1.dbafb26a84722p+3 +-0x0p+0 +-0x1.4a38126427e55p+4 +-0x0p+0 +-0x1.cfa6c45514455p+3 +-0x0p+0 +-0x1.2ad402b183703p+4 +-0x0p+0 +-0x1.f81f85b8a0d79p+3 +-0x0p+0 +-0x1.52bde9a10d8d4p+4 +-0x0p+0 +-0x1.c08f43c0d8b8fp+3 +-0x0p+0 +-0x1.df9cd8f8d96fp+3 +-0x0p+0 +-0x1.2be2ce5aa08c1p+4 +-0x0p+0 +-0x1.ffdaa209ad647p+3 +-0x0p+0 +-0x1.24a0997c1c673p+4 +-0x0p+0 +-0x1.fe0e508aa2eb6p+3 +-0x0p+0 +-0x1.abb1d3c03962p+3 +-0x0p+0 +-0x1.154e83f2284e5p+4 +-0x0p+0 +-0x1.10b8f41819628p+4 +-0x0p+0 +-0x1.9658087c73c99p+3 +-0x0p+0 +-0x1.0049933d5e10cp+4 +-0x0p+0 +-0x1.1470fa3fa9a69p+4 +-0x0p+0 +-0x1.9669b6a143ae2p+3 +-0x0p+0 +-0x1.b096db55d277dp+3 +-0x0p+0 +-0x1.395027ae451e7p+4 +-0x0p+0 +-0x1.a65130580909ep+3 +-0x0p+0 +-0x1.1d6ccd940948ap+4 +-0x0p+0 +-0x1.5ee1099d44ae8p+3 +-0x0p+0 +-0x1.1fa587d970d36p+4 +-0x0p+0 +-0x1.6eadca207437ep+3 +-0x0p+0 +-0x1.e7a84ce294822p+3 +-0x0p+0 +-0x1.ec314d1b2cea8p+3 +-0x0p+0 +-0x1.3a26593873362p+4 +-0x0p+0 +-0x1.c0e158406cfd2p+3 +-0x0p+0 +-0x1.bd450c39f68bdp+4 +-0x0p+0 +-0x1.41854d4fa0ab4p+3 +-0x0p+0 +-0x1.6bfa091568435p+3 +-0x0p+0 +-0x1.59359709e00e7p+3 +-0x0p+0 +-0x1.e2c7db9b494d1p+3 +-0x0p+0 +-0x1.0e6008c5e512dp+3 +-0x0p+0 +-0x1.972ed8572e9d9p+3 +-0x0p+0 +-0x1.3dfde31276b5fp+3 +-0x0p+0 +-0x1.b0610ac75aa06p+3 +-0x0p+0 +-0x1.885a96f2afd3bp+3 +-0x0p+0 +-0x1.8a72eea9f8ebep+3 +-0x0p+0 +-0x1.fc989b4cb8778p+3 +-0x0p+0 +-0x1.fd7ea8443cf75p+3 +-0x0p+0 +-0x1.cfa8ed06fbb8ep+2 +-0x0p+0 +-0x1.16f8fbf214967p+3 +-0x0p+0 +-0x1.e299c8314e154p+2 +-0x0p+0 +-0x1.6d098a32c5b2cp+3 +-0x0p+0 +-0x1.7161794be5337p+2 +-0x0p+0 +-0x1.cb5f964eaceffp+2 +-0x0p+0 +-0x1.bb672771606bcp+2 +-0x0p+0 +-0x1.f451f6f983f5ap+2 +-0x0p+0 +-0x1.572be0da9fc21p+3 +-0x0p+0 +-0x1.0115736eb863dp+3 +-0x0p+0 +-0x1.6d2199ada896ep+3 +-0x0p+0 +-0x1.24bbb562aef13p+3 +-0x0p+0 +-0x1.632c06c0c72e3p+3 +-0x0p+0 +-0x1.162c0247a9761p+3 +-0x0p+0 +-0x1.779db88900414p+2 +-0x0p+0 +-0x1.ba3e061b57911p+2 +-0x0p+0 +-0x1.c3681ae12847fp+2 +-0x0p+0 +-0x1.37b760d7f96bep+3 +-0x0p+0 +-0x1.d3ccd0ce88297p+2 +-0x0p+0 +-0x1.3cda761e5aebdp+3 +-0x0p+0 +-0x1.5926cf7d576dap+3 +-0x0p+0 +-0x1.d61d8fa6a722ap+3 +-0x0p+0 +-0x1.ca3bb54a96d93p+3 +-0x0p+0 +-0x1.b1e9eb3b52929p+3 +-0x0p+0 +-0x1.ee7a1c6cec56ep+2 +-0x0p+0 +-0x1.4d5526ea2657bp+3 +-0x0p+0 +-0x1.eb8e11d3ac57dp+2 +-0x0p+0 +-0x1.16c6fde61b0a2p+3 +-0x0p+0 +-0x1.c440058e6eb08p+2 +-0x0p+0 +-0x1.70b117df7a3bbp+3 +-0x0p+0 +-0x1.00496f00a9c51p+3 +-0x0p+0 +-0x1.77291e058bdecp+3 +-0x0p+0 +-0x1.30ef45f5eaebp+3 +-0x0p+0 +-0x1.31bb9d4e6561p+3 +-0x0p+0 +-0x1.b04453b822a1fp+3 +-0x0p+0 +-0x1.6e60236d5b94ap+3 +-0x0p+0 +-0x1.768af21c9872ap+3 +-0x0p+0 +-0x1.0f22627733417p+4 +-0x0p+0 +-0x1.d0a8ba838e943p+3 +-0x0p+0 +-0x1.44a09d6269944p+4 +-0x0p+0 +-0x1.c9e7878d3e692p+3 +-0x0p+0 +-0x1.b33fdb68ce837p+2 +-0x0p+0 +-0x1.2f92b42e875cap+3 +-0x0p+0 +-0x1.9c6022bc858c6p+2 +-0x0p+0 +-0x1.0375514b94e49p+3 +-0x0p+0 +-0x1.6a63f85e5ae07p+2 +-0x0p+0 +-0x1.19e57b99b9965p+3 +-0x0p+0 +-0x1.513d46afb3f3ap+2 +-0x0p+0 +-0x1.9f92c37c9202cp+2 +-0x0p+0 +-0x1.c9115a9755223p+2 +-0x0p+0 +-0x1.5257f414f9067p+2 +-0x0p+0 +-0x1.e0eba110b5a71p+2 +-0x0p+0 +-0x1.48f98288a8419p+2 +-0x0p+0 +-0x1.a0a0eb97cde95p+2 +-0x0p+0 +-0x1.254b62341cf71p+3 +-0x0p+0 +-0x1.bbecbedac33eap+2 +-0x0p+0 +-0x1.1c193ae2d74c8p+3 +-0x0p+0 +-0x1.bb635ea99532cp+2 +-0x0p+0 +-0x1.432d12f54b452p+3 +-0x0p+0 +-0x1.07038a2645ccbp+3 +-0x0p+0 +-0x1.59a306a1ab5d2p+3 +-0x0p+0 +-0x1.646cbaf06c5f2p+3 +-0x0p+0 +-0x1.1c4b9a581ac7dp+3 +-0x0p+0 +-0x1.35e7557665d6p+3 +-0x0p+0 +-0x1.8726d40432322p+3 +-0x0p+0 +-0x1.73034bd5edd22p+3 +-0x0p+0 +-0x1.0013972151fc4p+4 +-0x0p+0 +-0x1.ad4e8b410c64dp+3 +-0x0p+0 +-0x1.582f186898278p+4 +-0x0p+0 +-0x1.aebf7bedd2c8ap+3 +-0x0p+0 +-0x1.49d4f83ba1a82p+4 +-0x0p+0 +-0x1.74f58ea07199p+3 +-0x0p+0 +-0x1.0522f7466b206p+4 +-0x0p+0 +-0x1.05370ddd75546p+3 +-0x0p+0 +-0x1.57d1106d034b3p+3 +-0x0p+0 +-0x1.289d660b01e63p+3 +-0x0p+0 +-0x1.564adfbc80694p+3 +-0x0p+0 +-0x1.3e7d4d25673f2p+3 +-0x0p+0 +-0x1.0a4f828805a5fp+4 +-0x0p+0 +-0x1.6c62222bdcfccp+3 +-0x0p+0 +-0x1.01a6a5cac9226p+4 +-0x0p+0 +-0x1.a2b5608e8e446p+3 +-0x0p+0 +-0x1.a24e08f4859dp+3 +-0x0p+0 +-0x1.0379cbf645e5p+4 +-0x0p+0 +-0x1.4addb6d96991ep+4 +-0x0p+0 +-0x1.4c5343d987d4dp+3 +-0x0p+0 +-0x1.d595a6aaa44e1p+3 +-0x0p+0 +-0x1.4963a0a779ac2p+3 +-0x0p+0 +-0x1.7e10dd93f0a55p+3 +-0x0p+0 +-0x1.4f73517ca317bp+3 +-0x0p+0 +-0x1.0e275cfeb3a16p+4 +-0x0p+0 +-0x1.7b94fde39ac37p+3 +-0x0p+0 +-0x1.b2afe42cbd99p+3 +-0x0p+0 +-0x1.19198583f420ap+4 +-0x0p+0 +-0x1.ae98d7ebb3aa7p+3 +-0x0p+0 +-0x1.2e3d87ac69495p+4 +-0x0p+0 +-0x1.dde197bbff5bep+3 +-0x0p+0 +-0x1.646f87f71a796p+3 +-0x0p+0 +-0x1.0cbcca4a7bb0dp+4 +-0x0p+0 +-0x1.4540f99fbe96bp+3 +-0x0p+0 +-0x1.708168ca03487p+3 +-0x0p+0 +-0x1.37425dc42f86fp+3 +-0x0p+0 +-0x1.f434652580f0ep+3 +-0x0p+0 +-0x1.3143cf986eadep+3 +-0x0p+0 +-0x1.94c9d8579d391p+3 +-0x0p+0 +-0x1.728a0d6a04c37p+3 +-0x0p+0 +-0x1.32333f1f52fa1p+3 +-0x0p+0 +-0x1.7f964d88a5f83p+3 +-0x0p+0 +-0x1.0eadaf0a5497cp+4 +-0x0p+0 +-0x1.b59b1819accbp+3 +-0x0p+0 +-0x1.37f547ec97a09p+4 +-0x0p+0 +-0x1.6526c2fad73bbp+3 +-0x0p+0 +-0x1.a23fb791c7cc5p+3 +-0x0p+0 +-0x1.28c3cd1102833p+4 +-0x0p+0 +-0x1.bbbbb8fa203bcp+3 +-0x0p+0 +-0x1.5596bc4a06608p+4 +-0x0p+0 +-0x1.8903c588957fep+3 +-0x0p+0 +-0x1.0d43b704aca11p+4 +-0x0p+0 +-0x1.5e871f2e10e2cp+3 +-0x0p+0 +-0x1.b7b24c28f0323p+3 +-0x0p+0 +-0x1.407aba7103dfdp+3 +-0x0p+0 +-0x1.570946b0d2461p+3 +-0x0p+0 +-0x1.fe287f3cc7f37p+3 +-0x0p+0 +-0x1.4b7a2fe9be057p+3 +-0x0p+0 +-0x1.7127176e71585p+3 +-0x0p+0 +-0x1.5d18b7ea44617p+3 +-0x0p+0 +-0x1.0127123433ca6p+4 +-0x0p+0 +-0x1.7a46f33decec9p+3 +-0x0p+0 +-0x1.c4a1a4d232023p+3 +-0x0p+0 +-0x1.16c3bdcdd7dd8p+4 +-0x0p+0 +-0x1.2312e0b16ec76p+4 +-0x0p+0 +-0x1.2c81a4b01cbc4p+4 +-0x0p+0 +-0x1.f4777e63341ap+3 +-0x0p+0 +-0x1.5214466fbf1c2p+4 +-0x0p+0 +-0x1.e46b4e9562bdp+3 +-0x0p+0 +-0x1.3038a7a77e1c9p+4 +-0x0p+0 +-0x1.52b2c5c77c27ap+4 +-0x0p+0 +-0x1.35657889bd7e4p+4 +-0x0p+0 +-0x1.13b017d047eb4p+5 +-0x0p+0 +-0x1.41de50997bd5cp+4 +-0x0p+0 +-0x1.51b38727f8287p+4 +-0x0p+0 +-0x1.5d42c892b4f65p+4 +-0x0p+0 +-0x1.3f39d5fd00e3p+5 +-0x0p+0 +-0x1.68a8171372ccep+4 +-0x0p+0 +-0x1.405c66348b7cap+4 +-0x0p+0 +-0x1.925c25d1a766ep+3 +-0x0p+0 +-0x1.21366fa66f873p+4 +-0x0p+0 +-0x1.c477e959ab86ep+3 +-0x0p+0 +-0x1.3abd56237d722p+4 +-0x0p+0 +-0x1.25ac90d97a42dp+4 +-0x0p+0 +-0x1.0c35c6322fdd7p+4 +-0x0p+0 +-0x1.608f004560d87p+4 +-0x0p+0 +-0x1.5b842eceb5b84p+4 +-0x0p+0 +-0x1.a6242ff3d0df6p+3 +-0x0p+0 +-0x1.1fc382d4e123dp+4 +-0x0p+0 +-0x1.a799233322b1p+3 +-0x0p+0 +-0x1.0fcc552f8168dp+4 +-0x0p+0 +-0x1.90850875abf13p+3 +-0x0p+0 +-0x1.f8e3bb34b0d0ap+3 +-0x0p+0 +-0x1.eca2d734e152bp+3 +-0x0p+0 +-0x1.94fbdf054b8c5p+3 +-0x0p+0 +-0x1.10973fa274c26p+4 +-0x0p+0 +-0x1.90e3d2919e0cp+3 +-0x0p+0 +-0x1.e3d2ef49b0a71p+3 +-0x0p+0 +-0x1.791c9c33cad9bp+3 +-0x0p+0 +-0x1.1326631d1125ap+4 +-0x0p+0 +-0x1.8b991482dc6d6p+3 +-0x0p+0 +-0x1.1f414b281d684p+4 +-0x0p+0 +-0x1.00fb0384867e1p+4 +-0x0p+0 +-0x1.8a15409f6a358p+3 +-0x0p+0 +-0x1.eb36cecd847d6p+3 +-0x0p+0 +-0x1.15cb6459ae141p+4 +-0x0p+0 +-0x1.9d5c0b752ff34p+3 +-0x0p+0 +-0x1.fa95714bd0ff9p+3 +-0x0p+0 +-0x1.0b95a47f2a383p+4 +-0x0p+0 +-0x1.eb06af4979638p+3 +-0x0p+0 +-0x1.54a8b9d6a4022p+4 +-0x0p+0 +-0x1.f77f330f7fa64p+3 +-0x0p+0 +-0x1.12e5d6da9bc9cp+4 +-0x0p+0 +-0x1.1b77b8303f31dp+4 +-0x0p+0 +-0x1.5c14e48fd0bacp+4 +-0x0p+0 +-0x1.643b9800893ap+4 +-0x0p+0 +-0x1.c66de1382e85dp+4 +-0x0p+0 +-0x1.b966bf25e6a3ep+4 +-0x0p+0 +-0x1.b47c0e1c7e5bap+3 +-0x0p+0 +-0x1.193a0a2160b53p+4 +-0x0p+0 +-0x1.01ce72f29a5bap+4 +-0x0p+0 +-0x1.568e2b0f4a695p+4 +-0x0p+0 +-0x1.0caf8ce77bf3bp+4 +-0x0p+0 +-0x1.55061327c8077p+4 +-0x0p+0 +-0x1.38a081f2de52ep+4 +-0x0p+0 +-0x1.369ad32858e14p+4 +-0x0p+0 +-0x1.1fbb6ac61923fp+5 +-0x0p+0 +-0x1.65f0d6dab2bd6p+4 +-0x0p+0 +-0x1.da5fa9832cdd9p+3 +-0x0p+0 +-0x1.e8e0adde100cfp+3 +-0x0p+0 +-0x1.241dd52b675a5p+4 +-0x0p+0 +-0x1.4d91adc17f362p+4 +-0x0p+0 +-0x1.1cd47a0d51c05p+4 +-0x0p+0 +-0x1.1ea1f6a48045fp+4 +-0x0p+0 +-0x1.810576c0e425dp+4 +-0x0p+0 +-0x1.fd52c0275e833p+3 +-0x0p+0 +-0x1.27316b3a53e7ep+4 +-0x0p+0 +-0x1.577e5673b79edp+4 +-0x0p+0 +-0x1.33d8a721e39c6p+4 +-0x0p+0 +-0x1.4d9cb43f1ef8cp+4 +-0x0p+0 +-0x1.4e7aee9db864cp+4 +-0x0p+0 +-0x1.87fe44020be6ep+4 +-0x0p+0 +-0x1.c3ad8e7edd7ap+3 +-0x0p+0 +-0x1.16cbc4d0db364p+4 +-0x0p+0 +-0x1.addfd3444d47fp+3 +-0x0p+0 +-0x1.8dbdca61bb997p+4 +-0x0p+0 +-0x1.02a06e5d5cc2ep+4 +-0x0p+0 +-0x1.59b4444140354p+4 +-0x0p+0 +-0x1.8fc98fd4defc7p+3 +-0x0p+0 +-0x1.13598747032aap+4 +-0x0p+0 +-0x1.8a931711f8b9cp+3 +-0x0p+0 +-0x1.10544f294816ep+4 +-0x0p+0 +-0x1.4d3736a026208p+3 +-0x0p+0 +-0x1.61bbc1bf15e1ep+3 +-0x0p+0 +-0x1.aec840be01154p+3 +-0x0p+0 +-0x1.ec56cdd4e9d7dp+3 +-0x0p+0 +-0x1.72b1ab445762bp+3 +-0x0p+0 +-0x1.c9757d3a7342p+3 +-0x0p+0 +-0x1.149e0100fb5dcp+4 +-0x0p+0 +-0x1.7113fa433f923p+3 +-0x0p+0 +-0x1.bbe568723887p+3 +-0x0p+0 +-0x1.1b20d89ee4ee6p+4 +-0x0p+0 +-0x1.54f558c51c465p+3 +-0x0p+0 +-0x1.11f11bcf303d5p+4 +-0x0p+0 +-0x1.639e0b58dbbcep+3 +-0x0p+0 +-0x1.b814135f0cd3p+3 +-0x0p+0 +-0x1.9959b7824f21ap+3 +-0x0p+0 +-0x1.2cdb48b48aef7p+4 +-0x0p+0 +-0x1.5a19648e3e93cp+3 +-0x0p+0 +-0x1.9c592626c4d1p+3 +-0x0p+0 +-0x1.ab131fe0267cbp+3 +-0x0p+0 +-0x1.430459c35fca4p+4 +-0x0p+0 +-0x1.11f8ae1d1c0eap+4 +-0x0p+0 +-0x1.9ba68c4c5729cp+3 +-0x0p+0 +-0x1.e42ac4a613002p+3 +-0x0p+0 +-0x1.424d43bf532d1p+4 +-0x0p+0 +-0x1.703efdfc50314p+3 +-0x0p+0 +-0x1.0833ad69238dap+4 +-0x0p+0 +-0x1.508d45f7f8e5ep+3 +-0x0p+0 +-0x1.784181f463792p+3 +-0x0p+0 +-0x1.2aa7fae17386ep+3 +-0x0p+0 +-0x1.e7b315e58d255p+3 +-0x0p+0 +-0x1.2eec263c9c863p+3 +-0x0p+0 +-0x1.83d8a66fc74e9p+3 +-0x0p+0 +-0x1.b826b2bdf53a6p+3 +-0x0p+0 +-0x1.1bf69bb56736ep+3 +-0x0p+0 +-0x1.53d26de4f0045p+3 +-0x0p+0 +-0x1.2e28e00770625p+3 +-0x0p+0 +-0x1.2c3897de4b388p+3 +-0x0p+0 +-0x1.8642b97ea9c09p+3 +-0x0p+0 +-0x1.3be131e0cf854p+3 +-0x0p+0 +-0x1.9fd71a47525cfp+3 +-0x0p+0 +-0x1.379c103cb0966p+3 +-0x0p+0 +-0x1.f646e088bf905p+3 +-0x0p+0 +-0x1.7bb8c87f40bbap+3 +-0x0p+0 +-0x1.8a0705606e9adp+3 +-0x0p+0 +-0x1.097fba5e5f8edp+4 +-0x0p+0 +-0x1.fbe488aeec994p+3 +-0x0p+0 +-0x1.37f0b6eba3504p+3 +-0x0p+0 +-0x1.e0647c11ad76fp+3 +-0x0p+0 +-0x1.0406798be54d6p+3 +-0x0p+0 +-0x1.1fad45402ca76p+3 +-0x0p+0 +-0x1.05a885226ffb1p+3 +-0x0p+0 +-0x1.aafa772bf8481p+3 +-0x0p+0 +-0x1.f4b55404cfc81p+2 +-0x0p+0 +-0x1.3fc9aec03265fp+3 +-0x0p+0 +-0x1.711e20808ab34p+3 +-0x0p+0 +-0x1.c5fb714759b6bp+2 +-0x0p+0 +-0x1.1e7cc817db8a4p+3 +-0x0p+0 +-0x1.561016f4b6767p+3 +-0x0p+0 +-0x1.8a5ad7d9f348ep+2 +-0x0p+0 +-0x1.fc8b8fccc5384p+2 +-0x0p+0 +-0x1.f98ed9c419bbep+2 +-0x0p+0 +-0x1.90f566a9f90b5p+2 +-0x0p+0 +-0x1.ce3f5cde16da7p+2 +-0x0p+0 +-0x1.29aef92b1ce31p+3 +-0x0p+0 +-0x1.d7cbf45eebe3fp+2 +-0x0p+0 +-0x1.ee35b61cb334fp+2 +-0x0p+0 +-0x1.09002054c6bebp+3 +-0x0p+0 +-0x1.33880f8819ea1p+3 +-0x0p+0 +-0x1.2e15e2f3e0ff3p+3 +-0x0p+0 +-0x1.b7d3e51cba737p+3 +-0x0p+0 +-0x1.2d840e03f3569p+3 +-0x0p+0 +-0x1.51376efbf4b61p+3 +-0x0p+0 +-0x1.29c9086edde51p+3 +-0x0p+0 +-0x1.bb471ecc97f4ep+3 +-0x0p+0 +-0x1.50c842bb1a4dfp+3 +-0x0p+0 +-0x1.c8cb7cb9caa0cp+3 +-0x0p+0 +-0x1.9a658dc11f295p+3 +-0x0p+0 +-0x1.90d1c2a813fcp+3 +-0x0p+0 +-0x1.029d583e175ap+4 +-0x0p+0 +-0x1.0bc694cdb57cap+4 +-0x0p+0 +-0x1.64c094cedb994p+4 +-0x0p+0 +-0x1.2c7ac8fa759a4p+4 +-0x0p+0 +-0x1.4a1278d458a46p+3 +-0x0p+0 +-0x1.9642796462426p+3 +-0x0p+0 +-0x1.5a16e96606b26p+3 +-0x0p+0 +-0x1.a9437dafd499cp+3 +-0x0p+0 +-0x1.266906a4b9171p+4 +-0x0p+0 +-0x1.144d123c6f4d1p+4 +-0x0p+0 +-0x1.8b5d8ffcec9bp+3 +-0x0p+0 +-0x1.20b5bc8bbe2c5p+4 +-0x0p+0 +-0x1.4835dcfb7cde3p+4 +-0x0p+0 +-0x1.317596c6c2cf8p+5 +-0x0p+0 +-0x1.6400d09b28d6p+4 +-0x0p+0 +-0x1.02ad2053d1368p+4 +-0x0p+0 +-0x1.3197d9bc2cc26p+4 +-0x0p+0 +-0x1.08eeee2f74607p+4 +-0x0p+0 +-0x1.613ab92ed481dp+4 +-0x0p+0 +-0x1.a1f14b476487dp+3 +-0x0p+0 +-0x1.161b018a900a8p+4 +-0x0p+0 +-0x1.072f6d1537262p+4 +-0x0p+0 +-0x1.647dc5c7e5a03p+4 +-0x0p+0 +-0x1.2aca65dfe2626p+4 +-0x0p+0 +-0x1.8efe7b16d4042p+3 +-0x0p+0 +-0x1.203c66e936f7bp+4 +-0x0p+0 +-0x1.588dc82fec6ffp+3 +-0x0p+0 +-0x1.a9300ef446ef5p+3 +-0x0p+0 +-0x1.2809b79ec31c1p+3 +-0x0p+0 +-0x1.c728a08e534e5p+3 +-0x0p+0 +-0x1.105c4fdf60a5dp+3 +-0x0p+0 +-0x1.538eb333bae81p+3 +-0x0p+0 +-0x1.6989fbff9034bp+3 +-0x0p+0 +-0x1.0ad518cdc2727p+3 +-0x0p+0 +-0x1.681c13a8f285p+3 +-0x0p+0 +-0x1.2d0aca7c06edap+3 +-0x0p+0 +-0x1.6e9bd8791248ep+3 +-0x0p+0 +-0x1.441076ec6cbc5p+3 +-0x0p+0 +-0x1.42e2034cf5522p+3 +-0x0p+0 +-0x1.a8e3233c1c918p+3 +-0x0p+0 +-0x1.66cefd7fd68a7p+3 +-0x0p+0 +-0x1.adecbf5e319cbp+3 +-0x0p+0 +-0x1.6cbd08f0a1171p+3 +-0x0p+0 +-0x1.ffd4235b00abcp+3 +-0x0p+0 +-0x1.a53a720926976p+3 +-0x0p+0 +-0x1.42c55545efc6ap+4 +-0x0p+0 +-0x1.1637628ad8f42p+4 +-0x0p+0 +-0x1.a68ce9da89cfp+3 +-0x0p+0 +-0x1.ec778f34344fep+3 +-0x0p+0 +-0x1.32f879ce1a633p+4 +-0x0p+0 +-0x1.dbc2b4f965e57p+3 +-0x0p+0 +-0x1.69a2258074ae4p+4 +-0x0p+0 +-0x1.2eddcbd0cffdfp+4 +-0x0p+0 +-0x1.022eb8be409a1p+4 +-0x0p+0 +-0x1.3f1beb6f3059ap+4 +-0x0p+0 +-0x1.7b7ac6eb1a9d6p+4 +-0x0p+0 +-0x1.3af48563170d6p+4 +-0x0p+0 +-0x1.38791cb954915p+4 +-0x0p+0 +-0x1.b13eabc35dcfap+3 +-0x0p+0 +-0x1.2c028c07ed1c2p+4 +-0x0p+0 +-0x1.c6f670f4c3118p+3 +-0x0p+0 +-0x1.10dbb8dfdd77bp+4 +-0x0p+0 +-0x1.ac0855a2e06bp+3 +-0x0p+0 +-0x1.e5928f6c902e5p+3 +-0x0p+0 +-0x1.39eeff8b883abp+4 +-0x0p+0 +-0x1.5f5816d48b55fp+4 +-0x0p+0 +-0x1.00e4c159198eep+4 +-0x0p+0 +-0x1.43ade2c69d181p+4 +-0x0p+0 +-0x1.6955b259e135fp+4 +-0x0p+0 +-0x1.5edd11a9b13c9p+4 +-0x0p+0 +-0x1.6f22f75bb73dep+4 +-0x0p+0 +-0x1.9bf7fb4da2c9ap+4 +-0x0p+0 +-0x1.d2a1c583bd901p+3 +-0x0p+0 +-0x1.226c4be7a319ap+4 +-0x0p+0 +-0x1.3adc7796134f6p+4 +-0x0p+0 +-0x1.ae9ec5bf87c78p+3 +-0x0p+0 +-0x1.f65626c47b215p+3 +-0x0p+0 +-0x1.071b82777f518p+4 +-0x0p+0 +-0x1.07d5b351b7af2p+4 +-0x0p+0 +-0x1.8de04856195fap+4 +-0x0p+0 +-0x1.021f37050d39ep+4 +-0x0p+0 +-0x1.70b61152d8b8ap+4 +-0x0p+0 +-0x1.e789e07191805p+3 +-0x0p+0 +-0x1.57f1d38714785p+4 +-0x0p+0 +-0x1.54ad1ac296642p+4 +-0x0p+0 +-0x1.466cfcc4e2788p+4 +-0x0p+0 +-0x1.3292b3d5591fbp+4 +-0x0p+0 +-0x1.e3c3c70a36074p+3 +-0x0p+0 +-0x1.2c5a7846e2a66p+4 +-0x0p+0 +-0x1.4d0e9317ed4c1p+4 +-0x0p+0 +-0x1.5eb81bf4bd215p+4 +-0x0p+0 +-0x1.0e73be067ae23p+4 +-0x0p+0 +-0x1.40974ea6b2333p+4 +-0x0p+0 +-0x1.1442f6e8c0abcp+4 +-0x0p+0 +-0x1.39575930bce9ap+4 +-0x0p+0 +-0x1.655aaab8ab20fp+4 +-0x0p+0 +-0x1.769f1d5a827cp+4 +-0x0p+0 +-0x1.5902b8958ac7fp+4 +-0x0p+0 +-0x1.81b1bed73f1d6p+4 +-0x0p+0 +-0x1.679ce74c29784p+4 +-0x0p+0 +-0x1.90dd7de8fb702p+4 +-0x0p+0 +-0x0p+0 +-0x1.ad54b346ef136p-3 +-0x0p+0 +-0x1.7ac4315deeba3p-3 +-0x0p+0 +-0x1.8a5f97c971b8fp-3 +-0x0p+0 +-0x1.08d752bf2c158p-1 +-0x0p+0 +-0x1.f0fc275e56a9cp-2 +-0x0p+0 +-0x1.019d93841a80dp+0 +-0x0p+0 +-0x1.4652a7207754bp-1 +-0x0p+0 +-0x1.80a59ded25d23p-1 +-0x0p+0 +-0x1.813b596b9d486p+0 +-0x0p+0 +-0x1.3bc840da03b51p-1 +-0x0p+0 +-0x1.285d94231480ap+0 +-0x0p+0 +-0x1.c3f45538bc852p+0 +-0x0p+0 +-0x1.1404d3a15673bp+1 +-0x0p+0 +-0x1.5d8546a3271c9p+0 +-0x0p+0 +-0x1.0227a187e34bep-2 +-0x0p+0 +-0x1.bf152a198c358p-2 +-0x0p+0 +-0x1.0634f5f1fbafdp-1 +-0x0p+0 +-0x1.ac046e58d8c1p-1 +-0x0p+0 +-0x1.8a404d12d94f5p-1 +-0x0p+0 +-0x1.fba57bae8bbe6p-1 +-0x0p+0 +-0x1.1eddbaf760d52p+0 +-0x0p+0 +-0x1.f37613e2c90fp+0 +-0x0p+0 +-0x1.e8a24160f915ep+0 +-0x0p+0 +-0x1.e9ff42c49cf9ep-1 +-0x0p+0 +-0x1.1ae9312f6b961p+0 +-0x0p+0 +-0x1.f43f27ac817ffp-1 +-0x0p+0 +-0x1.ab59c03ae44a5p+0 +-0x0p+0 +-0x1.64230815c07a9p+1 +-0x0p+0 +-0x1.4b726083ff2adp+1 +-0x0p+0 +-0x1.f1214dfa9ccfbp+0 +-0x0p+0 +-0x1.22560df149fecp+1 +-0x0p+0 +-0x1.d4815a666950ep+1 +-0x0p+0 +-0x1.0ce7bcf2e557ap+1 +-0x0p+0 +-0x1.a7599a00128b4p+0 +-0x0p+0 +-0x1.7aa962375fc9fp+1 +-0x0p+0 +-0x1.60d6446303e93p+1 +-0x0p+0 +-0x1.6e7a0f83e4ae3p+0 +-0x0p+0 +-0x1.18c811da7bf2p+1 +-0x0p+0 +-0x1.f2bcf6319b9b2p+0 +-0x0p+0 +-0x1.1dc0ab0edb823p+1 +-0x0p+0 +-0x1.50801a88e93cep+1 +-0x0p+0 +-0x1.f711a09621932p+1 +-0x0p+0 +-0x1.abc030df82a38p+1 +-0x0p+0 +-0x1.18b2d16158c56p+2 +-0x0p+0 +-0x1.6381b118df983p+2 +-0x0p+0 +-0x1.c5220c4d2393p+1 +-0x0p+0 +-0x1.bf22abc9f7eedp+1 +-0x0p+0 +-0x1.63f6a5393a481p+2 +-0x0p+0 +-0x1.2534a96512625p+2 +-0x0p+0 +-0x1.beae977c6017ep+2 +-0x0p+0 +-0x1.5124a9f766739p+2 +-0x0p+0 +-0x1.cf45a7382f2e5p+1 +-0x0p+0 +-0x1.2f24767851ee3p+2 +-0x0p+0 +-0x1.3d9494a8ea5d7p+2 +-0x0p+0 +-0x1.b9747d6247887p+2 +-0x0p+0 +-0x1.6dcda9d31b148p+2 +-0x0p+0 +-0x1.f8110686684ccp+2 +-0x0p+0 +-0x1.0f1996bfe3d0bp+3 +-0x0p+0 +-0x1.6cddcd55cfa44p+3 +-0x0p+0 +-0x1.8c638b581e8ffp+3 +-0x0p+0 +-0x1.44d0dbac357dbp+3 +-0x0p+0 +-0x1.474c8854271b6p+4 +-0x0p+0 +-0x1.99797756f6128p+2 +-0x0p+0 +-0x1.015602aa5506fp+3 +-0x0p+0 +-0x1.fdd12141b3adbp+2 +-0x0p+0 +-0x1.615d6198330eep+3 +-0x0p+0 +-0x1.e5cff383c6508p+2 +-0x0p+0 +-0x1.393eb2e35598bp+3 +-0x0p+0 +-0x1.5c046e525affcp+3 +-0x0p+0 +-0x1.c815b1e6eb1ecp+3 +-0x0p+0 +-0x1.e05099e607dbep+3 +-0x0p+0 +-0x1.ab92023308928p+3 +-0x0p+0 +-0x1.dd4bcce39f016p+4 +-0x0p+0 +-0x1.eca158a2b02b6p+2 +-0x0p+0 +-0x1.64bf696c73f0dp+3 +-0x0p+0 +-0x1.fe2d931fada37p+2 +-0x0p+0 +-0x1.3e1a2a50c671ap+3 +-0x0p+0 +-0x1.01ccaeb66eccfp+3 +-0x0p+0 +-0x1.7e9c77d588ff2p+3 +-0x0p+0 +-0x1.1de6afb9191ddp+3 +-0x0p+0 +-0x1.afec1b7934685p+3 +-0x0p+0 +-0x1.6113c1c51eee9p+3 +-0x0p+0 +-0x1.090dc91bccc53p+3 +-0x0p+0 +-0x1.542bfc8aad12dp+3 +-0x0p+0 +-0x1.dcb8dc866e789p+3 +-0x0p+0 +-0x1.8fea9d79bfae9p+3 +-0x0p+0 +-0x1.44e0bded26974p+4 +-0x0p+0 +-0x1.6edbe8c6369bbp+3 +-0x0p+0 +-0x1.0702c6420541cp+4 +-0x0p+0 +-0x1.351673d62882ep+3 +-0x0p+0 +-0x1.8ec4098eae7b4p+3 +-0x0p+0 +-0x1.12aa0b9298ad4p+3 +-0x0p+0 +-0x1.49655a472d1b2p+3 +-0x0p+0 +-0x1.2b49caf38f1b8p+3 +-0x0p+0 +-0x1.a2e129684a0dfp+3 +-0x0p+0 +-0x1.434b94228569fp+3 +-0x0p+0 +-0x1.7e711d4591ef5p+3 +-0x0p+0 +-0x1.536f6ed21b7c5p+3 +-0x0p+0 +-0x1.058cd2b30ace4p+4 +-0x0p+0 +-0x1.87dd0caab52b8p+3 +-0x0p+0 +-0x1.200db24a34038p+4 +-0x0p+0 +-0x1.28cb0f005a7c1p+4 +-0x0p+0 +-0x1.d03f432ee108bp+3 +-0x0p+0 +-0x1.f08cf14aa2a42p+3 +-0x0p+0 +-0x1.2def9342696dp+4 +-0x0p+0 +-0x1.3bc5451500fa8p+4 +-0x0p+0 +-0x1.85b41eb7e978dp+3 +-0x0p+0 +-0x1.1841081b8be27p+4 +-0x0p+0 +-0x1.8e6d587404ec3p+3 +-0x0p+0 +-0x1.cfb30791a1dcp+3 +-0x0p+0 +-0x1.a30d7149dbb81p+3 +-0x0p+0 +-0x1.5834088f83ce7p+4 +-0x0p+0 +-0x1.d18f02c4671a9p+3 +-0x0p+0 +-0x1.0662b1da30506p+4 +-0x0p+0 +-0x1.5d789197db7f7p+4 +-0x0p+0 +-0x1.13ab4e28c9812p+4 +-0x0p+0 +-0x1.a56085e6e2554p+4 +-0x0p+0 +-0x1.5dafd449a13a4p+4 +-0x0p+0 +-0x1.207d148ff97cp+4 +-0x0p+0 +-0x1.3b85a529e8bb8p+4 +-0x0p+0 +-0x1.7a1d2420e6592p+4 +-0x0p+0 +-0x1.ace4d7df8d404p+3 +-0x0p+0 +-0x1.3948b2705265p+4 +-0x0p+0 +-0x1.82998cc88f717p+3 +-0x0p+0 +-0x1.b403991840888p+3 +-0x0p+0 +-0x1.6e49696378013p+3 +-0x0p+0 +-0x1.1f00a57404654p+4 +-0x0p+0 +-0x1.60b656745a042p+3 +-0x0p+0 +-0x1.bcd8c850807afp+3 +-0x0p+0 +-0x1.d005dc08236b4p+3 +-0x0p+0 +-0x1.7a8233f080f46p+3 +-0x0p+0 +-0x1.175dd84c5c0f3p+4 +-0x0p+0 +-0x1.12322b0c04951p+4 +-0x0p+0 +-0x1.4894622e12d36p+3 +-0x0p+0 +-0x1.a5d1e2edddf15p+3 +-0x0p+0 +-0x1.9f8ae988a4d76p+3 +-0x0p+0 +-0x1.6863a129f153cp+3 +-0x0p+0 +-0x1.038f64b1b52b9p+4 +-0x0p+0 +-0x1.086597fa8a766p+4 +-0x0p+0 +-0x1.699a88048b7cp+3 +-0x0p+0 +-0x1.728eb49fe2953p+3 +-0x0p+0 +-0x1.a32e7002406d3p+3 +-0x0p+0 +-0x1.8ea411d8aa3fp+3 +-0x0p+0 +-0x1.a79ab570f812bp+3 +-0x0p+0 +-0x1.2081f2d59bcbep+4 +-0x0p+0 +-0x1.b10d11316ba5ep+3 +-0x0p+0 +-0x1.da170c1df343dp+3 +-0x0p+0 +-0x1.23abdeacaaaap+4 +-0x0p+0 +-0x1.01436ce246496p+4 +-0x0p+0 +-0x1.6ad6e5c708353p+4 +-0x0p+0 +-0x1.1bed13b9e12bcp+4 +-0x0p+0 +-0x1.077709ef58378p+4 +-0x0p+0 +-0x1.308e68864b61bp+4 +-0x0p+0 +-0x1.3af82b5e6cfa1p+4 +-0x0p+0 +-0x1.faa8dafad3be3p+3 +-0x0p+0 +-0x1.5e3457ecca5dcp+4 +-0x0p+0 +-0x1.4d890eaa792abp+4 +-0x0p+0 +-0x1.bd4aa84ee76c8p+4 +-0x0p+0 +-0x1.232159df4e1b9p+4 +-0x0p+0 +-0x1.7d37fd463859fp+4 +-0x0p+0 +-0x1.50d1910e7666bp+4 +-0x0p+0 +-0x1.59271b5d338bep+4 +-0x0p+0 +-0x1.a402c59ff27b5p+4 +-0x0p+0 +-0x1.7a3c5613c010dp+4 +-0x0p+0 +-0x1.62b4ed61bc4f2p+4 +-0x0p+0 +-0x1.942f5ea48810ap+4 +-0x0p+0 +-0x1.84278996cc377p+3 +-0x0p+0 +-0x1.3b4d65ad7b772p+4 +-0x0p+0 +-0x1.f4a0203aacbc8p+3 +-0x0p+0 +-0x1.20bec90c36175p+4 +-0x0p+0 +-0x1.2eb41dc39525dp+4 +-0x0p+0 +-0x1.83722fb59b3c7p+3 +-0x0p+0 +-0x1.09ac4fdde8214p+4 +-0x0p+0 +-0x1.f8e31060edae7p+3 +-0x0p+0 +-0x1.999052b0af941p+3 +-0x0p+0 +-0x1.dfd18efee19fp+3 +-0x0p+0 +-0x1.e1651efee1284p+3 +-0x0p+0 +-0x1.08ba2804a615dp+4 +-0x0p+0 +-0x1.d44e178a919f3p+3 +-0x0p+0 +-0x1.23c88335464eep+4 +-0x0p+0 +-0x1.902fcd869b9d2p+3 +-0x0p+0 +-0x1.8e363fb71b9ecp+3 +-0x0p+0 +-0x1.e4b1d894a9ddfp+3 +-0x0p+0 +-0x1.a36c9faa236acp+3 +-0x0p+0 +-0x1.2003faa313bc8p+4 +-0x0p+0 +-0x1.44dcb10e4d714p+3 +-0x0p+0 +-0x1.95e7fd52dc2fdp+3 +-0x0p+0 +-0x1.5b94cc64684c5p+3 +-0x0p+0 +-0x1.068d1d5c1d6f6p+4 +-0x0p+0 +-0x1.b2819936f6a3p+3 +-0x0p+0 +-0x1.32a990cba160cp+3 +-0x0p+0 +-0x1.241ed5093602cp+3 +-0x0p+0 +-0x1.6cb9aa50e0e09p+3 +-0x0p+0 +-0x1.2b762cc55db7cp+3 +-0x0p+0 +-0x1.7bb6df66fc7a2p+3 +-0x0p+0 +-0x1.53a632ae41f9ap+3 +-0x0p+0 +-0x1.d3fe1252eceep+3 +-0x0p+0 +-0x1.84a8542a09b56p+3 +-0x0p+0 +-0x1.2d031266ce97cp+4 +-0x0p+0 +-0x1.821a9f6079b87p+3 +-0x0p+0 +-0x1.32b8cd5e36ce7p+4 +-0x0p+0 +-0x1.7ad0b11849888p+3 +-0x0p+0 +-0x1.1663250e6ea9fp+4 +-0x0p+0 +-0x1.755f46b0971d6p+3 +-0x0p+0 +-0x1.aad49c1840ea1p+3 +-0x0p+0 +-0x1.59ad9ee341ec5p+3 +-0x0p+0 +-0x1.f74903cbf560dp+3 +-0x0p+0 +-0x1.90d59193f4daep+3 +-0x0p+0 +-0x1.276a0c90a4dcep+4 +-0x0p+0 +-0x1.193383f9cc709p+4 +-0x0p+0 +-0x1.53fe206b1ff0bp+3 +-0x0p+0 +-0x1.71da1c2f3ae8ap+3 +-0x0p+0 +-0x1.07d011975459fp+4 +-0x0p+0 +-0x1.700e908fe68ccp+3 +-0x0p+0 +-0x1.02e4f6b09b4eap+4 +-0x0p+0 +-0x1.64a9f2e5d9d21p+3 +-0x0p+0 +-0x1.c387699b0a404p+3 +-0x0p+0 +-0x1.7ad3148e65fbfp+4 +-0x0p+0 +-0x1.87389b05e08d9p+3 +-0x0p+0 +-0x1.22eaa7d542ecp+4 +-0x0p+0 +-0x1.8acc3d640160cp+3 +-0x0p+0 +-0x1.2daf889421126p+4 +-0x0p+0 +-0x1.528c16e44ccdep+3 +-0x0p+0 +-0x1.717d768747c37p+3 +-0x0p+0 +-0x1.8fb8e320d2ad5p+3 +-0x0p+0 +-0x1.0ba8d2c8e62ep+4 +-0x0p+0 +-0x1.804340549375bp+3 +-0x0p+0 +-0x1.9558f15774addp+3 +-0x0p+0 +-0x1.19d1ddd9c7923p+4 +-0x0p+0 +-0x1.8ff11ed508563p+3 +-0x0p+0 +-0x1.1f0ded156a3f5p+4 +-0x0p+0 +-0x1.8ea218591e70cp+3 +-0x0p+0 +-0x1.d16d46afa53a5p+3 +-0x0p+0 +-0x1.91f9f0bd760a7p+3 +-0x0p+0 +-0x1.34a0a4a39aac6p+4 +-0x0p+0 +-0x1.eecb464fe0f41p+3 +-0x0p+0 +-0x1.2e4dfc4d8ea05p+4 +-0x0p+0 +-0x1.30f67465b5ca6p+4 +-0x0p+0 +-0x1.36e173e5bf49ep+4 +-0x0p+0 +-0x1.17a418adcaa87p+5 +-0x0p+0 +-0x1.a99d30f09116bp+3 +-0x0p+0 +-0x1.01ca2b30af573p+4 +-0x0p+0 +-0x1.e7a5e8b30e0e6p+3 +-0x0p+0 +-0x1.647ae051e0e4bp+4 +-0x0p+0 +-0x1.b44a3817b2249p+3 +-0x0p+0 +-0x1.22777f1d6a3d1p+4 +-0x0p+0 +-0x1.f192426a6d405p+3 +-0x0p+0 +-0x1.6405191d7836p+4 +-0x0p+0 +-0x1.f57b2ebb9adb1p+3 +-0x0p+0 +-0x1.156c31c06bcabp+4 +-0x0p+0 +-0x1.7f45bc41055dbp+4 +-0x0p+0 +-0x1.f176ebc4201b2p+3 +-0x0p+0 +-0x1.1937c448efe4cp+4 +-0x0p+0 +-0x1.3a1b1a37997bp+4 +-0x0p+0 +-0x1.7d2913be827d5p+4 +-0x0p+0 +-0x1.714358e66455bp+4 +-0x0p+0 +-0x1.02df54f590cd9p+4 +-0x0p+0 +-0x1.659ddc2366dd8p+4 +-0x0p+0 +-0x1.6e981618982e9p+4 +-0x0p+0 +-0x1.84a41e7fc33a7p+4 +-0x0p+0 +-0x1.46613d0d98d07p+4 +-0x0p+0 +-0x1.c2894cdb02da9p+3 +-0x0p+0 +-0x1.34ee7755672b3p+4 +-0x0p+0 +-0x1.fb05daa4adbf7p+3 +-0x0p+0 +-0x1.497aefc64ddb2p+4 +-0x0p+0 +-0x1.7bcd7d0214579p+4 +-0x0p+0 +-0x1.0b246aae0e602p+4 +-0x0p+0 +-0x1.7835d69c97c7p+4 +-0x0p+0 +-0x1.3b6273cdef52fp+4 +-0x0p+0 +-0x1.2c72981b17ad4p+4 +-0x0p+0 +-0x1.57a25dd6fdbe4p+4 +-0x0p+0 +-0x1.8e6a363f7c7fp+4 +-0x0p+0 +-0x1.5922fd8fba3c7p+4 +-0x0p+0 +-0x1.f493b73f3d85p+3 +-0x0p+0 +-0x1.4ce098ecafa29p+4 +-0x0p+0 +-0x1.d1afb08ea5f97p+3 +-0x0p+0 +-0x1.52dbaaa4de445p+4 +-0x0p+0 +-0x1.fd629ae4ae912p+3 +-0x0p+0 +-0x1.d9b5a5978dec6p+3 +-0x0p+0 +-0x1.d20ab22690367p+3 +-0x0p+0 +-0x1.2777a5cfe2e18p+4 +-0x0p+0 +-0x1.056c150dc483cp+4 +-0x0p+0 +-0x1.fdf0f760e10b2p+3 +-0x0p+0 +-0x1.cb77818ef2a51p+3 +-0x0p+0 +-0x1.0979ab05fd6fbp+4 +-0x0p+0 +-0x1.f5d313a4d4f0ap+3 +-0x0p+0 +-0x1.4d2a5534011fp+4 +-0x0p+0 +-0x1.91a49e9a422a6p+3 +-0x0p+0 +-0x1.f827debaf9d41p+3 +-0x0p+0 +-0x1.0b5675be89e5cp+4 +-0x0p+0 +-0x1.48664f83f1c36p+4 +-0x0p+0 +-0x1.46205e10393c1p+4 +-0x0p+0 +-0x1.46cfefe53432fp+5 +-0x0p+0 +-0x1.7d463e72f754p+3 +-0x0p+0 +-0x1.fc940d9c47094p+3 +-0x0p+0 +-0x1.69a5853e0417fp+3 +-0x0p+0 +-0x1.d44dea75aded2p+3 +-0x0p+0 +-0x1.152f62c83106cp+3 +-0x0p+0 +-0x1.853db134f3234p+3 +-0x0p+0 +-0x1.418509c660fdcp+3 +-0x0p+0 +-0x1.9f921bf7c4e68p+3 +-0x0p+0 +-0x1.530c8a40adb17p+3 +-0x0p+0 +-0x1.bc60d0adb09dep+3 +-0x0p+0 +-0x1.0115d746afffbp+3 +-0x0p+0 +-0x1.51d54d4a5c187p+3 +-0x0p+0 +-0x1.d9f8c2b0a7addp+2 +-0x0p+0 +-0x1.37da0abf0fd0bp+3 +-0x0p+0 +-0x1.62d8f80ce32b3p+2 +-0x0p+0 +-0x1.13d3dcfe03937p+3 +-0x0p+0 +-0x1.870698952ae8fp+2 +-0x0p+0 +-0x1.33de521776ea1p+3 +-0x0p+0 +-0x1.bf49a30fc3fp+2 +-0x0p+0 +-0x1.8a335c10722abp+2 +-0x0p+0 +-0x1.81fe9a082c2d1p+2 +-0x0p+0 +-0x1.0a4662807978cp+3 +-0x0p+0 +-0x1.2afc8f069d1bcp+2 +-0x0p+0 +-0x1.4d48935f945eep+2 +-0x0p+0 +-0x1.20558b365636ap+2 +-0x0p+0 +-0x1.99d681343ed9fp+2 +-0x0p+0 +-0x1.0cd554e816d0ap+3 +-0x0p+0 +-0x1.3b02fb5b3c833p+3 +-0x0p+0 +-0x1.bd5dba2ceda5ap+2 +-0x0p+0 +-0x1.03b5a495867ebp+3 +-0x0p+0 +-0x1.8276db4e8ca8fp+3 +-0x0p+0 +-0x1.aeb98d812c306p+2 +-0x0p+0 +-0x1.30d6b81c44accp+3 +-0x0p+0 +-0x1.552e6864573d7p+3 +-0x0p+0 +-0x1.2eb8368530d2fp+2 +-0x0p+0 +-0x1.ea9039b87ab98p+2 +-0x0p+0 +-0x1.07fa68a1cac8ap+2 +-0x0p+0 +-0x1.5ce466e10d685p+2 +-0x0p+0 +-0x1.ddfa3bcf20513p+1 +-0x0p+0 +-0x1.3df9c77b444e9p+2 +-0x0p+0 +-0x1.6b3f15c83f3e1p+1 +-0x0p+0 +-0x1.1feae10bb1264p+2 +-0x0p+0 +-0x1.9e5592c779c11p+1 +-0x0p+0 +-0x1.31eff2377fa34p+2 +-0x0p+0 +-0x1.1d8e30c4267c6p+2 +-0x0p+0 +-0x1.9324b46d1a679p+1 +-0x0p+0 +-0x1.8e31974e152a1p+1 +-0x0p+0 +-0x1.296c6042f8c7fp+2 +-0x0p+0 +-0x1.003111b1fec1ep+2 +-0x0p+0 +-0x1.4518ea5b1059cp+2 +-0x0p+0 +-0x1.6b787576a2c9p+2 +-0x0p+0 +-0x1.1768938a2d0e6p+1 +-0x0p+0 +-0x1.0df3bdfd33c0cp+1 +-0x0p+0 +-0x1.290a910e0620cp+1 +-0x0p+0 +-0x1.bf362fff512a5p+1 +-0x0p+0 +-0x1.b5356bdf49cdp+0 +-0x0p+0 +-0x1.c363faaad8e74p+0 +-0x0p+0 +-0x1.0cd37d4749b97p+1 +-0x0p+0 +-0x1.4cb756fc43b1dp+1 +-0x0p+0 +-0x1.5036eab0187e1p+1 +-0x0p+0 +-0x1.938ab55754c43p+1 +-0x0p+0 +-0x1.00f8929f0e04p+2 +-0x0p+0 +-0x1.27d5b7f516a1p+2 +-0x0p+0 +-0x1.0c2b5115cf443p+2 +-0x0p+0 +-0x1.270b53905157p+2 +-0x0p+0 +-0x1.a6151999a6754p+2 +-0x0p+0 +-0x1.0921a3c1671fbp+1 +-0x0p+0 +-0x1.3eaa52aa9cdf5p+1 +-0x0p+0 +-0x1.64c64900aaf0ep+1 +-0x0p+0 +-0x1.e9d77d2788e87p+1 +-0x0p+0 +-0x1.8ea0de358eb6ap+1 +-0x0p+0 +-0x1.093c9388d2179p+2 +-0x0p+0 +-0x1.23e01ddb3cap+2 +-0x0p+0 +-0x1.a6af143a861bp+2 +-0x0p+0 +-0x1.c21ba5a01f13cp+2 +-0x0p+0 +-0x1.1a8f494d2fddep+2 +-0x0p+0 +-0x1.533d6c30c7f7ap+2 +-0x0p+0 +-0x1.eb30a34d6db52p+2 +-0x0p+0 +-0x1.88673d9a2ca85p+2 +-0x0p+0 +-0x1.2da311f326d6ap+3 +-0x0p+0 +-0x1.9b615d2a9339ap+2 +-0x0p+0 +-0x1.3528e3a770b3dp+3 +-0x0p+0 +-0x1.164d6d326989ap+4 +-0x0p+0 +-0x1.7f77b49e1213dp+2 +-0x0p+0 +-0x1.1cb2843444093p+3 +-0x0p+0 +-0x1.49b3a697df0a8p+2 +-0x0p+0 +-0x1.bc92c0bb9d60ap+2 +-0x0p+0 +-0x1.d43d1c9d831f8p+1 +-0x0p+0 +-0x1.37bc57d3a641cp+2 +-0x0p+0 +-0x1.254db8e96dc7ap+2 +-0x0p+0 +-0x1.a03ea1bddc33ep+2 +-0x0p+0 +-0x1.2942134845cf9p+2 +-0x0p+0 +-0x1.8b4e904858eb3p+2 +-0x0p+0 +-0x1.6fa67c3d3d384p+2 +-0x0p+0 +-0x1.ab99aca19055fp+2 +-0x0p+0 +-0x1.0f77742d98dedp+3 +-0x0p+0 +-0x1.d1b82395fd9cbp+2 +-0x0p+0 +-0x1.1f9e736212b84p+3 +-0x0p+0 +-0x1.446f4f56e6572p+3 +-0x0p+0 +-0x1.6feaf25ba5f55p+2 +-0x0p+0 +-0x1.08e2a770123e4p+3 +-0x0p+0 +-0x1.9e24078823155p+2 +-0x0p+0 +-0x1.0bf4b2b861c8ep+3 +-0x0p+0 +-0x1.acbf69235d69cp+2 +-0x0p+0 +-0x1.31cb169b5d4f3p+3 +-0x0p+0 +-0x1.ef9e05d7991eep+2 +-0x0p+0 +-0x1.4b47386fbb8fap+3 +-0x0p+0 +-0x1.8daf38fd832c7p+3 +-0x0p+0 +-0x1.d92557d116799p+2 +-0x0p+0 +-0x1.6d82e674f464fp+3 +-0x0p+0 +-0x1.50e9ec2217ccep+3 +-0x0p+0 +-0x1.979bdbce9ef3cp+3 +-0x0p+0 +-0x1.ca1bbced6198p+3 +-0x0p+0 +-0x1.cbb28e2f38f36p+3 +-0x0p+0 +-0x1.f067ad438a4bap+2 +-0x0p+0 +-0x1.1f31122072cf2p+3 +-0x0p+0 +-0x1.4d9eb914a1688p+3 +-0x0p+0 +-0x1.276be2f676acp+3 +-0x0p+0 +-0x1.0bb68375dde7fp+3 +-0x0p+0 +-0x1.8a935b8b4abf7p+3 +-0x0p+0 +-0x1.19d1dcd4e08c9p+3 +-0x0p+0 +-0x1.47af2e18fabb3p+3 +-0x0p+0 +-0x1.4515736d45c68p+3 +-0x0p+0 +-0x1.fba87acd09c61p+3 +-0x0p+0 +-0x1.a13b214c39185p+3 +-0x0p+0 +-0x1.d4e215e55d5edp+3 +-0x0p+0 +-0x1.361e955756392p+4 +-0x0p+0 +-0x1.fb32d75af0be1p+3 +-0x0p+0 +-0x1.611841546ed12p+3 +-0x0p+0 +-0x1.168cd98a39fadp+4 +-0x0p+0 +-0x1.4510fa9c51f26p+3 +-0x0p+0 +-0x1.5b24a93cff061p+3 +-0x0p+0 +-0x1.4f9956dcf28dap+3 +-0x0p+0 +-0x1.187be3f010cdbp+4 +-0x0p+0 +-0x1.534a2dc968af8p+3 +-0x0p+0 +-0x1.8bc3c3ffb58f7p+3 +-0x0p+0 +-0x1.e550ca57249b3p+3 +-0x0p+0 +-0x1.64a33a993badp+3 +-0x0p+0 +-0x1.f31d534362b39p+3 +-0x0p+0 +-0x1.7070adcebd7a2p+3 +-0x0p+0 +-0x1.72638788c3e27p+3 +-0x0p+0 +-0x1.01bdebee4ec68p+4 +-0x0p+0 +-0x1.7a37604005407p+3 +-0x0p+0 +-0x1.aff3474dd5e06p+3 +-0x0p+0 +-0x1.84ca6fdd4bfb7p+3 +-0x0p+0 +-0x1.1d456d46e347bp+4 +-0x0p+0 +-0x1.a9270ea3d6871p+3 +-0x0p+0 +-0x1.2940343f24c0ap+4 +-0x0p+0 +-0x1.59d8374a87022p+4 +-0x0p+0 +-0x1.715ff33d932a5p+3 +-0x0p+0 +-0x1.c101b7f8acb59p+3 +-0x0p+0 +-0x1.ff5c956b902bep+3 +-0x0p+0 +-0x1.7a0e2850458acp+4 +-0x0p+0 +-0x1.2794e0bfb7984p+4 +-0x0p+0 +-0x1.47e603587e509p+4 +-0x0p+0 +-0x1.e3e78c11ca12bp+3 +-0x0p+0 +-0x1.1ad43436d8befp+4 +-0x0p+0 +-0x1.266f881bd5ba8p+4 +-0x0p+0 +-0x1.65dfe7555797ep+4 +-0x0p+0 +-0x1.cb12b65cd443ep+3 +-0x0p+0 +-0x1.01a3353aeadfdp+4 +-0x0p+0 +-0x1.3bbd12d7f7be2p+4 +-0x0p+0 +-0x1.3f1605b79a723p+4 +-0x0p+0 +-0x1.4c1ee5e73a939p+4 +-0x0p+0 +-0x1.5ff6b75a0afbep+4 +-0x0p+0 +-0x1.a5078bf534d94p+4 +-0x0p+0 +-0x1.68f6fc36d2053p+5 +-0x0p+0 +-0x1.429c289ff64f9p+4 +-0x0p+0 +-0x1.59dbf7039be35p+4 +-0x0p+0 +-0x1.eb60ef2a67becp+3 +-0x0p+0 +-0x1.5361c0e570b7p+4 +-0x0p+0 +-0x1.df3032e2eb32ap+3 +-0x0p+0 +-0x1.3337cf7dc0f43p+4 +-0x0p+0 +-0x1.066937735376ep+4 +-0x0p+0 +-0x1.614af6b21dd64p+4 +-0x0p+0 +-0x1.cb649db0bd55bp+3 +-0x0p+0 +-0x1.e9a200bba69dfp+3 +-0x0p+0 +-0x1.32c4732e07103p+4 +-0x0p+0 +-0x1.0373639583a69p+4 +-0x0p+0 +-0x1.2bcfe0d683dfbp+4 +-0x0p+0 +-0x1.d2aeb230b0fa7p+3 +-0x0p+0 +-0x1.09b9b426cdc4dp+4 +-0x0p+0 +-0x1.774c387976026p+4 +-0x0p+0 +-0x1.8d819166c1debp+4 +-0x0p+0 +-0x1.ba2d7527c3d49p+3 +-0x0p+0 +-0x1.1de7e97d123e6p+4 +-0x0p+0 +-0x1.1a25cc3dc17d9p+4 +-0x0p+0 +-0x1.a282b0fe097bcp+3 +-0x0p+0 +-0x1.0620e2ef2ab79p+4 +-0x0p+0 +-0x1.1d5ca28857f7ep+4 +-0x0p+0 +-0x1.a3fd4e4a18707p+3 +-0x0p+0 +-0x1.4d278625e5581p+4 +-0x0p+0 +-0x1.bd282d5dc0528p+3 +-0x0p+0 +-0x1.4359fe352cb34p+4 +-0x0p+0 +-0x1.b010c421297d6p+3 +-0x0p+0 +-0x1.23b04eac05561p+4 +-0x0p+0 +-0x1.65976cf69e0dfp+3 +-0x0p+0 +-0x1.26ae47c9e1965p+4 +-0x0p+0 +-0x1.749b509739ac4p+3 +-0x0p+0 +-0x1.edf38a037ad91p+3 +-0x0p+0 +-0x1.f7fe68f077ef4p+3 +-0x0p+0 +-0x1.50b19822cbca6p+4 +-0x0p+0 +-0x1.416ccebda58c9p+4 +-0x0p+0 +-0x1.366ea1544e6a1p+4 +-0x0p+0 +-0x1.c5e739ed8d42bp+3 +-0x0p+0 +-0x1.c1f2c67842c0dp+4 +-0x0p+0 +-0x1.452d3dc985dbbp+3 +-0x0p+0 +-0x1.6ea1cce7ac40cp+3 +-0x0p+0 +-0x1.5cb4363c3d82ap+3 +-0x0p+0 +-0x1.ea219f7fc7173p+3 +-0x0p+0 +-0x1.0f208ec925294p+3 +-0x0p+0 +-0x1.9a5ab461a6531p+3 +-0x0p+0 +-0x1.3f3badab600fdp+3 +-0x0p+0 +-0x1.b150c995e504p+3 +-0x0p+0 +-0x1.874327c3cc909p+3 +-0x0p+0 +-0x1.9159f91f47328p+3 +-0x0p+0 +-0x1.046f90212052cp+4 +-0x0p+0 +-0x1.0448964a738dep+4 +-0x0p+0 +-0x1.ca357d3087ce2p+2 +-0x0p+0 +-0x1.12a05316e7ee2p+3 +-0x0p+0 +-0x1.d9ed3a6afeb64p+2 +-0x0p+0 +-0x1.68caa292ed32bp+3 +-0x0p+0 +-0x1.655951abd0a39p+2 +-0x0p+0 +-0x1.b6a3267b2d91p+2 +-0x0p+0 +-0x1.ad1c3fa3f3372p+2 +-0x0p+0 +-0x1.de7db46c7db6fp+2 +-0x0p+0 +-0x1.4d93f9401649cp+3 +-0x0p+0 +-0x1.f846fc5a23e2ep+2 +-0x0p+0 +-0x1.6a1c0701ba006p+3 +-0x0p+0 +-0x1.1ece40f51c4c5p+3 +-0x0p+0 +-0x1.5f1376327c775p+3 +-0x0p+0 +-0x1.0dfc8e9b12ff4p+3 +-0x0p+0 +-0x1.6c858b25305aep+2 +-0x0p+0 +-0x1.a8b6485b9724fp+2 +-0x0p+0 +-0x1.bcd85ce8fb8abp+2 +-0x0p+0 +-0x1.354fa9bd292efp+3 +-0x0p+0 +-0x1.d04ba0e18b7f3p+2 +-0x0p+0 +-0x1.388f8f4e2334ep+3 +-0x0p+0 +-0x1.5a441f35f3064p+3 +-0x0p+0 +-0x1.da24523395e43p+3 +-0x0p+0 +-0x1.ce16101bafdffp+3 +-0x0p+0 +-0x1.b25a72b992036p+3 +-0x0p+0 +-0x1.ee30a0ac1cf8ap+2 +-0x0p+0 +-0x1.4ffb1fb9c9462p+3 +-0x0p+0 +-0x1.ea95e8b24ce2ep+2 +-0x0p+0 +-0x1.1495ab0ba05efp+3 +-0x0p+0 +-0x1.c812d31f72aecp+2 +-0x0p+0 +-0x1.773769888d5d1p+3 +-0x0p+0 +-0x1.02a0df0ef10d2p+3 +-0x0p+0 +-0x1.7af0036b49d5cp+3 +-0x0p+0 +-0x1.3094807fe1ddfp+3 +-0x0p+0 +-0x1.38f10da0e3b3ep+3 +-0x0p+0 +-0x1.bb665a5f6635dp+3 +-0x0p+0 +-0x1.77d2ef84a438dp+3 +-0x0p+0 +-0x1.830a56a243311p+3 +-0x0p+0 +-0x1.18abb61c6e6a5p+4 +-0x0p+0 +-0x1.e30d452df2a22p+3 +-0x0p+0 +-0x1.53217b3e8d345p+4 +-0x0p+0 +-0x1.dbed98f40f536p+3 +-0x0p+0 +-0x1.b7f3358dc0a96p+2 +-0x0p+0 +-0x1.36845f5ddc0b4p+3 +-0x0p+0 +-0x1.9c04ec631b329p+2 +-0x0p+0 +-0x1.ffe8b6ba13e79p+2 +-0x0p+0 +-0x1.6c3d1ee9afc44p+2 +-0x0p+0 +-0x1.1f32e74f1d81dp+3 +-0x0p+0 +-0x1.4db5760c5bd7ap+2 +-0x0p+0 +-0x1.93a389a5caea1p+2 +-0x0p+0 +-0x1.c8253cb8597dfp+2 +-0x0p+0 +-0x1.4f73ce59911b3p+2 +-0x0p+0 +-0x1.e78edd63fba2ep+2 +-0x0p+0 +-0x1.3ee6d6330fd1p+2 +-0x0p+0 +-0x1.a5c4f2b0edabdp+2 +-0x0p+0 +-0x1.2ccc902224c0fp+3 +-0x0p+0 +-0x1.bec2e3e993296p+2 +-0x0p+0 +-0x1.1b62aa4418df6p+3 +-0x0p+0 +-0x1.c217d52302d02p+2 +-0x0p+0 +-0x1.490d13a2e7d9bp+3 +-0x0p+0 +-0x1.096f527589edep+3 +-0x0p+0 +-0x1.59ded6924f5bbp+3 +-0x0p+0 +-0x1.66decbed1ba71p+3 +-0x0p+0 +-0x1.21d8f016da0d1p+3 +-0x0p+0 +-0x1.3eb49736bb117p+3 +-0x0p+0 +-0x1.92ca5dd087a4ep+3 +-0x0p+0 +-0x1.806cfb9c7e19fp+3 +-0x0p+0 +-0x1.0b04dc454276ap+4 +-0x0p+0 +-0x1.bcaff76c81844p+3 +-0x0p+0 +-0x1.665feb0b1718p+4 +-0x0p+0 +-0x1.bb5293ccc3956p+3 +-0x0p+0 +-0x1.53eff36640822p+4 +-0x0p+0 +-0x1.7ccc04c4d4d29p+3 +-0x0p+0 +-0x1.095dfa155e2a5p+4 +-0x0p+0 +-0x1.0c6da89fb745ep+3 +-0x0p+0 +-0x1.6499015938323p+3 +-0x0p+0 +-0x1.30ab72e95f894p+3 +-0x0p+0 +-0x1.5d16597b9c12dp+3 +-0x0p+0 +-0x1.4a390115422d9p+3 +-0x0p+0 +-0x1.14d8ca1e5e2bp+4 +-0x0p+0 +-0x1.797e2a514a756p+3 +-0x0p+0 +-0x1.09a94d3a7e1ebp+4 +-0x0p+0 +-0x1.b1025e6908bd8p+3 +-0x0p+0 +-0x1.b4f47e0d22429p+3 +-0x0p+0 +-0x1.120da32214c6cp+4 +-0x0p+0 +-0x1.6279b4e46b2e4p+4 +-0x0p+0 +-0x1.5ac54d8e4f108p+4 +-0x0p+0 +-0x1.1050264b50f2p+4 +-0x0p+0 +-0x1.5ada48c7f5152p+4 +-0x0p+0 +-0x1.5b6e20c851ff7p+3 +-0x0p+0 +-0x1.ee383194ff594p+3 +-0x0p+0 +-0x1.58547d232ae37p+3 +-0x0p+0 +-0x1.8ce10feddb107p+3 +-0x0p+0 +-0x1.62145cbca97f8p+3 +-0x0p+0 +-0x1.1e7daae6db43fp+4 +-0x0p+0 +-0x1.9118dfb9266f1p+3 +-0x0p+0 +-0x1.c8928c85aa86fp+3 +-0x0p+0 +-0x1.2b81e23fadb4fp+4 +-0x0p+0 +-0x1.c686b9b3557a5p+3 +-0x0p+0 +-0x1.401a85424cbe8p+4 +-0x0p+0 +-0x1.f69009ec39147p+3 +-0x0p+0 +-0x1.7a161f186db48p+3 +-0x0p+0 +-0x1.1f65717b119b8p+4 +-0x0p+0 +-0x1.5735f4c08d8ecp+3 +-0x0p+0 +-0x1.8194ea8de61a6p+3 +-0x0p+0 +-0x1.4a68935c5fddp+3 +-0x0p+0 +-0x1.0b726ed4ea47p+4 +-0x0p+0 +-0x1.41f6608a3e054p+3 +-0x0p+0 +-0x1.ab2b35949f2cap+3 +-0x0p+0 +-0x1.8339b6c36f99bp+3 +-0x0p+0 +-0x1.451bc490856b9p+3 +-0x0p+0 +-0x1.9b8513e368e85p+3 +-0x0p+0 +-0x1.23b954285842p+4 +-0x0p+0 +-0x1.d70cc68c23724p+3 +-0x0p+0 +-0x1.521a1ea18449cp+4 +-0x0p+0 +-0x1.7dca710d3ca0ep+3 +-0x0p+0 +-0x1.bfa8764a6c899p+3 +-0x0p+0 +-0x1.3f927f547646ep+4 +-0x0p+0 +-0x1.d819ad1258e31p+3 +-0x0p+0 +-0x1.6c0e18e12a566p+4 +-0x0p+0 +-0x1.9ee8ba8825ac7p+3 +-0x0p+0 +-0x1.1b461e55336a4p+4 +-0x0p+0 +-0x1.7109ea5396d36p+3 +-0x0p+0 +-0x1.cc0094d461e71p+3 +-0x0p+0 +-0x1.53aa0c7a18b94p+3 +-0x0p+0 +-0x1.6d2659c804e0dp+3 +-0x0p+0 +-0x1.118f355dd2217p+4 +-0x0p+0 +-0x1.5ead08c9819f3p+3 +-0x0p+0 +-0x1.83ee1f4b155e1p+3 +-0x0p+0 +-0x1.72473fca1a6ffp+3 +-0x0p+0 +-0x1.1173541a2b9b3p+4 +-0x0p+0 +-0x1.8ebcc75ce23f5p+3 +-0x0p+0 +-0x1.da923527d145ap+3 +-0x0p+0 +-0x1.259f323c88596p+4 +-0x0p+0 +-0x1.b88ac0e424dd8p+3 +-0x0p+0 +-0x1.142b2cab910a3p+4 +-0x0p+0 +-0x1.334b39e6ec582p+4 +-0x0p+0 +-0x1.1dcd1f6f54ebap+4 +-0x0p+0 +-0x1.829e252b54eaap+4 +-0x0p+0 +-0x1.3a56379c15f2p+4 +-0x0p+0 +-0x1.d471a72462df6p+3 +-0x0p+0 +-0x1.eccd98a1d34f8p+3 +-0x0p+0 +-0x1.09b1283ed1cf7p+4 +-0x0p+0 +-0x1.56ce0517d6c1p+4 +-0x0p+0 +-0x1.7d5bab2bbf5a6p+4 +-0x0p+0 +-0x1.6c781b83f6cb8p+4 +-0x0p+0 +-0x1.06ca0aed5a866p+4 +-0x0p+0 +-0x1.4926b1e661ee5p+4 +-0x0p+0 +-0x1.6c5800b14cd03p+4 +-0x0p+0 +-0x1.50e8301ea6118p+4 +-0x0p+0 +-0x1.2b3f1d2304622p+5 +-0x0p+0 +-0x1.5cc5a388c16e7p+4 +-0x0p+0 +-0x1.ba37458921485p+4 +-0x0p+0 +-0x1.2ebac12798b13p+4 +-0x0p+0 +-0x1.51e83332630fbp+4 +-0x0p+0 +-0x1.5d47ba25c6c2bp+4 +-0x0p+0 +-0x1.3a597ac6d5a6dp+4 +-0x0p+0 +-0x1.7f6353013945cp+4 +-0x0p+0 +-0x1.5f539edc8af0fp+5 +-0x0p+0 +-0x1.89a53eddb1af2p+4 +-0x0p+0 +-0x1.03d789ca8694dp+4 +-0x0p+0 +-0x1.5a9d843ab2d84p+4 +-0x0p+0 +-0x1.af2a84257e843p+3 +-0x0p+0 +-0x1.35a15fc4b27fp+4 +-0x0p+0 +-0x1.e275bb5ef6923p+3 +-0x0p+0 +-0x1.50f10f094b025p+4 +-0x0p+0 +-0x1.38021582b8b42p+4 +-0x0p+0 +-0x1.1caa833ebeb1dp+4 +-0x0p+0 +-0x1.75113e232920ap+4 +-0x0p+0 +-0x1.6f843148fcf9ap+4 +-0x0p+0 +-0x1.c3e39c4b71a3ap+3 +-0x0p+0 +-0x1.327e0821f98ccp+4 +-0x0p+0 +-0x1.c7fb10facd9b8p+3 +-0x0p+0 +-0x1.25a77359c96e5p+4 +-0x0p+0 +-0x1.b01d1181840d4p+3 +-0x0p+0 +-0x1.0e72da445461ap+4 +-0x0p+0 +-0x1.0abc4faa83869p+4 +-0x0p+0 +-0x1.b840a14aecd24p+3 +-0x0p+0 +-0x1.27d3c0da4f5e9p+4 +-0x0p+0 +-0x1.b772666bcd2a7p+3 +-0x0p+0 +-0x1.09a7159dae8a2p+4 +-0x0p+0 +-0x1.a06aafc124279p+3 +-0x0p+0 +-0x1.2f16bdc572efbp+4 +-0x0p+0 +-0x1.b8c056ff3ddc1p+3 +-0x0p+0 +-0x1.41941e8f78bf3p+4 +-0x0p+0 +-0x1.1e0c36fdf5647p+4 +-0x0p+0 +-0x1.b8c114c605744p+3 +-0x0p+0 +-0x1.115971d689e23p+4 +-0x0p+0 +-0x1.36a395d92421fp+4 +-0x0p+0 +-0x1.d3428645e1246p+3 +-0x0p+0 +-0x1.1eeb6450ec9a9p+4 +-0x0p+0 +-0x1.2f0ef122e198fp+4 +-0x0p+0 +-0x1.16eed7154e057p+4 +-0x0p+0 +-0x1.81b77ff74c524p+4 +-0x0p+0 +-0x1.205ffac865661p+4 +-0x0p+0 +-0x1.3ce6f38658a92p+4 +-0x0p+0 +-0x1.4654554ea9ee9p+4 +-0x0p+0 +-0x1.93bec5197c727p+4 +-0x0p+0 +-0x1.98d2b7341fe87p+4 +-0x0p+0 +-0x1.03c5ca4366bccp+5 +-0x0p+0 +-0x1.fd2285319e6efp+4 +-0x0p+0 +-0x1.e335c81b9408cp+3 +-0x0p+0 +-0x1.36c8fee00fbf9p+4 +-0x0p+0 +-0x1.1e860eb38d049p+4 +-0x0p+0 +-0x1.7d453e49f1e9dp+4 +-0x0p+0 +-0x1.29ca484e95c1ap+4 +-0x0p+0 +-0x1.7a05c33efa77p+4 +-0x0p+0 +-0x1.5aff7ba20a1a7p+4 +-0x0p+0 +-0x1.5602a8b4bff02p+4 +-0x0p+0 +-0x1.3b8c6e758491bp+5 +-0x0p+0 +-0x1.944b72182fbbdp+4 +-0x0p+0 +-0x1.0e679488673cep+4 +-0x0p+0 +-0x1.1838d86feab44p+4 +-0x0p+0 +-0x1.4dee601afea2cp+4 +-0x0p+0 +-0x1.80306cd69f43p+4 +-0x0p+0 +-0x1.4b74d3ae01f94p+4 +-0x0p+0 +-0x1.bf5edf24bacf7p+4 +-0x0p+0 +-0x1.25ed54eb1e985p+4 +-0x0p+0 +-0x1.5442e697558ffp+4 +-0x0p+0 +-0x1.8e8a4e885718cp+4 +-0x0p+0 +-0x1.60d748e58ace1p+4 +-0x0p+0 +-0x1.7cc7fa5a1ee8bp+4 +-0x0p+0 +-0x1.7ea6103983c99p+4 +-0x0p+0 +-0x1.c1e4fd991ad25p+4 +-0x0p+0 +-0x1.00e2f39a137b8p+4 +-0x0p+0 +-0x1.3bcc30bcec317p+4 +-0x0p+0 +-0x1.e9e7b5f35eb6bp+3 +-0x0p+0 +-0x1.ca4bc164d0ec6p+4 +-0x0p+0 +-0x1.26ea26c37f61fp+4 +-0x0p+0 +-0x1.8b245c9cbfa7p+4 +-0x0p+0 +-0x1.c6ad2292c9dc4p+3 +-0x0p+0 +-0x1.372aa9617b9afp+4 +-0x0p+0 +-0x1.c2d1213cebfa3p+3 +-0x0p+0 +-0x1.3962adceba87dp+4 +-0x0p+0 +-0x1.7b4173c16e04p+3 +-0x0p+0 +-0x1.9519538b874f1p+3 +-0x0p+0 +-0x1.ebcd75eaf7a6fp+3 +-0x0p+0 +-0x1.1c7ea22be4971p+4 +-0x0p+0 +-0x1.a747410697ca7p+3 +-0x0p+0 +-0x1.05ba907504e93p+4 +-0x0p+0 +-0x1.3d224bab38385p+4 +-0x0p+0 +-0x1.a0509b637e927p+3 +-0x0p+0 +-0x1.f1b6696f180fap+3 +-0x0p+0 +-0x1.3e85b0e65cfacp+4 +-0x0p+0 +-0x1.809c614e80682p+3 +-0x0p+0 +-0x1.353cf4787a596p+4 +-0x0p+0 +-0x1.8d6f3bb97d2e4p+3 +-0x0p+0 +-0x1.eb27b01fb7bd2p+3 +-0x0p+0 +-0x1.c6ca1ed7c82bdp+3 +-0x0p+0 +-0x1.4ed50292eeadep+4 +-0x0p+0 +-0x1.7d844db87863dp+3 +-0x0p+0 +-0x1.c667260d9c8c9p+3 +-0x0p+0 +-0x1.d73dd9b600b98p+3 +-0x0p+0 +-0x1.648772e7a25a8p+4 +-0x0p+0 +-0x1.2cf7efb21794bp+4 +-0x0p+0 +-0x1.c948a27f6b52p+3 +-0x0p+0 +-0x1.0cfbb75abb78cp+4 +-0x0p+0 +-0x1.647a841a525b5p+4 +-0x0p+0 +-0x1.924724180b31ep+3 +-0x0p+0 +-0x1.208aa25c40b74p+4 +-0x0p+0 +-0x1.6cda65804b727p+3 +-0x0p+0 +-0x1.98612ed1b7d0bp+3 +-0x0p+0 +-0x1.406dec1004bffp+3 +-0x0p+0 +-0x1.05b64eecfab57p+4 +-0x0p+0 +-0x1.43a3fbe062eeap+3 +-0x0p+0 +-0x1.9a8aaa496b6c2p+3 +-0x0p+0 +-0x1.d9828dc509afap+3 +-0x0p+0 +-0x1.2f4feedf4448bp+3 +-0x0p+0 +-0x1.6e4b59822914fp+3 +-0x0p+0 +-0x1.3f7fe3b6c6788p+3 +-0x0p+0 +-0x1.3fcbb0d55d5eep+3 +-0x0p+0 +-0x1.a154391eca891p+3 +-0x0p+0 +-0x1.4d16976a256a8p+3 +-0x0p+0 +-0x1.b541d3cff2168p+3 +-0x0p+0 +-0x1.4696bfbe5090ap+3 +-0x0p+0 +-0x1.083e5883ee66dp+4 +-0x0p+0 +-0x1.895f35aff8b45p+3 +-0x0p+0 +-0x1.95a042a21c4c3p+3 +-0x0p+0 +-0x1.12553f53d24f3p+4 +-0x0p+0 +-0x1.0753a13c9a9bbp+4 +-0x0p+0 +-0x1.4748d613ad37fp+3 +-0x0p+0 +-0x1.f8fb3a36cdaep+3 +-0x0p+0 +-0x1.10e38ecb85c2bp+3 +-0x0p+0 +-0x1.2da5735c40c03p+3 +-0x0p+0 +-0x1.137a33418675p+3 +-0x0p+0 +-0x1.c047953daa05bp+3 +-0x0p+0 +-0x1.0614b625ac5fp+3 +-0x0p+0 +-0x1.516a20001488bp+3 +-0x0p+0 +-0x1.8378c4d90f349p+3 +-0x0p+0 +-0x1.d266d5826c7c5p+2 +-0x0p+0 +-0x1.24527d4efe906p+3 +-0x0p+0 +-0x1.5e0ddf3f05471p+3 +-0x0p+0 +-0x1.94254cdb276a4p+2 +-0x0p+0 +-0x1.069ee704681afp+3 +-0x0p+0 +-0x1.052024a660bbep+3 +-0x0p+0 +-0x1.921825900ec23p+2 +-0x0p+0 +-0x1.c998884468092p+2 +-0x0p+0 +-0x1.29ceecce2ad05p+3 +-0x0p+0 +-0x1.d9d796ab189d5p+2 +-0x0p+0 +-0x1.f38d3d62fcbf7p+2 +-0x0p+0 +-0x1.06588539bfff1p+3 +-0x0p+0 +-0x1.38531494ebb74p+3 +-0x0p+0 +-0x1.42612f62e8cp+3 +-0x0p+0 +-0x1.d7787c754093ep+3 +-0x0p+0 +-0x1.43bc0c35c6d89p+3 +-0x0p+0 +-0x1.68dd38e9e248fp+3 +-0x0p+0 +-0x1.434279a7848d9p+3 +-0x0p+0 +-0x1.e1ff6f19aacp+3 +-0x0p+0 +-0x1.70a167cbf546ap+3 +-0x0p+0 +-0x1.f3ae919b6a079p+3 +-0x0p+0 +-0x1.c102b79025e48p+3 +-0x0p+0 +-0x1.bb1943763f9e5p+3 +-0x0p+0 +-0x1.1fc80cffb440ep+4 +-0x0p+0 +-0x1.2828a455de3ap+4 +-0x0p+0 +-0x1.8c881e59dd9eep+4 +-0x0p+0 +-0x1.4ab904145a1a7p+4 +-0x0p+0 +-0x1.66e4e339a1012p+3 +-0x0p+0 +-0x1.bc09f4d8fa31ap+3 +-0x0p+0 +-0x1.76fe1d8d90172p+3 +-0x0p+0 +-0x1.cabc2abaeb277p+3 +-0x0p+0 +-0x1.3e517138f2812p+4 +-0x0p+0 +-0x1.2823c210492b7p+4 +-0x0p+0 +-0x1.082650a47ce8dp+4 +-0x0p+0 +-0x1.644e80cd5965ap+4 +-0x0p+0 +-0x1.ad2cee1235c91p+3 +-0x0p+0 +-0x1.38fa6708b6bb6p+4 +-0x0p+0 +-0x1.24b925f8b188dp+4 +-0x0p+0 +-0x1.587983b0645abp+4 +-0x0p+0 +-0x1.3f572c873326dp+5 +-0x0p+0 +-0x1.285dd096a7eaap+4 +-0x0p+0 +-0x1.7ad9e56d4a35bp+4 +-0x0p+0 +-0x1.aafb05d943ee7p+4 +-0x0p+0 +-0x1.850a5177b781bp+4 +-0x0p+0 +-0x1.1893cb2ef9fbap+4 +-0x0p+0 +-0x1.4ac74585ce855p+4 +-0x0p+0 +-0x1.1e23a20cd86aap+4 +-0x0p+0 +-0x1.7e7510d1fb34ap+4 +-0x0p+0 +-0x1.bf97f56061e7ap+3 +-0x0p+0 +-0x1.28f1cdd565d8dp+4 +-0x0p+0 +-0x1.18e9eee2a9952p+4 +-0x0p+0 +-0x1.7d9c49350c98ep+4 +-0x0p+0 +-0x1.3cead5b6f612p+4 +-0x0p+0 +-0x1.8215f74fb9e48p+4 +-0x0p+0 +-0x1.aab52f801ee6bp+3 +-0x0p+0 +-0x1.361ac51e7b38dp+4 +-0x0p+0 +-0x1.6d55ad0837393p+3 +-0x0p+0 +-0x1.c0b4916a324c2p+3 +-0x0p+0 +-0x1.38d37a8a842d3p+3 +-0x0p+0 +-0x1.e52864de60b8bp+3 +-0x0p+0 +-0x1.1d283043d2c95p+3 +-0x0p+0 +-0x1.62463d2c2a4afp+3 +-0x0p+0 +-0x1.7d4c80613dc9fp+3 +-0x0p+0 +-0x1.13b6f1d961b23p+3 +-0x0p+0 +-0x1.75a1f709c2ec4p+3 +-0x0p+0 +-0x1.3230bfab8891cp+3 +-0x0p+0 +-0x1.722d8d7a20606p+3 +-0x0p+0 +-0x1.4823b5377e2cp+3 +-0x0p+0 +-0x1.532f56df497d9p+3 +-0x0p+0 +-0x1.be16b607251cp+3 +-0x0p+0 +-0x1.78c77f71bff49p+3 +-0x0p+0 +-0x1.c44a894a7bf2bp+3 +-0x0p+0 +-0x1.7e6464e72a686p+3 +-0x0p+0 +-0x1.0b5f6caa3706bp+4 +-0x0p+0 +-0x1.b76466af4628fp+3 +-0x0p+0 +-0x1.517e0cbbd5377p+4 +-0x0p+0 +-0x1.1ff9f270ef2f1p+4 +-0x0p+0 +-0x1.ba1955489b36bp+3 +-0x0p+0 +-0x1.01792dc30c0b1p+4 +-0x0p+0 +-0x1.433b29ec08316p+4 +-0x0p+0 +-0x1.efd9c9f4ad109p+3 +-0x0p+0 +-0x1.79b31ff52b6bap+4 +-0x0p+0 +-0x1.3978bd68f3525p+4 +-0x0p+0 +-0x1.0e0a4d054d54cp+4 +-0x0p+0 +-0x1.4d3b7afe76a3dp+4 +-0x0p+0 +-0x1.8f454ef6e14e3p+4 +-0x0p+0 +-0x1.48eae350133a1p+4 +-0x0p+0 +-0x1.4492c9ad7a241p+4 +-0x0p+0 +-0x1.81ef1e0f3216bp+4 +-0x0p+0 +-0x1.a4a0ecbaaebeap+4 +-0x0p+0 +-0x1.ca7102149b22dp+3 +-0x0p+0 +-0x1.3e29234bafe15p+4 +-0x0p+0 +-0x1.e3e561126a0fcp+3 +-0x0p+0 +-0x1.21d2eb704a6d2p+4 +-0x0p+0 +-0x1.cac504f6ba8adp+3 +-0x0p+0 +-0x1.390070d062bd6p+4 +-0x0p+0 +-0x1.05c597b788b6dp+4 +-0x0p+0 +-0x1.518f894ca4f6dp+4 +-0x0p+0 +-0x1.7c108263ffaadp+4 +-0x0p+0 +-0x1.167f7d859cd7bp+4 +-0x0p+0 +-0x1.5ddaeffe224ebp+4 +-0x0p+0 +-0x1.899718065027bp+4 +-0x0p+0 +-0x1.bde4587801447p+4 +-0x0p+0 +-0x1.08d65c97cff9ep+4 +-0x0p+0 +-0x1.237df3e88226cp+4 +-0x0p+0 +-0x1.753f44ebd8e27p+4 +-0x0p+0 +-0x1.a9c97236e67eap+4 +-0x0p+0 +-0x1.80cd33ecf171fp+4 +-0x0p+0 +-0x1.8bd3ca068822cp+4 +-0x0p+0 +-0x1.2b6e330539793p+4 +-0x0p+0 +-0x1.891b747b13f22p+4 +-0x0p+0 +-0x1.7c67e2b4b4ab3p+4 +-0x0p+0 +-0x1.b117bfe7f3bfbp+4 +-0x0p+0 +-0x1.c5116067a1ec3p+4 +-0x0p+0 +-0x1.f35dbfe8f944bp+4 +-0x0p+0 +-0x1.ac69e76ea791dp+4 +-0x0p+0 +-0x1.7a9607822e0fdp+5 +-0x0p+0 +-0x1.f4f09dfb39b19p+3 +-0x0p+0 +-0x1.37c7187977051p+4 +-0x0p+0 +-0x1.52711f8c7594ap+4 +-0x0p+0 +-0x1.caf79defe61c1p+3 +-0x0p+0 +-0x1.0b5e7e23a2409p+4 +-0x0p+0 +-0x1.97e3a7e4cfa1cp+4 +-0x0p+0 +-0x1.1669f266a6a4p+4 +-0x0p+0 +-0x1.a21cdd412a59bp+4 +-0x0p+0 +-0x1.15a8f1d530ea7p+4 +-0x0p+0 +-0x1.a0f8cb403155ap+4 +-0x0p+0 +-0x1.0fd8ec14df032p+4 +-0x0p+0 +-0x1.82cd24dad42e9p+4 +-0x0p+0 +-0x1.02750cbef3452p+4 +-0x0p+0 +-0x1.6d4caff85c39ep+4 +-0x0p+0 +-0x1.6f49a907bde37p+4 +-0x0p+0 +-0x1.0cf06f40b9d49p+4 +-0x0p+0 +-0x1.5e97316c548b1p+4 +-0x0p+0 +-0x1.f1098a9b801fdp+3 +-0x0p+0 +-0x1.47590e044ed0dp+4 +-0x0p+0 +-0x1.003e63d60a5c1p+4 +-0x0p+0 +-0x1.3d2e921bb5314p+4 +-0x0p+0 +-0x1.600e5c7540d1ep+4 +-0x0p+0 +-0x1.21a80f1e164b4p+4 +-0x0p+0 +-0x1.7017019ce2254p+4 +-0x0p+0 +-0x1.1b9968ffef8c7p+4 +-0x0p+0 +-0x1.5082b5b088a1ap+4 +-0x0p+0 +-0x1.208d501b43e74p+4 +-0x0p+0 +-0x1.7ce60d5631bbap+4 +-0x0p+0 +-0x1.d369392839a98p+4 +-0x0p+0 +-0x1.464ddca2978b9p+4 +-0x0p+0 +-0x1.746e199722da6p+4 +-0x0p+0 +-0x1.8535b5f04c1f7p+4 +-0x0p+0 +-0x1.2dc68ab59d882p+4 +-0x0p+0 +-0x1.71db0cb1385f9p+4 +-0x0p+0 +-0x1.9ec3015668fc1p+4 +-0x0p+0 +-0x1.3794400ff2314p+4 +-0x0p+0 +-0x1.85830837c411ap+4 +-0x0p+0 +-0x1.b413846960ef3p+4 +-0x0p+0 +-0x0p+0 +-0x1.cb68bc1beea0bp-3 +-0x0p+0 +-0x1.971b3cddb620cp-3 +-0x0p+0 +-0x1.505e12b914caap-2 +-0x0p+0 +-0x1.092c7a2474087p-1 +-0x0p+0 +-0x1.a6e5acea8c59dp-1 +-0x0p+0 +-0x1.d78e97c7999bdp-1 +-0x0p+0 +-0x1.5504469243495p+0 +-0x0p+0 +-0x1.edd3f1bb9fc8p+0 +-0x0p+0 +-0x1.d4f8f73e422e5p-1 +-0x0p+0 +-0x1.440a6b912bcc1p+0 +-0x0p+0 +-0x1.b022953e2cf5ap+0 +-0x0p+0 +-0x1.2ca21ba270a6p+1 +-0x0p+0 +-0x1.ba6c9f357a7e3p+0 +-0x0p+0 +-0x1.da62ce8d55924p-2 +-0x0p+0 +-0x1.f71c33d397d3cp-1 +-0x0p+0 +-0x1.698d8fef1cf17p-1 +-0x0p+0 +-0x1.bf5857166ccbcp-1 +-0x0p+0 +-0x1.1f4aac0206a38p+0 +-0x0p+0 +-0x1.ac3935b930898p+0 +-0x0p+0 +-0x1.747630625f6dp+0 +-0x0p+0 +-0x1.1e4dd7adbc0dp+1 +-0x0p+0 +-0x1.4160604bbd66ep+1 +-0x0p+0 +-0x1.43538476c1b56p+0 +-0x0p+0 +-0x1.adab09544c87ep+0 +-0x0p+0 +-0x1.2f05d5bf01b39p+0 +-0x0p+0 +-0x1.fdc42dfc689cep+0 +-0x0p+0 +-0x1.87c6311b61a58p+1 +-0x0p+0 +-0x1.9b62c89bd365cp+1 +-0x0p+0 +-0x1.1fa197a8abe35p+1 +-0x0p+0 +-0x1.36feedcc96b4p+1 +-0x0p+0 +-0x1.05fc0f7371879p+2 +-0x0p+0 +-0x1.55c15bec3f3bbp+1 +-0x0p+0 +-0x1.2348b8ae2921cp+1 +-0x0p+0 +-0x1.ce4570c76d1cap+1 +-0x0p+0 +-0x1.ca9f70bb2dd67p+1 +-0x0p+0 +-0x1.e975da4b50948p+0 +-0x0p+0 +-0x1.5a67123000a27p+1 +-0x0p+0 +-0x1.50261501e6ea6p+1 +-0x0p+0 +-0x1.8dc724ca4b2e9p+1 +-0x0p+0 +-0x1.b144fde64ec7dp+1 +-0x0p+0 +-0x1.40b2dacd3cbdap+2 +-0x0p+0 +-0x1.1a5d871fa898fp+2 +-0x0p+0 +-0x1.73eb4416fcab5p+2 +-0x0p+0 +-0x1.c6cebbaa42ac5p+2 +-0x0p+0 +-0x1.390287d112805p+2 +-0x0p+0 +-0x1.44173977578aap+2 +-0x0p+0 +-0x1.ebbdec78e1c87p+2 +-0x0p+0 +-0x1.8aa5ec0e9bb3dp+2 +-0x0p+0 +-0x1.209f91d70e357p+3 +-0x0p+0 +-0x1.cf4a19d6bea41p+2 +-0x0p+0 +-0x1.183c7e5c3a9b3p+2 +-0x0p+0 +-0x1.66111349a86f7p+2 +-0x0p+0 +-0x1.78814412816bfp+2 +-0x0p+0 +-0x1.08dcf140c449ep+3 +-0x0p+0 +-0x1.a31f58b65aabep+2 +-0x0p+0 +-0x1.19940a2bae5dp+3 +-0x0p+0 +-0x1.335ffafa257e4p+3 +-0x0p+0 +-0x1.a506dbf4b4ba9p+3 +-0x0p+0 +-0x1.baaef098ccef2p+3 +-0x0p+0 +-0x1.6b4c1c1678edcp+3 +-0x0p+0 +-0x1.6c79dcd73ea22p+4 +-0x0p+0 +-0x1.d9facd739b313p+2 +-0x0p+0 +-0x1.31d431da7de1ep+3 +-0x0p+0 +-0x1.206f37de2f98dp+3 +-0x0p+0 +-0x1.87db21782a908p+3 +-0x0p+0 +-0x1.13b9fd7173e47p+3 +-0x0p+0 +-0x1.64f49204f8e5bp+3 +-0x0p+0 +-0x1.82d497010e985p+3 +-0x0p+0 +-0x1.f3e3c462117ddp+3 +-0x0p+0 +-0x1.09e4ae4bcc38dp+4 +-0x0p+0 +-0x1.dd1a35c1871a6p+3 +-0x0p+0 +-0x1.07a7b6af810ccp+5 +-0x0p+0 +-0x1.1ca8cf7596a85p+3 +-0x0p+0 +-0x1.9bd4c9f2635ccp+3 +-0x0p+0 +-0x1.2aafacd754e1ap+3 +-0x0p+0 +-0x1.74b5eb3b7b2ddp+3 +-0x0p+0 +-0x1.3110f54ab8697p+3 +-0x0p+0 +-0x1.c8a1b3c4f673dp+3 +-0x0p+0 +-0x1.5662df6503006p+3 +-0x0p+0 +-0x1.034de8e20022dp+4 +-0x0p+0 +-0x1.ad1e567facd74p+3 +-0x0p+0 +-0x1.398eef930c07fp+3 +-0x0p+0 +-0x1.8e8813e2be8f9p+3 +-0x0p+0 +-0x1.17752407a54fcp+4 +-0x0p+0 +-0x1.cfbf54e08f661p+3 +-0x0p+0 +-0x1.76b6b538708ecp+4 +-0x0p+0 +-0x1.a7c0e8601d02cp+3 +-0x0p+0 +-0x1.2d13fb3c6581fp+4 +-0x0p+0 +-0x1.67b19a01b4f1cp+3 +-0x0p+0 +-0x1.cd8bc929a9228p+3 +-0x0p+0 +-0x1.4423015beb5fcp+3 +-0x0p+0 +-0x1.8841a3517ed69p+3 +-0x0p+0 +-0x1.5d13b12e9cf47p+3 +-0x0p+0 +-0x1.e9e3f73258d61p+3 +-0x0p+0 +-0x1.738577e000897p+3 +-0x0p+0 +-0x1.b596b1b5620cp+3 +-0x0p+0 +-0x1.823e27fe2a091p+3 +-0x0p+0 +-0x1.2ad70ddf218f9p+4 +-0x0p+0 +-0x1.b7e8cd00a0a84p+3 +-0x0p+0 +-0x1.41496e09b9559p+4 +-0x0p+0 +-0x1.04c52154df831p+4 +-0x0p+0 +-0x1.183a85a6a2627p+4 +-0x0p+0 +-0x1.4fd378cb6c43fp+4 +-0x0p+0 +-0x1.64b98c5dc8eaap+4 +-0x0p+0 +-0x1.ba50817e896afp+3 +-0x0p+0 +-0x1.c2ee9143e35d2p+3 +-0x0p+0 +-0x1.06294a3f7a66cp+4 +-0x0p+0 +-0x1.d8bc6829b7dbcp+3 +-0x0p+0 +-0x1.81fb53bf4b161p+4 +-0x0p+0 +-0x1.04875b689a3e5p+4 +-0x0p+0 +-0x1.272bae353c34ap+4 +-0x0p+0 +-0x1.8762a2be4091dp+4 +-0x0p+0 +-0x1.2fe00459a741ap+4 +-0x0p+0 +-0x1.cf44ce7c8999ep+4 +-0x0p+0 +-0x1.811a20b7d1de9p+4 +-0x0p+0 +-0x1.3aa6b00bf3c37p+4 +-0x0p+0 +-0x1.5988498a14639p+4 +-0x0p+0 +-0x1.97277b123e95p+4 +-0x0p+0 +-0x1.e99d11f663d8ap+3 +-0x0p+0 +-0x1.650de8b19be84p+4 +-0x0p+0 +-0x1.bec66e1602d35p+3 +-0x0p+0 +-0x1.f89d3f5887787p+3 +-0x0p+0 +-0x1.ac46017fb52afp+3 +-0x0p+0 +-0x1.4ec10a45fd9ecp+4 +-0x0p+0 +-0x1.a3107c1e0a1fbp+3 +-0x0p+0 +-0x1.08319225dc81ep+4 +-0x0p+0 +-0x1.1455c53bbd76dp+4 +-0x0p+0 +-0x1.c6e33a24cb2cp+3 +-0x0p+0 +-0x1.5052ac1fe3e64p+4 +-0x0p+0 +-0x1.474617e0dde9ep+4 +-0x0p+0 +-0x1.91e3e99acab49p+3 +-0x0p+0 +-0x1.013d2c77314ffp+4 +-0x0p+0 +-0x1.00552db46e684p+4 +-0x0p+0 +-0x1.bc46efe1e2ffap+3 +-0x0p+0 +-0x1.401c3b0bb0907p+4 +-0x0p+0 +-0x1.4293377ff83fbp+4 +-0x0p+0 +-0x1.c67cffec56435p+3 +-0x0p+0 +-0x1.d7474e9ea5353p+3 +-0x0p+0 +-0x1.07d63bce4d4a8p+4 +-0x0p+0 +-0x1.f477e6a4f4727p+3 +-0x0p+0 +-0x1.eed36f397aaf3p+3 +-0x0p+0 +-0x1.f7d7021d0aec9p+3 +-0x0p+0 +-0x1.130a396c51e67p+4 +-0x0p+0 +-0x1.4de34ab7d3954p+4 +-0x0p+0 +-0x1.315306efd017bp+4 +-0x0p+0 +-0x1.27a6e6e05696dp+4 +-0x0p+0 +-0x1.50ed8f8c4f2ecp+4 +-0x0p+0 +-0x1.b9f37b1844275p+4 +-0x0p+0 +-0x1.869e4604a13c7p+4 +-0x0p+0 +-0x1.bc60165b1924fp+4 +-0x0p+0 +-0x1.64c520f7a46fap+4 +-0x0p+0 +-0x1.d2d85ecc469d3p+3 +-0x0p+0 +-0x1.413c4583f75cfp+4 +-0x0p+0 +-0x1.317084983fbabp+4 +-0x0p+0 +-0x1.ee8c33356dc57p+3 +-0x0p+0 +-0x1.1fda90d23b193p+4 +-0x0p+0 +-0x1.26499d83a2568p+4 +-0x0p+0 +-0x1.3dfcf55506c48p+4 +-0x0p+0 +-0x1.e44f7b0663ab8p+3 +-0x0p+0 +-0x1.297a10baa4acep+4 +-0x0p+0 +-0x1.fd38a9cbc094p+3 +-0x0p+0 +-0x1.5aa5d9ceda02bp+4 +-0x0p+0 +-0x1.8e5e9f51997bdp+3 +-0x0p+0 +-0x1.f71e9fdf37c4ep+3 +-0x0p+0 +-0x1.a7f3ad1458d5cp+3 +-0x0p+0 +-0x1.3cb4f18b7d1c6p+4 +-0x0p+0 +-0x1.0acd0dcbe5d8ep+4 +-0x0p+0 +-0x1.755dc39848795p+3 +-0x0p+0 +-0x1.687a3e294c237p+3 +-0x0p+0 +-0x1.c8be56e5384cdp+3 +-0x0p+0 +-0x1.6fabf7b2e1a2bp+3 +-0x0p+0 +-0x1.d7667a4a59eb1p+3 +-0x0p+0 +-0x1.9941cfc29f3b1p+3 +-0x0p+0 +-0x1.180ee26120674p+4 +-0x0p+0 +-0x1.cff228a531b6dp+3 +-0x0p+0 +-0x1.63588e4f8e981p+4 +-0x0p+0 +-0x1.cf40d84491c13p+3 +-0x0p+0 +-0x1.6d4bf3d1ad0d9p+4 +-0x0p+0 +-0x1.d0457d6f838ap+3 +-0x0p+0 +-0x1.ce7522d3d0f29p+3 +-0x0p+0 +-0x1.0b1c4805ab7f6p+4 +-0x0p+0 +-0x1.aafefd8dc7ef2p+3 +-0x0p+0 +-0x1.33a532dc40edep+4 +-0x0p+0 +-0x1.f16919c1d27e8p+3 +-0x0p+0 +-0x1.6d4871ed7f26ep+4 +-0x0p+0 +-0x1.5af8e735059d6p+4 +-0x0p+0 +-0x1.ac23e1642e0b5p+3 +-0x0p+0 +-0x1.d653154e2a405p+3 diff --git a/libc/AOR_v20.02/math/test/traces/sincosf.txt b/libc/AOR_v20.02/math/test/traces/sincosf.txt new file mode 100644 index 00000000000000..33de0c7ab9e327 --- /dev/null +++ b/libc/AOR_v20.02/math/test/traces/sincosf.txt @@ -0,0 +1,31999 @@ +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.d7dbf4p-10 +0x1.d7dbf4p-10 +-0x1.3e4a7p-14 +0x0p+0 +-0x1.088c36p-9 +0x1.fd3378p-10 +-0x1.7f293cp-14 +0x0p+0 +-0x1.0c0774p-9 +0x1.000dfep-9 +-0x1.88f704p-14 +0x0p+0 +-0x1.0c7494p-9 +0x1.002cbp-9 +-0x1.8aaa08p-14 +0x0p+0 +-0x1.0c822ap-9 +0x1.002cbp-9 +-0x1.8aaa44p-14 +0x0p+0 +-0x1.0c822cp-9 +0x1.002cbp-9 +-0x1.8aaa44p-14 +0x0p+0 +-0x1.0c822cp-9 +0x1.002cbp-9 +-0x1.8ae7e8p-14 +0x0p+0 +-0x1.0c822cp-9 +0x1.002ac2p-9 +-0x1.8ae48p-14 +0x0p+0 +-0x1.0c8212p-9 +0x1.002ac2p-9 +-0x1.8ae48p-14 +0x1.0812dap-17 +0x1.8513cep-6 +0x1.4ea49cp-8 +0x1.7c2b0ep-6 +-0x1.0812cap-17 +0x1.a147dcp-12 +-0x1.4bf24cp-8 +0x1.bce1fcp-7 +-0x1.95f3b8p-7 +-0x1.aa0414p-7 +0x1.90bca2p-16 +0x1.7fef44p-9 +-0x1.71f412p-14 +-0x1.a8c0bap-11 +0x1.5b0e4ep-12 +0x1.0b9b26p-11 +-0x1.45f88cp-10 +-0x1.51a32ep-10 +0x0p+0 +-0x1.90bbeap-16 +0x1.a8929cp-7 +0x1.71f3e4p-14 +-0x1.7ba034p-9 +-0x1.5b0e4cp-12 +0x1.a47ccap-11 +0x1.45f884p-10 +-0x1.0a8a12p-11 +0x0p+0 +0x1.518104p-10 +0x1.21eeacp-14 +0x1.faffcap-18 +-0x1.a34ef4p-10 +0x1.b76764p-10 +-0x1.cea338p-15 +-0x1.7cabbap-18 +-0x1.0324dap-9 +0x1.f6593p-10 +-0x1.85b41p-14 +-0x1.fef13ap-18 +-0x1.0be6c4p-9 +0x1.fd74fcp-10 +-0x1.a5367p-14 +-0x1.0d0cbep-17 +-0x1.0d4b34p-9 +0x1.fe2aa8p-10 +-0x1.ab6ac4p-14 +-0x1.0d0ebep-17 +-0x1.0d8856p-9 +0x1.fe41a4p-10 +-0x1.abff58p-14 +-0x1.0b237ep-17 +-0x1.0d8904p-9 +0x1.fe3d8ap-10 +-0x1.ac3cfcp-14 +-0x1.0d28fep-17 +-0x1.0d8eecp-9 +0x1.fe4178p-10 +-0x1.ac3f44p-14 +-0x1.0d0efep-17 +-0x1.0d8d0ep-9 +0x1.fe3dcep-10 +-0x1.ac38bcp-14 +0x1.6c84eep-10 +-0x1.6efbdap-8 +0x1.c272f4p-8 +0x1.ecbd6p-11 +0x1.4a5fecp-7 +0x1.15fb34p-6 +0x1.bb96dp-7 +0x1.0c52b4p-6 +-0x1.4abd46p-7 +0x1.afa85ap-11 +-0x1.bba80cp-7 +0x1.35d038p-6 +-0x1.2952c2p-6 +-0x1.2fc60ep-6 +0x1.214494p-9 +0x1.1705eap-8 +-0x1.4aa4ecp-11 +-0x1.367a6ep-10 +0x1.e87f56p-12 +0x1.42224ep-11 +-0x1.4bd012p-10 +-0x1.56f264p-10 +0x0p+0 +-0x1.1e06bap-9 +0x1.2f0388p-6 +0x1.47723ep-11 +-0x1.141514p-8 +-0x1.e6e5b8p-12 +0x1.336d76p-10 +0x1.4bc894p-10 +-0x1.408adp-11 +0x0p+0 +0x1.56baf2p-10 +0x1.083b4ep-13 +0x1.9965c4p-16 +-0x1.76fc6ap-10 +0x1.9e64a2p-10 +-0x1.dd84ap-16 +-0x1.0d55bcp-17 +-0x1.f85ebcp-10 +0x1.eecfeep-10 +-0x1.7b8d52p-14 +-0x1.e6395ep-17 +-0x1.0b14e6p-9 +0x1.faa7fcp-10 +-0x1.bbfaecp-14 +-0x1.09aa6ep-16 +-0x1.0df1c8p-9 +0x1.fc0104p-10 +-0x1.cae89cp-14 +-0x1.0a0f7ep-16 +-0x1.0e8414p-9 +0x1.fc353p-10 +-0x1.ccaafp-14 +-0x1.0c01aep-16 +-0x1.0e8e8ap-9 +0x1.fc2636p-10 +-0x1.cd8bccp-14 +-0x1.0c156ep-16 +-0x1.0e996ap-9 +0x1.fc2d96p-10 +-0x1.cd5afp-14 +0x1.0adea6p-12 +-0x1.336a04p-9 +0x1.463292p-9 +0x1.de4982p-14 +0x1.9ba552p-10 +-0x1.d3fe32p-8 +0x1.207bc6p-7 +0x1.0bd0dcp-10 +0x1.0d9cb2p-6 +0x1.9744bep-7 +0x1.362182p-6 +0x1.8742e2p-7 +-0x1.0e09fcp-6 +0x1.8b3f36p-11 +-0x1.369998p-6 +0x1.6f8ee6p-6 +-0x1.67567p-6 +-0x1.6b892ap-6 +0x1.e55026p-9 +0x1.4d70bp-8 +-0x1.0f7a2p-10 +-0x1.731e3ap-10 +0x1.2bc90cp-11 +0x1.62c95p-11 +-0x1.5161d4p-10 +-0x1.599324p-10 +0x0p+0 +-0x1.e02946p-9 +0x1.6ace7ep-6 +0x1.0cd2e2p-10 +-0x1.4a34ccp-8 +-0x1.2a91bep-11 +0x1.6fbb7ep-10 +0x1.5153dap-10 +-0x1.6104p-11 +0x0p+0 +0x1.596016p-10 +0x1.6c4196p-13 +0x1.86913cp-15 +-0x1.d35cf8p-18 +-0x1.523acep-16 +-0x1.876e3ep-16 +-0x1.8ce08ep-16 +-0x1.913ecep-16 +0x1.24105ap-16 +0x1.0b8006p-11 +0x1.508a02p-10 +-0x1.549a52p-6 +0x1.3462aap-8 +-0x1.57806p-10 +0x1.523e9p-11 +-0x1.5575ap-10 +0x0p+0 +0x1.540accp-6 +-0x1.315688p-8 +0x1.546564p-10 +-0x1.50c402p-11 +0x1.555c5cp-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.09bd2cp-31 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.50c402p-11 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.523e9p-11 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.6c4196p-13 +0x1.86913cp-15 +0x1.86913cp-15 +-0x1.d35cf8p-18 +-0x1.d35cf8p-18 +-0x1.523acep-16 +-0x1.523acep-16 +-0x1.876e3ep-16 +-0x1.876e3ep-16 +-0x1.8ce08ep-16 +-0x1.8ce08ep-16 +-0x1.913ecep-16 +-0x1.913ecep-16 +0x1.24105ap-16 +0x1.24105ap-16 +0x1.0b8006p-11 +0x1.0b8006p-11 +0x1.508a02p-10 +0x1.508a02p-10 +0x1.540accp-6 +0x1.508a02p-10 +-0x1.549a52p-6 +-0x1.549a52p-6 +0x1.540accp-6 +0x1.3462aap-8 +-0x1.549a52p-6 +-0x1.57806p-10 +0x1.3462aap-8 +0x1.523e9p-11 +-0x1.57806p-10 +-0x1.5575ap-10 +0x1.523e9p-11 +0x0p+0 +-0x1.5575ap-10 +0x1.540accp-6 +-0x1.315688p-8 +-0x1.315688p-8 +0x1.546564p-10 +0x1.546564p-10 +-0x1.50c402p-11 +-0x1.50c402p-11 +0x1.555c5cp-10 +0x1.555c5cp-10 +0x0p+0 +0x1.6c4196p-13 +0x1.86913cp-15 +-0x1.5127cp-10 +0x1.8adbcp-10 +0x1.babf28p-21 +-0x1.d35cf8p-18 +-0x1.e8ca0cp-10 +0x1.e72fc2p-10 +-0x1.63d4f6p-14 +-0x1.523acep-16 +-0x1.098b36p-9 +0x1.f79526p-10 +-0x1.cea7ap-14 +-0x1.876e3ep-16 +-0x1.0e63cep-9 +0x1.f9c53p-10 +-0x1.e90fp-14 +-0x1.8ce08ep-16 +-0x1.0f6d56p-9 +0x1.fa1c14p-10 +-0x1.eca2c4p-14 +-0x1.913ecep-16 +-0x1.0f9222p-9 +0x1.fa1b06p-10 +-0x1.ee248cp-14 +0x1.24105ap-16 +-0x1.1279eap-9 +0x1.054e4ep-9 +-0x1.5a9b9p-14 +0x1.0b8006p-11 +-0x1.61cea2p-9 +0x1.9979e2p-9 +0x1.52c83p-12 +0x1.508a02p-10 +-0x1.f6f7fcp-8 +0x1.2f874cp-7 +0x1.8c5452p-11 +0x1.544aa6p-6 +0x1.33a2fp-7 +0x1.73154ap-6 +0x1.262ba4p-7 +-0x1.54da2ap-6 +0x1.e3d202p-12 +-0x1.73b482p-6 +0x1.999c86p-6 +-0x1.93f64p-6 +-0x1.96c916p-6 +0x1.377de4p-8 +0x1.765dfcp-8 +-0x1.85b1c4p-10 +-0x1.ca9956p-10 +0x1.569e86p-10 +0x1.69a8e4p-10 +-0x1.f0b1aep-9 +-0x1.f37eeap-9 +0x0p+0 +-0x1.3471cap-8 +0x1.961588p-6 +0x1.8296ep-10 +-0x1.730792p-8 +-0x1.55e146p-10 +0x1.c72416p-10 +0x1.f0a504p-9 +-0x1.68cc54p-10 +0x0p+0 +0x1.f36776p-9 +0x1.c25dp-13 +0x1.2bdec6p-14 +-0x1.3070ap-10 +0x1.7b6d5cp-10 +0x1.07198ep-15 +-0x1.45e4ecp-19 +-0x1.d841dp-10 +0x1.dfd85cp-10 +-0x1.3d44eap-14 +-0x1.a0ee9ep-16 +-0x1.075eb2p-9 +0x1.f46b8cp-10 +-0x1.d909ap-14 +-0x1.00f258p-15 +-0x1.0e8f4ap-9 +0x1.f78e18p-10 +-0x1.02804p-13 +-0x1.0745ep-15 +-0x1.1048a6p-9 +0x1.f80ef8p-10 +-0x1.0630aep-13 +-0x1.b6643p-16 +-0x1.10ca0ep-9 +0x1.f9faf8p-10 +-0x1.fa22ecp-14 +0x1.606318p-14 +-0x1.193904p-9 +0x1.145f16p-9 +-0x1.c285dap-16 +0x1.662b4ep-11 +-0x1.8d3128p-9 +0x1.e2a1cep-9 +0x1.e4d7b6p-12 +0x1.bc3766p-11 +-0x1.f9a44ep-8 +0x1.275bbep-7 +0x1.951a72p-12 +0x1.861f3cp-6 +0x1.e08bd2p-8 +0x1.9efa8ap-6 +0x1.cc626p-8 +-0x1.86bf16p-6 +0x1.4ecf5cp-13 +-0x1.9f9bdap-6 +0x1.b9abdep-6 +-0x1.b58f92p-6 +-0x1.b7906ap-6 +0x1.64ed3ap-8 +0x1.924cdp-8 +-0x1.b74ffcp-10 +-0x1.e898d6p-10 +0x1.63bbdep-10 +0x1.7147c6p-10 +-0x1.f21bb2p-9 +-0x1.f40614p-9 +0x0p+0 +-0x1.61ae78p-8 +0x1.b6dd5cp-6 +0x1.b3fb18p-10 +-0x1.8ee452p-8 +-0x1.62f5fep-10 +0x1.e5285ap-10 +0x1.f20b14p-9 +-0x1.7078bp-10 +0x0p+0 +0x1.f3f2e8p-9 +0x1.06c09ap-12 +0x1.99638ap-14 +-0x1.13d6p-10 +0x1.6f0bb2p-10 +0x1.023f22p-14 +0x1.385d4cp-18 +-0x1.c77922p-10 +0x1.d8d48p-10 +-0x1.0df96cp-14 +-0x1.d3fa7ep-16 +-0x1.04b35ep-9 +0x1.f13e3p-10 +-0x1.dc6c3p-14 +-0x1.39a5ep-15 +-0x1.0e6e92p-9 +0x1.f552a6p-10 +-0x1.0eea92p-13 +-0x1.4156cp-15 +-0x1.110982p-9 +0x1.f634bp-10 +-0x1.145524p-13 +-0x1.41b764p-16 +-0x1.125336p-9 +0x1.fd1988p-10 +-0x1.e5cffcp-14 +0x1.5b3a92p-13 +-0x1.220ceap-9 +0x1.2879ep-9 +0x1.5f5ff6p-15 +0x1.915758p-11 +-0x1.b1addp-9 +0x1.0d6228p-8 +0x1.138f5ep-11 +0x1.c4d4c2p-12 +-0x1.edaf6ep-8 +0x1.161306p-7 +0x1.68bbe8p-15 +0x1.ab2f88p-6 +0x1.8558e4p-8 +0x1.c05806p-6 +0x1.762e62p-8 +-0x1.abd6f2p-6 +-0x1.e00c9ap-14 +-0x1.c0eddap-6 +0x1.d364d2p-6 +-0x1.d03b68p-6 +-0x1.d1bb6ap-6 +0x1.85b622p-8 +0x1.a7e4b4p-8 +-0x1.daba82p-10 +-0x1.ff8322p-10 +0x1.6d0516p-10 +0x1.77002ap-10 +-0x1.f31748p-9 +-0x1.f468f8p-9 +0x0p+0 +-0x1.8255d2p-8 +0x1.d1058cp-6 +0x1.d7549cp-10 +-0x1.a46746p-8 +-0x1.6c3c3cp-10 +0x1.fbf9bap-10 +0x1.f2ffb6p-9 +-0x1.762e6cp-10 +0x0p+0 +0x1.f45532p-9 +0x1.285604p-12 +0x1.03b306p-13 +0x1.cefe88p-17 +-0x1.ee683ep-16 +-0x1.6c5358p-15 +-0x1.691928p-15 +-0x1.886354p-19 +0x1.026bcap-12 +0x1.96ca6ep-11 +0x1.50a91p-14 +-0x1.c8c252p-6 +0x1.9e6282p-8 +-0x1.f52404p-10 +0x1.73d75p-10 +-0x1.f3bbd8p-9 +0x0p+0 +0x1.c814fp-6 +-0x1.9aef4cp-8 +0x1.f1a508p-10 +-0x1.72ff24p-10 +0x1.f3aebap-9 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.50068ap-32 +0x1.50068ap-32 +0x0p+0 +-0x1.97e756p-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.6c4196p-13 +0x1.86913cp-15 +-0x1.d35cf8p-18 +-0x1.523acep-16 +-0x1.876e3ep-16 +-0x1.8ce08ep-16 +-0x1.913ecep-16 +0x1.24105ap-16 +0x1.0b8006p-11 +0x1.508a02p-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x0p+0 +0x1.555c5cp-10 +-0x1.50c402p-11 +0x1.546564p-10 +-0x1.315688p-8 +0x1.540accp-6 +-0x1.549a52p-6 +0x1.3462aap-8 +-0x1.57806p-10 +0x1.523e9p-11 +-0x1.5575ap-10 +0x0p+0 +0x1.92153p+2 +0x0p+0 +0x1.920886p+2 +0x0p+0 +0x1.523e9p-11 +0x0p+0 +0x1.73d75p-10 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.50068ap-32 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.285604p-12 +0x1.03b306p-13 +0x1.03b306p-13 +0x1.cefe88p-17 +0x1.cefe88p-17 +-0x1.ee683ep-16 +-0x1.ee683ep-16 +-0x1.6c5358p-15 +-0x1.6c5358p-15 +-0x1.691928p-15 +-0x1.691928p-15 +-0x1.886354p-19 +-0x1.886354p-19 +0x1.026bcap-12 +0x1.026bcap-12 +0x1.96ca6ep-11 +0x1.96ca6ep-11 +0x1.50a91p-14 +0x1.50a91p-14 +0x1.c814fp-6 +0x1.50a91p-14 +-0x1.c8c252p-6 +-0x1.c8c252p-6 +0x1.c814fp-6 +0x1.9e6282p-8 +-0x1.c8c252p-6 +-0x1.f52404p-10 +0x1.9e6282p-8 +0x1.73d75p-10 +-0x1.f52404p-10 +-0x1.f3bbd8p-9 +0x1.73d75p-10 +0x0p+0 +-0x1.f3bbd8p-9 +0x1.c814fp-6 +-0x1.9aef4cp-8 +-0x1.9aef4cp-8 +0x1.f1a508p-10 +0x1.f1a508p-10 +-0x1.72ff24p-10 +-0x1.72ff24p-10 +0x1.f3aebap-9 +0x1.f3aebap-9 +0x0p+0 +0x1.285604p-12 +0x1.03b306p-13 +-0x1.f54074p-11 +0x1.6517e8p-10 +0x1.7f6302p-14 +0x1.cefe88p-17 +-0x1.b6aa28p-10 +0x1.d23b54p-10 +-0x1.ad06f8p-15 +-0x1.ee683ep-16 +-0x1.0191f6p-9 +0x1.ee0974p-10 +-0x1.d98006p-14 +-0x1.6c5358p-15 +-0x1.0e0aa8p-9 +0x1.f325b8p-10 +-0x1.18faacp-13 +-0x1.691928p-15 +-0x1.11a454p-9 +0x1.f4eb76p-10 +-0x1.1e76fep-13 +-0x1.886354p-19 +-0x1.144a1cp-9 +0x1.0200aep-9 +-0x1.ae57bcp-14 +0x1.026bcap-12 +-0x1.2c135p-9 +0x1.3ec87ep-9 +0x1.cdd194p-14 +0x1.96ca6ep-11 +-0x1.ceb9d8p-9 +0x1.2103fcp-8 +0x1.14fa46p-11 +0x1.50a91p-14 +-0x1.dbee88p-8 +0x1.01f584p-7 +-0x1.0064c8p-12 +0x1.c861dep-6 +0x1.46b4bep-8 +0x1.db2e42p-6 +0x1.3af3a8p-8 +-0x1.c90f3ap-6 +-0x1.6ad936p-12 +-0x1.dbb7bap-6 +0x1.e918c8p-6 +-0x1.e682ep-6 +-0x1.e7b24p-6 +0x1.a2dc58p-8 +0x1.bd9b14p-8 +-0x1.1d08bap-9 +-0x1.2b323cp-9 +0x1.3beb3p-9 +0x1.3fa75ep-9 +-0x1.ee4fep-8 +-0x1.eeb144p-8 +0x0p+0 +-0x1.9f6952p-8 +0x1.e6f81ep-6 +0x1.1b497cp-9 +-0x1.ba0b82p-8 +-0x1.3b7f38p-9 +0x1.296d92p-9 +0x1.ee494ep-8 +-0x1.3f3e22p-9 +0x0p+0 +0x1.eea698p-8 +0x1.4661dcp-12 +0x1.3a224ep-13 +-0x1.c8726ep-11 +0x1.5cfe92p-10 +0x1.f727e4p-14 +0x1.a0f794p-16 +-0x1.a63142p-10 +0x1.cc223p-10 +-0x1.32017ap-15 +-0x1.f6636ep-16 +-0x1.fc3ea2p-10 +0x1.eadc86p-10 +-0x1.d1ca1ep-14 +-0x1.937c9p-15 +-0x1.0d6a92p-9 +0x1.f128dcp-10 +-0x1.20abcap-13 +-0x1.7a2298p-15 +-0x1.1232acp-9 +0x1.f48a4p-10 +-0x1.233d86p-13 +0x1.656e5ep-16 +-0x1.169bd2p-9 +0x1.072fa6p-9 +-0x1.5a0cb8p-14 +0x1.4c4a54p-12 +-0x1.369822p-9 +0x1.551e6cp-9 +0x1.63a88p-13 +0x1.818cfp-11 +-0x1.e51804p-9 +0x1.2d6eacp-8 +0x1.002578p-11 +-0x1.a10682p-13 +-0x1.c8aa44p-8 +0x1.dc0a36p-8 +-0x1.ee6132p-12 +0x1.dfd682p-6 +0x1.1b49c8p-8 +0x1.f11936p-6 +0x1.124164p-8 +-0x1.e0885ap-6 +-0x1.130ce2p-11 +-0x1.f197eep-6 +0x1.fb7fd2p-6 +-0x1.f952a4p-6 +-0x1.fa4a0ap-6 +0x1.b625a8p-8 +0x1.cbe02ep-8 +-0x1.2723aep-9 +-0x1.328278p-9 +0x1.3e4612p-9 +0x1.413f98p-9 +-0x1.ee7faap-8 +-0x1.eebedp-8 +0x0p+0 +-0x1.b29a46p-8 +0x1.f98bdp-6 +0x1.255d36p-9 +-0x1.c8393ep-8 +-0x1.3de672p-9 +0x1.30b056p-9 +0x1.ee78b6p-8 +-0x1.40d91ap-9 +0x0p+0 +0x1.eeb482p-8 +0x1.61e6eap-12 +0x1.6ed44cp-13 +-0x1.a04a3cp-11 +0x1.565f28p-10 +0x1.355012p-13 +0x1.38f392p-15 +-0x1.961dfcp-10 +0x1.c68786p-10 +-0x1.5dd536p-16 +-0x1.e7428ep-16 +-0x1.f4ce56p-10 +0x1.e7c136p-10 +-0x1.c4b716p-14 +-0x1.b0199p-15 +-0x1.0c89fp-9 +0x1.ef54bep-10 +-0x1.2634ccp-13 +-0x1.6d725p-15 +-0x1.12ba2ep-9 +0x1.f54d3cp-10 +-0x1.21234ap-13 +0x1.a875c4p-15 +-0x1.19414p-9 +0x1.0dc99cp-9 +-0x1.e2b5fep-15 +0x1.85e866p-12 +-0x1.41152ep-9 +0x1.6a0914p-9 +0x1.c48a4ep-13 +0x1.5b5e7ep-11 +-0x1.f5eddep-9 +0x1.341eeap-8 +0x1.ba7948p-12 +-0x1.b5da2ap-12 +-0x1.b6009p-8 +0x1.b6e0ecp-8 +-0x1.546842p-11 +0x1.f3a27ep-6 +0x1.f88654p-9 +0x1.01ed2ap-5 +0x1.ea90d6p-9 +-0x1.f4589cp-6 +-0x1.5c57a8p-11 +-0x1.0228b2p-5 +0x1.05db7ep-5 +-0x1.04ea28p-5 +-0x1.0551d2p-5 +0x1.c5c6e8p-8 +0x1.d7f252p-8 +-0x1.2f2c9p-9 +-0x1.3891fep-9 +0x1.400da4p-9 +0x1.427a9ap-9 +-0x1.eea10ap-8 +-0x1.eec256p-8 +0x0p+0 +-0x1.c2275ep-8 +0x1.04f03ap-5 +0x1.2d625cp-9 +-0x1.d430e8p-8 +-0x1.3faf98p-9 +0x1.36b238p-9 +0x1.ee9892p-8 +-0x1.42143ep-9 +0x0p+0 +0x1.eeb702p-8 +0x1.7b110ep-12 +0x1.a2417ep-13 +0x1.aa4a44p-15 +-0x1.bef1bep-16 +-0x1.c22dbp-15 +-0x1.445b72p-15 +0x1.5a41a4p-14 +0x1.ad8316p-12 +0x1.2b90b4p-11 +-0x1.33c9fep-11 +-0x1.02c71ap-5 +0x1.d2cd06p-8 +-0x1.35bf8p-9 +0x1.4174f2p-9 +-0x1.eeafdcp-8 +0x0p+0 +0x1.026a54p-5 +-0x1.cf17fep-8 +0x1.33e926p-9 +-0x1.4115b8p-9 +0x1.eea8aap-8 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.7d7864p-32 +0x1.7d7864p-32 +0x0p+0 +-0x1.8730f4p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.285604p-12 +0x1.03b306p-13 +0x1.cefe88p-17 +-0x1.ee683ep-16 +-0x1.6c5358p-15 +-0x1.691928p-15 +-0x1.886354p-19 +0x1.026bcap-12 +0x1.96ca6ep-11 +0x1.50a91p-14 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x0p+0 +0x1.f3aebap-9 +-0x1.72ff24p-10 +0x1.f1a508p-10 +-0x1.9aef4cp-8 +0x1.c814fp-6 +-0x1.c8c252p-6 +0x1.9e6282p-8 +-0x1.f52404p-10 +0x1.73d75p-10 +-0x1.f3bbd8p-9 +0x0p+0 +0x1.920886p+2 +0x0p+0 +0x1.91f794p+2 +0x0p+0 +0x1.73d75p-10 +0x0p+0 +0x1.4174f2p-9 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7d7864p-32 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.7b110ep-12 +0x1.a2417ep-13 +0x1.a2417ep-13 +0x1.aa4a44p-15 +0x1.aa4a44p-15 +-0x1.bef1bep-16 +-0x1.bef1bep-16 +-0x1.c22dbp-15 +-0x1.c22dbp-15 +-0x1.445b72p-15 +-0x1.445b72p-15 +0x1.5a41a4p-14 +0x1.5a41a4p-14 +0x1.ad8316p-12 +0x1.ad8316p-12 +0x1.2b90b4p-11 +0x1.2b90b4p-11 +-0x1.33c9fep-11 +-0x1.33c9fep-11 +0x1.026a54p-5 +-0x1.33c9fep-11 +-0x1.02c71ap-5 +-0x1.02c71ap-5 +0x1.026a54p-5 +0x1.d2cd06p-8 +-0x1.02c71ap-5 +-0x1.35bf8p-9 +0x1.d2cd06p-8 +0x1.4174f2p-9 +-0x1.35bf8p-9 +-0x1.eeafdcp-8 +0x1.4174f2p-9 +0x0p+0 +-0x1.eeafdcp-8 +0x1.026a54p-5 +-0x1.cf17fep-8 +-0x1.cf17fep-8 +0x1.33e926p-9 +0x1.33e926p-9 +-0x1.4115b8p-9 +-0x1.4115b8p-9 +0x1.eea8aap-8 +0x1.eea8aap-8 +0x0p+0 +0x1.7b110ep-12 +0x1.a2417ep-13 +-0x1.7bf7cep-11 +0x1.50eb94p-10 +0x1.6cc6dcp-13 +0x1.aa4a44p-15 +-0x1.868c9ap-10 +0x1.c16ce4p-10 +-0x1.0d254p-18 +-0x1.bef942p-16 +-0x1.ece056p-10 +0x1.e4ddecp-10 +-0x1.af8cc2p-14 +-0x1.c22c82p-15 +-0x1.0b5e8p-9 +0x1.edc078p-10 +-0x1.286cf8p-13 +-0x1.444266p-15 +-0x1.13342p-9 +0x1.f74242p-10 +-0x1.18f44ep-13 +0x1.5a5f8cp-14 +-0x1.1c3892p-9 +0x1.15707p-9 +-0x1.f95e3ap-16 +0x1.ad70ccp-12 +-0x1.4b373p-9 +0x1.7caaa8p-9 +0x1.033954p-12 +0x1.2b50d4p-11 +-0x1.013236p-8 +0x1.3670b4p-8 +0x1.63f8f4p-12 +-0x1.346976p-11 +-0x1.a4d55ep-8 +0x1.954042p-8 +-0x1.9d4efep-11 +0x1.028106p-5 +0x1.cafcb6p-9 +0x1.0a3f24p-5 +0x1.c02ab8p-9 +-0x1.02ddecp-5 +-0x1.96028ep-11 +-0x1.0a7832p-5 +0x1.0d3648p-5 +-0x1.0c5e14p-5 +-0x1.0cb538p-5 +0x1.d81b18p-8 +0x1.e7881cp-8 +-0x1.6301p-9 +-0x1.6ad24p-9 +0x1.ee392cp-9 +0x1.f01934p-9 +-0x1.9a3ca6p-7 +-0x1.9a297cp-7 +0x0p+0 +-0x1.d4676ep-8 +0x1.0c4ff4p-5 +0x1.612bf6p-9 +-0x1.e3aaep-8 +-0x1.edda7cp-9 +0x1.68e832p-9 +0x1.9a3914p-7 +-0x1.efb302p-9 +0x0p+0 +0x1.9a2464p-7 +0x1.9259c4p-12 +0x1.d30d8ap-13 +-0x1.5b24f2p-11 +0x1.4c6b9ep-10 +0x1.a0cdeap-13 +0x1.11141ap-14 +-0x1.77941cp-10 +0x1.bcb15cp-10 +0x1.acdb1cp-17 +-0x1.7bd03ep-16 +-0x1.e4b1f4p-10 +0x1.e22206p-10 +-0x1.95aaeap-14 +-0x1.c32578p-15 +-0x1.0a01aep-9 +0x1.ec9d26p-10 +-0x1.269cf6p-13 +-0x1.01b172p-15 +-0x1.139d72p-9 +0x1.fa6152p-10 +-0x1.0a33aap-13 +0x1.e0a1e6p-14 +-0x1.1f6078p-9 +0x1.1db1b2p-9 +-0x1.61c2bcp-19 +0x1.c3ef36p-12 +-0x1.54d53ep-9 +0x1.8cabap-9 +0x1.15827p-12 +0x1.edaa8cp-12 +-0x1.05ae98p-8 +0x1.358e2ep-8 +0x1.0645d8p-12 +-0x1.791556p-11 +-0x1.95413ap-8 +0x1.7750fcp-8 +-0x1.d56baep-11 +0x1.0a1adap-5 +0x1.a9267cp-9 +0x1.119512p-5 +0x1.a0ed3cp-9 +-0x1.0a7a5ap-5 +-0x1.c1c66cp-11 +-0x1.11cdap-5 +0x1.13cd74p-5 +-0x1.130bbp-5 +-0x1.1356a8p-5 +0x1.e316a4p-8 +0x1.f076ccp-8 +-0x1.685468p-9 +-0x1.6f01f4p-9 +0x1.eee8e2p-9 +0x1.f088b6p-9 +-0x1.9a31aap-7 +-0x1.9a16eep-7 +0x0p+0 +-0x1.df45f4p-8 +0x1.12eddep-5 +0x1.667346p-9 +-0x1.ec7b3p-8 +-0x1.ee8b14p-9 +0x1.6d0a86p-9 +0x1.9a2efep-7 +-0x1.f02264p-9 +0x0p+0 +0x1.9a1276p-7 +0x1.a822f4p-12 +0x1.010f9cp-12 +-0x1.3ce502p-11 +0x1.489e3p-10 +0x1.d2da58p-13 +0x1.4ec776p-14 +-0x1.693558p-10 +0x1.b86c82p-10 +0x1.f4d8fcp-16 +-0x1.241c6cp-16 +-0x1.dc4594p-10 +0x1.df8cd8p-10 +-0x1.77980ep-14 +-0x1.b52d4p-15 +-0x1.087c08p-9 +0x1.ebe254p-10 +-0x1.217eep-13 +-0x1.4b0398p-16 +-0x1.1401b4p-9 +0x1.feac24p-10 +-0x1.eb9678p-14 +0x1.2f3aaap-13 +-0x1.22a522p-9 +0x1.2626d6p-9 +0x1.85292cp-16 +0x1.cb14ccp-12 +-0x1.5dd512p-9 +0x1.99ee5p-9 +0x1.1a607ep-12 +0x1.8279f2p-12 +-0x1.08d312p-8 +0x1.325b14p-8 +0x1.4d54acp-13 +-0x1.aea538p-11 +-0x1.87588ep-8 +0x1.5cc98ep-8 +-0x1.00abf4p-10 +0x1.10f6dp-5 +0x1.8f1e3ap-9 +0x1.183d94p-5 +0x1.890efcp-9 +-0x1.11598ap-5 +-0x1.e3cecep-11 +-0x1.187746p-5 +0x1.19dafep-5 +-0x1.192c2cp-5 +-0x1.196c8cp-5 +0x1.ec8f74p-8 +0x1.f84b5cp-8 +-0x1.6cb90ap-9 +-0x1.728332p-9 +0x1.ef599p-9 +0x1.f0bea8p-9 +-0x1.9a250ap-7 +-0x1.9a01dep-7 +0x0p+0 +-0x1.e8a104p-8 +0x1.190094p-5 +0x1.6acbbcp-9 +-0x1.f42f5cp-8 +-0x1.eefd4cp-9 +0x1.7081p-9 +0x1.9a2198p-7 +-0x1.f05526p-9 +0x0p+0 +0x1.99fdacp-7 +0x1.bc8918p-12 +0x1.17bd68p-12 +0x1.8e938ap-14 +-0x1.70d6b8p-17 +-0x1.974f4p-15 +-0x1.af4ceap-18 +0x1.673aa4p-13 +0x1.c5437ap-12 +0x1.1914fap-12 +-0x1.d8d358p-11 +-0x1.17a052p-5 +0x1.f4cdbep-8 +-0x1.706ae6p-9 +0x1.efa0d8p-9 +-0x1.9a136ap-7 +0x0p+0 +0x1.173abap-5 +-0x1.f0be24p-8 +0x1.6e7752p-9 +-0x1.ef3d2ap-9 +0x1.9a0ee2p-7 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.839dccp-32 +0x1.839dccp-32 +0x0p+0 +-0x1.84ee52p-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.7b110ep-12 +0x1.a2417ep-13 +0x1.aa4a44p-15 +-0x1.bef1bep-16 +-0x1.c22dbp-15 +-0x1.445b72p-15 +0x1.5a41a4p-14 +0x1.ad8316p-12 +0x1.2b90b4p-11 +-0x1.33c9fep-11 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x0p+0 +0x1.eea8aap-8 +-0x1.4115b8p-9 +0x1.33e926p-9 +-0x1.cf17fep-8 +0x1.026a54p-5 +-0x1.02c71ap-5 +0x1.d2cd06p-8 +-0x1.35bf8p-9 +0x1.4174f2p-9 +-0x1.eeafdcp-8 +0x0p+0 +0x1.91f794p+2 +0x0p+0 +0x1.91e1cep+2 +0x0p+0 +0x1.4174f2p-9 +0x0p+0 +0x1.efa0d8p-9 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.839dccp-32 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.bc8918p-12 +0x1.17bd68p-12 +0x1.17bd68p-12 +0x1.8e938ap-14 +0x1.8e938ap-14 +-0x1.70d6b8p-17 +-0x1.70d6b8p-17 +-0x1.974f4p-15 +-0x1.974f4p-15 +-0x1.af4ceap-18 +-0x1.af4ceap-18 +0x1.673aa4p-13 +0x1.673aa4p-13 +0x1.c5437ap-12 +0x1.c5437ap-12 +0x1.1914fap-12 +0x1.1914fap-12 +-0x1.d8d358p-11 +-0x1.d8d358p-11 +0x1.173abap-5 +-0x1.d8d358p-11 +-0x1.17a052p-5 +-0x1.17a052p-5 +0x1.173abap-5 +0x1.f4cdbep-8 +-0x1.17a052p-5 +-0x1.706ae6p-9 +0x1.f4cdbep-8 +0x1.efa0d8p-9 +-0x1.706ae6p-9 +-0x1.9a136ap-7 +0x1.efa0d8p-9 +0x0p+0 +-0x1.9a136ap-7 +0x1.173abap-5 +-0x1.f0be24p-8 +-0x1.f0be24p-8 +0x1.6e7752p-9 +0x1.6e7752p-9 +-0x1.ef3d2ap-9 +-0x1.ef3d2ap-9 +0x1.9a0ee2p-7 +0x1.9a0ee2p-7 +0x0p+0 +0x1.bc88cap-12 +0x1.17bc84p-12 +-0x1.2129d6p-11 +0x1.458388p-10 +0x1.00fc22p-12 +0x1.8e9362p-14 +-0x1.5b6fcep-10 +0x1.b4849ap-10 +0x1.8cd1dcp-15 +-0x1.6fed9p-17 +-0x1.d3b33ep-10 +0x1.dd3cbp-10 +-0x1.5407e2p-14 +-0x1.96cf96p-15 +-0x1.06d23p-9 +0x1.ebb9a2p-10 +-0x1.189432p-13 +-0x1.aea942p-18 +-0x1.145e5p-9 +0x1.01fe4p-9 +-0x1.ba2e24p-14 +0x1.6713f6p-13 +-0x1.260f9p-9 +0x1.2e95c2p-9 +0x1.82aab8p-15 +0x1.c5b6c6p-12 +-0x1.664524p-9 +0x1.a4b0b6p-9 +0x1.14213ep-12 +0x1.1bb674p-12 +-0x1.0af7acp-8 +0x1.2dbd6cp-8 +0x1.2bb368p-14 +-0x1.d6902ep-11 +-0x1.7adb64p-8 +0x1.459a0cp-8 +-0x1.110ab8p-10 +0x1.172ba6p-5 +0x1.7ae8d4p-9 +0x1.1e497ap-5 +0x1.76b3bap-9 +-0x1.178d3cp-5 +-0x1.fd018cp-11 +-0x1.1e812ep-5 +0x1.1f6398p-5 +-0x1.1ec054p-5 +-0x1.1ef26ap-5 +0x1.f9f17ep-8 +0x1.02124cp-7 +-0x1.a72612p-9 +-0x1.ac012ap-9 +0x1.62e35ep-8 +0x1.635768p-8 +-0x1.32b9ap-6 +-0x1.328a9p-6 +0x0p+0 +-0x1.f5e568p-8 +0x1.1e8412p-5 +0x1.a535e2p-9 +-0x1.ffeedcp-8 +-0x1.62b222p-8 +0x1.a9f6acp-9 +0x1.32b762p-6 +-0x1.6327a8p-8 +0x0p+0 +0x1.3289b8p-6 +0x1.d0234ap-12 +0x1.2d1166p-12 +-0x1.077d36p-11 +0x1.42e78ap-10 +0x1.174692p-12 +0x1.cf8e8ap-14 +-0x1.4e46fcp-10 +0x1.b0fb4cp-10 +0x1.0f603cp-14 +-0x1.a5496p-19 +-0x1.cb0088p-10 +0x1.db24bcp-10 +-0x1.2b4178p-14 +-0x1.683798p-15 +-0x1.04fae4p-9 +0x1.ec0ab8p-10 +-0x1.0b5e94p-13 +0x1.1c6b66p-17 +-0x1.14b0a2p-9 +0x1.0515a4p-9 +-0x1.818374p-14 +0x1.96b162p-13 +-0x1.296662p-9 +0x1.36a7cep-9 +0x1.148b1p-14 +0x1.b55ff8p-12 +-0x1.6ded22p-9 +0x1.ace7b4p-9 +0x1.04808p-12 +0x1.6d6db4p-13 +-0x1.0c4a62p-8 +0x1.27d42cp-8 +-0x1.e61606p-17 +-0x1.f91772p-11 +-0x1.6fc672p-8 +0x1.3095bcp-8 +-0x1.1f619ep-10 +0x1.1ce21ep-5 +0x1.6a770ap-9 +0x1.23e078p-5 +0x1.67dd4p-9 +-0x1.1d4a9ap-5 +-0x1.09538ap-10 +-0x1.241dfp-5 +0x1.248d1cp-5 +-0x1.241dfp-5 +-0x1.243496p-5 +0x1.007e4ap-7 +0x1.050feap-7 +-0x1.aa064p-9 +-0x1.ae492ep-9 +0x1.62955cp-8 +0x1.6304b4p-8 +-0x1.32a12cp-6 +-0x1.3270aep-6 +0x0p+0 +-0x1.fcd604p-8 +0x1.23c2acp-5 +0x1.a7fa3ep-9 +-0x1.02e434p-7 +-0x1.6261bep-8 +0x1.ac296ap-9 +0x1.32a042p-6 +-0x1.62cfaap-8 +0x0p+0 +0x1.326f1ap-6 +0x1.e2dc26p-12 +0x1.4178c6p-12 +-0x1.df3478p-12 +0x1.40bccp-10 +0x1.2cd26p-12 +0x1.086ca2p-13 +-0x1.419a44p-10 +0x1.adc378p-10 +0x1.57570cp-14 +0x1.874592p-18 +-0x1.c268b2p-10 +0x1.d9641ap-10 +-0x1.fe912ep-15 +-0x1.297298p-15 +-0x1.03026cp-9 +0x1.eccd88p-10 +-0x1.f52c76p-14 +0x1.96f5dp-16 +-0x1.14f62ap-9 +0x1.087706p-9 +-0x1.44fd04p-14 +0x1.bd0be8p-13 +-0x1.2cc1dep-9 +0x1.3e49b8p-9 +0x1.582f42p-14 +0x1.9ca4ep-12 +-0x1.74e7b2p-9 +0x1.b2ea36p-9 +0x1.db00e6p-13 +0x1.5d6324p-14 +-0x1.0d04d6p-8 +0x1.213642p-8 +-0x1.926422p-14 +-0x1.09538ap-10 +-0x1.65fa58p-8 +0x1.1e413p-8 +-0x1.2a14fp-10 +0x1.223f98p-5 +0x1.5cbb3ep-9 +0x1.29217ap-5 +0x1.5ba08p-9 +-0x1.22aac6p-5 +-0x1.115224p-10 +-0x1.2961acp-5 +0x1.296a1ep-5 +-0x1.2961acp-5 +-0x1.29437p-5 +0x1.039e3ep-7 +0x1.07d396p-7 +-0x1.ac4a7ap-9 +-0x1.b028a4p-9 +0x1.623468p-8 +0x1.62970ep-8 +-0x1.328988p-6 +-0x1.325624p-6 +0x0p+0 +-0x1.017894p-7 +0x1.28cdf2p-5 +0x1.aa2fb4p-9 +-0x1.059718p-7 +-0x1.6203aep-8 +0x1.adfbb6p-9 +0x1.3287bcp-6 +-0x1.62635ap-8 +0x0p+0 +0x1.325418p-6 +0x1.f48258p-12 +0x1.5572fep-12 +0x1.2958b2p-13 +0x1.089d84p-16 +-0x1.b9a7d2p-16 +0x1.51d3e6p-15 +0x1.da04e6p-13 +0x1.7dab7ep-12 +-0x1.28e3dcp-20 +-0x1.115224p-10 +-0x1.27cca6p-5 +0x1.067702p-7 +-0x1.ae3714p-9 +0x1.61cbbp-8 +-0x1.326fbep-6 +0x0p+0 +0x1.275d84p-5 +-0x1.04403p-7 +0x1.ac11cap-9 +-0x1.619a54p-8 +0x1.326e9cp-6 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.84729p-32 +0x1.84729p-32 +0x0p+0 +-0x1.84a014p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.bc8918p-12 +0x1.17bd68p-12 +0x1.8e938ap-14 +-0x1.70d6b8p-17 +-0x1.974f4p-15 +-0x1.af4ceap-18 +0x1.673aa4p-13 +0x1.c5437ap-12 +0x1.1914fap-12 +-0x1.d8d358p-11 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x0p+0 +0x1.9a0ee2p-7 +-0x1.ef3d2ap-9 +0x1.6e7752p-9 +-0x1.f0be24p-8 +0x1.173abap-5 +-0x1.17a052p-5 +0x1.f4cdbep-8 +-0x1.706ae6p-9 +0x1.efa0d8p-9 +-0x1.9a136ap-7 +0x0p+0 +0x1.91e1cep+2 +0x0p+0 +0x1.91c75p+2 +0x0p+0 +0x1.efa0d8p-9 +0x0p+0 +0x1.61cbbp-8 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84729p-32 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.f48258p-12 +0x1.5572fep-12 +0x1.5572fep-12 +0x1.2958b2p-13 +0x1.2958b2p-13 +0x1.089d84p-16 +0x1.089d84p-16 +-0x1.b9a7d2p-16 +-0x1.b9a7d2p-16 +0x1.51d3e6p-15 +0x1.51d3e6p-15 +0x1.da04e6p-13 +0x1.da04e6p-13 +0x1.7dab7ep-12 +0x1.7dab7ep-12 +-0x1.28e3dcp-20 +-0x1.28e3dcp-20 +-0x1.115224p-10 +-0x1.115224p-10 +0x1.275d84p-5 +-0x1.115224p-10 +-0x1.27cca6p-5 +-0x1.27cca6p-5 +0x1.275d84p-5 +0x1.067702p-7 +-0x1.27cca6p-5 +-0x1.ae3714p-9 +0x1.067702p-7 +0x1.61cbbp-8 +-0x1.ae3714p-9 +-0x1.326fbep-6 +0x1.61cbbp-8 +0x0p+0 +-0x1.326fbep-6 +0x1.275d84p-5 +-0x1.04403p-7 +-0x1.04403p-7 +0x1.ac11cap-9 +0x1.ac11cap-9 +-0x1.619a54p-8 +-0x1.619a54p-8 +0x1.326e9cp-6 +0x1.326e9cp-6 +0x0p+0 +0x1.f480fep-12 +0x1.5577b4p-12 +-0x1.b2ef04p-12 +0x1.3f1312p-10 +0x1.419e1ap-12 +0x1.2963dep-13 +-0x1.3580c2p-10 +0x1.aaf92p-10 +0x1.a0e918p-14 +0x1.06cfbep-16 +-0x1.b9d27cp-10 +0x1.d7f8bp-10 +-0x1.9e903p-15 +-0x1.bfc73cp-16 +-0x1.010da8p-9 +0x1.ee2e2ap-10 +-0x1.ce34fap-14 +0x1.4f5438p-15 +-0x1.1551f6p-9 +0x1.0c17b2p-9 +-0x1.09b6f4p-14 +0x1.dc498ap-13 +-0x1.3048eap-9 +0x1.459bb4p-9 +0x1.8d22a6p-14 +0x1.828d58p-12 +-0x1.7b4b24p-9 +0x1.b7b576p-9 +0x1.aa528ap-13 +0x1.2ad9b8p-17 +-0x1.0d19f2p-8 +0x1.1af1aap-8 +-0x1.544c6cp-13 +-0x1.0d9de4p-10 +-0x1.5ce058p-8 +0x1.0fb89ep-8 +-0x1.2d3b82p-10 +0x1.26f71ap-5 +0x1.51ef42p-9 +0x1.2db96ap-5 +0x1.51ef42p-9 +-0x1.275d0ep-5 +-0x1.132a4ep-10 +-0x1.2df5b6p-5 +0x1.2db96ap-5 +-0x1.2df5b6p-5 +-0x1.2da614p-5 +0x1.07f8fcp-7 +0x1.0bc69cp-7 +-0x1.eb957p-9 +-0x1.eee0dep-9 +0x1.dfdf6ep-8 +0x1.e00b4ep-8 +-0x1.ac1f6p-6 +-0x1.abbd2cp-6 +0x0p+0 +-0x1.05c648p-7 +0x1.2d2e2p-5 +0x1.e97698p-9 +-0x1.097cfep-7 +-0x1.dfae32p-8 +0x1.eca63cp-9 +0x1.ac1e1cp-6 +-0x1.dfd2a6p-8 +0x0p+0 +0x1.abbb12p-6 +0x1.02b4d8p-11 +0x1.686cbcp-12 +-0x1.892356p-12 +0x1.3d967cp-10 +0x1.556442p-12 +0x1.4ada4cp-13 +-0x1.29dd66p-10 +0x1.a8737cp-10 +0x1.e9b144p-14 +0x1.bf2d06p-16 +-0x1.b134fep-10 +0x1.d6c69ep-10 +-0x1.37d708p-15 +-0x1.073d22p-16 +-0x1.fdeb9ep-10 +0x1.f01394p-10 +-0x1.9efa22p-14 +0x1.d6a074p-15 +-0x1.157a38p-9 +0x1.0fd4b4p-9 +-0x1.973266p-15 +0x1.efe35p-13 +-0x1.338a6p-9 +0x1.4c0576p-9 +0x1.af0d3ap-14 +0x1.5ed57ep-12 +-0x1.810fd8p-9 +0x1.ba17d4p-9 +0x1.68ecf4p-13 +-0x1.1ce4b4p-14 +-0x1.0d06c8p-8 +0x1.13d5bep-8 +-0x1.e5169ap-13 +-0x1.132a4ep-10 +-0x1.5536f6p-8 +0x1.022204p-8 +-0x1.31da32p-10 +0x1.2bc308p-5 +0x1.477e9ap-9 +0x1.326984p-5 +0x1.477e9ap-9 +-0x1.2c34bep-5 +-0x1.167454p-10 +-0x1.32aedep-5 +0x1.326984p-5 +-0x1.32aedep-5 +-0x1.3258cp-5 +0x1.0a7446p-7 +0x1.0e0e92p-7 +-0x1.ecbd18p-9 +-0x1.efccp-9 +0x1.ded36cp-8 +0x1.df0a24p-8 +-0x1.abee22p-6 +-0x1.ab8a1ap-6 +0x0p+0 +-0x1.0832bep-7 +0x1.31dc68p-5 +0x1.ea9326p-9 +-0x1.0bb1fp-7 +-0x1.de9fe6p-8 +0x1.ed8bd2p-9 +0x1.abec42p-6 +-0x1.ded55ep-8 +0x0p+0 +0x1.ab888p-6 +0x1.0ac7cep-11 +0x1.7ad0fap-12 +-0x1.620e7p-12 +0x1.3c72ccp-10 +0x1.686d1cp-12 +0x1.6cb0dep-13 +-0x1.1eadb6p-10 +0x1.a63e42p-10 +0x1.18f2c8p-13 +0x1.43a6cap-15 +-0x1.a8ac6ep-10 +0x1.d5df18p-10 +-0x1.90c53ap-16 +-0x1.c2891ep-19 +-0x1.f987ecp-10 +0x1.f263fep-10 +-0x1.69f4bep-14 +0x1.2c9502p-14 +-0x1.1597dcp-9 +0x1.13a26cp-9 +-0x1.1bddb6p-15 +0x1.fa33fep-13 +-0x1.36b57p-9 +0x1.51c158p-9 +0x1.c1dfbcp-14 +0x1.380c06p-12 +-0x1.8643d4p-9 +0x1.bb0f98p-9 +0x1.219c1cp-13 +-0x1.1fda38p-13 +-0x1.0cb54ap-8 +0x1.0cc8aap-8 +-0x1.342b74p-12 +-0x1.167454p-10 +-0x1.4e86f2p-8 +0x1.ed0196p-9 +-0x1.34a0f8p-10 +0x1.307a5ap-5 +0x1.3ce184p-9 +0x1.37011p-5 +0x1.3ce184p-9 +-0x1.30ef6ap-5 +-0x1.185f48p-10 +-0x1.3747e6p-5 +0x1.37011p-5 +-0x1.3747e6p-5 +-0x1.36ee6ap-5 +0x1.0cc78p-7 +0x1.103868p-7 +-0x1.ed8258p-9 +-0x1.f06d4p-9 +0x1.ddbcbp-8 +0x1.ddf03cp-8 +-0x1.abbbcep-6 +-0x1.ab5698p-6 +0x0p+0 +-0x1.0a71bp-7 +0x1.366f0ep-5 +0x1.eb468cp-9 +-0x1.0dcab8p-7 +-0x1.dd8896p-8 +0x1.ee21cap-9 +0x1.abba4ap-6 +-0x1.ddbd3p-8 +0x0p+0 +0x1.ab5562p-6 +0x1.128ec8p-11 +0x1.8ccabp-12 +0x1.8e02fcp-13 +0x1.aff20ap-15 +0x1.4bf256p-17 +0x1.6a1e46p-14 +0x1.fd12d8p-13 +0x1.0f55e2p-12 +-0x1.a1be96p-13 +-0x1.185f48p-10 +-0x1.358abep-5 +0x1.0ef5dcp-7 +-0x1.ee19ecp-9 +0x1.dca3fcp-8 +-0x1.ab8834p-6 +0x0p+0 +0x1.3511fp-5 +-0x1.0c8d5ep-7 +0x1.ebce12p-9 +-0x1.dc717ep-8 +0x1.ab8714p-6 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.848f56p-32 +0x1.848f56p-32 +0x0p+0 +-0x1.84958p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.f48258p-12 +0x1.5572fep-12 +0x1.2958b2p-13 +0x1.089d84p-16 +-0x1.b9a7d2p-16 +0x1.51d3e6p-15 +0x1.da04e6p-13 +0x1.7dab7ep-12 +-0x1.28e3dcp-20 +-0x1.115224p-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x0p+0 +0x1.326e9cp-6 +-0x1.619a54p-8 +0x1.ac11cap-9 +-0x1.04403p-7 +0x1.275d84p-5 +-0x1.27cca6p-5 +0x1.067702p-7 +-0x1.ae3714p-9 +0x1.61cbbp-8 +-0x1.326fbep-6 +0x0p+0 +0x1.91c75p+2 +0x0p+0 +0x1.91a89ap+2 +0x0p+0 +0x1.61cbbp-8 +0x0p+0 +0x1.dca3fcp-8 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.848f56p-32 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.128ec8p-11 +0x1.8ccabp-12 +0x1.8ccabp-12 +0x1.8e02fcp-13 +0x1.8e02fcp-13 +0x1.aff20ap-15 +0x1.aff20ap-15 +0x1.4bf256p-17 +0x1.4bf256p-17 +0x1.6a1e46p-14 +0x1.6a1e46p-14 +0x1.fd12d8p-13 +0x1.fd12d8p-13 +0x1.0f55e2p-12 +0x1.0f55e2p-12 +-0x1.a1be96p-13 +-0x1.a1be96p-13 +-0x1.185f48p-10 +-0x1.185f48p-10 +0x1.3511fp-5 +-0x1.185f48p-10 +-0x1.358abep-5 +-0x1.358abep-5 +0x1.3511fp-5 +0x1.0ef5dcp-7 +-0x1.358abep-5 +-0x1.ee19ecp-9 +0x1.0ef5dcp-7 +0x1.dca3fcp-8 +-0x1.ee19ecp-9 +-0x1.ab8834p-6 +0x1.dca3fcp-8 +0x0p+0 +-0x1.ab8834p-6 +0x1.3511fp-5 +-0x1.0c8d5ep-7 +-0x1.0c8d5ep-7 +0x1.ebce12p-9 +0x1.ebce12p-9 +-0x1.dc717ep-8 +-0x1.dc717ep-8 +0x1.ab8714p-6 +0x1.ab8714p-6 +0x0p+0 +0x1.129942p-11 +0x1.8cc13p-12 +-0x1.3d503ap-12 +0x1.3ba718p-10 +0x1.7b1192p-12 +0x1.8d23f6p-13 +-0x1.14149ap-10 +0x1.a45a3ep-10 +0x1.3c4d64p-13 +0x1.a7c3bp-15 +-0x1.a09046p-10 +0x1.d54c5ap-10 +-0x1.6a2c34p-17 +0x1.27d9b4p-17 +-0x1.f595cap-10 +0x1.f50e2p-10 +-0x1.366bcap-14 +0x1.6c35a6p-14 +-0x1.16039p-9 +0x1.17a4fep-9 +-0x1.4edf7ap-16 +0x1.040762p-12 +-0x1.39f50cp-9 +0x1.57ae7cp-9 +0x1.d886b4p-14 +0x1.1e0f6ep-12 +-0x1.8a9bfap-9 +0x1.bce2a8p-9 +0x1.e387bap-14 +-0x1.6c3df8p-13 +-0x1.0b7ea2p-8 +0x1.07b7ap-8 +-0x1.563c16p-12 +-0x1.0f9104p-10 +-0x1.4728fp-8 +0x1.dd69cap-9 +-0x1.2dc4acp-10 +0x1.33fedep-5 +0x1.348332p-9 +0x1.3a5c74p-5 +0x1.348332p-9 +-0x1.346586p-5 +-0x1.1261dap-10 +-0x1.3a9662p-5 +0x1.3a5c74p-5 +-0x1.3a9662p-5 +-0x1.3a2b6p-5 +0x1.0dae2cp-7 +0x1.10c6b6p-7 +-0x1.1656d8p-8 +-0x1.178292p-8 +0x1.35152cp-7 +0x1.35091ap-7 +-0x1.1c5886p-5 +-0x1.1bff7p-5 +0x0p+0 +-0x1.0b4e62p-7 +0x1.39a96ep-5 +0x1.15352cp-8 +-0x1.0e4c82p-7 +-0x1.34f9d6p-7 +0x1.16510ep-8 +0x1.1c577cp-5 +-0x1.34eb6ap-7 +0x0p+0 +0x1.1bfe2ap-5 +0x1.1a0bb8p-11 +0x1.9e0c38p-12 +-0x1.1a8ccep-12 +0x1.3b0162p-10 +0x1.8cb4cp-12 +0x1.aef8fcp-13 +-0x1.09c87ap-10 +0x1.a2af1ap-10 +0x1.601ee8p-13 +0x1.0e0bc6p-14 +-0x1.984692p-10 +0x1.d51c5ep-10 +0x1.15dc54p-18 +0x1.85092ap-16 +-0x1.f100c4p-10 +0x1.f8240cp-10 +-0x1.f3570ap-15 +0x1.a758p-14 +-0x1.160caep-9 +0x1.1b6b14p-9 +-0x1.a53262p-18 +0x1.01fb6ap-12 +-0x1.3cd0d8p-9 +0x1.5c137ep-9 +0x1.d11f54p-14 +0x1.e9f4eap-13 +-0x1.8ecb3p-9 +0x1.bbbb98p-9 +0x1.4d483ep-14 +-0x1.e16f22p-13 +-0x1.0ad87ep-8 +0x1.0116dep-8 +-0x1.8b75b8p-12 +-0x1.1261dap-10 +-0x1.41ab82p-8 +0x1.ca5732p-9 +-0x1.302502p-10 +0x1.384388p-5 +0x1.2a3566p-9 +0x1.3e8194p-5 +0x1.2a3566p-9 +-0x1.38be78p-5 +-0x1.13841ap-10 +-0x1.3ecd48p-5 +0x1.3e8194p-5 +-0x1.3ecd48p-5 +-0x1.3e568ap-5 +0x1.0f81f4p-7 +0x1.125824p-7 +-0x1.1623b4p-8 +-0x1.172e54p-8 +0x1.3402cep-7 +0x1.340526p-7 +-0x1.1c2b1ap-5 +-0x1.1bd142p-5 +0x0p+0 +-0x1.0d10eap-7 +0x1.3dd0a8p-5 +0x1.14f766p-8 +-0x1.0fcc7p-7 +-0x1.33e63p-7 +0x1.15f5fap-8 +0x1.1c29eap-5 +-0x1.33e67cp-7 +0x0p+0 +0x1.1bcfd8p-5 +0x1.215734p-11 +0x1.aec08p-12 +-0x1.f2e478p-13 +0x1.3a8cc6p-10 +0x1.9e1a2ap-12 +0x1.d0948cp-13 +-0x1.ffa2a4p-11 +0x1.a14264p-10 +0x1.839aap-13 +0x1.4bd306p-14 +-0x1.900be4p-10 +0x1.d52a5cp-10 +0x1.48c5c4p-16 +0x1.3d60dcp-15 +-0x1.ec6e08p-10 +0x1.fb71acp-10 +-0x1.781feap-15 +0x1.de67ap-14 +-0x1.160dp-9 +0x1.1f0ecp-9 +0x1.a12322p-18 +0x1.f96ffcp-13 +-0x1.3f9564p-9 +0x1.5fd2e4p-9 +0x1.befa76p-14 +0x1.97beeap-13 +-0x1.928c58p-9 +0x1.b9d018p-9 +0x1.6d67b4p-15 +-0x1.25a64ep-12 +-0x1.0a17aep-8 +0x1.f567a2p-9 +-0x1.bbb41ap-12 +-0x1.13841ap-10 +-0x1.3ca5bcp-8 +0x1.b9a968p-9 +-0x1.310da2p-10 +0x1.3c7628p-5 +0x1.204ep-9 +0x1.42936ap-5 +0x1.204ep-9 +-0x1.3cf4d6p-5 +-0x1.13ddbap-10 +-0x1.42e194p-5 +0x1.42936ap-5 +-0x1.42e194p-5 +-0x1.4266b2p-5 +0x1.11201cp-7 +0x1.13cb6ap-7 +-0x1.15a8e4p-8 +-0x1.16a4dp-8 +0x1.32ed5cp-7 +0x1.32efeep-7 +-0x1.1bfe76p-5 +-0x1.1ba3dp-5 +0x0p+0 +-0x1.0e9be8p-7 +0x1.41dd8cp-5 +0x1.14755ap-8 +-0x1.112f18p-7 +-0x1.32d00ap-7 +0x1.15661ap-8 +0x1.1bfcdcp-5 +-0x1.32cfbap-7 +0x0p+0 +0x1.1ba1fep-5 +0x1.284edcp-11 +0x1.bf43b8p-12 +0x1.f28ceap-13 +0x1.8c0ffap-14 +0x1.bbd914p-15 +0x1.0746cap-13 +0x1.e9d82p-13 +0x1.4686e4p-13 +-0x1.551c14p-12 +-0x1.13ddbap-10 +-0x1.410a92p-5 +0x1.12962ap-7 +-0x1.1514f4p-8 +0x1.31dd1ap-7 +-0x1.1bd112p-5 +0x0p+0 +0x1.408822p-5 +-0x1.1000eep-7 +0x1.13dd0ap-8 +-0x1.31be38p-7 +0x1.1bcef6p-5 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.84933cp-32 +0x1.84933cp-32 +0x0p+0 +-0x1.84940cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.128ec8p-11 +0x1.8ccabp-12 +0x1.8e02fcp-13 +0x1.aff20ap-15 +0x1.4bf256p-17 +0x1.6a1e46p-14 +0x1.fd12d8p-13 +0x1.0f55e2p-12 +-0x1.a1be96p-13 +-0x1.185f48p-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x0p+0 +0x1.ab8714p-6 +-0x1.dc717ep-8 +0x1.ebce12p-9 +-0x1.0c8d5ep-7 +0x1.3511fp-5 +-0x1.358abep-5 +0x1.0ef5dcp-7 +-0x1.ee19ecp-9 +0x1.dca3fcp-8 +-0x1.ab8834p-6 +0x0p+0 +0x1.91a89ap+2 +0x0p+0 +0x1.9186d6p+2 +0x0p+0 +0x1.dca3fcp-8 +0x0p+0 +0x1.31dd1ap-7 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.84933cp-32 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.284edcp-11 +0x1.bf43b8p-12 +0x1.bf43b8p-12 +0x1.f28ceap-13 +0x1.f28ceap-13 +0x1.8c0ffap-14 +0x1.8c0ffap-14 +0x1.bbd914p-15 +0x1.bbd914p-15 +0x1.0746cap-13 +0x1.0746cap-13 +0x1.e9d82p-13 +0x1.e9d82p-13 +0x1.4686e4p-13 +0x1.4686e4p-13 +-0x1.551c14p-12 +-0x1.551c14p-12 +-0x1.13ddbap-10 +-0x1.13ddbap-10 +0x1.408822p-5 +-0x1.13ddbap-10 +-0x1.410a92p-5 +-0x1.410a92p-5 +0x1.408822p-5 +0x1.12962ap-7 +-0x1.410a92p-5 +-0x1.1514f4p-8 +0x1.12962ap-7 +0x1.31dd1ap-7 +-0x1.1514f4p-8 +-0x1.1bd112p-5 +0x1.31dd1ap-7 +0x0p+0 +-0x1.1bd112p-5 +0x1.408822p-5 +-0x1.1000eep-7 +-0x1.1000eep-7 +0x1.13dd0ap-8 +0x1.13dd0ap-8 +-0x1.31be38p-7 +-0x1.31be38p-7 +0x1.1bcef6p-5 +0x1.1bcef6p-5 +0x0p+0 +0x1.2834e4p-11 +0x1.be7bfap-12 +-0x1.b61da2p-13 +0x1.3a50ecp-10 +0x1.ae49a4p-12 +0x1.eee5ap-13 +-0x1.ed7f9ep-11 +0x1.a004bp-10 +0x1.a45faap-13 +0x1.819898p-14 +-0x1.88c1a8p-10 +0x1.d551dap-10 +0x1.18a40ep-15 +0x1.af620cp-15 +-0x1.e8ec52p-10 +0x1.ff1dcp-10 +-0x1.05226ap-15 +0x1.0e74d8p-13 +-0x1.168ed4p-9 +0x1.234dfap-9 +0x1.52898ap-16 +0x1.040c14p-12 +-0x1.422fe8p-9 +0x1.652bp-9 +0x1.d9d5fap-14 +0x1.8a7654p-13 +-0x1.94885ep-9 +0x1.bbd284p-9 +0x1.3d755ep-15 +-0x1.1c592ep-12 +-0x1.077ac4p-8 +0x1.f09e7ap-9 +-0x1.b1c784p-12 +-0x1.01e3aap-10 +-0x1.34e30ap-8 +0x1.b4261ep-9 +-0x1.1febdcp-10 +0x1.3e4644p-5 +0x1.1b516p-9 +0x1.4433acp-5 +0x1.1b516p-9 +-0x1.3ea7eep-5 +-0x1.054b4p-10 +-0x1.4469acp-5 +0x1.4433acp-5 +-0x1.4469acp-5 +-0x1.43d69p-5 +0x1.0bce3cp-7 +0x1.0e07d4p-7 +-0x1.3051ccp-8 +-0x1.30f496p-8 +0x1.7d05ecp-7 +0x1.7cd4e2p-7 +-0x1.6ba0d2p-5 +-0x1.6b080ep-5 +0x0p+0 +-0x1.09497cp-7 +0x1.434daap-5 +0x1.2f1c1ap-8 +-0x1.0b6ae8p-7 +-0x1.7cdd64p-7 +0x1.2fad94p-8 +0x1.6b9ce6p-5 +-0x1.7caac4p-7 +0x0p+0 +0x1.6b04aep-5 +0x1.2ef68ep-11 +0x1.ce44c4p-12 +-0x1.7a7d6ap-13 +0x1.3a2f44p-10 +0x1.be6084p-12 +0x1.088f8p-12 +-0x1.db3b34p-11 +0x1.9f2d14p-10 +0x1.c82396p-13 +0x1.c52352p-14 +-0x1.80cd04p-10 +0x1.d60ae6p-10 +0x1.a4b98cp-15 +0x1.1a0d62p-14 +-0x1.e43764p-10 +0x1.017598p-9 +-0x1.0169b6p-16 +0x1.24e4a2p-13 +-0x1.167a96p-9 +0x1.26b0b6p-9 +0x1.01dcd6p-15 +0x1.f5ed08p-13 +-0x1.449336p-9 +0x1.67cedap-9 +0x1.b9babep-14 +0x1.3bb3a8p-13 +-0x1.9767bap-9 +0x1.b8ccc2p-9 +0x1.c55dd6p-19 +-0x1.47fd78p-12 +-0x1.068f3ep-8 +0x1.e4d956p-9 +-0x1.d9bf48p-12 +-0x1.054b4p-10 +-0x1.306abap-8 +0x1.a47d16p-9 +-0x1.22cbf4p-10 +0x1.41e852p-5 +0x1.122552p-9 +0x1.47bae8p-5 +0x1.122552p-9 +-0x1.426ae6p-5 +-0x1.06841p-10 +-0x1.480e9ep-5 +0x1.47bae8p-5 +-0x1.480e9ep-5 +-0x1.476944p-5 +0x1.0ccb26p-7 +0x1.0eb5b4p-7 +-0x1.2f083cp-8 +-0x1.2f85e8p-8 +0x1.7b2554p-7 +0x1.7b09cep-7 +-0x1.6b543ap-5 +-0x1.6abaccp-5 +0x0p+0 +-0x1.0a3842p-7 +0x1.46dc9ep-5 +0x1.2dc46cp-8 +-0x1.0c09bcp-7 +-0x1.7af7d6p-7 +0x1.2e359ap-8 +0x1.6b4fep-5 +-0x1.7adbf2p-7 +0x0p+0 +0x1.6ab6bap-5 +0x1.359512p-11 +0x1.dda0dap-12 +-0x1.4124a2p-13 +0x1.3a29d6p-10 +0x1.ce09fcp-12 +0x1.19ce6p-12 +-0x1.c98892p-11 +0x1.9e8b94p-10 +0x1.eb90f4p-13 +0x1.056cf6p-13 +-0x1.790788p-10 +0x1.d70af4p-10 +0x1.1b1f7ep-14 +0x1.5bdbbap-14 +-0x1.df6e86p-10 +0x1.0363aep-9 +0x1.1f614ap-21 +0x1.3870d6p-13 +-0x1.16622p-9 +0x1.29e444p-9 +0x1.505a0ep-15 +0x1.e00decp-13 +-0x1.46d956p-9 +0x1.69f23ap-9 +0x1.9246cep-14 +0x1.de3f9p-14 +-0x1.99f962p-9 +0x1.b56158p-9 +-0x1.f79a74p-16 +-0x1.708bf2p-12 +-0x1.0592e6p-8 +0x1.d97828p-9 +-0x1.fedd52p-12 +-0x1.06841p-10 +-0x1.2c4822p-8 +0x1.96f03ap-9 +-0x1.23c3cap-10 +0x1.4585cep-5 +0x1.0997a6p-9 +0x1.4b3c56p-5 +0x1.0997a6p-9 +-0x1.460ba2p-5 +-0x1.07079cp-10 +-0x1.4b923ep-5 +0x1.4b3c56p-5 +-0x1.4b923ep-5 +-0x1.4ae8c4p-5 +0x1.0d8884p-7 +0x1.0f4b5p-7 +-0x1.2d63f4p-8 +-0x1.2dd7fap-8 +0x1.79429p-7 +0x1.792a24p-7 +-0x1.6b0766p-5 +-0x1.6a6e66p-5 +0x0p+0 +-0x1.0ae466p-7 +0x1.4a5864p-5 +0x1.2c1494p-8 +-0x1.0c8d4ap-7 +-0x1.7911ep-7 +0x1.2c7db2p-8 +0x1.6b02ep-5 +-0x1.78f99p-7 +0x0p+0 +0x1.6a69fep-5 +0x1.3c1084p-11 +0x1.ecdb98p-12 +0x1.2abd42p-12 +0x1.292b8p-13 +0x1.9d5f12p-14 +0x1.498456p-13 +0x1.c68a7ap-13 +0x1.4a3458p-14 +-0x1.9573aep-12 +-0x1.07079cp-10 +-0x1.498fd6p-5 +0x1.0e1ebep-7 +-0x1.2ba55ep-8 +0x1.776a1ep-7 +-0x1.6aba44p-5 +0x0p+0 +0x1.4906bap-5 +-0x1.0b67fep-7 +0x1.2a4b66p-8 +-0x1.773782p-7 +0x1.6ab5bp-5 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493c4p-32 +0x1.8493c4p-32 +0x0p+0 +-0x1.8493ep-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.284edcp-11 +0x1.bf43b8p-12 +0x1.f28ceap-13 +0x1.8c0ffap-14 +0x1.bbd914p-15 +0x1.0746cap-13 +0x1.e9d82p-13 +0x1.4686e4p-13 +-0x1.551c14p-12 +-0x1.13ddbap-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x0p+0 +0x1.1bcef6p-5 +-0x1.31be38p-7 +0x1.13dd0ap-8 +-0x1.1000eep-7 +0x1.408822p-5 +-0x1.410a92p-5 +0x1.12962ap-7 +-0x1.1514f4p-8 +0x1.31dd1ap-7 +-0x1.1bd112p-5 +0x0p+0 +0x1.9186d6p+2 +0x0p+0 +0x1.91641ap+2 +0x0p+0 +0x1.31dd1ap-7 +0x0p+0 +0x1.776a1ep-7 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493c4p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.3c1084p-11 +0x1.ecdb98p-12 +0x1.ecdb98p-12 +0x1.2abd42p-12 +0x1.2abd42p-12 +0x1.292b8p-13 +0x1.292b8p-13 +0x1.9d5f12p-14 +0x1.9d5f12p-14 +0x1.498456p-13 +0x1.498456p-13 +0x1.c68a7ap-13 +0x1.c68a7ap-13 +0x1.4a3458p-14 +0x1.4a3458p-14 +-0x1.9573aep-12 +-0x1.9573aep-12 +-0x1.07079cp-10 +-0x1.07079cp-10 +0x1.4906bap-5 +-0x1.07079cp-10 +-0x1.498fd6p-5 +-0x1.498fd6p-5 +0x1.4906bap-5 +0x1.0e1ebep-7 +-0x1.498fd6p-5 +-0x1.2ba55ep-8 +0x1.0e1ebep-7 +0x1.776a1ep-7 +-0x1.2ba55ep-8 +-0x1.6aba44p-5 +0x1.776a1ep-7 +0x0p+0 +-0x1.6aba44p-5 +0x1.4906bap-5 +-0x1.0b67fep-7 +-0x1.0b67fep-7 +0x1.2a4b66p-8 +0x1.2a4b66p-8 +-0x1.773782p-7 +-0x1.773782p-7 +0x1.6ab5bp-5 +0x1.6ab5bp-5 +0x0p+0 +0x1.3b2462p-11 +0x1.e9e5bcp-12 +-0x1.0f860cp-13 +0x1.39ce5cp-10 +0x1.dac138p-12 +0x1.262706p-12 +-0x1.ba6a38p-11 +0x1.9d3e62p-10 +0x1.02cf5cp-12 +0x1.2114b8p-13 +-0x1.72d832p-10 +0x1.d78e6p-10 +0x1.52ea98p-14 +0x1.abb368p-14 +-0x1.dc32fcp-10 +0x1.05fff2p-9 +0x1.3a841ap-16 +0x1.6c415cp-13 +-0x1.163588p-9 +0x1.2f549ap-9 +0x1.08f3p-14 +0x1.f72ebcp-13 +-0x1.47882p-9 +0x1.6f1a16p-9 +0x1.c12d18p-14 +0x1.85b8a6p-14 +-0x1.9a1434p-9 +0x1.b43908p-9 +-0x1.8f88b2p-15 +-0x1.99902p-12 +-0x1.040c12p-8 +0x1.cf087ep-9 +-0x1.115bep-11 +-0x1.0c412cp-10 +-0x1.290becp-8 +0x1.891ab6p-9 +-0x1.28d482p-10 +0x1.434edep-5 +0x1.ffb5bep-10 +-0x1.43d314p-5 +0x1.48ebd2p-5 +-0x1.493d3cp-5 +-0x1.4863dap-5 +0x1.f7ad2ap-8 +0x1.fa193ep-8 +-0x1.3a84p-8 +-0x1.3a9704p-8 +0x1.c13c2ep-7 +0x1.c0e5bep-7 +-0x1.c2e4ap-5 +-0x1.c1ef08p-5 +0x0p+0 +-0x1.f2aa8cp-8 +0x1.47daf8p-5 +0x1.393f78p-8 +-0x1.f4e87ep-8 +-0x1.c0fc24p-7 +0x1.394b16p-8 +0x1.c2dd1cp-5 +-0x1.c0a5f4p-7 +0x0p+0 +0x1.c1e774p-5 +0x1.4169ep-11 +0x1.f8eccp-12 +-0x1.b5ef24p-14 +0x1.3a207ap-10 +0x1.ea2396p-12 +0x1.3799cap-12 +-0x1.a9deacp-11 +0x1.9d2bacp-10 +0x1.14d02ep-12 +0x1.46629p-13 +-0x1.6b486p-10 +0x1.d924c8p-10 +0x1.9fae5ap-14 +0x1.ef289cp-14 +-0x1.d765fcp-10 +0x1.081926p-9 +0x1.26c8fep-15 +0x1.7914c2p-13 +-0x1.15f72p-9 +0x1.320864p-9 +0x1.2510f4p-14 +0x1.d7a2bep-13 +-0x1.498ebep-9 +0x1.700b14p-9 +0x1.8918ccp-14 +0x1.e3c654p-15 +-0x1.9c3e08p-9 +0x1.b00b44p-9 +-0x1.504e7cp-14 +-0x1.bac792p-12 +-0x1.031052p-8 +0x1.c4ad3cp-9 +-0x1.20b372p-11 +-0x1.0a8f86p-10 +-0x1.254a04p-8 +0x1.7e902cp-9 +-0x1.273c18p-10 +0x1.46751cp-5 +0x1.f31ec2p-10 +-0x1.46f736p-5 +0x1.4bf95ap-5 +-0x1.4c48c6p-5 +-0x1.4b6cb2p-5 +0x1.f7b066p-8 +0x1.f9989p-8 +-0x1.37d226p-8 +-0x1.37cd4ap-8 +0x1.be2e2ap-7 +0x1.bdfbacp-7 +-0x1.c268a2p-5 +-0x1.c172f6p-5 +0x0p+0 +-0x1.f28bf6p-8 +0x1.4adf8cp-5 +0x1.3686e8p-8 +-0x1.f443cep-8 +-0x1.bdedf8p-7 +0x1.367a4ap-8 +0x1.c26106p-5 +-0x1.bdba7cp-7 +0x0p+0 +0x1.c16b62p-5 +0x1.4784a2p-11 +0x1.03e396p-11 +-0x1.511402p-14 +0x1.3a9634p-10 +0x1.f91592p-12 +0x1.490806p-12 +-0x1.99e78ap-11 +0x1.9d45fep-10 +0x1.26c146p-12 +0x1.6bdaaep-13 +-0x1.63e28ap-10 +0x1.dae68ap-10 +0x1.eb9e94p-14 +0x1.18537ep-13 +-0x1.d2a812p-10 +0x1.0a23a2p-9 +0x1.aaf0cep-15 +0x1.8372ep-13 +-0x1.15c11ep-9 +0x1.3487f2p-9 +0x1.3c06bcp-14 +0x1.b6e038p-13 +-0x1.4b76b4p-9 +0x1.70a0fp-9 +0x1.4e887cp-14 +0x1.90fc8ap-16 +-0x1.9e247p-9 +0x1.abb772p-9 +-0x1.d32e06p-14 +-0x1.d83fd6p-12 +-0x1.0209fep-8 +0x1.bae0eap-9 +-0x1.2e596ep-11 +-0x1.092p-10 +-0x1.21b2c4p-8 +0x1.74a71p-9 +-0x1.25d544p-10 +0x1.4984d4p-5 +0x1.e6964cp-10 +-0x1.4a0aecp-5 +0x1.4ef0c4p-5 +-0x1.4f43ecp-5 +-0x1.4e62c2p-5 +0x1.f744dcp-8 +0x1.f8e8bcp-8 +-0x1.34b7dep-8 +-0x1.34b7dep-8 +0x1.bb22ccp-7 +0x1.baf852p-7 +-0x1.c1ed36p-5 +-0x1.c0f904p-5 +0x0p+0 +-0x1.f1fcd4p-8 +0x1.4dd204p-5 +0x1.33681ep-8 +-0x1.f36eb4p-8 +-0x1.bae224p-7 +0x1.335a96p-8 +0x1.c1e5bp-5 +-0x1.bab60ap-7 +0x0p+0 +0x1.c0f18cp-5 +0x1.4d962ep-11 +0x1.0b1dc2p-11 +0x1.5aaf4cp-12 +0x1.9146dcp-13 +0x1.37e0bep-13 +0x1.8b558ep-13 +0x1.952acep-13 +-0x1.1554a6p-17 +-0x1.f2a92cp-12 +-0x1.07aa0ep-10 +-0x1.4d0488p-5 +0x1.f68aep-8 +-0x1.318992p-8 +0x1.b82e64p-7 +-0x1.c17296p-5 +0x0p+0 +0x1.4c7b0cp-5 +-0x1.f123aap-8 +0x1.30310ep-8 +-0x1.b7ebccp-7 +0x1.c16b4cp-5 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.3c1084p-11 +0x1.ecdb98p-12 +0x1.2abd42p-12 +0x1.292b8p-13 +0x1.9d5f12p-14 +0x1.498456p-13 +0x1.c68a7ap-13 +0x1.4a3458p-14 +-0x1.9573aep-12 +-0x1.07079cp-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.6ab5bp-5 +-0x1.773782p-7 +0x1.2a4b66p-8 +-0x1.0b67fep-7 +0x1.4906bap-5 +-0x1.498fd6p-5 +0x1.0e1ebep-7 +-0x1.2ba55ep-8 +0x1.776a1ep-7 +-0x1.6aba44p-5 +0x0p+0 +0x1.91641ap+2 +0x0p+0 +0x1.9143cp+2 +0x0p+0 +0x1.776a1ep-7 +0x0p+0 +0x1.b82e64p-7 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.4d962ep-11 +0x1.0b1dc2p-11 +0x1.0b1dc2p-11 +0x1.5aaf4cp-12 +0x1.5aaf4cp-12 +0x1.9146dcp-13 +0x1.9146dcp-13 +0x1.37e0bep-13 +0x1.37e0bep-13 +0x1.8b558ep-13 +0x1.8b558ep-13 +0x1.952acep-13 +0x1.952acep-13 +-0x1.1554a6p-17 +-0x1.1554a6p-17 +-0x1.f2a92cp-12 +-0x1.f2a92cp-12 +-0x1.07aa0ep-10 +-0x1.07aa0ep-10 +0x1.4c7b0cp-5 +-0x1.07aa0ep-10 +-0x1.4d0488p-5 +-0x1.4d0488p-5 +0x1.4c7b0cp-5 +0x1.f68aep-8 +-0x1.4d0488p-5 +-0x1.318992p-8 +0x1.f68aep-8 +0x1.b82e64p-7 +-0x1.318992p-8 +-0x1.c17296p-5 +0x1.b82e64p-7 +0x0p+0 +-0x1.c17296p-5 +0x1.4c7b0cp-5 +-0x1.f123aap-8 +-0x1.f123aap-8 +0x1.30310ep-8 +0x1.30310ep-8 +-0x1.b7ebccp-7 +-0x1.b7ebccp-7 +0x1.c16b4cp-5 +0x1.c16b4cp-5 +0x0p+0 +0x1.4a2f16p-11 +0x1.07709p-11 +-0x1.10501cp-14 +0x1.39a514p-10 +0x1.004c3ap-11 +0x1.5641e6p-12 +-0x1.8efc3cp-11 +0x1.9cfcaap-10 +0x1.33bccep-12 +0x1.9b34f2p-13 +-0x1.5e86eep-10 +0x1.deaf5p-10 +0x1.2309a4p-13 +0x1.5a3944p-13 +-0x1.ce060cp-10 +0x1.0ec14cp-9 +0x1.5388cap-14 +0x1.b635bap-13 +-0x1.144ffep-9 +0x1.3a3266p-9 +0x1.a1cf6cp-14 +0x1.a95372p-13 +-0x1.4ba3ccp-9 +0x1.732826p-9 +0x1.3f1074p-14 +-0x1.39fe74p-16 +-0x1.9f98fep-9 +0x1.a7259cp-9 +-0x1.3912b2p-13 +-0x1.074d8ep-11 +-0x1.022b92p-8 +0x1.af6a56p-9 +-0x1.479f76p-11 +-0x1.108bb2p-10 +-0x1.209182p-8 +0x1.68574ep-9 +-0x1.2d1cfcp-10 +0x1.4288e6p-5 +0x1.d3c67cp-10 +-0x1.430144p-5 +0x1.47dfd2p-5 +-0x1.48224cp-5 +-0x1.470a02p-5 +0x1.b0081cp-8 +0x1.b08e5ep-8 +-0x1.29d4fep-8 +-0x1.2991a4p-8 +0x1.f82004p-7 +0x1.f7b7dcp-7 +-0x1.104d04p-4 +-0x1.0f90fcp-4 +0x0p+0 +-0x1.ab7388p-8 +0x1.46892p-5 +0x1.28bb4ap-8 +-0x1.abc61ep-8 +-0x1.f7d8d2p-7 +0x1.286ed2p-8 +0x1.104844p-4 +-0x1.f77354p-7 +0x0p+0 +0x1.0f8cb4p-4 +0x1.500ddp-11 +0x1.0efc0ap-11 +-0x1.651d62p-15 +0x1.3a7d86p-10 +0x1.07d56ep-11 +0x1.68995p-12 +-0x1.7fa652p-11 +0x1.9da9ecp-10 +0x1.46641p-12 +0x1.c0df4cp-13 +-0x1.57570ep-10 +0x1.e0dae8p-10 +0x1.49b45ap-13 +0x1.76494p-13 +-0x1.c960f2p-10 +0x1.1098acp-9 +0x1.8e2c9ap-14 +0x1.b8779p-13 +-0x1.14272ep-9 +0x1.3c0276p-9 +0x1.aaf09cp-14 +0x1.84d65cp-13 +-0x1.4d736cp-9 +0x1.72fbdcp-9 +0x1.fc471p-15 +-0x1.984348p-15 +-0x1.a1134cp-9 +0x1.a2b20ep-9 +-0x1.73541ep-13 +-0x1.128c6cp-11 +-0x1.010744p-8 +0x1.a6b23ap-9 +-0x1.520ddap-11 +-0x1.0d6ddep-10 +-0x1.1d20eep-8 +0x1.605fccp-9 +-0x1.2a243ep-10 +0x1.451936p-5 +0x1.cb48ep-10 +-0x1.45924ep-5 +0x1.4a5c24p-5 +-0x1.4a9fd8p-5 +-0x1.49833ep-5 +0x1.ae231ep-8 +0x1.ae10f6p-8 +-0x1.25973cp-8 +-0x1.2538a2p-8 +0x1.f38842p-7 +0x1.f353e6p-7 +-0x1.0fee7ap-4 +-0x1.0f3394p-4 +0x0p+0 +-0x1.a96a5p-8 +0x1.48fddp-5 +0x1.247216p-8 +-0x1.a92072p-8 +-0x1.f3442p-7 +0x1.240a2p-8 +0x1.0fe9f2p-4 +-0x1.f31034p-7 +0x0p+0 +0x1.0f2f7p-4 +0x1.55f0acp-11 +0x1.165e7p-11 +-0x1.5e838cp-16 +0x1.3b70bep-10 +0x1.0f34a8p-11 +0x1.7ab452p-12 +-0x1.70e7a4p-11 +0x1.9e7ec8p-10 +0x1.58a9bcp-12 +0x1.e60df8p-13 +-0x1.50481cp-10 +0x1.e2ffa4p-10 +0x1.6f72bap-13 +0x1.91068ep-13 +-0x1.c4e37ap-10 +0x1.126002p-9 +0x1.c5f8b6p-14 +0x1.b9095p-13 +-0x1.13fbcap-9 +0x1.3d9e52p-9 +0x1.afe004p-14 +0x1.60ca86p-13 +-0x1.4f1b32p-9 +0x1.728d44p-9 +0x1.7959b2p-15 +-0x1.43335cp-14 +-0x1.a24f92p-9 +0x1.9e305p-9 +-0x1.aacd66p-13 +-0x1.1c6e22p-11 +-0x1.ffb912p-9 +0x1.9e704ep-9 +-0x1.5b3e2p-11 +-0x1.0acaa2p-10 +-0x1.19d704p-8 +0x1.58c8cap-9 +-0x1.2794ap-10 +0x1.479c56p-5 +0x1.c27a7p-10 +-0x1.481968p-5 +0x1.4ccb6ap-5 +-0x1.4d136p-5 +-0x1.4bf17ap-5 +0x1.abc414p-8 +0x1.ab70fap-8 +-0x1.20d392p-8 +-0x1.2081ep-8 +0x1.eef81ap-7 +0x1.eed026p-7 +-0x1.0f90e8p-4 +-0x1.0ed7cap-4 +0x0p+0 +-0x1.a6e32ep-8 +0x1.4b6854p-5 +0x1.1fa762p-8 +-0x1.a65a1ap-8 +-0x1.eeb4dep-7 +0x1.1f4b5cp-8 +0x1.0f8c56p-4 +-0x1.ee8c8ap-7 +0x0p+0 +0x1.0ed366p-4 +0x1.5bd856p-11 +0x1.1da9p-11 +0x1.8ca632p-12 +0x1.0535a4p-12 +0x1.aac7acp-13 +0x1.b8444cp-13 +0x1.3cfad8p-13 +-0x1.b406f2p-14 +-0x1.253896p-11 +-0x1.0871b6p-10 +-0x1.4a8b6p-5 +0x1.a91786p-8 +-0x1.1c0144p-8 +0x1.ea8bdcp-7 +-0x1.0f33dcp-4 +0x0p+0 +0x1.4a0a5ap-5 +-0x1.a411a2p-8 +0x1.1ace92p-8 +-0x1.ea4918p-7 +0x1.0f2f7ep-4 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.4d962ep-11 +0x1.0b1dc2p-11 +0x1.5aaf4cp-12 +0x1.9146dcp-13 +0x1.37e0bep-13 +0x1.8b558ep-13 +0x1.952acep-13 +-0x1.1554a6p-17 +-0x1.f2a92cp-12 +-0x1.07aa0ep-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.c16b4cp-5 +-0x1.b7ebccp-7 +0x1.30310ep-8 +-0x1.f123aap-8 +0x1.4c7b0cp-5 +-0x1.4d0488p-5 +0x1.f68aep-8 +-0x1.318992p-8 +0x1.b82e64p-7 +-0x1.c17296p-5 +0x0p+0 +0x1.9143cp+2 +0x0p+0 +0x1.912a92p+2 +0x0p+0 +0x1.b82e64p-7 +0x0p+0 +0x1.ea8bdcp-7 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.5bd856p-11 +0x1.1da9p-11 +0x1.1da9p-11 +0x1.8ca632p-12 +0x1.8ca632p-12 +0x1.0535a4p-12 +0x1.0535a4p-12 +0x1.aac7acp-13 +0x1.aac7acp-13 +0x1.b8444cp-13 +0x1.b8444cp-13 +0x1.3cfad8p-13 +0x1.3cfad8p-13 +-0x1.b406f2p-14 +-0x1.b406f2p-14 +-0x1.253896p-11 +-0x1.253896p-11 +-0x1.0871b6p-10 +-0x1.0871b6p-10 +0x1.4a0a5ap-5 +-0x1.0871b6p-10 +-0x1.4a8b6p-5 +-0x1.4a8b6p-5 +0x1.4a0a5ap-5 +0x1.a91786p-8 +-0x1.4a8b6p-5 +-0x1.1c0144p-8 +0x1.a91786p-8 +0x1.ea8bdcp-7 +-0x1.1c0144p-8 +-0x1.0f33dcp-4 +0x1.ea8bdcp-7 +0x0p+0 +-0x1.0f33dcp-4 +0x1.4a0a5ap-5 +-0x1.a411a2p-8 +-0x1.a411a2p-8 +0x1.1ace92p-8 +0x1.1ace92p-8 +-0x1.ea4918p-7 +-0x1.ea4918p-7 +0x1.0f2f7ep-4 +0x1.0f2f7ep-4 +0x0p+0 +0x1.55d8aap-11 +0x1.1a4d12p-11 +-0x1.ca145ap-17 +0x1.3b74eap-10 +0x1.12f4e6p-11 +0x1.90c696p-12 +-0x1.67f322p-11 +0x1.a16532p-10 +0x1.6d4802p-12 +0x1.14f4b6p-12 +-0x1.4a004ap-10 +0x1.ea550ap-10 +0x1.b05eeep-13 +0x1.d2b218p-13 +-0x1.beb0bp-10 +0x1.176e22p-9 +0x1.241544p-13 +0x1.cfb424p-13 +-0x1.127414p-9 +0x1.4194p-9 +0x1.e374f4p-14 +0x1.30fc44p-13 +-0x1.505128p-9 +0x1.7268eap-9 +0x1.aa0e14p-16 +-0x1.0b6c8p-13 +-0x1.a54af8p-9 +0x1.9806dep-9 +-0x1.066a5ep-12 +-0x1.37ee7ep-11 +-0x1.00dcfep-8 +0x1.9376ap-9 +-0x1.7577c4p-11 +-0x1.1350b2p-10 +-0x1.19bee6p-8 +0x1.4dc154p-9 +-0x1.300f02p-10 +0x1.3a8488p-5 +0x1.b16356p-10 +-0x1.3ae9acp-5 +0x1.3fa30ep-5 +-0x1.3fcfecp-5 +-0x1.3e733p-5 +0x1.342df8p-8 +0x1.32eb66p-8 +-0x1.e2b3ep-9 +-0x1.e24076p-9 +0x1.0a6f5cp-6 +0x1.0a4d06p-6 +-0x1.414c88p-4 +-0x1.403d44p-4 +0x0p+0 +-0x1.3071a2p-8 +0x1.3e03e8p-5 +0x1.e13ecap-9 +-0x1.2ef8c8p-8 +-0x1.0a55bcp-6 +0x1.e0b8cap-9 +0x1.41485p-4 +-0x1.0a3302p-6 +0x0p+0 +0x1.40396ap-4 +0x1.5bec48p-11 +0x1.2218fcp-11 +0x1.00374cp-17 +0x1.3ccf7cp-10 +0x1.1aaa9ap-11 +0x1.a29364p-12 +-0x1.59b74ep-11 +0x1.a29342p-10 +0x1.7f8a0ep-12 +0x1.25c5b4p-12 +-0x1.4345aap-10 +0x1.ec5c04p-10 +0x1.d2d63p-13 +0x1.e88d42p-13 +-0x1.baacdcp-10 +0x1.18fp-9 +0x1.3b2fbp-13 +0x1.cba316p-13 +-0x1.1267b8p-9 +0x1.42b85cp-9 +0x1.e02a92p-14 +0x1.0d4838p-13 +-0x1.51bf72p-9 +0x1.7184ap-9 +0x1.557528p-17 +-0x1.3f666p-13 +-0x1.a6155p-9 +0x1.939854p-9 +-0x1.1e9414p-12 +-0x1.3f5472p-11 +-0x1.ff3452p-9 +0x1.8c147p-9 +-0x1.7c6238p-11 +-0x1.0f4bbp-10 +-0x1.169678p-8 +0x1.47af1p-9 +-0x1.2c3568p-10 +0x1.3c8bap-5 +0x1.ac5b26p-10 +-0x1.3cf2b4p-5 +0x1.419aa6p-5 +-0x1.41ca58p-5 +-0x1.40682ep-5 +0x1.30986cp-8 +0x1.2ea4b6p-8 +-0x1.d72f94p-9 +-0x1.d672fp-9 +0x1.07369p-6 +0x1.073506p-6 +-0x1.40c3c4p-4 +-0x1.3fb74cp-4 +0x0p+0 +-0x1.2cb56ep-8 +0x1.3ff506p-5 +0x1.d5b0fp-9 +-0x1.2a8c6p-8 +-0x1.071deep-6 +0x1.d4de4ep-9 +0x1.40bffep-4 +-0x1.071ba6p-6 +0x0p+0 +0x1.3fb3bap-4 +0x1.62171ap-11 +0x1.2994p-11 +0x1.dc08dap-16 +0x1.3e3222p-10 +0x1.2231eep-11 +0x1.b46002p-12 +-0x1.4bd7ecp-11 +0x1.a3d858p-10 +0x1.918894p-12 +0x1.3649cap-12 +-0x1.3cbbcp-10 +0x1.ee6fbp-10 +0x1.f4f40ep-13 +0x1.fd0f8cp-13 +-0x1.b6be64p-10 +0x1.1a617ap-9 +0x1.5116dcp-13 +0x1.c6604ap-13 +-0x1.12589ep-9 +0x1.43b3c2p-9 +0x1.daf636p-14 +0x1.d555cap-14 +-0x1.530266p-9 +0x1.70770cp-9 +-0x1.433bacp-18 +-0x1.70156cp-13 +-0x1.a6aaep-9 +0x1.8f30e2p-9 +-0x1.35264ap-12 +-0x1.45be78p-11 +-0x1.fca274p-9 +0x1.851772p-9 +-0x1.824dd6p-11 +-0x1.0bf88p-10 +-0x1.138f06p-8 +0x1.41c6ap-9 +-0x1.28f8e4p-10 +0x1.3e8e82p-5 +0x1.a69d9ap-10 +-0x1.3ef98ap-5 +0x1.438ddap-5 +-0x1.43c21p-5 +-0x1.425b2ap-5 +0x1.2c80fap-8 +0x1.2a55fep-8 +-0x1.ca6bf8p-9 +-0x1.c9de5ep-9 +0x1.0402bep-6 +0x1.040a3ap-6 +-0x1.403d2p-4 +-0x1.3f33b4p-4 +0x0p+0 +-0x1.287a1ap-8 +0x1.41e3b2p-5 +0x1.c8e488p-9 +-0x1.261602p-8 +-0x1.03eb04p-6 +0x1.c84024p-9 +0x1.40398ap-4 +-0x1.03f274p-6 +0x0p+0 +0x1.3f3054p-4 +0x1.683688p-11 +0x1.31020ap-11 +0x1.c5c8d4p-12 +0x1.468f6ap-12 +0x1.0814p-12 +0x1.c0cd14p-13 +0x1.913e52p-14 +-0x1.9dbec8p-13 +-0x1.4b5362p-11 +-0x1.0914bap-10 +-0x1.40f008p-5 +0x1.282368p-8 +-0x1.bda15ap-9 +0x1.00e99ep-6 +-0x1.3fb7f2p-4 +0x0p+0 +0x1.408122p-5 +-0x1.23f582p-8 +0x1.bc095ap-9 +-0x1.00d2f4p-6 +0x1.3fb47cp-4 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.5bd856p-11 +0x1.1da9p-11 +0x1.8ca632p-12 +0x1.0535a4p-12 +0x1.aac7acp-13 +0x1.b8444cp-13 +0x1.3cfad8p-13 +-0x1.b406f2p-14 +-0x1.253896p-11 +-0x1.0871b6p-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.0f2f7ep-4 +-0x1.ea4918p-7 +0x1.1ace92p-8 +-0x1.a411a2p-8 +0x1.4a0a5ap-5 +-0x1.4a8b6p-5 +0x1.a91786p-8 +-0x1.1c0144p-8 +0x1.ea8bdcp-7 +-0x1.0f33dcp-4 +0x0p+0 +0x1.912a92p+2 +0x0p+0 +0x1.911ee4p+2 +0x0p+0 +0x1.ea8bdcp-7 +0x0p+0 +0x1.00e99ep-6 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.683688p-11 +0x1.31020ap-11 +0x1.31020ap-11 +0x1.c5c8d4p-12 +0x1.c5c8d4p-12 +0x1.468f6ap-12 +0x1.468f6ap-12 +0x1.0814p-12 +0x1.0814p-12 +0x1.c0cd14p-13 +0x1.c0cd14p-13 +0x1.913e52p-14 +0x1.913e52p-14 +-0x1.9dbec8p-13 +-0x1.9dbec8p-13 +-0x1.4b5362p-11 +-0x1.4b5362p-11 +-0x1.0914bap-10 +-0x1.0914bap-10 +0x1.408122p-5 +-0x1.0914bap-10 +-0x1.40f008p-5 +-0x1.40f008p-5 +0x1.408122p-5 +0x1.282368p-8 +-0x1.40f008p-5 +-0x1.bda15ap-9 +0x1.282368p-8 +0x1.00e99ep-6 +-0x1.bda15ap-9 +-0x1.3fb7f2p-4 +0x1.00e99ep-6 +0x0p+0 +-0x1.3fb7f2p-4 +0x1.408122p-5 +-0x1.23f582p-8 +-0x1.23f582p-8 +0x1.bc095ap-9 +0x1.bc095ap-9 +-0x1.00d2f4p-6 +-0x1.00d2f4p-6 +0x1.3fb47cp-4 +0x1.3fb47cp-4 +0x0p+0 +0x1.656c7ap-11 +0x1.31f9b2p-11 +0x1.52a858p-15 +0x1.40e91ap-10 +0x1.2a0e3ap-11 +0x1.d1fe88p-12 +-0x1.3fee6ap-11 +0x1.a935b8p-10 +0x1.ad9d14p-12 +0x1.587208p-12 +-0x1.354cfep-10 +0x1.f68c02p-10 +0x1.1c2f46p-12 +0x1.15bdf2p-12 +-0x1.b09cdap-10 +0x1.1e6d86p-9 +0x1.812442p-13 +0x1.c0f21cp-13 +-0x1.11b6e8p-9 +0x1.45be3ap-9 +0x1.d8c482p-14 +0x1.4c87ccp-14 +-0x1.55687ap-9 +0x1.6e8afp-9 +-0x1.1fac16p-15 +-0x1.ddf1e4p-13 +-0x1.aa8b6cp-9 +0x1.885e4p-9 +-0x1.68ecc2p-12 +-0x1.6062e2p-11 +-0x1.ff7c38p-9 +0x1.7ad31p-9 +-0x1.9c208p-11 +-0x1.150cp-10 +-0x1.14218p-8 +0x1.37e7eap-9 +-0x1.320ad6p-10 +0x1.2a2232p-5 +0x1.9790bcp-10 +-0x1.2a6a3cp-5 +0x1.2f14dp-5 +-0x1.2f22f4p-5 +-0x1.2d862p-5 +0x1.e6b5acp-10 +0x1.dc59bp-10 +-0x1.09b956p-9 +-0x1.0ac2c8p-9 +0x1.0403p-6 +0x1.042378p-6 +-0x1.731024p-4 +-0x1.719dfep-4 +0x0p+0 +-0x1.dd1cc8p-10 +0x1.2d32aep-5 +0x1.098d34p-9 +-0x1.d1c158p-10 +-0x1.040006p-6 +0x1.0a80d6p-9 +0x1.730e6cp-4 +-0x1.042172p-6 +0x0p+0 +0x1.719d06p-4 +0x1.6c111cp-11 +0x1.3998eep-11 +0x1.00d2dp-14 +0x1.429288p-10 +0x1.31be3ep-11 +0x1.e23164p-12 +-0x1.32ba0ep-11 +0x1.aa7e7ap-10 +0x1.be1946p-12 +0x1.6758dcp-12 +-0x1.2f501p-10 +0x1.f8651cp-10 +0x1.2b6c02p-12 +0x1.1deab8p-12 +-0x1.ad1392p-10 +0x1.1f9508p-9 +0x1.92b52cp-13 +0x1.b97bfp-13 +-0x1.11ade8p-9 +0x1.465758p-9 +0x1.cec97ep-14 +0x1.0afecep-14 +-0x1.567794p-9 +0x1.6d40c8p-9 +-0x1.966e6cp-15 +-0x1.03a0fap-12 +-0x1.aabeeep-9 +0x1.8425e2p-9 +-0x1.7c30e6p-12 +-0x1.65085ep-11 +-0x1.fccaf8p-9 +0x1.7490bp-9 +-0x1.a06058p-11 +-0x1.10932ep-10 +-0x1.1134c6p-8 +0x1.33324p-9 +-0x1.2dc4acp-10 +0x1.2bbbd6p-5 +0x1.94f758p-10 +-0x1.2c060ep-5 +0x1.30a278p-5 +-0x1.30b3d6p-5 +-0x1.2f11b6p-5 +0x1.d47896p-10 +0x1.c6dbf8p-10 +-0x1.f88996p-10 +-0x1.f98a6cp-10 +0x1.ff9ae8p-7 +0x1.00113cp-6 +-0x1.72561ap-4 +-0x1.70e8cep-4 +0x0p+0 +-0x1.ca1d58p-10 +0x1.2eba48p-5 +0x1.f7fdaap-10 +-0x1.bba31p-10 +-0x1.ff966ap-7 +0x1.f8dd48p-10 +0x1.725488p-4 +-0x1.000f34p-6 +0x0p+0 +0x1.70e7bcp-4 +0x1.72a578p-11 +0x1.4123dep-11 +0x1.55d9cp-14 +0x1.44512cp-10 +0x1.395892p-11 +0x1.f24e3p-12 +-0x1.25babap-11 +0x1.abd16ep-10 +0x1.ce9d08p-12 +0x1.75e792p-12 +-0x1.2978ecp-10 +0x1.fa4ffp-10 +0x1.3a7018p-12 +0x1.256b88p-12 +-0x1.a9aa4ep-10 +0x1.20b00ep-9 +0x1.a34d3cp-13 +0x1.b1aa36p-13 +-0x1.119db4p-9 +0x1.46d402p-9 +0x1.c45d16p-14 +0x1.97a2ccp-15 +-0x1.575738p-9 +0x1.6bd662p-9 +-0x1.058db2p-14 +-0x1.170fd8p-12 +-0x1.aad0e8p-9 +0x1.7ffb2cp-9 +-0x1.8e374ep-12 +-0x1.68c8ccp-11 +-0x1.fa0ba2p-9 +0x1.6ea0cap-9 +-0x1.a3d01ep-11 +-0x1.0ce558p-10 +-0x1.0e6a68p-8 +0x1.2e90eap-9 +-0x1.2a3074p-10 +0x1.2d5944p-5 +0x1.916ddap-10 +-0x1.2da886p-5 +0x1.323378p-5 +-0x1.324a92p-5 +-0x1.30a352p-5 +0x1.c0542ep-10 +0x1.b1cadep-10 +-0x1.dabf6p-10 +-0x1.dc25eap-10 +0x1.f73776p-7 +0x1.f7d972p-7 +-0x1.719eeep-4 +-0x1.7036ecp-4 +0x0p+0 +-0x1.b54edap-10 +0x1.304856p-5 +0x1.da1556p-10 +-0x1.a5f51cp-10 +-0x1.f7342p-7 +0x1.db5e7ap-10 +0x1.719d9ep-4 +-0x1.f7d5e2p-7 +0x0p+0 +0x1.7035d4p-4 +0x1.792ac8p-11 +0x1.488a52p-11 +0x1.012966p-11 +0x1.840f2p-12 +0x1.2c60ccp-12 +0x1.aa4d16p-13 +0x1.1b25b6p-15 +-0x1.29226ap-12 +-0x1.6bea1ap-11 +-0x1.09b7dcp-10 +-0x1.2f3f3cp-5 +0x1.ab235cp-10 +-0x1.bced24p-10 +0x1.ef1a54p-7 +-0x1.70ea3ap-4 +0x0p+0 +0x1.2eec08p-5 +-0x1.9f7e72p-10 +0x1.bc2d72p-10 +-0x1.ef18a2p-7 +0x1.70e946p-4 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.683688p-11 +0x1.31020ap-11 +0x1.c5c8d4p-12 +0x1.468f6ap-12 +0x1.0814p-12 +0x1.c0cd14p-13 +0x1.913e52p-14 +-0x1.9dbec8p-13 +-0x1.4b5362p-11 +-0x1.0914bap-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.3fb47cp-4 +-0x1.00d2f4p-6 +0x1.bc095ap-9 +-0x1.23f582p-8 +0x1.408122p-5 +-0x1.40f008p-5 +0x1.282368p-8 +-0x1.bda15ap-9 +0x1.00e99ep-6 +-0x1.3fb7f2p-4 +0x0p+0 +0x1.911ee4p+2 +0x0p+0 +0x1.91282ap+2 +0x0p+0 +0x1.00e99ep-6 +0x0p+0 +0x1.ef1a54p-7 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.792ac8p-11 +0x1.488a52p-11 +0x1.488a52p-11 +0x1.012966p-11 +0x1.012966p-11 +0x1.840f2p-12 +0x1.840f2p-12 +0x1.2c60ccp-12 +0x1.2c60ccp-12 +0x1.aa4d16p-13 +0x1.aa4d16p-13 +0x1.1b25b6p-15 +0x1.1b25b6p-15 +-0x1.29226ap-12 +-0x1.29226ap-12 +-0x1.6bea1ap-11 +-0x1.6bea1ap-11 +-0x1.09b7dcp-10 +-0x1.09b7dcp-10 +0x1.2eec08p-5 +-0x1.09b7dcp-10 +-0x1.2f3f3cp-5 +-0x1.2f3f3cp-5 +0x1.2eec08p-5 +0x1.ab235cp-10 +-0x1.2f3f3cp-5 +-0x1.bced24p-10 +0x1.ab235cp-10 +0x1.ef1a54p-7 +-0x1.bced24p-10 +-0x1.70ea3ap-4 +0x1.ef1a54p-7 +0x0p+0 +-0x1.70ea3ap-4 +0x1.2eec08p-5 +-0x1.9f7e72p-10 +-0x1.9f7e72p-10 +0x1.bc2d72p-10 +0x1.bc2d72p-10 +-0x1.ef18a2p-7 +-0x1.ef18a2p-7 +0x1.70e946p-4 +0x1.70e946p-4 +0x0p+0 +0x1.7e8f28p-11 +0x1.4f89f6p-11 +0x1.c8038ep-14 +0x1.4a5564p-10 +0x1.4788d4p-11 +0x1.0955bep-11 +-0x1.14b8bep-11 +0x1.b27da2p-10 +0x1.eec72cp-12 +0x1.919e98p-12 +-0x1.2159dep-10 +0x1.00938ep-9 +0x1.56aa26p-12 +0x1.303634p-12 +-0x1.a4e088p-10 +0x1.232c0ep-9 +0x1.bc5dfap-13 +0x1.94c5ep-13 +-0x1.120b1ep-9 +0x1.4706b6p-9 +0x1.946b42p-14 +0x1.4d1c58p-17 +-0x1.5a92b2p-9 +0x1.6885f8p-9 +-0x1.9aa8e6p-14 +-0x1.4c3f48p-12 +-0x1.af1902p-9 +0x1.78fa26p-9 +-0x1.c1449cp-12 +-0x1.80c874p-11 +-0x1.fd2ccep-9 +0x1.65624p-9 +-0x1.bb4a9p-11 +-0x1.155f5ap-10 +-0x1.0f35dep-8 +0x1.260768p-9 +-0x1.32b0fap-10 +0x1.10dd86p-5 +0x1.84d4d2p-10 +-0x1.10ff5cp-5 +0x1.15ad6ap-5 +-0x1.159442p-5 +-0x1.13c67ap-5 +-0x1.0642a8p-9 +-0x1.0cb244p-9 +0x1.151188p-11 +0x1.03646ep-11 +0x1.c140ap-7 +0x1.c2a946p-7 +-0x1.a3fe0ep-4 +-0x1.a22162p-4 +0x0p+0 +0x1.079e7p-9 +0x1.1399f8p-5 +-0x1.0f48acp-11 +0x1.0e7832p-9 +-0x1.c179fcp-7 +-0x1.fc0212p-12 +0x1.a4003ep-4 +-0x1.c2e086p-7 +0x0p+0 +0x1.a2239ep-4 +0x1.854768p-11 +0x1.56ce56p-11 +0x1.0d936ap-13 +0x1.4c20f6p-10 +0x1.4eee9p-11 +0x1.10f51ap-11 +-0x1.088e26p-11 +0x1.b3e942p-10 +0x1.fe54ep-12 +0x1.9e8014p-12 +-0x1.1be53cp-10 +0x1.0165fcp-9 +0x1.642c6cp-12 +0x1.36799ep-12 +-0x1.a1c542p-10 +0x1.241654p-9 +0x1.cad35cp-13 +0x1.8c2b34p-13 +-0x1.11ebep-9 +0x1.4745b4p-9 +0x1.879536p-14 +-0x1.cdf5aep-19 +-0x1.5b358ep-9 +0x1.670408p-9 +-0x1.cda372p-14 +-0x1.5cbe96p-12 +-0x1.aec476p-9 +0x1.750108p-9 +-0x1.d093ccp-12 +-0x1.834448p-11 +-0x1.fa5ceep-9 +0x1.60094ap-9 +-0x1.bd845ap-11 +-0x1.10c088p-10 +-0x1.0c8374p-8 +0x1.225bacp-9 +-0x1.2e3852p-10 +0x1.12387p-5 +0x1.837d2p-10 +-0x1.125dap-5 +0x1.16fe34p-5 +-0x1.16e99ap-5 +-0x1.15166ep-5 +-0x1.0ec1a6p-9 +-0x1.1703f6p-9 +0x1.4a03p-11 +0x1.3ba46ap-11 +0x1.b7071cp-7 +0x1.b8b112p-7 +-0x1.a30e9ap-4 +-0x1.a13996p-4 +0x0p+0 +0x1.106dfap-9 +0x1.14e59cp-5 +-0x1.4487dp-11 +0x1.1926eep-9 +-0x1.b741p-7 +-0x1.3684d2p-11 +0x1.a3110ap-4 +-0x1.b8ea5p-7 +0x0p+0 +0x1.a13c2p-4 +0x1.8bde9p-11 +0x1.5e0bcap-11 +0x1.35a92cp-13 +0x1.4e07fep-10 +0x1.562b98p-11 +0x1.1867a8p-11 +-0x1.f979e6p-12 +0x1.b556e2p-10 +0x1.06d65p-11 +0x1.aafd0cp-12 +-0x1.169e4p-10 +0x1.023bf6p-9 +0x1.714e24p-12 +0x1.3c9828p-12 +-0x1.9eb348p-10 +0x1.24f498p-9 +0x1.d89492p-13 +0x1.837d7ap-13 +-0x1.11b936p-9 +0x1.4764dap-9 +0x1.7addb2p-14 +-0x1.1239a4p-16 +-0x1.5bb02ep-9 +0x1.656a5ep-9 +-0x1.fe93eap-14 +-0x1.6c1044p-12 +-0x1.ae53ep-9 +0x1.7121ap-9 +-0x1.dea75ep-12 +-0x1.85219ep-11 +-0x1.f787dep-9 +0x1.5af9fp-9 +-0x1.bf262cp-11 +-0x1.0cf48ep-10 +-0x1.09ed24p-8 +0x1.1ea5b8p-9 +-0x1.2a8428p-10 +0x1.139fbcp-5 +0x1.8113d6p-10 +-0x1.13c874p-5 +0x1.185ad6p-5 +-0x1.184aaap-5 +-0x1.1673eep-5 +-0x1.18169ep-9 +-0x1.20d41p-9 +0x1.84f6a8p-11 +0x1.7610bp-11 +0x1.acc9d8p-7 +0x1.ae922ep-7 +-0x1.a22356p-4 +-0x1.a05542p-4 +0x0p+0 +0x1.1a218ap-9 +0x1.163ed4p-5 +-0x1.7fd4b4p-11 +0x1.234f88p-9 +-0x1.ad061ap-7 +-0x1.7135b8p-11 +0x1.a22622p-4 +-0x1.aecd66p-7 +0x0p+0 +0x1.a057fcp-4 +0x1.92761p-11 +0x1.650ecp-11 +0x1.1fbd18p-11 +0x1.b74f44p-12 +0x1.424e44p-12 +0x1.7ad876p-13 +-0x1.e3a2f4p-16 +-0x1.7a22c6p-12 +-0x1.868158p-11 +-0x1.09c342p-10 +-0x1.152c14p-5 +-0x1.21dbap-9 +0x1.bfe688p-11 +0x1.a2e0fp-7 +-0x1.a13bfap-4 +0x0p+0 +0x1.14fec2p-5 +0x1.244384p-9 +-0x1.bb034ap-11 +-0x1.a31eb6p-7 +0x1.a13eaap-4 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.792ac8p-11 +0x1.488a52p-11 +0x1.012966p-11 +0x1.840f2p-12 +0x1.2c60ccp-12 +0x1.aa4d16p-13 +0x1.1b25b6p-15 +-0x1.29226ap-12 +-0x1.6bea1ap-11 +-0x1.09b7dcp-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.70e946p-4 +-0x1.ef18a2p-7 +0x1.bc2d72p-10 +-0x1.9f7e72p-10 +0x1.2eec08p-5 +-0x1.2f3f3cp-5 +0x1.ab235cp-10 +-0x1.bced24p-10 +0x1.ef1a54p-7 +-0x1.70ea3ap-4 +0x0p+0 +0x1.91282ap+2 +0x0p+0 +0x1.914e26p+2 +0x0p+0 +0x1.ef1a54p-7 +0x0p+0 +0x1.a2e0fp-7 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.92761p-11 +0x1.650ecp-11 +0x1.650ecp-11 +0x1.1fbd18p-11 +0x1.1fbd18p-11 +0x1.b74f44p-12 +0x1.b74f44p-12 +0x1.424e44p-12 +0x1.424e44p-12 +0x1.7ad876p-13 +0x1.7ad876p-13 +-0x1.e3a2f4p-16 +-0x1.e3a2f4p-16 +-0x1.7a22c6p-12 +-0x1.7a22c6p-12 +-0x1.868158p-11 +-0x1.868158p-11 +-0x1.09c342p-10 +-0x1.09c342p-10 +0x1.14fec2p-5 +-0x1.09c342p-10 +-0x1.152c14p-5 +-0x1.152c14p-5 +0x1.14fec2p-5 +-0x1.21dbap-9 +-0x1.152c14p-5 +0x1.bfe688p-11 +-0x1.21dbap-9 +0x1.a2e0fp-7 +0x1.bfe688p-11 +-0x1.a13bfap-4 +0x1.a2e0fp-7 +0x0p+0 +-0x1.a13bfap-4 +0x1.14fec2p-5 +0x1.244384p-9 +0x1.244384p-9 +-0x1.bb034ap-11 +-0x1.bb034ap-11 +-0x1.a31eb6p-7 +-0x1.a31eb6p-7 +0x1.a13eaap-4 +0x1.a13eaap-4 +0x0p+0 +0x1.a00d68p-11 +0x1.715ee8p-11 +0x1.8e21dep-13 +0x1.56b96p-10 +0x1.69c08cp-11 +0x1.29480ep-11 +-0x1.cebd9cp-12 +0x1.bce184p-10 +0x1.17f4b6p-11 +0x1.bcfb3ep-12 +-0x1.0ed6e8p-10 +0x1.04dfep-9 +0x1.852868p-12 +0x1.3086cep-12 +-0x1.9d369p-10 +0x1.253112p-9 +0x1.c7358cp-13 +0x1.4aac34p-13 +-0x1.156bdep-9 +0x1.46755ep-9 +0x1.0f2882p-14 +-0x1.49f888p-15 +-0x1.612b8p-9 +0x1.64847ep-9 +-0x1.31fd7ap-13 +-0x1.6f52eap-12 +-0x1.b1a694p-9 +0x1.70df12p-9 +-0x1.e49024p-12 +-0x1.6d8ac4p-11 +-0x1.f5c8d2p-9 +0x1.5e5b6ap-9 +-0x1.aa65acp-11 +-0x1.e84f6ap-11 +-0x1.059c66p-8 +0x1.279114p-9 +-0x1.133284p-10 +0x1.efb2a8p-6 +0x1.3db9bap-10 +0x1.f7e1e6p-6 +0x1.3db9bap-10 +-0x1.ef1d38p-6 +-0x1.eaf60ep-11 +-0x1.f6e512p-6 +0x1.f7e1e6p-6 +-0x1.f6e512p-6 +-0x1.f333f2p-6 +-0x1.a1e48cp-8 +-0x1.a5594p-8 +0x1.f6b92ep-9 +0x1.ed092ep-9 +0x1.326f9cp-7 +0x1.35d568p-7 +-0x1.d264c2p-4 +-0x1.d01c24p-4 +0x0p+0 +0x1.a0b48cp-8 +0x1.f33176p-6 +-0x1.f3a61p-9 +0x1.a45da8p-8 +-0x1.32deap-7 +-0x1.ea1d0ap-9 +0x1.d269cp-4 +-0x1.363fbep-7 +0x0p+0 +0x1.d0207ap-4 +0x1.a66266p-11 +0x1.78641ap-11 +0x1.b3ee5p-13 +0x1.58ac62p-10 +0x1.70c728p-11 +0x1.2fed9p-11 +-0x1.b8b4dp-12 +0x1.be3402p-10 +0x1.1ee32p-11 +0x1.c7cbap-12 +-0x1.0a22fap-10 +0x1.059a9ap-9 +0x1.906894p-12 +0x1.38018ap-12 +-0x1.9a7172p-10 +0x1.2624fp-9 +0x1.d6f328p-13 +0x1.471432p-13 +-0x1.14defcp-9 +0x1.46ab16p-9 +0x1.0bd4a6p-14 +-0x1.a889bap-15 +-0x1.6125f8p-9 +0x1.62ec32p-9 +-0x1.46864ap-13 +-0x1.7aa50ap-12 +-0x1.b0d304p-9 +0x1.6d5ab8p-9 +-0x1.eef34cp-12 +-0x1.6eeeacp-11 +-0x1.f2bf3p-9 +0x1.59abd2p-9 +-0x1.ab69acp-11 +-0x1.eaf60ep-11 +-0x1.01753cp-8 +0x1.1e53c4p-9 +-0x1.139efp-10 +0x1.f0d126p-6 +0x1.47c2p-10 +0x1.f92588p-6 +0x1.47c2p-10 +-0x1.f0c804p-6 +-0x1.e87a96p-11 +-0x1.f8af5p-6 +0x1.f92588p-6 +-0x1.f8af5p-6 +-0x1.f4b8p-6 +-0x1.a49b06p-8 +-0x1.a9aap-8 +0x1.005536p-8 +0x1.f8a346p-9 +0x1.26e06ap-7 +0x1.2a6a46p-7 +-0x1.d13f5cp-4 +-0x1.cf02p-4 +0x0p+0 +0x1.a39022p-8 +0x1.f4ac46p-6 +-0x1.fdb69cp-9 +0x1.a8d8cap-8 +-0x1.274ad2p-7 +-0x1.f5d51cp-9 +0x1.d14432p-4 +-0x1.2ad01ap-7 +0x0p+0 +0x1.cf0622p-4 +0x1.acb5cp-11 +0x1.7f212cp-11 +0x1.d8eaaap-13 +0x1.5a948ap-10 +0x1.779aaap-11 +0x1.36a088p-11 +-0x1.a36cc8p-12 +0x1.bfa3d8p-10 +0x1.25bba6p-11 +0x1.d2989cp-12 +-0x1.057a08p-10 +0x1.0654ecp-9 +0x1.9c01dep-12 +0x1.3ee638p-12 +-0x1.97a79ap-10 +0x1.270ee6p-9 +0x1.e5defp-13 +0x1.429d86p-13 +-0x1.1448f4p-9 +0x1.46bcaep-9 +0x1.0728e6p-14 +-0x1.ff600ap-15 +-0x1.610308p-9 +0x1.614a7cp-9 +-0x1.59ec68p-13 +-0x1.8559b8p-12 +-0x1.afe29cp-9 +0x1.69df3cp-9 +-0x1.f8a884p-12 +-0x1.717284p-11 +-0x1.ef7ba6p-9 +0x1.54908p-9 +-0x1.ad5f6p-11 +-0x1.e87a96p-11 +-0x1.fc2e42p-9 +0x1.17b36ep-9 +-0x1.120698p-10 +0x1.f2b272p-6 +0x1.4f00d2p-10 +0x1.fb1b04p-6 +0x1.4f00d2p-10 +-0x1.f2b084p-6 +-0x1.e622d8p-11 +-0x1.faad9ep-6 +0x1.fb1b04p-6 +-0x1.faad9ep-6 +-0x1.f6b214p-6 +-0x1.a80704p-8 +-0x1.ad464cp-8 +0x1.062dd8p-8 +0x1.022c16p-8 +0x1.1b2de6p-7 +0x1.1ed7b6p-7 +-0x1.d02002p-4 +-0x1.cdeb7cp-4 +0x0p+0 +0x1.a726fep-8 +0x1.f69cbcp-6 +-0x1.04c2bap-8 +0x1.aca436p-8 +-0x1.1b922ap-7 +-0x1.00d108p-8 +0x1.d024c4p-4 +-0x1.1f39a8p-7 +0x0p+0 +0x1.cdefc2p-4 +0x1.b2f27ap-11 +0x1.85ce0ep-11 +0x1.3d0f86p-11 +0x1.dd9266p-12 +0x1.454b58p-12 +0x1.3e46f4p-13 +-0x1.291d6p-14 +-0x1.8fb2eap-12 +-0x1.73edb8p-11 +-0x1.e622d8p-11 +-0x1.f4b516p-6 +-0x1.ab8daep-8 +0x1.0c0b6cp-8 +0x1.0fd816p-7 +-0x1.cf0568p-4 +0x0p+0 +0x1.f4aebcp-6 +0x1.aadf64p-8 +-0x1.0ab08ap-8 +-0x1.1039e4p-7 +0x1.cf09a2p-4 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.92761p-11 +0x1.650ecp-11 +0x1.1fbd18p-11 +0x1.b74f44p-12 +0x1.424e44p-12 +0x1.7ad876p-13 +-0x1.e3a2f4p-16 +-0x1.7a22c6p-12 +-0x1.868158p-11 +-0x1.09c342p-10 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.a13eaap-4 +-0x1.a31eb6p-7 +-0x1.bb034ap-11 +0x1.244384p-9 +0x1.14fec2p-5 +-0x1.152c14p-5 +-0x1.21dbap-9 +0x1.bfe688p-11 +0x1.a2e0fp-7 +-0x1.a13bfap-4 +0x0p+0 +0x1.914e26p+2 +0x0p+0 +0x1.91979ap+2 +0x0p+0 +0x1.a2e0fp-7 +0x0p+0 +0x1.0fd816p-7 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.b2f27ap-11 +0x1.85ce0ep-11 +0x1.85ce0ep-11 +0x1.3d0f86p-11 +0x1.3d0f86p-11 +0x1.dd9266p-12 +0x1.dd9266p-12 +0x1.454b58p-12 +0x1.454b58p-12 +0x1.3e46f4p-13 +0x1.3e46f4p-13 +-0x1.291d6p-14 +-0x1.291d6p-14 +-0x1.8fb2eap-12 +-0x1.8fb2eap-12 +-0x1.73edb8p-11 +-0x1.73edb8p-11 +-0x1.e622d8p-11 +-0x1.e622d8p-11 +0x1.f4aebcp-6 +-0x1.e622d8p-11 +-0x1.f4b516p-6 +-0x1.f4b516p-6 +0x1.f4aebcp-6 +-0x1.ab8daep-8 +-0x1.f4b516p-6 +0x1.0c0b6cp-8 +-0x1.ab8daep-8 +0x1.0fd816p-7 +0x1.0c0b6cp-8 +-0x1.cf0568p-4 +0x1.0fd816p-7 +0x0p+0 +-0x1.cf0568p-4 +0x1.f4aebcp-6 +0x1.aadf64p-8 +0x1.aadf64p-8 +-0x1.0ab08ap-8 +-0x1.0ab08ap-8 +-0x1.1039e4p-7 +-0x1.1039e4p-7 +0x1.cf09a2p-4 +0x1.cf09a2p-4 +0x0p+0 +0x1.c6598p-11 +0x1.94d816p-11 +0x1.1ebc0cp-12 +0x1.65afdep-10 +0x1.8dbdcep-11 +0x1.42b44cp-11 +-0x1.78d1ccp-12 +0x1.c61968p-10 +0x1.33147ep-11 +0x1.d18542p-12 +-0x1.ff5042p-11 +0x1.06a0cap-9 +0x1.9e02ccp-12 +0x1.2ce82ap-12 +-0x1.987988p-10 +0x1.25786ap-9 +0x1.c649fap-13 +0x1.2741a2p-13 +-0x1.16b226p-9 +0x1.4574e4p-9 +0x1.9e5486p-15 +-0x1.f4be24p-15 +-0x1.624668p-9 +0x1.60f68cp-9 +-0x1.5a8f72p-13 +-0x1.799434p-12 +-0x1.add918p-9 +0x1.69444ep-9 +-0x1.ed8d32p-12 +-0x1.6559c4p-11 +-0x1.ea1724p-9 +0x1.539414p-9 +-0x1.a165ecp-11 +-0x1.cf3746p-11 +-0x1.f3f5b6p-9 +0x1.18c3cap-9 +-0x1.05be68p-10 +0x1.b32cp-6 +0x1.01a5bep-10 +0x1.ba524p-6 +0x1.01a5bep-10 +-0x1.b27e98p-6 +-0x1.ce8e7ep-11 +-0x1.b93a9ep-6 +0x1.ba524p-6 +-0x1.b93a9ep-6 +-0x1.b552e2p-6 +-0x1.6d0914p-7 +-0x1.6eeadap-7 +0x1.f7377p-8 +0x1.ef0bccp-8 +0x1.406d34p-9 +0x1.5a011cp-9 +-0x1.fc912p-4 +-0x1.f9e9f8p-4 +0x0p+0 +0x1.6b8684p-7 +0x1.b5a332p-6 +-0x1.f5165ep-8 +0x1.6d85b4p-7 +-0x1.4223p-9 +-0x1.ecfa92p-8 +0x1.fc948cp-4 +-0x1.5bb018p-9 +0x0p+0 +0x1.f9ecc6p-4 +0x1.cc28a8p-11 +0x1.9aafbp-11 +0x1.2fba6ep-12 +0x1.67434p-10 +0x1.93d34cp-11 +0x1.48e55p-11 +-0x1.658fdep-12 +0x1.c76aecp-10 +0x1.394862p-11 +0x1.dd5ac8p-12 +-0x1.f6aa96p-11 +0x1.077df8p-9 +0x1.a9e8fep-12 +0x1.35aa68p-12 +-0x1.956772p-10 +0x1.268356p-9 +0x1.d89594p-13 +0x1.2567cp-13 +-0x1.15ccbap-9 +0x1.4596b2p-9 +0x1.9f883ep-15 +-0x1.26e4b8p-14 +-0x1.61d742p-9 +0x1.5f2a06p-9 +-0x1.6d9328p-13 +-0x1.840634p-12 +-0x1.accb0cp-9 +0x1.65b98ep-9 +-0x1.f6fc1ep-12 +-0x1.67334cp-11 +-0x1.e6ce28p-9 +0x1.4ea65cp-9 +-0x1.a2c8d8p-11 +-0x1.ce8e7ep-11 +-0x1.eae9aep-9 +0x1.0f8326p-9 +-0x1.04b18ep-10 +0x1.b4264ep-6 +0x1.145a94p-10 +0x1.bb8ae6p-6 +0x1.145a94p-10 +-0x1.b3ca3ap-6 +-0x1.cba83ap-11 +-0x1.bac376p-6 +0x1.bb8ae6p-6 +-0x1.bac376p-6 +-0x1.b6b3a4p-6 +-0x1.6d03dep-7 +-0x1.6f7de8p-7 +0x1.f89e3cp-8 +0x1.f178a8p-8 +0x1.1040e4p-9 +0x1.29b1aep-9 +-0x1.fb3cd8p-4 +-0x1.f8a4aap-4 +0x0p+0 +0x1.6b9be6p-7 +0x1.b6f98p-6 +-0x1.f6904ep-8 +0x1.6e341ap-7 +-0x1.11eadcp-9 +-0x1.ef7d44p-8 +0x1.fb402cp-4 +-0x1.2b4d62p-9 +0x0p+0 +0x1.f8a74p-4 +0x1.d1ba1ep-11 +0x1.a0c152p-11 +0x1.4025a8p-12 +0x1.68f992p-10 +0x1.99dd84p-11 +0x1.4f0c44p-11 +-0x1.52c1dcp-12 +0x1.c8cecp-10 +0x1.3f9e9ap-11 +0x1.e8ccf6p-12 +-0x1.ee22f4p-11 +0x1.085edep-9 +0x1.b5eb08p-12 +0x1.3dbb4ap-12 +-0x1.92495p-10 +0x1.2775a2p-9 +0x1.e93262p-13 +0x1.22cd2p-13 +-0x1.14e804p-9 +0x1.45925p-9 +0x1.9e863ep-15 +-0x1.4f9bcp-14 +-0x1.615452p-9 +0x1.5d5f24p-9 +-0x1.7ecee4p-13 +-0x1.8df21ap-12 +-0x1.aba182p-9 +0x1.624072p-9 +-0x1.ffc85ap-12 +-0x1.69c302p-11 +-0x1.e339fp-9 +0x1.495466p-9 +-0x1.a4acd6p-11 +-0x1.cba83ap-11 +-0x1.e3d4fep-9 +0x1.08a94p-9 +-0x1.02dceep-10 +0x1.b5c66ep-6 +0x1.223ea8p-10 +0x1.bd55bp-6 +0x1.223ea8p-10 +-0x1.b57408p-6 +-0x1.c9429ep-11 +-0x1.bc9a5cp-6 +0x1.bd55bp-6 +-0x1.bc9a5cp-6 +-0x1.b8852ep-6 +-0x1.6d1496p-7 +-0x1.6fa6b6p-7 +0x1.fab95cp-8 +0x1.f3b458p-8 +0x1.bdc62ap-10 +0x1.f1a41cp-10 +-0x1.f9f056p-4 +-0x1.f762ecp-4 +0x0p+0 +0x1.6bc696p-7 +0x1.b8c1bp-6 +-0x1.f8bd52p-8 +0x1.6e760ep-7 +-0x1.c0f4d4p-10 +-0x1.f1cc3ep-8 +0x1.f9f358p-4 +-0x1.f4a7ep-10 +0x0p+0 +0x1.f76538p-4 +0x1.d752dep-11 +0x1.a69b36p-11 +0x1.55161cp-11 +0x1.f4827ep-12 +0x1.44de84p-12 +0x1.1fc382p-13 +-0x1.753eacp-14 +-0x1.979d42p-12 +-0x1.6c3cdep-11 +-0x1.c9429ep-11 +-0x1.b74e2ap-6 +-0x1.6d2c32p-7 +0x1.fcf27ep-8 +0x1.5dfd5ep-10 +-0x1.f8a91ap-4 +0x0p+0 +0x1.b79704p-6 +0x1.6bf676p-7 +-0x1.fb05d6p-8 +-0x1.60ff98p-10 +0x1.f8abecp-4 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.b2f27ap-11 +0x1.85ce0ep-11 +0x1.3d0f86p-11 +0x1.dd9266p-12 +0x1.454b58p-12 +0x1.3e46f4p-13 +-0x1.291d6p-14 +-0x1.8fb2eap-12 +-0x1.73edb8p-11 +-0x1.e622d8p-11 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.cf09a2p-4 +-0x1.1039e4p-7 +-0x1.0ab08ap-8 +0x1.aadf64p-8 +0x1.f4aebcp-6 +-0x1.f4b516p-6 +-0x1.ab8daep-8 +0x1.0c0b6cp-8 +0x1.0fd816p-7 +-0x1.cf0568p-4 +0x0p+0 +0x1.91979ap+2 +0x0p+0 +0x1.9209a6p+2 +0x0p+0 +0x1.0fd816p-7 +0x0p+0 +0x1.5dfd5ep-10 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.d752dep-11 +0x1.a69b36p-11 +0x1.a69b36p-11 +0x1.55161cp-11 +0x1.55161cp-11 +0x1.f4827ep-12 +0x1.f4827ep-12 +0x1.44de84p-12 +0x1.44de84p-12 +0x1.1fc382p-13 +0x1.1fc382p-13 +-0x1.753eacp-14 +-0x1.753eacp-14 +-0x1.979d42p-12 +-0x1.979d42p-12 +-0x1.6c3cdep-11 +-0x1.6c3cdep-11 +-0x1.c9429ep-11 +-0x1.c9429ep-11 +0x1.b79704p-6 +-0x1.c9429ep-11 +-0x1.b74e2ap-6 +-0x1.b74e2ap-6 +0x1.b79704p-6 +-0x1.6d2c32p-7 +-0x1.b74e2ap-6 +0x1.fcf27ep-8 +-0x1.6d2c32p-7 +0x1.5dfd5ep-10 +0x1.fcf27ep-8 +-0x1.f8a91ap-4 +0x1.5dfd5ep-10 +0x0p+0 +-0x1.f8a91ap-4 +0x1.b79704p-6 +0x1.6bf676p-7 +0x1.6bf676p-7 +-0x1.fb05d6p-8 +-0x1.fb05d6p-8 +-0x1.60ff98p-10 +-0x1.60ff98p-10 +0x1.f8abecp-4 +0x1.f8abecp-4 +0x0p+0 +0x1.e887cp-11 +0x1.b0ec56p-11 +0x1.73c6b6p-12 +0x1.6f8e7p-10 +0x1.aafc5ap-11 +0x1.55778p-11 +-0x1.284c0ep-12 +0x1.c9f7ecp-10 +0x1.4766e4p-11 +0x1.e82a3ep-12 +-0x1.e21d58p-11 +0x1.073b54p-9 +0x1.b779b6p-12 +0x1.3ab0ap-12 +-0x1.902ddep-10 +0x1.263722p-9 +0x1.e4eb2ap-13 +0x1.26453cp-13 +-0x1.144b5ap-9 +0x1.44e70cp-9 +0x1.aa3864p-15 +-0x1.42b964p-14 +-0x1.5fae7ap-9 +0x1.5c4f7ep-9 +-0x1.77cd3ap-13 +-0x1.8ce576p-12 +-0x1.a87b0ap-9 +0x1.5fada4p-9 +-0x1.fd66cap-12 +-0x1.66f13ap-11 +-0x1.de51c8p-9 +0x1.456c7ap-9 +-0x1.a1299ep-11 +-0x1.bea40ap-11 +-0x1.dd5cc4p-9 +0x1.064d46p-9 +-0x1.f8e284p-11 +0x1.70932ap-6 +0x1.9b3fc6p-11 +0x1.76dc6ap-6 +0x1.9b3fc6p-11 +-0x1.6fb6b8p-6 +-0x1.babf3p-11 +-0x1.759386p-6 +0x1.76dc6ap-6 +-0x1.759386p-6 +-0x1.71bedp-6 +-0x1.02f75p-6 +-0x1.03aaeep-6 +0x1.79bee6p-7 +0x1.73a14cp-7 +-0x1.d2d2c4p-8 +-0x1.bdca06p-8 +-0x1.108e52p-3 +-0x1.0f18b4p-3 +0x0p+0 +0x1.01d588p-6 +0x1.7259bap-6 +-0x1.7884bcp-7 +0x1.0299c6p-6 +0x1.d2383ap-8 +-0x1.727816p-7 +0x1.108e4cp-3 +0x1.bd4002p-8 +0x0p+0 +0x1.0f1874p-3 +0x1.ed326p-11 +0x1.b6694p-11 +0x1.81d7b6p-12 +0x1.711d98p-10 +0x1.b0701p-11 +0x1.5bcea4p-11 +-0x1.173efcp-12 +0x1.cb98bep-10 +0x1.4dd33ep-11 +0x1.f52438p-12 +-0x1.d992e6p-11 +0x1.0851e4p-9 +0x1.c47498p-12 +0x1.42f66cp-12 +-0x1.8cb9b6p-10 +0x1.27242p-9 +0x1.f6a9fap-13 +0x1.226d28p-13 +-0x1.133eap-9 +0x1.44b906p-9 +0x1.a44604p-15 +-0x1.6af6acp-14 +-0x1.5f0d24p-9 +0x1.5a563ep-9 +-0x1.891a08p-13 +-0x1.962b1cp-12 +-0x1.a72b04p-9 +0x1.5c219p-9 +-0x1.02ddbep-11 +-0x1.6877e8p-11 +-0x1.dab474p-9 +0x1.406224p-9 +-0x1.a2210ep-11 +-0x1.babf3p-11 +-0x1.d416ccp-9 +0x1.fb76eep-10 +-0x1.f3e874p-11 +0x1.71dd46p-6 +0x1.cbaf4cp-11 +0x1.7872fap-6 +0x1.cbaf4cp-11 +-0x1.7136bcp-6 +-0x1.b67a76p-11 +-0x1.77618ap-6 +0x1.7872fap-6 +-0x1.77618ap-6 +-0x1.737126p-6 +-0x1.01c1a8p-6 +-0x1.02bd0cp-6 +0x1.777d2p-7 +0x1.7213aep-7 +-0x1.e96e2cp-8 +-0x1.d50e98p-8 +-0x1.0fd37p-3 +-0x1.0e6728p-3 +0x0p+0 +0x1.00ac92p-6 +0x1.74017p-6 +-0x1.764f7cp-7 +0x1.01b8bep-6 +0x1.e8de2ap-8 +-0x1.70f358p-7 +0x1.0fd344p-3 +0x1.d48b8ap-8 +0x0p+0 +0x1.0e66bap-3 +0x1.f1e61ep-11 +0x1.bbc5eep-11 +0x1.8fd866p-12 +0x1.72a548p-10 +0x1.b5d5cap-11 +0x1.623482p-11 +-0x1.064c1ep-12 +0x1.cd4082p-10 +0x1.542de2p-11 +0x1.00bbbap-11 +-0x1.d14d16p-11 +0x1.096062p-9 +0x1.d11416p-12 +0x1.4aad28p-12 +-0x1.894f2p-10 +0x1.27f8aap-9 +0x1.03bac6p-12 +0x1.1e7c7ep-13 +-0x1.122a2p-9 +0x1.447284p-9 +0x1.9e5eecp-15 +-0x1.900252p-14 +-0x1.5e6284p-9 +0x1.586d42p-9 +-0x1.98f81p-13 +-0x1.9f30dep-12 +-0x1.a5ba1p-9 +0x1.58936p-9 +-0x1.06cad4p-11 +-0x1.6a4efap-11 +-0x1.d6d15cp-9 +0x1.3b0d4ep-9 +-0x1.a3506ap-11 +-0x1.b67a76p-11 +-0x1.cce6e8p-9 +0x1.ee95bap-10 +-0x1.eefc94p-11 +0x1.73c57cp-6 +0x1.efff28p-11 +0x1.7a927ep-6 +0x1.efff28p-11 +-0x1.73291ep-6 +-0x1.b32c2cp-11 +-0x1.798e4cp-6 +0x1.7a927ep-6 +-0x1.798e4cp-6 +-0x1.759798p-6 +-0x1.00823ep-6 +-0x1.018d38p-6 +0x1.758376p-7 +0x1.704454p-7 +-0x1.00985ep-7 +-0x1.ecae44p-8 +-0x1.0f1d54p-3 +-0x1.0db6b8p-3 +0x0p+0 +0x1.fef76ap-7 +0x1.761e42p-6 +-0x1.746092p-7 +0x1.009688p-6 +0x1.005524p-7 +-0x1.6f2d6cp-7 +0x1.0f1ceep-3 +0x1.ec2f9ep-8 +0x0p+0 +0x1.0db66p-3 +0x1.f690c8p-11 +0x1.c134fep-11 +0x1.68633ep-11 +0x1.06adcap-11 +0x1.51de9cp-12 +0x1.1ab4fep-13 +-0x1.b31c66p-14 +-0x1.a7e7e8p-12 +-0x1.6c00b4p-11 +-0x1.b32c2cp-11 +-0x1.755618p-6 +-0x1.fe8bfap-7 +0x1.73ac9p-7 +-0x1.0c245cp-7 +-0x1.0e6a04p-3 +0x0p+0 +0x1.75e832p-6 +0x1.fc9b42p-7 +-0x1.72957ep-7 +0x1.0be636p-7 +0x1.0e698cp-3 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.d752dep-11 +0x1.a69b36p-11 +0x1.55161cp-11 +0x1.f4827ep-12 +0x1.44de84p-12 +0x1.1fc382p-13 +-0x1.753eacp-14 +-0x1.979d42p-12 +-0x1.6c3cdep-11 +-0x1.c9429ep-11 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.f8abecp-4 +-0x1.60ff98p-10 +-0x1.fb05d6p-8 +0x1.6bf676p-7 +0x1.b79704p-6 +-0x1.b74e2ap-6 +-0x1.6d2c32p-7 +0x1.fcf27ep-8 +0x1.5dfd5ep-10 +-0x1.f8a91ap-4 +0x0p+0 +0x1.9209a6p+2 +0x0p+0 +0x1.92a5aap+2 +0x0p+0 +0x1.5dfd5ep-10 +0x0p+0 +-0x1.0c245cp-7 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.f690c8p-11 +0x1.c134fep-11 +0x1.c134fep-11 +0x1.68633ep-11 +0x1.68633ep-11 +0x1.06adcap-11 +0x1.06adcap-11 +0x1.51de9cp-12 +0x1.51de9cp-12 +0x1.1ab4fep-13 +0x1.1ab4fep-13 +-0x1.b31c66p-14 +-0x1.b31c66p-14 +-0x1.a7e7e8p-12 +-0x1.a7e7e8p-12 +-0x1.6c00b4p-11 +-0x1.6c00b4p-11 +-0x1.b32c2cp-11 +-0x1.b32c2cp-11 +0x1.75e832p-6 +-0x1.b32c2cp-11 +-0x1.755618p-6 +-0x1.755618p-6 +0x1.75e832p-6 +-0x1.fe8bfap-7 +-0x1.755618p-6 +0x1.73ac9p-7 +-0x1.fe8bfap-7 +-0x1.0c245cp-7 +0x1.73ac9p-7 +-0x1.0e6a04p-3 +-0x1.0c245cp-7 +0x0p+0 +-0x1.0e6a04p-3 +0x1.75e832p-6 +0x1.fc9b42p-7 +0x1.fc9b42p-7 +-0x1.72957ep-7 +-0x1.72957ep-7 +0x1.0be636p-7 +0x1.0be636p-7 +0x1.0e698cp-3 +0x1.0e698cp-3 +0x0p+0 +0x1.fc58dcp-11 +0x1.c4017cp-11 +0x1.ad4a9cp-12 +0x1.74a05cp-10 +0x1.be8bcap-11 +0x1.686564p-11 +-0x1.d178f8p-13 +0x1.cd4fecp-10 +0x1.5ae888p-11 +0x1.06853p-11 +-0x1.c44b2ap-11 +0x1.094012p-9 +0x1.dd7bd2p-12 +0x1.567f66p-12 +-0x1.835636p-10 +0x1.280228p-9 +0x1.1029ep-12 +0x1.2e21d6p-13 +-0x1.0f284p-9 +0x1.43f8b8p-9 +0x1.e71894p-15 +-0x1.a2b9eap-14 +-0x1.5b40bcp-9 +0x1.55db7ap-9 +-0x1.9d74dcp-13 +-0x1.b6e6aap-12 +-0x1.a2d49ep-9 +0x1.527436p-9 +-0x1.10cdcp-11 +-0x1.7b519cp-11 +-0x1.d4471ap-9 +0x1.31c378p-9 +-0x1.b2826ap-11 +-0x1.c12cc2p-11 +-0x1.cb0d64p-9 +0x1.dde6d6p-10 +-0x1.f935e2p-11 +0x1.2cd822p-6 +0x1.330da4p-11 +0x1.3266bep-6 +0x1.330da4p-11 +-0x1.2bdf8p-6 +-0x1.b7757cp-11 +-0x1.30fb16p-6 +0x1.3266bep-6 +-0x1.30fb16p-6 +-0x1.2d6e58p-6 +-0x1.429b28p-6 +-0x1.42f1cp-6 +0x1.dd82dp-7 +0x1.d58adcp-7 +-0x1.3a1844p-6 +-0x1.325598p-6 +-0x1.1f8d72p-3 +-0x1.1e07a6p-3 +0x0p+0 +0x1.413b28p-6 +0x1.2e4382p-6 +-0x1.dc574p-7 +0x1.41a25ep-6 +0x1.3a0a58p-6 +-0x1.d46eb2p-7 +0x1.1f8b9ap-3 +0x1.324bcp-6 +0x0p+0 +0x1.1e05f6p-3 +0x1.0046eap-10 +0x1.c967f6p-11 +0x1.b9b53cp-12 +0x1.76530ap-10 +0x1.c3c73p-11 +0x1.6eb6d6p-11 +-0x1.b22d04p-13 +0x1.cf2b84p-10 +0x1.615776p-11 +0x1.0c948ap-11 +-0x1.bbe334p-11 +0x1.0a4494p-9 +0x1.e9ef44p-12 +0x1.5d2482p-12 +-0x1.7feb36p-10 +0x1.28aeeep-9 +0x1.17651cp-12 +0x1.28bf96p-13 +-0x1.0e1bacp-9 +0x1.437dd6p-9 +0x1.dc9e94p-15 +-0x1.c851b2p-14 +-0x1.5a7e64p-9 +0x1.53c41cp-9 +-0x1.ad6436p-13 +-0x1.beedfap-12 +-0x1.a1443ep-9 +0x1.4ee50ep-9 +-0x1.144b38p-11 +-0x1.7b936ep-11 +-0x1.d05b56p-9 +0x1.2ce684p-9 +-0x1.b2370ep-11 +-0x1.b7757cp-11 +-0x1.c1a086p-9 +0x1.cffcb4p-10 +-0x1.ef0b96p-11 +0x1.2ee7a6p-6 +0x1.6ba07p-11 +0x1.34c7aap-6 +0x1.6ba07p-11 +-0x1.2e08f8p-6 +-0x1.afca16p-11 +-0x1.337aap-6 +0x1.34c7aap-6 +-0x1.337aap-6 +-0x1.2fdcf2p-6 +-0x1.3febf4p-6 +-0x1.407f48p-6 +0x1.d76eacp-7 +0x1.d04f04p-7 +-0x1.3ebc7p-6 +-0x1.375442p-6 +-0x1.1eca7cp-3 +-0x1.1d4f96p-3 +0x0p+0 +0x1.3e9b78p-6 +0x1.30a754p-6 +-0x1.d64fe2p-7 +0x1.3f3f0ep-6 +0x1.3eb0d6p-6 +-0x1.cf40aap-7 +0x1.1ec8b2p-3 +0x1.374ca8p-6 +0x0p+0 +0x1.1d4dc4p-3 +0x1.0276acp-10 +0x1.ce8374p-11 +0x1.c60fdep-12 +0x1.77f984p-10 +0x1.c8dc56p-11 +0x1.74f60ap-11 +-0x1.9340b4p-13 +0x1.d0f6dcp-10 +0x1.67892ep-11 +0x1.127e52p-11 +-0x1.b3c9fep-11 +0x1.0b441ep-9 +0x1.f5c232p-12 +0x1.630958p-12 +-0x1.7cab1ep-10 +0x1.294526p-9 +0x1.1e34dap-12 +0x1.23a5b2p-13 +-0x1.0d0ce2p-9 +0x1.42f7dp-9 +0x1.d07eacp-15 +-0x1.eb1b5ap-14 +-0x1.59ae32p-9 +0x1.51ae98p-9 +-0x1.bc7ec6p-13 +-0x1.c6a0b2p-12 +-0x1.9f96a8p-9 +0x1.4b506ep-9 +-0x1.179facp-11 +-0x1.7b9bep-11 +-0x1.cc3484p-9 +0x1.27e6fp-9 +-0x1.b1bc8ap-11 +-0x1.afca16p-11 +-0x1.ba4642p-9 +0x1.c54d94p-10 +-0x1.e70a44p-11 +0x1.3177ap-6 +0x1.9624a6p-11 +0x1.379442p-6 +0x1.9624a6p-11 +-0x1.30a3bcp-6 +-0x1.aa1906p-11 +-0x1.36564ap-6 +0x1.379442p-6 +-0x1.36564ap-6 +-0x1.32b07ep-6 +-0x1.3d2128p-6 +-0x1.3dc988p-6 +0x1.d17b88p-7 +0x1.caaa88p-7 +-0x1.43d838p-6 +-0x1.3c70b6p-6 +-0x1.1e0d04p-3 +-0x1.1c9802p-3 +0x0p+0 +0x1.3bdf0cp-6 +0x1.336eacp-6 +-0x1.d069ep-7 +0x1.3c9954p-6 +0x1.43cd54p-6 +-0x1.c9aaacp-7 +0x1.1e0b42p-3 +0x1.3c6b34p-6 +0x0p+0 +0x1.1c9634p-3 +0x1.04a95ep-10 +0x1.d3a3c4p-11 +0x1.7b22b2p-11 +0x1.17ee56p-11 +0x1.68dc22p-12 +0x1.1eb316p-13 +-0x1.061a42p-13 +-0x1.cdec4ap-12 +-0x1.7b607ep-11 +-0x1.aa1906p-11 +-0x1.337a42p-6 +-0x1.3a5a98p-6 +0x1.cbd1fcp-7 +-0x1.48d30ep-6 +-0x1.1d526ep-3 +0x0p+0 +0x1.3443f2p-6 +0x1.39275ep-6 +-0x1.cacbfcp-7 +0x1.48ca9cp-6 +0x1.1d50bcp-3 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.f690c8p-11 +0x1.c134fep-11 +0x1.68633ep-11 +0x1.06adcap-11 +0x1.51de9cp-12 +0x1.1ab4fep-13 +-0x1.b31c66p-14 +-0x1.a7e7e8p-12 +-0x1.6c00b4p-11 +-0x1.b32c2cp-11 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.0e698cp-3 +0x1.0be636p-7 +-0x1.72957ep-7 +0x1.fc9b42p-7 +0x1.75e832p-6 +-0x1.755618p-6 +-0x1.fe8bfap-7 +0x1.73ac9p-7 +-0x1.0c245cp-7 +-0x1.0e6a04p-3 +0x0p+0 +0x1.0be636p-7 +0x0p+0 +0x1.48ca9cp-6 +0x0p+0 +0x1.9199a4p+2 +0x0p+0 +0x1.90d6e2p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.04a95ep-10 +0x1.d3a3c4p-11 +0x1.d3a3c4p-11 +0x1.7b22b2p-11 +0x1.7b22b2p-11 +0x1.17ee56p-11 +0x1.17ee56p-11 +0x1.68dc22p-12 +0x1.68dc22p-12 +0x1.1eb316p-13 +0x1.1eb316p-13 +-0x1.061a42p-13 +-0x1.061a42p-13 +-0x1.cdec4ap-12 +-0x1.cdec4ap-12 +-0x1.7b607ep-11 +-0x1.7b607ep-11 +-0x1.aa1906p-11 +-0x1.aa1906p-11 +0x1.3443f2p-6 +-0x1.aa1906p-11 +-0x1.337a42p-6 +-0x1.337a42p-6 +0x1.3443f2p-6 +-0x1.3a5a98p-6 +-0x1.337a42p-6 +0x1.cbd1fcp-7 +-0x1.3a5a98p-6 +-0x1.48d30ep-6 +0x1.cbd1fcp-7 +-0x1.1d526ep-3 +-0x1.48d30ep-6 +0x0p+0 +-0x1.1d526ep-3 +0x1.3443f2p-6 +0x1.39275ep-6 +0x1.39275ep-6 +-0x1.cacbfcp-7 +-0x1.cacbfcp-7 +0x1.48ca9cp-6 +0x1.48ca9cp-6 +0x1.1d50bcp-3 +0x1.1d50bcp-3 +0x0p+0 +0x1.0257dp-10 +0x1.d12a32p-11 +0x1.cd36c4p-12 +0x1.7764p-10 +0x1.cb6cdap-11 +0x1.7cdb3ep-11 +-0x1.710e26p-13 +0x1.d1e98ap-10 +0x1.6f0608p-11 +0x1.1e177ap-11 +-0x1.a6195p-11 +0x1.0c9bfcp-9 +0x1.063d24p-11 +0x1.7939d8p-12 +-0x1.73dea2p-10 +0x1.2a7b3cp-9 +0x1.34ec0cp-12 +0x1.31f212p-13 +-0x1.0888ap-9 +0x1.423124p-9 +0x1.0f4902p-14 +-0x1.27a858p-13 +-0x1.5647e4p-9 +0x1.4c654p-9 +-0x1.e3b24ep-13 +-0x1.056ff6p-11 +-0x1.9eafap-9 +0x1.3f772cp-9 +-0x1.360bc4p-11 +-0x1.ac3cdp-11 +-0x1.ce99cap-9 +0x1.168d5ep-9 +-0x1.df2898p-11 +-0x1.ddd076p-11 +-0x1.c011e8p-9 +0x1.a322a6p-10 +-0x1.0a009ap-10 +0x1.db4abap-7 +0x1.87e9f8p-12 +0x1.e53a6p-7 +0x1.87e9f8p-12 +-0x1.d95c92p-7 +-0x1.cb694ep-11 +-0x1.e24d2cp-7 +0x1.e53a6p-7 +-0x1.e24d2cp-7 +-0x1.dc13f4p-7 +-0x1.692f3cp-6 +-0x1.69293p-6 +0x1.03052cp-6 +0x1.fd0232p-7 +-0x1.101b4cp-5 +-0x1.0ade46p-5 +-0x1.2b1bf8p-3 +-0x1.299ae2p-3 +0x0p+0 +0x1.67c928p-6 +0x1.ddedc2p-7 +-0x1.029b98p-6 +0x1.67d76cp-6 +0x1.102014p-5 +-0x1.fc448cp-7 +0x1.2b1a2ep-3 +0x1.0ae61cp-5 +0x0p+0 +0x1.299954p-3 +0x1.04960ep-10 +0x1.d69b4ep-11 +0x1.d95a7ap-12 +0x1.79516ep-10 +0x1.d0d92p-11 +0x1.82da46p-11 +-0x1.5207d6p-13 +0x1.d3bd2cp-10 +0x1.74fa5ap-11 +0x1.230dbp-11 +-0x1.9e5b14p-11 +0x1.0d6638p-9 +0x1.0b5e96p-11 +0x1.7d3952p-12 +-0x1.70eacep-10 +0x1.2ac92ap-9 +0x1.399d74p-12 +0x1.288b46p-13 +-0x1.07a2d6p-9 +0x1.414bdap-9 +0x1.00f306p-14 +-0x1.3a47fp-13 +-0x1.559494p-9 +0x1.4a16d6p-9 +-0x1.f47364p-13 +-0x1.08305ap-11 +-0x1.9cf9c2p-9 +0x1.3c0594p-9 +-0x1.3869f2p-11 +-0x1.a9c538p-11 +-0x1.ca52bcp-9 +0x1.124a22p-9 +-0x1.dc68b4p-11 +-0x1.cb694ep-11 +-0x1.b67594p-9 +0x1.9a67b8p-10 +-0x1.00ff66p-10 +0x1.e1685ap-7 +0x1.033ed8p-11 +0x1.ebf67ep-7 +0x1.033ed8p-11 +-0x1.df76fp-7 +-0x1.be093p-11 +-0x1.e916b4p-7 +0x1.ebf67ep-7 +-0x1.e916b4p-7 +-0x1.e2ccf4p-7 +-0x1.65162ap-6 +-0x1.65373p-6 +0x1.fbe154p-7 +0x1.f3c192p-7 +-0x1.11a48ep-5 +-0x1.0cb0e4p-5 +-0x1.2a5b96p-3 +-0x1.28e5c4p-3 +0x0p+0 +0x1.63c13ep-6 +0x1.e49064p-7 +-0x1.fb1ea8p-7 +0x1.63f62cp-6 +0x1.11aa1ap-5 +-0x1.f311c6p-7 +0x1.2a59e4p-3 +0x1.0cb90cp-5 +0x0p+0 +0x1.28e44ap-3 +0x1.06d644p-10 +0x1.dc0fd2p-11 +-0x1.4b5a18p+0 +0x1.1af076p-2 +-0x1.4b5efp+0 +0x1.1af04ap-2 +-0x1.b73246p+5 +-0x1.cf62d4p+4 +-0x1.887e8ap+5 +0x1.9ac152p+3 +0x1.0f627cp-2 +0x1.9ac152p+3 +0x1.0f627cp-2 +0x1.9ac152p+3 +-0x1.cf62d4p+4 +-0x1.887e8ap+5 +-0x1.380ec6p+5 +0x1.3e8ec6p+2 +-0x1.380eb6p+5 +0x1.3e8eecp+2 +0x1.3e8eecp+2 +0x1.0f698p-2 +0x1.3e8eecp+2 +0x1.0f698p-2 +0x1.0bb1dap-2 +0x1.3e8eecp+2 +0x1.0bb1dap-2 +-0x1.380eb6p+5 +0x1.0bb1dap-2 +-0x1.380eb6p+5 +-0x1.f2fdaep+4 +0x1.f79d1p-3 +-0x1.f2fce8p+4 +0x1.fc350cp-3 +-0x1.299104p+4 +0x1.fdc6f6p-3 +-0x1.2991ep+4 +0x1.001cfap-2 +-0x1.f2fce2p+4 +0x1.49fe6p-3 +-0x1.f2fe5p+4 +0x1.419756p-3 +-0x1.1eb808p+4 +0x1.419756p-3 +-0x1.11ca14p+4 +0x1.4aff4cp-3 +-0x1.11cbc8p+4 +0x1.527b46p-3 +-0x1.f87e4ap+2 +0x1.206366p-7 +-0x1.f881bap+2 +0x1.539f9p-7 +-0x1.60c1dap+3 +0x1.a0e44p-8 +-0x1.60bbf6p+3 +0x1.9195e2p-7 +-0x1.1eb952p+4 +0x1.b95c5ap-7 +-0x1.60bc4ap+3 +-0x1.3a454ep-3 +-0x1.60bf1cp+3 +-0x1.462c68p-3 +-0x1.306622p+4 +-0x1.4a0696p-3 +-0x1.3068fcp+4 +-0x1.449feep-3 +-0x1.2793fap+4 +-0x1.16da3ap-2 +-0x1.31b44p+4 +-0x1.1596ap-2 +-0x1.31b568p+4 +-0x1.1241fp-2 +-0x1.d79b0cp+4 +-0x1.1259aap-2 +-0x1.1d2ffep+4 +-0x1.85869cp-2 +-0x1.1d2a0ep+4 +-0x1.75ee8p-2 +-0x1.d00c94p+3 +-0x1.75ee8p-2 +-0x1.d00e6ep+3 +-0x1.758d68p-2 +-0x1.2793fap+4 +-0x1.767c54p-2 +-0x1.1d2a0ep+4 +-0x1.e41a72p-2 +-0x1.1d2a3ap+4 +-0x1.d7efbep+4 +-0x1.1d2cfp+4 +-0x1.18d8ap+5 +-0x1.1d2ffep+4 +-0x1.18d782p+5 +-0x1.d79beap+4 +-0x1.2fcfa4p+3 +-0x1.d79cbcp+4 +-0x1.536f8cp+3 +-0x1.306664p+4 +-0x1.5372f8p+3 +-0x1.3065c8p+4 +-0x1.463d06p+4 +-0x1.14ece8p+4 +-0x1.463dep+4 +-0x1.14ece8p+4 +-0x1.f871d6p+2 +-0x1.14ed36p+4 +-0x1.f872fap+2 +-0x1.14ed74p+4 +-0x1.60bf9p+3 +-0x1.14ee7p+4 +-0x1.60bd9ap+3 +-0x1.936b38p+4 +-0x1.f8742p+2 +-0x1.31b444p+4 +-0x1.2fce58p+3 +-0x1.2793fap+4 +-0x1.09e916p+5 +-0x1.31b4bcp+4 +-0x1.09e93ep+5 +-0x1.31b42p+4 +-0x1.09e928p+5 +-0x1.60c106p+3 +-0x1.f87ebep+2 +-0x1.60c05p+3 +-0x1.f8800ap+2 +-0x1.1eb75cp+4 +-0x1.11c9acp+4 +0x1.48b018p+3 +-0x1.11c9acp+4 +-0x1.1eb75cp+4 +-0x1.67abfap+1 +-0x1.32c5e4p+2 +0x1.48b21ep+3 +0x1.48af3cp+3 +-0x1.f2fe5p+4 +-0x1.32c5e4p+2 +-0x1.f2fe5p+4 +-0x1.71fc64p+1 +-0x1.29914cp+4 +-0x1.71fc8ep+1 +-0x1.29914cp+4 +0x1.1473b2p-2 +0x1.0fa41ap-2 +0x1.0fe8f6p-2 +0x1.fe7e5p-3 +0x1.1aee06p-2 +0x1.1398dep-2 +0x0p+0 +0x1.1a7e1p-2 +0x1.02ffacp-2 +0x1.4f645ep-3 +0x1.6b9da8p-3 +0x1.ae318ap-8 +0x1.fd4b6ap-6 +-0x1.4efec2p-3 +-0x1.1fd946p-3 +-0x1.1d834ap-2 +-0x1.09cf3ap-2 +-0x1.772eaep-2 +-0x1.6acd8p-2 +-0x1.e5561ep-2 +-0x1.e3aa5p-2 +0x0p+0 +-0x1.bf95e2p+1 +-0x1.d00dbp+3 +-0x1.bf901p+1 +-0x1.1d2f08p+4 +-0x1.88502cp-4 +-0x1.18d828p+5 +-0x1.86e83cp-4 +-0x1.d7ef46p+4 +-0x1.7ca714p-3 +-0x1.d79b0ap+4 +-0x1.7c3fcp-3 +-0x1.31b42p+4 +-0x1.84dae4p+1 +-0x1.536f7p+3 +-0x1.84e1f6p+1 +-0x1.463dep+4 +-0x1.91bb1cp+1 +-0x1.14ecbap+4 +-0x1.91c4aap+1 +-0x1.936afcp+4 +-0x1.99f31ap-3 +-0x1.2fcf26p+3 +-0x1.999fe8p-3 +-0x1.09e928p+5 +-0x1.a14efcp+1 +-0x1.30659p+4 +-0x1.a1583ap+1 +-0x1.60c1aep+3 +-0x1.8f2198p+3 +-0x1.f87d0ap+2 +-0x1.8f2372p+3 +-0x1.1eb6f8p+4 +-0x1.4b0456p+3 +-0x1.11c9a8p+4 +-0x1.4b031ep+3 +-0x1.67aadep+1 +-0x1.72c5c2p+1 +-0x1.29914ep+4 +-0x1.72bfdcp+1 +-0x1.f2fe62p+4 +-0x1.5040b8p+0 +0x1.684c78p+3 +0x1.0fc3dap-2 +0x1.14df18p-2 +0x1.1ab1d2p-2 +0x0p+0 +-0x1.4b5c9ap+0 +-0x1.b73246p+5 +0x1.9ac11ap+3 +-0x1.887e8ap+5 +-0x1.cf62d4p+4 +0x1.3e8eecp+2 +-0x1.380ec6p+5 +0x1.0f698p-2 +0x1.0bb446p-2 +0x1.f77412p-3 +0x1.4a22d8p-3 +0x1.1f482ap-7 +-0x1.3a4588p-3 +-0x1.16d88p-2 +-0x1.859d66p-2 +-0x1.e3fb96p-2 +-0x1.d00dbp+3 +-0x1.bf983cp+1 +-0x1.1d2f08p+4 +-0x1.18d828p+5 +-0x1.87ca12p-4 +-0x1.d7ef46p+4 +-0x1.d79b0ap+4 +-0x1.7c8f06p-3 +-0x1.536f7p+3 +-0x1.84dd0ep+1 +-0x1.463dep+4 +-0x1.14ecbap+4 +-0x1.91baf4p+1 +-0x1.936afcp+4 +-0x1.2fcf26p+3 +-0x1.99e264p-3 +-0x1.09e928p+5 +-0x1.31b42p+4 +-0x1.2793fap+4 +-0x1.30659p+4 +-0x1.a14f02p+1 +-0x1.60c1aep+3 +-0x1.f87d0ap+2 +-0x1.8f2162p+3 +-0x1.11c9a8p+4 +-0x1.4b03d6p+3 +-0x1.67aadep+1 +0x1.48af34p+3 +-0x1.32c5e4p+2 +-0x1.1eb6f8p+4 +-0x1.29914ep+4 +-0x1.72c766p+1 +-0x1.f2fe62p+4 +-0x1.71f87ep+1 +-0x1.4ff244p+0 +0x1.685036p+3 +-0x1.71c06ep+1 +0x1.48b48cp+3 +0x1.0cb75ep-2 +-0x1.380d22p+5 +0x1.3e9e42p+2 +0x1.107fcp-2 +0x1.9acb32p+3 +-0x1.4b1a84p+0 +-0x1.b72ae2p+5 +-0x1.cf654p+4 +-0x1.887c0ap+5 +-0x1.27993ep+4 +-0x1.32b382p+2 +-0x1.91e338p+1 +-0x1.14f298p+4 +-0x1.9372fp+4 +-0x1.7f31dap-3 +-0x1.d7a05p+4 +-0x1.31b8e6p+4 +-0x1.bfca2p+1 +-0x1.1d3934p+4 +-0x1.d0187cp+3 +-0x1.914016p-4 +-0x1.18dd36p+5 +-0x1.d7f95ep+4 +-0x1.9c65ap-3 +-0x1.2fda28p+3 +-0x1.09eba2p+5 +-0x1.a179fep+1 +-0x1.306a4cp+4 +-0x1.60cc14p+3 +-0x1.72a22cp+1 +-0x1.f2fb38p+4 +-0x1.298daap+4 +-0x1.850496p+1 +-0x1.5380eap+3 +-0x1.463f4ap+4 +-0x1.8f2e6ep+3 +-0x1.1ec0bap+4 +-0x1.f8963cp+2 +-0x1.4afd7ep+3 +-0x1.67115p+1 +-0x1.11c8eap+4 +0x1.1bc09p-2 +0x1.15f2fep-2 +0x1.10e036p-2 +0x1.f95ecp-3 +0x1.4b2b12p-3 +0x1.0530e8p-7 +-0x1.3d5d28p-3 +-0x1.184418p-2 +-0x1.86d4c2p-2 +-0x1.e4384cp-2 +0x0p+0 +0x1.0530e8p-7 +0x0p+0 +0x1.1f482ap-7 +0x0p+0 +0x1.162e2ap+2 +0x0p+0 +0x1.1643c2p+2 +0x0p+0 +0x1.4b2b12p-3 +0x0p+0 +0x1.4a22d8p-3 +0x0p+0 +0x1.8834ccp+2 +0x0p+0 +0x1.884d8ap+2 +0x0p+0 +0x1.0cb75ep-2 +0x0p+0 +0x1.0bb446p-2 +0x0p+0 +0x1.a71958p+0 +0x0p+0 +0x1.a62cd8p+0 +0x0p+0 +0x1.3f5914p+2 +0x0p+0 +0x1.3f489p+2 +0x0p+0 +0x1.3a131cp+1 +0x0p+0 +0x1.3a267cp+1 +0x0p+0 +0x1.34758p+0 +0x0p+0 +0x1.34258p+0 +0x0p+0 +0x1.7fa2ap-2 +0x0p+0 +0x1.80f3ap-2 +0x0p+0 +0x1.8bdab6p+2 +0x0p+0 +0x1.8c008ep+2 +0x0p+0 +0x1.eae458p+0 +0x0p+0 +0x1.eb85d8p+0 +0x0p+0 +0x1.4ba928p+1 +0x0p+0 +0x1.4bfa08p+1 +0x0p+0 +0x1.862628p+2 +0x0p+0 +0x1.863b3ep+2 +0x0p+0 +0x1.819b4p+2 +0x0p+0 +0x1.81ae58p+2 +0x0p+0 +0x1.10e036p-2 +0x0p+0 +0x1.0fc3dap-2 +0x0p+0 +0x1.05e948p+0 +0x0p+0 +0x1.068c08p+0 +0x0p+0 +0x1.f07538p+0 +0x0p+0 +0x1.f0c998p+0 +0x0p+0 +0x1.64754cp+1 +0x0p+0 +0x1.64a73p+1 +0x0p+0 +0x1.79b26ap+2 +0x0p+0 +0x1.79c5ep+2 +0x0p+0 +0x1.809b74p+2 +0x0p+0 +0x1.80b22ep+2 +0x0p+0 +0x1.15f2fep-2 +0x0p+0 +0x1.14df18p-2 +0x0p+0 +0x1.79b26ap+2 +0x0p+0 +0x1.79c5ep+2 +-0x1.5040b8p+0 +-0x1.71f87ep+1 +-0x1.5040b8p+0 +0x1.f77412p-3 +-0x1.5040b8p+0 +0x1.0bb446p-2 +-0x1.5040b8p+0 +0x1.0fc3dap-2 +-0x1.5040b8p+0 +0x1.684c78p+3 +0x1.684c78p+3 +0x1.0bb446p-2 +0x1.0f698p-2 +0x1.0fc3dap-2 +0x1.3e8eecp+2 +0x1.0fc3dap-2 +0x1.0bb446p-2 +0x1.0fc3dap-2 +-0x1.cf62d4p+4 +0x1.14df18p-2 +-0x1.887e8ap+5 +0x1.14df18p-2 +0x1.9ac11ap+3 +0x1.14df18p-2 +0x1.0f698p-2 +0x1.14df18p-2 +-0x1.b73246p+5 +0x1.1ab1d2p-2 +-0x1.4b5c9ap+0 +0x1.1ab1d2p-2 +-0x1.b73246p+5 +-0x1.cf62d4p+4 +-0x1.887e8ap+5 +0x1.9ac11ap+3 +0x1.0f698p-2 +0x1.9ac11ap+3 +-0x1.cf62d4p+4 +-0x1.887e8ap+5 +-0x1.380ec6p+5 +0x1.3e8eecp+2 +0x1.3e8eecp+2 +0x1.0f698p-2 +0x1.0bb446p-2 +0x1.3e8eecp+2 +0x1.0bb446p-2 +-0x1.380ec6p+5 +-0x1.f2fe62p+4 +0x1.f77412p-3 +-0x1.29914ep+4 +0x1.f77412p-3 +-0x1.f2fe62p+4 +0x1.4a22d8p-3 +-0x1.1eb6f8p+4 +0x1.4a22d8p-3 +-0x1.11c9a8p+4 +0x1.4a22d8p-3 +-0x1.f87d0ap+2 +0x1.1f482ap-7 +-0x1.60c1aep+3 +0x1.1f482ap-7 +-0x1.1eb6f8p+4 +0x1.1f482ap-7 +-0x1.60c1aep+3 +-0x1.3a4588p-3 +-0x1.30659p+4 +-0x1.3a4588p-3 +-0x1.2793fap+4 +-0x1.16d88p-2 +-0x1.31b42p+4 +-0x1.16d88p-2 +-0x1.d79b0ap+4 +-0x1.16d88p-2 +-0x1.1d2f08p+4 +-0x1.859d66p-2 +-0x1.d00dbp+3 +-0x1.859d66p-2 +-0x1.2793fap+4 +-0x1.859d66p-2 +-0x1.1d2f08p+4 +-0x1.e3fb96p-2 +-0x1.1d2f08p+4 +-0x1.d7ef46p+4 +-0x1.1d2f08p+4 +-0x1.18d828p+5 +-0x1.d79b0ap+4 +-0x1.2fcf26p+3 +-0x1.d79b0ap+4 +-0x1.536f7p+3 +-0x1.30659p+4 +-0x1.536f7p+3 +-0x1.30659p+4 +-0x1.463dep+4 +-0x1.14ecbap+4 +-0x1.463dep+4 +-0x1.14ecbap+4 +-0x1.f87d0ap+2 +-0x1.14ecbap+4 +-0x1.60c1aep+3 +-0x1.936afcp+4 +-0x1.f87d0ap+2 +-0x1.31b42p+4 +-0x1.2fcf26p+3 +-0x1.2793fap+4 +-0x1.09e928p+5 +-0x1.31b42p+4 +-0x1.09e928p+5 +-0x1.60c1aep+3 +-0x1.f87d0ap+2 +-0x1.1eb6f8p+4 +-0x1.11c9a8p+4 +0x1.48af34p+3 +-0x1.11c9a8p+4 +-0x1.1eb6f8p+4 +-0x1.67aadep+1 +-0x1.32c5e4p+2 +0x1.48af34p+3 +0x1.48af34p+3 +-0x1.f2fe62p+4 +-0x1.32c5e4p+2 +-0x1.f2fe62p+4 +-0x1.71f87ep+1 +-0x1.29914ep+4 +0x1.0fc3dap-2 +0x1.14df18p-2 +0x1.f77412p-3 +0x1.0fc3dap-2 +0x1.14df18p-2 +0x1.1ab1d2p-2 +0x1.1ab1d2p-2 +0x0p+0 +0x1.4a22d8p-3 +0x1.f77412p-3 +0x1.1f482ap-7 +0x1.4a22d8p-3 +-0x1.3a4588p-3 +0x1.1f482ap-7 +-0x1.16d88p-2 +-0x1.3a4588p-3 +-0x1.859d66p-2 +-0x1.16d88p-2 +-0x1.e3fb96p-2 +-0x1.859d66p-2 +0x0p+0 +-0x1.e3fb96p-2 +-0x1.d00dbp+3 +-0x1.bf983cp+1 +-0x1.1d2f08p+4 +-0x1.bf983cp+1 +-0x1.18d828p+5 +-0x1.87ca12p-4 +-0x1.d7ef46p+4 +-0x1.87ca12p-4 +-0x1.d79b0ap+4 +-0x1.7c8f06p-3 +-0x1.31b42p+4 +-0x1.7c8f06p-3 +-0x1.536f7p+3 +-0x1.84dd0ep+1 +-0x1.463dep+4 +-0x1.84dd0ep+1 +-0x1.14ecbap+4 +-0x1.91baf4p+1 +-0x1.936afcp+4 +-0x1.91baf4p+1 +-0x1.2fcf26p+3 +-0x1.99e264p-3 +-0x1.09e928p+5 +-0x1.99e264p-3 +-0x1.30659p+4 +-0x1.a14f02p+1 +-0x1.60c1aep+3 +-0x1.a14f02p+1 +-0x1.f87d0ap+2 +-0x1.8f2162p+3 +-0x1.1eb6f8p+4 +-0x1.8f2162p+3 +-0x1.11c9a8p+4 +-0x1.4b03d6p+3 +-0x1.67aadep+1 +-0x1.4b03d6p+3 +-0x1.29914ep+4 +-0x1.72c766p+1 +-0x1.f2fe62p+4 +-0x1.72c766p+1 +-0x1.506898p+0 +-0x1.7215b8p+1 +-0x1.50793ap+0 +-0x1.721e2ap+1 +-0x1.50855cp+0 +0x1.f5a1c2p-3 +-0x1.50855cp+0 +0x1.0b1d3ep-2 +-0x1.50855cp+0 +0x1.0b1d3ep-2 +-0x1.507a74p+0 +0x1.0e4e26p-2 +-0x1.507a74p+0 +0x1.0e4e26p-2 +-0x1.507a74p+0 +0x1.68477cp+3 +-0x1.5079b2p+0 +0x1.68473cp+3 +0x1.68473cp+3 +0x1.0af154p-2 +0x1.0de2f8p-2 +0x1.0e4e26p-2 +0x1.0dd5e6p-2 +0x1.0e4c2p-2 +0x1.3e738ap+2 +0x1.0e433cp-2 +0x1.3e738ap+2 +0x1.0e433cp-2 +0x1.0af154p-2 +0x1.0e3fecp-2 +0x1.0af154p-2 +0x1.0e3fecp-2 +-0x1.cf5fd8p+4 +0x1.13a6a6p-2 +-0x1.88812p+5 +0x1.134848p-2 +0x1.9ab74ep+3 +0x1.13341p-2 +0x1.9ab5bep+3 +0x1.13440cp-2 +0x1.0de43ap-2 +0x1.134b08p-2 +0x1.0df1fap-2 +0x1.134f82p-2 +-0x1.b73a1p+5 +0x1.19ca48p-2 +-0x1.4b967cp+0 +0x1.19fb4ap-2 +-0x1.4b9b8cp+0 +0x1.19fb1cp-2 +-0x1.b73a1p+5 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +0x1.9ab84ap+3 +0x1.0df3ap-2 +0x1.9ab84ap+3 +0x1.0df3ap-2 +0x1.9ab84ap+3 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +-0x1.380ff4p+5 +0x1.3e74eap+2 +-0x1.380ff4p+5 +0x1.3e74eap+2 +0x1.3e74eap+2 +0x1.0e0066p-2 +0x1.3e74eap+2 +0x1.0e0066p-2 +0x1.0af154p-2 +0x1.3e74eap+2 +0x1.0af154p-2 +-0x1.380ff4p+5 +0x1.0af154p-2 +-0x1.380ff4p+5 +-0x1.f3005ep+4 +0x1.f5a1c2p-3 +-0x1.f2ff9cp+4 +0x1.fa25a6p-3 +-0x1.2994f6p+4 +0x1.fbb092p-3 +-0x1.2995d2p+4 +0x1.fe25acp-3 +-0x1.f2ff96p+4 +0x1.48d09ap-3 +-0x1.f300fep+4 +0x1.408caep-3 +-0x1.1eaf5cp+4 +0x1.408caep-3 +-0x1.11cc36p+4 +0x1.49c33p-3 +-0x1.11cdeap+4 +0x1.514204p-3 +-0x1.f867a2p+2 +0x1.598278p-7 +-0x1.f86b0cp+2 +0x1.8c4a14p-7 +-0x1.60b6fap+3 +0x1.08668ep-7 +-0x1.60b11cp+3 +0x1.c8b28ap-7 +-0x1.1eb0a2p+4 +0x1.eed514p-7 +-0x1.60b16ep+3 +-0x1.3793dcp-3 +-0x1.60b44p+3 +-0x1.43755ap-3 +-0x1.30606p+4 +-0x1.474d8p-3 +-0x1.30633ap+4 +-0x1.41ea7cp-3 +-0x1.278ee4p+4 +-0x1.15d7b2p-2 +-0x1.31af98p+4 +-0x1.1493acp-2 +-0x1.31b0cp+4 +-0x1.113deep-2 +-0x1.d793eap+4 +-0x1.115512p-2 +-0x1.1d27c2p+4 +-0x1.83ded6p-2 +-0x1.1d21d2p+4 +-0x1.7449fap-2 +-0x1.cfffb6p+3 +-0x1.7449fap-2 +-0x1.d00192p+3 +-0x1.73e862p-2 +-0x1.278ee4p+4 +-0x1.74d99cp-2 +-0x1.1d21d2p+4 +-0x1.e4465cp-2 +-0x1.1d21fep+4 +-0x1.d7e70cp+4 +-0x1.1d24b4p+4 +-0x1.18d486p+5 +-0x1.1d27c4p+4 +-0x1.18d368p+5 +-0x1.d794c8p+4 +-0x1.2fc71cp+3 +-0x1.d795aap+4 +-0x1.535f4cp+3 +-0x1.3060a4p+4 +-0x1.5362cp+3 +-0x1.306008p+4 +-0x1.46393ep+4 +-0x1.14e736p+4 +-0x1.463a12p+4 +-0x1.14e736p+4 +-0x1.f85b16p+2 +-0x1.14e786p+4 +-0x1.f85c42p+2 +-0x1.14e7c6p+4 +-0x1.60b4b4p+3 +-0x1.14e8c6p+4 +-0x1.60b2b6p+3 +-0x1.936446p+4 +-0x1.f85d6ep+2 +-0x1.31afap+4 +-0x1.2fc5b8p+3 +-0x1.278ee4p+4 +-0x1.09e6e4p+5 +-0x1.31b00ep+4 +-0x1.09e70cp+5 +-0x1.31af72p+4 +-0x1.09e6f6p+5 +-0x1.60b61cp+3 +-0x1.f8682p+2 +-0x1.60b56p+3 +-0x1.f86976p+2 +-0x1.1eaebp+4 +-0x1.11cbdp+4 +0x1.48ac92p+3 +-0x1.11cbdp+4 +-0x1.1eaebp+4 +-0x1.68574p+1 +-0x1.32cf26p+2 +0x1.48aeep+3 +0x1.48abfp+3 +-0x1.f300fep+4 +-0x1.32cf26p+2 +-0x1.f300fep+4 +-0x1.7224b8p+1 +-0x1.29953ep+4 +-0x1.7224b8p+1 +-0x1.29953ep+4 +0x1.13502p-2 +0x1.0e3fecp-2 +0x1.0e9b42p-2 +0x1.fc6aeap-3 +0x1.19f8dp-2 +0x1.12801p-2 +0x0p+0 +0x1.198e8cp-2 +0x1.01eb96p-2 +0x1.4e2b88p-3 +0x1.6a4ccep-3 +0x1.0e423cp-7 +0x1.05066ep-5 +-0x1.4c40dap-3 +-0x1.1d23p-3 +-0x1.1c7c7cp-2 +-0x1.088b02p-2 +-0x1.758abp-2 +-0x1.6946fap-2 +-0x1.e58758p-2 +-0x1.e3918ap-2 +0x0p+0 +-0x1.bf60f8p+1 +-0x1.d000d2p+3 +-0x1.bf5b12p+1 +-0x1.1d26cep+4 +-0x1.80172p-4 +-0x1.18d40ep+5 +-0x1.7eb178p-4 +-0x1.d7e692p+4 +-0x1.7a75acp-3 +-0x1.d793f4p+4 +-0x1.7a0acep-3 +-0x1.31af72p+4 +-0x1.84abf2p+1 +-0x1.535f3ap+3 +-0x1.84b2bep+1 +-0x1.463a12p+4 +-0x1.9190fcp+1 +-0x1.14e714p+4 +-0x1.919a84p+1 +-0x1.93640ap+4 +-0x1.979f76p-3 +-0x1.2fc678p+3 +-0x1.974736p-3 +-0x1.09e6f6p+5 +-0x1.a124c4p+1 +-0x1.305fdp+4 +-0x1.a12d68p+1 +-0x1.60b6b8p+3 +-0x1.8f1284p+3 +-0x1.f86682p+2 +-0x1.8f144p+3 +-0x1.1eae4cp+4 +-0x1.4b0a3ep+3 +-0x1.11cbccp+4 +-0x1.4b08ep+3 +-0x1.68563p+1 +-0x1.72e93p+1 +-0x1.299542p+4 +-0x1.72e378p+1 +-0x1.f3011p+4 +-0x1.5079b2p+0 +-0x1.721f36p+1 +-0x1.50864ap+0 +-0x1.72259ap+1 +-0x1.508f4ap+0 +0x1.f5c55p-3 +-0x1.508f4ap+0 +0x1.0af39ep-2 +-0x1.508f4ap+0 +0x1.0af39ep-2 +-0x1.508468p+0 +0x1.0e867p-2 +-0x1.508468p+0 +0x1.0e867p-2 +-0x1.508468p+0 +0x1.68473cp+3 +-0x1.5083aep+0 +0x1.6847p+3 +0x1.6847p+3 +0x1.0ac7dp-2 +0x1.0e0066p-2 +0x1.0e867p-2 +0x1.0de70ep-2 +0x1.0e8284p-2 +0x1.3e74eap+2 +0x1.0e74acp-2 +0x1.3e74eap+2 +0x1.0e74acp-2 +0x1.0ac7dp-2 +0x1.0e702ap-2 +0x1.0ac7dp-2 +0x1.0e702ap-2 +-0x1.cf5fd8p+4 +0x1.13cf78p-2 +-0x1.88812p+5 +0x1.1369bcp-2 +0x1.9ab7e4p+3 +0x1.13555p-2 +0x1.9ab67p+3 +0x1.136422p-2 +0x1.0dfd5cp-2 +0x1.136afp-2 +0x1.0e070ep-2 +0x1.136e18p-2 +-0x1.b73a1p+5 +0x1.19c0dcp-2 +-0x1.4b993p+0 +0x1.19f21p-2 +-0x1.4b9e5p+0 +0x1.19f1ep-2 +-0x1.b73a1p+5 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +0x1.9ab8ecp+3 +0x1.0e070ep-2 +0x1.9ab8ecp+3 +0x1.0e070ep-2 +0x1.9ab8ecp+3 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +-0x1.381004p+5 +0x1.3e76c8p+2 +-0x1.381004p+5 +0x1.3e76c8p+2 +0x1.3e76c8p+2 +0x1.0e12dcp-2 +0x1.3e76c8p+2 +0x1.0e12dcp-2 +0x1.0ac7dp-2 +0x1.3e76c8p+2 +0x1.0ac7dp-2 +-0x1.381004p+5 +0x1.0ac7dp-2 +-0x1.381004p+5 +-0x1.f3011p+4 +0x1.f5c55p-3 +-0x1.f3004ep+4 +0x1.fa3f28p-3 +-0x1.299542p+4 +0x1.fbbd9p-3 +-0x1.29961cp+4 +0x1.fe2b58p-3 +-0x1.f3004ap+4 +0x1.48a91ep-3 +-0x1.f301b2p+4 +0x1.406bdep-3 +-0x1.1eae4cp+4 +0x1.406bdep-3 +-0x1.11cbccp+4 +0x1.49bf46p-3 +-0x1.11cd82p+4 +0x1.514432p-3 +-0x1.f86682p+2 +0x1.4233bcp-7 +-0x1.f869ecp+2 +0x1.750712p-7 +-0x1.60b6b8p+3 +0x1.e619ccp-8 +-0x1.60b0d8p+3 +0x1.b35ca6p-7 +-0x1.1eaf98p+4 +0x1.db4c4cp-7 +-0x1.60b12cp+3 +-0x1.36e3f6p-3 +-0x1.60b4p+3 +-0x1.42d02ap-3 +-0x1.305fdp+4 +-0x1.46b35ep-3 +-0x1.3062a4p+4 +-0x1.415c54p-3 +-0x1.278ee4p+4 +-0x1.159054p-2 +-0x1.31af72p+4 +-0x1.14520cp-2 +-0x1.31b098p+4 +-0x1.11006cp-2 +-0x1.d793f4p+4 +-0x1.111816p-2 +-0x1.1d26cep+4 +-0x1.8432d6p-2 +-0x1.1d20dap+4 +-0x1.749a8p-2 +-0x1.d000d2p+3 +-0x1.749a8p-2 +-0x1.d002bp+3 +-0x1.74387ap-2 +-0x1.278ee4p+4 +-0x1.7525e2p-2 +-0x1.1d20dap+4 +-0x1.e409aep-2 +-0x1.1d2108p+4 +-0x1.d7e692p+4 +-0x1.1d23bcp+4 +-0x1.18d40ep+5 +-0x1.1d26ccp+4 +-0x1.18d2fp+5 +-0x1.d794d2p+4 +-0x1.2fc678p+3 +-0x1.d795b2p+4 +-0x1.535f3ap+3 +-0x1.30601p+4 +-0x1.5362aap+3 +-0x1.305f74p+4 +-0x1.463a12p+4 +-0x1.14e714p+4 +-0x1.463ae8p+4 +-0x1.14e714p+4 +-0x1.f85a32p+2 +-0x1.14e766p+4 +-0x1.f85b64p+2 +-0x1.14e7a8p+4 +-0x1.60b474p+3 +-0x1.14e8a6p+4 +-0x1.60b276p+3 +-0x1.93640ap+4 +-0x1.f85c96p+2 +-0x1.31af76p+4 +-0x1.2fc516p+3 +-0x1.278ee4p+4 +-0x1.09e6f6p+5 +-0x1.31afe6p+4 +-0x1.09e71ep+5 +-0x1.31af4ap+4 +-0x1.09e708p+5 +-0x1.60b5dap+3 +-0x1.f86728p+2 +-0x1.60b50ap+3 +-0x1.f868a2p+2 +-0x1.1eadb2p+4 +-0x1.11cb68p+4 +0x1.48abep+3 +-0x1.11cb68p+4 +-0x1.1eadb2p+4 +-0x1.68563p+1 +-0x1.32cf26p+2 +0x1.48ae14p+3 +0x1.48abp+3 +-0x1.f301b2p+4 +-0x1.32cf26p+2 +-0x1.f301b2p+4 +-0x1.722a76p+1 +-0x1.299588p+4 +-0x1.722a76p+1 +-0x1.299588p+4 +0x1.136e18p-2 +0x1.0e702ap-2 +0x1.0eb13ap-2 +0x1.fc71dp-3 +0x1.19ef78p-2 +0x1.1287d2p-2 +0x0p+0 +0x1.197b5ep-2 +0x1.01eac6p-2 +0x1.4e2d2cp-3 +0x1.6a33eap-3 +0x1.ffd072p-8 +0x1.041a62p-5 +-0x1.4bac7p-3 +-0x1.1ce68ap-3 +-0x1.1c46bap-2 +-0x1.08864cp-2 +-0x1.75cf9ep-2 +-0x1.697378p-2 +-0x1.e5596cp-2 +-0x1.e37ebep-2 +0x0p+0 +-0x1.bf6334p+1 +-0x1.d001f4p+3 +-0x1.bf5d5cp+1 +-0x1.1d25d6p+4 +-0x1.7f923ap-4 +-0x1.18d396p+5 +-0x1.7e29e6p-4 +-0x1.d7e61ap+4 +-0x1.7a5e6ap-3 +-0x1.d793fep+4 +-0x1.79f872p-3 +-0x1.31af4ap+4 +-0x1.84ae1ap+1 +-0x1.535f22p+3 +-0x1.84b516p+1 +-0x1.463ae8p+4 +-0x1.9190f4p+1 +-0x1.14e6f4p+4 +-0x1.919a78p+1 +-0x1.9363cep+4 +-0x1.978b4cp-3 +-0x1.2fc5dap+3 +-0x1.973622p-3 +-0x1.09e708p+5 +-0x1.a1247ep+1 +-0x1.305f3cp+4 +-0x1.a12d94p+1 +-0x1.60b66ep+3 +-0x1.8f125cp+3 +-0x1.f86594p+2 +-0x1.8f141ep+3 +-0x1.1ead4ap+4 +-0x1.4b09b2p+3 +-0x1.11cb64p+4 +-0x1.4b0872p+3 +-0x1.685512p+1 +-0x1.72ea7cp+1 +-0x1.29958cp+4 +-0x1.72e4ccp+1 +-0x1.f301c4p+4 +-0x1.5083aep+0 +-0x1.72244p+1 +-0x1.508dc2p+0 +-0x1.72295ep+1 +-0x1.5094dp+0 +0x1.f5ac4cp-3 +-0x1.5094dp+0 +0x1.0ac9f8p-2 +-0x1.5094dp+0 +0x1.0ac9f8p-2 +-0x1.508a68p+0 +0x1.0e9218p-2 +-0x1.508a68p+0 +0x1.0e9218p-2 +-0x1.508a68p+0 +0x1.6847p+3 +-0x1.5089cp+0 +0x1.6846c8p+3 +0x1.6846c8p+3 +0x1.0aa014p-2 +0x1.0e12dcp-2 +0x1.0e9218p-2 +0x1.0df6cap-2 +0x1.0e8dcp-2 +0x1.3e76c8p+2 +0x1.0e7f68p-2 +0x1.3e767ep+2 +0x1.0e7fccp-2 +0x1.0aa014p-2 +0x1.0e7b28p-2 +0x1.0aa014p-2 +0x1.0e7b28p-2 +-0x1.cf5fd8p+4 +0x1.13c9aap-2 +-0x1.88812p+5 +0x1.136224p-2 +0x1.9ab88cp+3 +0x1.134da8p-2 +0x1.9ab6f2p+3 +0x1.135e0ep-2 +0x1.0e0de8p-2 +0x1.1364f4p-2 +0x1.0e1b86p-2 +0x1.136964p-2 +-0x1.b73a1p+5 +0x1.19b16p-2 +-0x1.4b9bd6p+0 +0x1.19e3bcp-2 +-0x1.4ba138p+0 +0x1.19e38ap-2 +-0x1.b73a1p+5 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +0x1.9ab976p+3 +0x1.0e1d2ep-2 +0x1.9ab976p+3 +0x1.0e1d2ep-2 +0x1.9ab976p+3 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +-0x1.381012p+5 +0x1.3e786ap+2 +-0x1.381012p+5 +0x1.3e786ap+2 +0x1.3e786ap+2 +0x1.0e27cp-2 +0x1.3e786ap+2 +0x1.0e27cp-2 +0x1.0aa6d8p-2 +0x1.3e786ap+2 +0x1.0aa6d8p-2 +-0x1.381012p+5 +0x1.0aa6d8p-2 +-0x1.381012p+5 +-0x1.f301c4p+4 +0x1.f5ac4cp-3 +-0x1.f30102p+4 +0x1.fa26e8p-3 +-0x1.29958cp+4 +0x1.fba2ep-3 +-0x1.299666p+4 +0x1.fe0d7cp-3 +-0x1.f300fep+4 +0x1.4904cp-3 +-0x1.f30264p+4 +0x1.40c92ep-3 +-0x1.1ead4ap+4 +0x1.40c92ep-3 +-0x1.11cb64p+4 +0x1.4a24c6p-3 +-0x1.11cd18p+4 +0x1.519ddp-3 +-0x1.f86594p+2 +0x1.3e3e1ep-7 +-0x1.f868f8p+2 +0x1.70c53cp-7 +-0x1.60b66ep+3 +0x1.ded1d6p-8 +-0x1.60b092p+3 +0x1.af3bb8p-7 +-0x1.1eae96p+4 +0x1.d73bd4p-7 +-0x1.60b0e8p+3 +-0x1.3710d6p-3 +-0x1.60b3b8p+3 +-0x1.42edc2p-3 +-0x1.305f3cp+4 +-0x1.46c47ep-3 +-0x1.30620ep+4 +-0x1.4170cep-3 +-0x1.278ee4p+4 +-0x1.158172p-2 +-0x1.31af4ap+4 +-0x1.144476p-2 +-0x1.31b07p+4 +-0x1.10f45ep-2 +-0x1.d793fep+4 +-0x1.110c26p-2 +-0x1.1d25d6p+4 +-0x1.84530ep-2 +-0x1.1d1fe2p+4 +-0x1.74bb16p-2 +-0x1.d001f4p+3 +-0x1.74bb16p-2 +-0x1.d003d4p+3 +-0x1.74587ep-2 +-0x1.278ee4p+4 +-0x1.7547c6p-2 +-0x1.1d1fe2p+4 +-0x1.e3e00ap-2 +-0x1.1d2012p+4 +-0x1.d7e61ap+4 +-0x1.1d22c4p+4 +-0x1.18d396p+5 +-0x1.1d25d6p+4 +-0x1.18d276p+5 +-0x1.d794dcp+4 +-0x1.2fc5dap+3 +-0x1.d795bap+4 +-0x1.535f22p+3 +-0x1.305f7ep+4 +-0x1.53628ep+3 +-0x1.305ee2p+4 +-0x1.463ae8p+4 +-0x1.14e6f4p+4 +-0x1.463bbep+4 +-0x1.14e6f4p+4 +-0x1.f85952p+2 +-0x1.14e746p+4 +-0x1.f85a84p+2 +-0x1.14e788p+4 +-0x1.60b42ap+3 +-0x1.14e886p+4 +-0x1.60b23p+3 +-0x1.9363cep+4 +-0x1.f85bb6p+2 +-0x1.31af4ep+4 +-0x1.2fc47cp+3 +-0x1.278ee4p+4 +-0x1.09e708p+5 +-0x1.31afcp+4 +-0x1.09e72ep+5 +-0x1.31af26p+4 +-0x1.09e718p+5 +-0x1.60b592p+3 +-0x1.f8662cp+2 +-0x1.60b4b8p+3 +-0x1.f867b6p+2 +-0x1.1eacb4p+4 +-0x1.11cbp+4 +0x1.48aae8p+3 +-0x1.11cbp+4 +-0x1.1eacb4p+4 +-0x1.685512p+1 +-0x1.32cf26p+2 +0x1.48ad0ap+3 +0x1.48a9e2p+3 +-0x1.f30264p+4 +-0x1.32cf26p+2 +-0x1.f30264p+4 +-0x1.722d2ep+1 +-0x1.2995d4p+4 +-0x1.722d2ep+1 +-0x1.2995d4p+4 +0x1.136a02p-2 +0x1.0e7bcp-2 +0x1.0ec0fap-2 +0x1.fc559ep-3 +0x1.19e116p-2 +0x1.128b2ep-2 +0x0p+0 +0x1.196b3cp-2 +0x1.01e198p-2 +0x1.4e8874p-3 +0x1.6a609p-3 +0x1.fb56ap-8 +0x1.0385bep-5 +-0x1.4bb384p-3 +-0x1.1ce82ep-3 +-0x1.1c39ccp-2 +-0x1.0881a2p-2 +-0x1.75f012p-2 +-0x1.69913cp-2 +-0x1.e5384p-2 +-0x1.e36ae8p-2 +0x0p+0 +-0x1.bf658ep+1 +-0x1.d00316p+3 +-0x1.bf5facp+1 +-0x1.1d24ep+4 +-0x1.7f0bd2p-4 +-0x1.18d31cp+5 +-0x1.7da342p-4 +-0x1.d7e5a2p+4 +-0x1.7a480ap-3 +-0x1.d79408p+4 +-0x1.79e302p-3 +-0x1.31af26p+4 +-0x1.84b044p+1 +-0x1.535f0ap+3 +-0x1.84b74ap+1 +-0x1.463bbep+4 +-0x1.9190dp+1 +-0x1.14e6d4p+4 +-0x1.919a56p+1 +-0x1.936394p+4 +-0x1.977904p-3 +-0x1.2fc542p+3 +-0x1.97248p-3 +-0x1.09e718p+5 +-0x1.a1246cp+1 +-0x1.305eaap+4 +-0x1.a12d8ap+1 +-0x1.60b61ep+3 +-0x1.8f1222p+3 +-0x1.f864a4p+2 +-0x1.8f13eep+3 +-0x1.1eac4ap+4 +-0x1.4b093p+3 +-0x1.11cafcp+4 +-0x1.4b07fap+3 +-0x1.6853eep+1 +-0x1.72ec1ep+1 +-0x1.2995d8p+4 +-0x1.72e656p+1 +-0x1.f30276p+4 +-0x1.5089cp+0 +0x1.6846c8p+3 +0x1.0e9f62p-2 +0x1.13c782p-2 +0x1.19a1fp-2 +0x0p+0 +-0x1.4b9eb2p+0 +-0x1.b73a1p+5 +0x1.9ab92p+3 +-0x1.88812p+5 +-0x1.cf5fd8p+4 +0x1.3e786ap+2 +-0x1.38102p+5 +0x1.0e27cp-2 +0x1.0aa8f8p-2 +0x1.f58124p-3 +0x1.492bc8p-3 +0x1.3c5a6ep-7 +-0x1.371b26p-3 +-0x1.157a3ep-2 +-0x1.846bc6p-2 +-0x1.e3c096p-2 +-0x1.d00316p+3 +-0x1.bf67e6p+1 +-0x1.1d24ep+4 +-0x1.18d31cp+5 +-0x1.7e84cap-4 +-0x1.d7e5a2p+4 +-0x1.d79408p+4 +-0x1.7a31ep-3 +-0x1.535f0ap+3 +-0x1.84b27p+1 +-0x1.463bbep+4 +-0x1.14e6d4p+4 +-0x1.9190bcp+1 +-0x1.936394p+4 +-0x1.2fc542p+3 +-0x1.9766e8p-3 +-0x1.09e718p+5 +-0x1.31af26p+4 +-0x1.278ee4p+4 +-0x1.305eaap+4 +-0x1.a12466p+1 +-0x1.60b61ep+3 +-0x1.f864a4p+2 +-0x1.8f11f2p+3 +-0x1.11cafcp+4 +-0x1.4b08b8p+3 +-0x1.6853eep+1 +0x1.48a9c6p+3 +-0x1.32cf26p+2 +-0x1.1eac4ap+4 +-0x1.2995d8p+4 +-0x1.72edb2p+1 +-0x1.f30276p+4 +-0x1.7226bp+1 +-0x1.5040b8p+0 +0x1.684c78p+3 +-0x1.71f87ep+1 +0x1.48af34p+3 +0x1.0bb446p-2 +-0x1.380ec6p+5 +0x1.3e8eecp+2 +0x1.0f698p-2 +0x1.9ac11ap+3 +-0x1.4b5c9ap+0 +-0x1.b73246p+5 +-0x1.cf62d4p+4 +-0x1.887e8ap+5 +-0x1.2793fap+4 +-0x1.32c5e4p+2 +-0x1.91baf4p+1 +-0x1.14ecbap+4 +-0x1.936afcp+4 +-0x1.7c8f06p-3 +-0x1.d79b0ap+4 +-0x1.31b42p+4 +-0x1.bf983cp+1 +-0x1.1d2f08p+4 +-0x1.d00dbp+3 +-0x1.87ca12p-4 +-0x1.18d828p+5 +-0x1.d7ef46p+4 +-0x1.99e264p-3 +-0x1.2fcf26p+3 +-0x1.09e928p+5 +-0x1.a14f02p+1 +-0x1.30659p+4 +-0x1.60c1aep+3 +-0x1.72c766p+1 +-0x1.f2fe62p+4 +-0x1.29914ep+4 +-0x1.84dd0ep+1 +-0x1.536f7p+3 +-0x1.463dep+4 +-0x1.8f2162p+3 +-0x1.1eb6f8p+4 +-0x1.f87d0ap+2 +-0x1.4b03d6p+3 +-0x1.67aadep+1 +-0x1.11c9a8p+4 +0x1.1ab1d2p-2 +0x1.14df18p-2 +0x1.0fc3dap-2 +0x1.f77412p-3 +0x1.4a22d8p-3 +0x1.1f482ap-7 +-0x1.3a4588p-3 +-0x1.16d88p-2 +-0x1.859d66p-2 +-0x1.e3fb96p-2 +0x0p+0 +0x1.1f482ap-7 +0x0p+0 +0x1.3c5a6ep-7 +0x0p+0 +0x1.1643c2p+2 +0x0p+0 +0x1.1658f6p+2 +0x0p+0 +0x1.4a22d8p-3 +0x0p+0 +0x1.492bc8p-3 +0x0p+0 +0x1.884d8ap+2 +0x0p+0 +0x1.8866dcp+2 +0x0p+0 +0x1.0bb446p-2 +0x0p+0 +0x1.0aa8f8p-2 +0x0p+0 +0x1.a62cd8p+0 +0x0p+0 +0x1.a53398p+0 +0x0p+0 +0x1.3f489p+2 +0x0p+0 +0x1.3f380ap+2 +0x0p+0 +0x1.3a267cp+1 +0x0p+0 +0x1.3a3e5cp+1 +0x0p+0 +0x1.34258p+0 +0x0p+0 +0x1.33d2cp+0 +0x0p+0 +0x1.80f3ap-2 +0x0p+0 +0x1.82392p-2 +0x0p+0 +0x1.8c008ep+2 +0x0p+0 +0x1.8c25a2p+2 +0x0p+0 +0x1.eb85d8p+0 +0x0p+0 +0x1.ec2018p+0 +0x0p+0 +0x1.4bfa08p+1 +0x0p+0 +0x1.4c4ac8p+1 +0x0p+0 +0x1.863b3ep+2 +0x0p+0 +0x1.864e28p+2 +0x0p+0 +0x1.81ae58p+2 +0x0p+0 +0x1.81c24p+2 +0x0p+0 +0x1.0fc3dap-2 +0x0p+0 +0x1.0e9f62p-2 +0x0p+0 +0x1.068c08p+0 +0x0p+0 +0x1.072e88p+0 +0x0p+0 +0x1.f0c998p+0 +0x0p+0 +0x1.f139b8p+0 +0x0p+0 +0x1.64a73p+1 +0x0p+0 +0x1.64d786p+1 +0x0p+0 +0x1.79c5ep+2 +0x0p+0 +0x1.79d8fap+2 +0x0p+0 +0x1.80b22ep+2 +0x0p+0 +0x1.80c812p+2 +0x0p+0 +0x1.14df18p-2 +0x0p+0 +0x1.13c782p-2 +0x0p+0 +0x1.79c5ep+2 +0x0p+0 +0x1.79d8fap+2 +-0x1.5089cp+0 +-0x1.7226bp+1 +-0x1.5089cp+0 +0x1.f58124p-3 +-0x1.5089cp+0 +0x1.0aa8f8p-2 +-0x1.5089cp+0 +0x1.0e9f62p-2 +-0x1.5089cp+0 +0x1.6846c8p+3 +0x1.0e27cp-2 +0x1.0e9f62p-2 +0x1.3e786ap+2 +0x1.0e9f62p-2 +0x1.0aa8f8p-2 +0x1.0e9f62p-2 +-0x1.cf5fd8p+4 +0x1.13c782p-2 +-0x1.88812p+5 +0x1.13c782p-2 +0x1.9ab92p+3 +0x1.13c782p-2 +0x1.0e27cp-2 +0x1.13c782p-2 +-0x1.b73a1p+5 +0x1.19a1fp-2 +-0x1.4b9eb2p+0 +0x1.19a1fp-2 +-0x1.b73a1p+5 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +0x1.9ab92p+3 +0x1.0e27cp-2 +0x1.9ab92p+3 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +-0x1.38102p+5 +0x1.3e786ap+2 +0x1.3e786ap+2 +0x1.0e27cp-2 +0x1.0aa8f8p-2 +0x1.3e786ap+2 +0x1.0aa8f8p-2 +-0x1.38102p+5 +-0x1.f30276p+4 +0x1.f58124p-3 +-0x1.2995d8p+4 +0x1.f58124p-3 +-0x1.f30276p+4 +0x1.492bc8p-3 +-0x1.1eac4ap+4 +0x1.492bc8p-3 +-0x1.11cafcp+4 +0x1.492bc8p-3 +-0x1.f864a4p+2 +0x1.3c5a6ep-7 +-0x1.60b61ep+3 +0x1.3c5a6ep-7 +-0x1.1eac4ap+4 +0x1.3c5a6ep-7 +-0x1.60b61ep+3 +-0x1.371b26p-3 +-0x1.305eaap+4 +-0x1.371b26p-3 +-0x1.278ee4p+4 +-0x1.157a3ep-2 +-0x1.31af26p+4 +-0x1.157a3ep-2 +-0x1.d79408p+4 +-0x1.157a3ep-2 +-0x1.1d24ep+4 +-0x1.846bc6p-2 +-0x1.d00316p+3 +-0x1.846bc6p-2 +-0x1.278ee4p+4 +-0x1.846bc6p-2 +-0x1.1d24ep+4 +-0x1.e3c096p-2 +-0x1.1d24ep+4 +-0x1.d7e5a2p+4 +-0x1.1d24ep+4 +-0x1.18d31cp+5 +-0x1.d79408p+4 +-0x1.2fc542p+3 +-0x1.d79408p+4 +-0x1.535f0ap+3 +-0x1.305eaap+4 +-0x1.535f0ap+3 +-0x1.305eaap+4 +-0x1.463bbep+4 +-0x1.14e6d4p+4 +-0x1.463bbep+4 +-0x1.14e6d4p+4 +-0x1.f864a4p+2 +-0x1.14e6d4p+4 +-0x1.60b61ep+3 +-0x1.936394p+4 +-0x1.f864a4p+2 +-0x1.31af26p+4 +-0x1.2fc542p+3 +-0x1.278ee4p+4 +-0x1.09e718p+5 +-0x1.31af26p+4 +-0x1.09e718p+5 +-0x1.60b61ep+3 +-0x1.f864a4p+2 +0x1.48a9c6p+3 +-0x1.11cafcp+4 +-0x1.1eac4ap+4 +-0x1.6853eep+1 +-0x1.32cf26p+2 +0x1.48a9c6p+3 +0x1.48a9c6p+3 +-0x1.f30276p+4 +-0x1.32cf26p+2 +-0x1.f30276p+4 +-0x1.7226bp+1 +-0x1.2995d8p+4 +0x1.0e9f62p-2 +0x1.13c782p-2 +0x1.f58124p-3 +0x1.0e9f62p-2 +0x1.13c782p-2 +0x1.19a1fp-2 +0x1.19a1fp-2 +0x0p+0 +0x1.492bc8p-3 +0x1.f58124p-3 +0x1.3c5a6ep-7 +0x1.492bc8p-3 +-0x1.371b26p-3 +0x1.3c5a6ep-7 +-0x1.157a3ep-2 +-0x1.371b26p-3 +-0x1.846bc6p-2 +-0x1.157a3ep-2 +-0x1.e3c096p-2 +-0x1.846bc6p-2 +0x0p+0 +-0x1.e3c096p-2 +-0x1.d00316p+3 +-0x1.bf67e6p+1 +-0x1.1d24ep+4 +-0x1.bf67e6p+1 +-0x1.18d31cp+5 +-0x1.7e84cap-4 +-0x1.d7e5a2p+4 +-0x1.7e84cap-4 +-0x1.d79408p+4 +-0x1.7a31ep-3 +-0x1.31af26p+4 +-0x1.7a31ep-3 +-0x1.535f0ap+3 +-0x1.84b27p+1 +-0x1.463bbep+4 +-0x1.84b27p+1 +-0x1.14e6d4p+4 +-0x1.9190bcp+1 +-0x1.936394p+4 +-0x1.9190bcp+1 +-0x1.2fc542p+3 +-0x1.9766e8p-3 +-0x1.09e718p+5 +-0x1.9766e8p-3 +-0x1.305eaap+4 +-0x1.a12466p+1 +-0x1.60b61ep+3 +-0x1.a12466p+1 +-0x1.f864a4p+2 +-0x1.8f11f2p+3 +-0x1.1eac4ap+4 +-0x1.8f11f2p+3 +-0x1.11cafcp+4 +-0x1.4b08b8p+3 +-0x1.6853eep+1 +-0x1.4b08b8p+3 +-0x1.2995d8p+4 +-0x1.72edb2p+1 +-0x1.f30276p+4 +-0x1.72edb2p+1 +-0x1.50d57p+0 +-0x1.7248fep+1 +-0x1.50da2p+0 +-0x1.724b5ep+1 +-0x1.50ddp+0 +0x1.f364fap-3 +-0x1.50ddp+0 +0x1.096c6ep-2 +-0x1.50ddp+0 +0x1.096c6ep-2 +-0x1.50d33p+0 +0x1.0d1524p-2 +-0x1.50d33p+0 +0x1.0d1524p-2 +-0x1.50d33p+0 +0x1.683d52p+3 +-0x1.50d2bp+0 +0x1.683d28p+3 +0x1.0c9fbap-2 +0x1.0d1524p-2 +0x1.0c9fbap-2 +0x1.0d1524p-2 +0x1.3e64e6p+2 +0x1.0d0fbcp-2 +0x1.3e64e6p+2 +0x1.0d0fbcp-2 +0x1.0944fcp-2 +0x1.0d0fbcp-2 +0x1.0944fcp-2 +0x1.0d0fbcp-2 +-0x1.cf5c2p+4 +0x1.1285acp-2 +-0x1.8883dp+5 +0x1.12366p-2 +0x1.9aac5cp+3 +0x1.12215ap-2 +0x1.9aaaeep+3 +0x1.122feep-2 +0x1.0ca88p-2 +0x1.1237aap-2 +0x1.0caeb6p-2 +0x1.1239bp-2 +-0x1.b74266p+5 +0x1.18be9p-2 +-0x1.4bd78ap+0 +0x1.18f1fap-2 +-0x1.4bdd2p+0 +0x1.18f1c6p-2 +-0x1.b74266p+5 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +0x1.9aadcp+3 +0x1.0caeb6p-2 +0x1.9aadcp+3 +0x1.0caeb6p-2 +0x1.9aadcp+3 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +-0x1.38129ap+5 +0x1.3e64e6p+2 +-0x1.38129ap+5 +0x1.3e64e6p+2 +0x1.3e64e6p+2 +0x1.0cbd82p-2 +0x1.3e64e6p+2 +0x1.0cbd82p-2 +0x1.0944fcp-2 +0x1.3e64e6p+2 +0x1.0944fcp-2 +0x1.3e64e6p+2 +0x1.0944fcp-2 +-0x1.38129ap+5 +0x1.094666p-2 +-0x1.3812a4p+5 +-0x1.f30506p+4 +0x1.f364fap-3 +-0x1.f30446p+4 +0x1.f7dc2ep-3 +-0x1.299a22p+4 +0x1.f95c4cp-3 +-0x1.299afcp+4 +0x1.fbc628p-3 +-0x1.f30442p+4 +0x1.47697p-3 +-0x1.f305a2p+4 +0x1.3f59p-3 +-0x1.1ea55p+4 +0x1.3f59p-3 +-0x1.11ce66p+4 +0x1.4886ap-3 +-0x1.11d01ap+4 +0x1.50007ep-3 +-0x1.f84e8p+2 +0x1.7c97bap-7 +-0x1.f851dcp+2 +0x1.ae8274p-7 +-0x1.60ab0cp+3 +0x1.2c22dcp-7 +-0x1.60a538p+3 +0x1.eaf1e2p-7 +-0x1.1ea698p+4 +0x1.087bc4p-6 +-0x1.60a58ap+3 +-0x1.341a7ep-3 +-0x1.60a85ap+3 +-0x1.3ff2c4p-3 +-0x1.3058dap+4 +-0x1.43c9f8p-3 +-0x1.305bacp+4 +-0x1.3e786cp-3 +-0x1.278a44p+4 +-0x1.1486d8p-2 +-0x1.31aa98p+4 +-0x1.13486ap-2 +-0x1.31abbep+4 +-0x1.0ff712p-2 +-0x1.d78cd8p+4 +-0x1.100e42p-2 +-0x1.1d1e4ep+4 +-0x1.82bd4ap-2 +-0x1.1d185ap+4 +-0x1.732822p-2 +-0x1.cff5f4p+3 +-0x1.732822p-2 +-0x1.cff7d8p+3 +-0x1.72c508p-2 +-0x1.278a44p+4 +-0x1.73b7e8p-2 +-0x1.1d185ap+4 +-0x1.e43214p-2 +-0x1.1d1888p+4 +-0x1.e5827p-2 +-0x1.1d1888p+4 +-0x1.d7dd1ap+4 +-0x1.1d1b3cp+4 +-0x1.18cfd4p+5 +-0x1.1d1e4ep+4 +-0x1.18ceb4p+5 +-0x1.d78db4p+4 +-0x1.2fbdc6p+3 +-0x1.d78e9ep+4 +-0x1.53505p+3 +-0x1.30591ep+4 +-0x1.5353c2p+3 +-0x1.305882p+4 +-0x1.4635f6p+4 +-0x1.14e13ap+4 +-0x1.4636cap+4 +-0x1.14e13ap+4 +-0x1.f8421ep+2 +-0x1.14e18ep+4 +-0x1.f84356p+2 +-0x1.14e1d2p+4 +-0x1.60a8cep+3 +-0x1.14e2dp+4 +-0x1.60a6d4p+3 +-0x1.935dc2p+4 +-0x1.f8448ep+2 +-0x1.31aaap+4 +-0x1.2fbc56p+3 +-0x1.278a44p+4 +-0x1.09e4dp+5 +-0x1.31ab0ap+4 +-0x1.09e4f6p+5 +-0x1.31aa7p+4 +-0x1.09e4ep+5 +-0x1.60aa34p+3 +-0x1.f84fp+2 +-0x1.60a958p+3 +-0x1.f8508ep+2 +0x1.48a622p+3 +-0x1.11ce04p+4 +-0x1.1ea4bcp+4 +-0x1.690098p+1 +-0x1.32de98p+2 +0x1.48a8a4p+3 +0x1.48a5a4p+3 +-0x1.f305a2p+4 +-0x1.32de98p+2 +-0x1.f305ap+4 +-0x1.724cecp+1 +-0x1.299a6ap+4 +-0x1.724d64p+1 +-0x1.299a6ap+4 +0x1.1239bp-2 +0x1.0d0fbcp-2 +0x1.0d6868p-2 +0x1.fa0e58p-3 +0x1.18ef46p-2 +0x1.116408p-2 +0x0p+0 +0x1.1882dp-2 +0x1.00c136p-2 +0x1.4ceb82p-3 +0x1.68d70ap-3 +0x1.399a26p-7 +0x1.0bcd78p-5 +-0x1.48b364p-3 +-0x1.1a03aap-3 +-0x1.1b3b08p-2 +-0x1.0751fep-2 +-0x1.745e52p-2 +-0x1.68124p-2 +-0x1.e5827p-2 +-0x1.e354f4p-2 +0x0p+0 +-0x1.bf3404p+1 +-0x1.cff716p+3 +-0x1.bf2e1ap+1 +-0x1.1d1d58p+4 +-0x1.771174p-4 +-0x1.18cf5ap+5 +-0x1.75a61ep-4 +-0x1.d7dca2p+4 +-0x1.783582p-3 +-0x1.d78ceap+4 +-0x1.77ccacp-3 +-0x1.31aa7p+4 +-0x1.847f2p+1 +-0x1.53503ep+3 +-0x1.8485eep+1 +-0x1.4636cap+4 +-0x1.9164dp+1 +-0x1.14e12p+4 +-0x1.916e54p+1 +-0x1.935d88p+4 +-0x1.952826p-3 +-0x1.2fbd0ep+3 +-0x1.94d234p-3 +-0x1.09e4ep+5 +-0x1.a0f626p+1 +-0x1.30584ap+4 +-0x1.a0feb4p+1 +-0x1.60aabap+3 +-0x1.8f014cp+3 +-0x1.f84d84p+2 +-0x1.8f030ep+3 +-0x1.1ea452p+4 +-0x1.4b0d1cp+3 +-0x1.11cep+4 +-0x1.4b0bdap+3 +-0x1.68ff82p+1 +-0x1.730e6ep+1 +-0x1.299a6ep+4 +-0x1.7308c6p+1 +-0x1.f305b2p+4 +-0x1.50d2bp+0 +-0x1.724738p+1 +-0x1.50d786p+0 +-0x1.7249acp+1 +-0x1.50da84p+0 +0x1.f3d7a8p-3 +-0x1.50da84p+0 +0x1.094666p-2 +-0x1.50da84p+0 +0x1.094666p-2 +-0x1.50d1e4p+0 +0x1.0d619p-2 +-0x1.50d1e4p+0 +0x1.0d619p-2 +-0x1.50d1e4p+0 +0x1.683d28p+3 +-0x1.50d182p+0 +0x1.683d08p+3 +0x1.0cbd82p-2 +0x1.0d619p-2 +0x1.0cace8p-2 +0x1.0d5fp-2 +0x1.3e64e6p+2 +0x1.0d5268p-2 +0x1.3e64e6p+2 +0x1.0d5268p-2 +0x1.0923bep-2 +0x1.0d50f8p-2 +0x1.0923bep-2 +0x1.0d50f8p-2 +-0x1.cf5c2p+4 +0x1.12b0cap-2 +-0x1.8883dp+5 +0x1.1258b6p-2 +0x1.9aad48p+3 +0x1.12435cp-2 +0x1.9aabeep+3 +0x1.12512ap-2 +0x1.0cc154p-2 +0x1.1258bp-2 +0x1.0cc516p-2 +0x1.1259eap-2 +-0x1.b74266p+5 +0x1.18b6ccp-2 +-0x1.4bda8cp+0 +0x1.18ea1ap-2 +-0x1.4be014p+0 +0x1.18e9e8p-2 +-0x1.b74266p+5 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +0x1.9aaeaep+3 +0x1.0cc516p-2 +0x1.9aaeaep+3 +0x1.0cc516p-2 +0x1.9aaeaep+3 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +-0x1.3812a4p+5 +0x1.3e657ep+2 +-0x1.3812a4p+5 +0x1.3e657ep+2 +0x1.3e657ep+2 +0x1.0cd328p-2 +0x1.3e657ep+2 +0x1.0cd328p-2 +0x1.0923bep-2 +0x1.3e657ep+2 +0x1.0923bep-2 +0x1.3e657ep+2 +0x1.0923bep-2 +-0x1.3812a4p+5 +0x1.09251ap-2 +-0x1.3812aep+5 +-0x1.f305b2p+4 +0x1.f3d7a8p-3 +-0x1.f304f4p+4 +0x1.f83a62p-3 +-0x1.299a6ep+4 +0x1.f9a36p-3 +-0x1.299b44p+4 +0x1.fc0316p-3 +-0x1.f304fp+4 +0x1.47a37p-3 +-0x1.f3065p+4 +0x1.3f9028p-3 +-0x1.1ea452p+4 +0x1.3f9028p-3 +-0x1.11cep+4 +0x1.48db88p-3 +-0x1.11cfb4p+4 +0x1.5051cep-3 +-0x1.f84d84p+2 +0x1.649d8cp-7 +-0x1.f850e4p+2 +0x1.96c88ep-7 +-0x1.60aabap+3 +0x1.163a9ap-7 +-0x1.60a4e2p+3 +0x1.d535d6p-7 +-0x1.1ea5ap+4 +0x1.fd33d2p-7 +-0x1.60a538p+3 +-0x1.33c07ap-3 +-0x1.60a808p+3 +-0x1.3f9b22p-3 +-0x1.30584ap+4 +-0x1.437584p-3 +-0x1.305b18p+4 +-0x1.3e2b8ep-3 +-0x1.278a44p+4 +-0x1.14410ap-2 +-0x1.31aa7p+4 +-0x1.130814p-2 +-0x1.31ab96p+4 +-0x1.0fbb42p-2 +-0x1.d78ceap+4 +-0x1.0fd302p-2 +-0x1.1d1d58p+4 +-0x1.82f814p-2 +-0x1.1d1762p+4 +-0x1.736264p-2 +-0x1.cff716p+3 +-0x1.736264p-2 +-0x1.cff8fap+3 +-0x1.72ff24p-2 +-0x1.278a44p+4 +-0x1.73f018p-2 +-0x1.1d1762p+4 +-0x1.e3dc36p-2 +-0x1.1d1794p+4 +-0x1.e54128p-2 +-0x1.1d1794p+4 +-0x1.d7dca2p+4 +-0x1.1d1a48p+4 +-0x1.18cf5ap+5 +-0x1.1d1d5cp+4 +-0x1.18ce3ap+5 +-0x1.d78dc8p+4 +-0x1.2fbd0ep+3 +-0x1.d78ebp+4 +-0x1.53503ep+3 +-0x1.30588cp+4 +-0x1.5353aep+3 +-0x1.3057fp+4 +-0x1.4636cap+4 +-0x1.14e12p+4 +-0x1.4637ap+4 +-0x1.14e12p+4 +-0x1.f8415ep+2 +-0x1.14e174p+4 +-0x1.f84296p+2 +-0x1.14e1b8p+4 +-0x1.60a87cp+3 +-0x1.14e2b4p+4 +-0x1.60a686p+3 +-0x1.935d88p+4 +-0x1.f843cep+2 +-0x1.31aa76p+4 +-0x1.2fbba2p+3 +-0x1.278a44p+4 +-0x1.09e4ep+5 +-0x1.31aae2p+4 +-0x1.09e506p+5 +-0x1.31aa48p+4 +-0x1.09e4fp+5 +-0x1.60a9e6p+3 +-0x1.f84e24p+2 +-0x1.60a8fep+3 +-0x1.f84fc8p+2 +0x1.48a584p+3 +-0x1.11cd9ep+4 +-0x1.1ea3cep+4 +-0x1.68ff82p+1 +-0x1.32de98p+2 +0x1.48a7e4p+3 +0x1.48a4b8p+3 +-0x1.f3065p+4 +-0x1.32de98p+2 +-0x1.f3064ep+4 +-0x1.724b4ap+1 +-0x1.299ab2p+4 +-0x1.724c6cp+1 +-0x1.299ab2p+4 +0x1.1259eap-2 +0x1.0d50f8p-2 +0x1.0d87e4p-2 +0x1.fa4936p-3 +0x1.18e74ap-2 +0x1.1169ecp-2 +0x0p+0 +0x1.186ed6p-2 +0x1.00c93p-2 +0x1.4d3a9ap-3 +0x1.68e1aap-3 +0x1.2ace08p-7 +0x1.0a59ecp-5 +-0x1.485edp-3 +-0x1.19e1c4p-3 +-0x1.1b0678p-2 +-0x1.07458ap-2 +-0x1.749188p-2 +-0x1.6838fep-2 +-0x1.e54128p-2 +-0x1.e342d4p-2 +0x0p+0 +-0x1.bf364p+1 +-0x1.cff83ap+3 +-0x1.bf305ep+1 +-0x1.1d1c64p+4 +-0x1.768afp-4 +-0x1.18ceep+5 +-0x1.752038p-4 +-0x1.d7dc2ap+4 +-0x1.781e02p-3 +-0x1.d78cfep+4 +-0x1.77b9ecp-3 +-0x1.31aa48p+4 +-0x1.848174p+1 +-0x1.53502ap+3 +-0x1.84885cp+1 +-0x1.4637ap+4 +-0x1.9164ccp+1 +-0x1.14e104p+4 +-0x1.916e42p+1 +-0x1.935d4ep+4 +-0x1.9514d8p-3 +-0x1.2fbc5ep+3 +-0x1.94bf78p-3 +-0x1.09e4fp+5 +-0x1.a0f5ccp+1 +-0x1.3057b8p+4 +-0x1.a0fec8p+1 +-0x1.60aa68p+3 +-0x1.8f013p+3 +-0x1.f84caep+2 +-0x1.8f02fp+3 +-0x1.1ea362p+4 +-0x1.4b0c9ap+3 +-0x1.11cd9ap+4 +-0x1.4b0b64p+3 +-0x1.68fe64p+1 +-0x1.730fa4p+1 +-0x1.299ab6p+4 +-0x1.730a0ep+1 +-0x1.f3065ep+4 +-0x1.50d182p+0 +-0x1.72467cp+1 +-0x1.50d636p+0 +-0x1.7248ep+1 +-0x1.50d91ap+0 +0x1.f3a938p-3 +-0x1.50d91ap+0 +0x1.09251ap-2 +-0x1.50d91ap+0 +0x1.09251ap-2 +-0x1.50d17p+0 +0x1.0d695ep-2 +-0x1.50d17p+0 +0x1.0d695ep-2 +-0x1.50d17p+0 +0x1.683d08p+3 +-0x1.50d12p+0 +0x1.683ceep+3 +0x1.0cd328p-2 +0x1.0d695ep-2 +0x1.0cbea2p-2 +0x1.0d6632p-2 +0x1.3e657ep+2 +0x1.0d5912p-2 +0x1.3e657ep+2 +0x1.0d5912p-2 +0x1.090652p-2 +0x1.0d5714p-2 +0x1.090652p-2 +0x1.0d5714p-2 +-0x1.cf5c2p+4 +0x1.12a7d2p-2 +-0x1.8883dp+5 +0x1.124d4cp-2 +0x1.9aae3cp+3 +0x1.1237ccp-2 +0x1.9aacacp+3 +0x1.1247c8p-2 +0x1.0cd3ecp-2 +0x1.124f66p-2 +0x1.0cdd92p-2 +0x1.12528ap-2 +-0x1.b74266p+5 +0x1.18a6f4p-2 +-0x1.4bdd62p+0 +0x1.18db62p-2 +-0x1.4be32p+0 +0x1.18db2ep-2 +-0x1.b74266p+5 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +0x1.9aaf74p+3 +0x1.0cdd92p-2 +0x1.9aaf74p+3 +0x1.0cdd92p-2 +0x1.9aaf74p+3 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +-0x1.3812aep+5 +0x1.3e6652p+2 +-0x1.3812aep+5 +0x1.3e6652p+2 +0x1.3e6652p+2 +0x1.0cea9p-2 +0x1.3e6652p+2 +0x1.0cea9p-2 +0x1.090652p-2 +0x1.3e6652p+2 +0x1.090652p-2 +0x1.3e6652p+2 +0x1.090652p-2 +-0x1.3812aep+5 +0x1.09079ap-2 +-0x1.3812b8p+5 +-0x1.f3065ep+4 +0x1.f3a938p-3 +-0x1.f305ap+4 +0x1.f80faap-3 +-0x1.299ab6p+4 +0x1.f97968p-3 +-0x1.299b8cp+4 +0x1.fbd6c6p-3 +-0x1.f3059cp+4 +0x1.481092p-3 +-0x1.f306fcp+4 +0x1.3ffec8p-3 +-0x1.1ea362p+4 +0x1.3ffec8p-3 +-0x1.11cd9ap+4 +0x1.495206p-3 +-0x1.11cf4ap+4 +0x1.50b904p-3 +-0x1.f84caep+2 +0x1.5fc7a8p-7 +-0x1.f85008p+2 +0x1.91a61ep-7 +-0x1.60aa68p+3 +0x1.11bb9cp-7 +-0x1.60a492p+3 +0x1.d03d82p-7 +-0x1.1ea4b2p+4 +0x1.f86496p-7 +-0x1.60a4e8p+3 +-0x1.33ed88p-3 +-0x1.60a7b4p+3 +-0x1.3fbc58p-3 +-0x1.3057b8p+4 +-0x1.438ccap-3 +-0x1.305a86p+4 +-0x1.3e441ep-3 +-0x1.278a44p+4 +-0x1.143016p-2 +-0x1.31aa48p+4 +-0x1.12f828p-2 +-0x1.31ab6cp+4 +-0x1.0faccep-2 +-0x1.d78cfep+4 +-0x1.0fc4bcp-2 +-0x1.1d1c64p+4 +-0x1.8320d2p-2 +-0x1.1d166cp+4 +-0x1.738b14p-2 +-0x1.cff83ap+3 +-0x1.738b14p-2 +-0x1.cffa2p+3 +-0x1.732758p-2 +-0x1.278a44p+4 +-0x1.74190cp-2 +-0x1.1d166cp+4 +-0x1.e3ad68p-2 +-0x1.1d16ap+4 +-0x1.e51c4ep-2 +-0x1.1d16ap+4 +-0x1.d7dc2ap+4 +-0x1.1d1954p+4 +-0x1.18ceep+5 +-0x1.1d1c68p+4 +-0x1.18cdcp+5 +-0x1.d78ddcp+4 +-0x1.2fbc5ep+3 +-0x1.d78ecp+4 +-0x1.53502ap+3 +-0x1.3057fcp+4 +-0x1.535396p+3 +-0x1.305762p+4 +-0x1.4637ap+4 +-0x1.14e104p+4 +-0x1.463876p+4 +-0x1.14e104p+4 +-0x1.f84098p+2 +-0x1.14e158p+4 +-0x1.f841cep+2 +-0x1.14e19ap+4 +-0x1.60a826p+3 +-0x1.14e294p+4 +-0x1.60a632p+3 +-0x1.935d4ep+4 +-0x1.f84304p+2 +-0x1.31aa4cp+4 +-0x1.2fbaf6p+3 +-0x1.278a44p+4 +-0x1.09e4fp+5 +-0x1.31aabap+4 +-0x1.09e516p+5 +-0x1.31aa2p+4 +-0x1.09e5p+5 +-0x1.60a992p+3 +-0x1.f84d42p+2 +-0x1.60a8a6p+3 +-0x1.f84eeep+2 +0x1.48a494p+3 +-0x1.11cd36p+4 +-0x1.1ea2e6p+4 +-0x1.68fe64p+1 +-0x1.32de98p+2 +0x1.48a6dcp+3 +0x1.48a398p+3 +-0x1.f306fcp+4 +-0x1.32de98p+2 +-0x1.f306fap+4 +-0x1.724a7p+1 +-0x1.299afap+4 +-0x1.724c1ap+1 +-0x1.299af8p+4 +0x1.12528ap-2 +0x1.0d5714p-2 +0x1.0d969p-2 +0x1.fa1f5p-3 +0x1.18d886p-2 +0x1.116dd2p-2 +0x0p+0 +0x1.185d82p-2 +0x1.00be18p-2 +0x1.4da3dcp-3 +0x1.6918a8p-3 +0x1.282614p-7 +0x1.099cf4p-5 +-0x1.486c96p-3 +-0x1.19ed6p-3 +-0x1.1af7ccp-2 +-0x1.073eaap-2 +-0x1.74b80cp-2 +-0x1.685a9ap-2 +-0x1.e51c4ep-2 +-0x1.e32ee6p-2 +0x0p+0 +-0x1.bf38ap+1 +-0x1.cff96p+3 +-0x1.bf32aep+1 +-0x1.1d1b7p+4 +-0x1.760292p-4 +-0x1.18ce68p+5 +-0x1.749802p-4 +-0x1.d7dbb2p+4 +-0x1.7808f8p-3 +-0x1.d78d1p+4 +-0x1.77a51cp-3 +-0x1.31aa2p+4 +-0x1.84839p+1 +-0x1.535014p+3 +-0x1.848a94p+1 +-0x1.463876p+4 +-0x1.9164c2p+1 +-0x1.14e0e4p+4 +-0x1.916e3p+1 +-0x1.935d14p+4 +-0x1.95021cp-3 +-0x1.2fbbb4p+3 +-0x1.94ad06p-3 +-0x1.09e5p+5 +-0x1.a0f5b2p+1 +-0x1.30572ap+4 +-0x1.a0feb4p+1 +-0x1.60aa1p+3 +-0x1.8f0102p+3 +-0x1.f84bd2p+2 +-0x1.8f02c6p+3 +-0x1.1ea278p+4 +-0x1.4b0c22p+3 +-0x1.11cd32p+4 +-0x1.4b0aecp+3 +-0x1.68fd44p+1 +-0x1.731136p+1 +-0x1.299afcp+4 +-0x1.730b88p+1 +-0x1.f3070ap+4 +-0x1.50d12p+0 +0x1.683ceep+3 +0x1.0d78b8p-2 +0x1.12a558p-2 +0x1.1896dp-2 +0x0p+0 +-0x1.4be064p+0 +-0x1.b74266p+5 +0x1.9aaf0cp+3 +-0x1.8883dp+5 +-0x1.cf5c2p+4 +0x1.3e6652p+2 +-0x1.3812b8p+5 +0x1.0cea9p-2 +0x1.09079ap-2 +0x1.f37c5ep-3 +0x1.4838dp-3 +0x1.5d1fdap-7 +-0x1.33f8ap-3 +-0x1.14243ap-2 +-0x1.833dep-2 +-0x1.e38b0cp-2 +-0x1.cff96p+3 +-0x1.bf3af4p+1 +-0x1.1d1b7p+4 +-0x1.18ce68p+5 +-0x1.757a72p-4 +-0x1.d7dbb2p+4 +-0x1.d78d1p+4 +-0x1.77f3c4p-3 +-0x1.535014p+3 +-0x1.8485bcp+1 +-0x1.463876p+4 +-0x1.14e0e4p+4 +-0x1.9164bep+1 +-0x1.935d14p+4 +-0x1.2fbbb4p+3 +-0x1.94ef38p-3 +-0x1.09e5p+5 +-0x1.31aa2p+4 +-0x1.278a44p+4 +-0x1.30572ap+4 +-0x1.a0f5a2p+1 +-0x1.60aa1p+3 +-0x1.f84bd2p+2 +-0x1.8f00dap+3 +-0x1.11cd32p+4 +-0x1.4b0baap+3 +-0x1.68fd44p+1 +0x1.48a372p+3 +-0x1.32de98p+2 +-0x1.1ea278p+4 +-0x1.299afcp+4 +-0x1.7312bcp+1 +-0x1.f3070ap+4 +-0x1.724654p+1 +-0x1.5089cp+0 +0x1.6846c8p+3 +-0x1.7226bp+1 +0x1.48a9c6p+3 +0x1.0aa8f8p-2 +-0x1.38102p+5 +0x1.3e786ap+2 +0x1.0e27cp-2 +0x1.9ab92p+3 +-0x1.4b9eb2p+0 +-0x1.b73a1p+5 +-0x1.cf5fd8p+4 +-0x1.88812p+5 +-0x1.278ee4p+4 +-0x1.32cf26p+2 +-0x1.9190bcp+1 +-0x1.14e6d4p+4 +-0x1.936394p+4 +-0x1.7a31ep-3 +-0x1.d79408p+4 +-0x1.31af26p+4 +-0x1.bf67e6p+1 +-0x1.1d24ep+4 +-0x1.d00316p+3 +-0x1.7e84cap-4 +-0x1.18d31cp+5 +-0x1.d7e5a2p+4 +-0x1.9766e8p-3 +-0x1.2fc542p+3 +-0x1.09e718p+5 +-0x1.a12466p+1 +-0x1.305eaap+4 +-0x1.60b61ep+3 +-0x1.72edb2p+1 +-0x1.f30276p+4 +-0x1.2995d8p+4 +-0x1.84b27p+1 +-0x1.535f0ap+3 +-0x1.463bbep+4 +-0x1.8f11f2p+3 +-0x1.1eac4ap+4 +-0x1.f864a4p+2 +-0x1.4b08b8p+3 +-0x1.6853eep+1 +-0x1.11cafcp+4 +0x1.19a1fp-2 +0x1.13c782p-2 +0x1.0e9f62p-2 +0x1.f58124p-3 +0x1.492bc8p-3 +0x1.3c5a6ep-7 +-0x1.371b26p-3 +-0x1.157a3ep-2 +-0x1.846bc6p-2 +-0x1.e3c096p-2 +0x0p+0 +0x1.3c5a6ep-7 +0x0p+0 +0x1.5d1fdap-7 +0x0p+0 +0x1.1658f6p+2 +0x0p+0 +0x1.166c62p+2 +0x0p+0 +0x1.492bc8p-3 +0x0p+0 +0x1.4838dp-3 +0x0p+0 +0x1.8866dcp+2 +0x0p+0 +0x1.887ffp+2 +0x0p+0 +0x1.0aa8f8p-2 +0x0p+0 +0x1.09079ap-2 +0x0p+0 +0x1.a53398p+0 +0x0p+0 +0x1.a428d8p+0 +0x0p+0 +0x1.3f380ap+2 +0x0p+0 +0x1.3f279cp+2 +0x0p+0 +0x1.3a3e5cp+1 +0x0p+0 +0x1.3a5c1cp+1 +0x0p+0 +0x1.33d2cp+0 +0x0p+0 +0x1.337ccp+0 +0x0p+0 +0x1.82392p-2 +0x0p+0 +0x1.83612p-2 +0x0p+0 +0x1.8c25a2p+2 +0x0p+0 +0x1.8c49ccp+2 +0x0p+0 +0x1.ec2018p+0 +0x0p+0 +0x1.ecbf18p+0 +0x0p+0 +0x1.4c4ac8p+1 +0x0p+0 +0x1.4c9608p+1 +0x0p+0 +0x1.864e28p+2 +0x0p+0 +0x1.866018p+2 +0x0p+0 +0x1.81c24p+2 +0x0p+0 +0x1.81d658p+2 +0x0p+0 +0x1.0e9f62p-2 +0x0p+0 +0x1.0d78b8p-2 +0x0p+0 +0x1.072e88p+0 +0x0p+0 +0x1.07c588p+0 +0x0p+0 +0x1.f139b8p+0 +0x0p+0 +0x1.f1a938p+0 +0x0p+0 +0x1.64d786p+1 +0x0p+0 +0x1.650478p+1 +0x0p+0 +0x1.79d8fap+2 +0x0p+0 +0x1.79ebd8p+2 +0x0p+0 +0x1.80c812p+2 +0x0p+0 +0x1.80dd72p+2 +0x0p+0 +0x1.13c782p-2 +0x0p+0 +0x1.12a558p-2 +0x0p+0 +0x1.79d8fap+2 +0x0p+0 +0x1.79ebd8p+2 +-0x1.50d12p+0 +-0x1.299afcp+4 +-0x1.50d12p+0 +-0x1.724654p+1 +-0x1.50d12p+0 +0x1.f37c5ep-3 +-0x1.50d12p+0 +0x1.09079ap-2 +-0x1.50d12p+0 +0x1.0d78b8p-2 +-0x1.50d12p+0 +0x1.683ceep+3 +0x1.683ceep+3 +0x1.09079ap-2 +0x1.0cea9p-2 +0x1.0d78b8p-2 +0x1.3e6652p+2 +0x1.0d78b8p-2 +0x1.09079ap-2 +0x1.0d78b8p-2 +-0x1.cf5c2p+4 +0x1.12a558p-2 +-0x1.8883dp+5 +0x1.12a558p-2 +0x1.9aaf0cp+3 +0x1.12a558p-2 +0x1.0cea9p-2 +0x1.12a558p-2 +-0x1.b74266p+5 +0x1.1896dp-2 +-0x1.4be064p+0 +0x1.1896dp-2 +-0x1.b74266p+5 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +0x1.9aaf0cp+3 +0x1.0cea9p-2 +0x1.9aaf0cp+3 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +-0x1.3812b8p+5 +0x1.3e6652p+2 +0x1.3e6652p+2 +0x1.0cea9p-2 +0x1.09079ap-2 +0x1.3e6652p+2 +0x1.09079ap-2 +-0x1.3812b8p+5 +-0x1.f3070ap+4 +0x1.f37c5ep-3 +-0x1.299afcp+4 +0x1.f37c5ep-3 +-0x1.f3070ap+4 +0x1.4838dp-3 +-0x1.1ea278p+4 +0x1.4838dp-3 +-0x1.11cd32p+4 +0x1.4838dp-3 +-0x1.f84bd2p+2 +0x1.5d1fdap-7 +-0x1.60aa1p+3 +0x1.5d1fdap-7 +-0x1.1ea278p+4 +0x1.5d1fdap-7 +-0x1.60aa1p+3 +-0x1.33f8ap-3 +-0x1.30572ap+4 +-0x1.33f8ap-3 +-0x1.278a44p+4 +-0x1.14243ap-2 +-0x1.31aa2p+4 +-0x1.14243ap-2 +-0x1.d78d1p+4 +-0x1.14243ap-2 +-0x1.1d1b7p+4 +-0x1.833dep-2 +-0x1.cff96p+3 +-0x1.833dep-2 +-0x1.278a44p+4 +-0x1.833dep-2 +-0x1.1d1b7p+4 +-0x1.e38b0cp-2 +-0x1.1d1b7p+4 +-0x1.d7dbb2p+4 +-0x1.1d1b7p+4 +-0x1.18ce68p+5 +-0x1.d78d1p+4 +-0x1.2fbbb4p+3 +-0x1.d78d1p+4 +-0x1.535014p+3 +-0x1.30572ap+4 +-0x1.535014p+3 +-0x1.30572ap+4 +-0x1.463876p+4 +-0x1.14e0e4p+4 +-0x1.463876p+4 +-0x1.14e0e4p+4 +-0x1.f84bd2p+2 +-0x1.14e0e4p+4 +-0x1.60aa1p+3 +-0x1.935d14p+4 +-0x1.f84bd2p+2 +-0x1.31aa2p+4 +-0x1.2fbbb4p+3 +-0x1.278a44p+4 +-0x1.09e5p+5 +-0x1.31aa2p+4 +-0x1.09e5p+5 +-0x1.60aa1p+3 +-0x1.f84bd2p+2 +0x1.48a372p+3 +-0x1.11cd32p+4 +-0x1.1ea278p+4 +-0x1.68fd44p+1 +-0x1.32de98p+2 +0x1.48a372p+3 +0x1.48a372p+3 +-0x1.f3070ap+4 +-0x1.32de98p+2 +-0x1.f3070ap+4 +-0x1.724654p+1 +-0x1.299afcp+4 +0x1.0d78b8p-2 +0x1.12a558p-2 +0x1.f37c5ep-3 +0x1.0d78b8p-2 +0x1.12a558p-2 +0x1.1896dp-2 +0x1.1896dp-2 +0x0p+0 +0x1.4838dp-3 +0x1.f37c5ep-3 +0x1.5d1fdap-7 +0x1.4838dp-3 +-0x1.33f8ap-3 +0x1.5d1fdap-7 +-0x1.14243ap-2 +-0x1.33f8ap-3 +-0x1.833dep-2 +-0x1.14243ap-2 +-0x1.e38b0cp-2 +-0x1.833dep-2 +0x0p+0 +-0x1.e38b0cp-2 +-0x1.cff96p+3 +-0x1.bf3af4p+1 +-0x1.1d1b7p+4 +-0x1.bf3af4p+1 +-0x1.18ce68p+5 +-0x1.757a72p-4 +-0x1.d7dbb2p+4 +-0x1.757a72p-4 +-0x1.d78d1p+4 +-0x1.77f3c4p-3 +-0x1.31aa2p+4 +-0x1.77f3c4p-3 +-0x1.535014p+3 +-0x1.8485bcp+1 +-0x1.463876p+4 +-0x1.8485bcp+1 +-0x1.14e0e4p+4 +-0x1.9164bep+1 +-0x1.935d14p+4 +-0x1.9164bep+1 +-0x1.2fbbb4p+3 +-0x1.94ef38p-3 +-0x1.09e5p+5 +-0x1.94ef38p-3 +-0x1.30572ap+4 +-0x1.a0f5a2p+1 +-0x1.60aa1p+3 +-0x1.a0f5a2p+1 +-0x1.f84bd2p+2 +-0x1.8f00dap+3 +-0x1.1ea278p+4 +-0x1.8f00dap+3 +-0x1.11cd32p+4 +-0x1.4b0baap+3 +-0x1.68fd44p+1 +-0x1.4b0baap+3 +-0x1.f3070ap+4 +-0x1.7312bcp+1 +-0x1.299afcp+4 +-0x1.7312bcp+1 +-0x1.5108bap+0 +-0x1.299eaap+4 +-0x1.5108bap+0 +-0x1.7263cap+1 +-0x1.5108bap+0 +-0x1.7263cap+1 +-0x1.5108bap+0 +0x1.f1af5p-3 +-0x1.5108bap+0 +0x1.07dd02p-2 +-0x1.5108bap+0 +0x1.07dd02p-2 +-0x1.510104p+0 +0x1.0c1414p-2 +-0x1.510104p+0 +0x1.0c1414p-2 +-0x1.510104p+0 +0x1.6835fap+3 +-0x1.5100dcp+0 +0x1.6835ecp+3 +0x1.6835ecp+3 +0x1.07be0ep-2 +0x1.0b8538p-2 +0x1.0c1414p-2 +0x1.0b8246p-2 +0x1.0c13ap-2 +0x1.3e53dp+2 +0x1.0c0c22p-2 +0x1.3e53dp+2 +0x1.0c0c22p-2 +0x1.07be0ep-2 +0x1.0c0c22p-2 +0x1.07be0ep-2 +0x1.0c0c22p-2 +-0x1.cf574ep+4 +0x1.112f1ap-2 +-0x1.8886f8p+5 +0x1.10f2bep-2 +0x1.9aa35ep+3 +0x1.10dcdcp-2 +0x1.9aa1d2p+3 +0x1.10ecaep-2 +0x1.0b8e7ep-2 +0x1.10f43ep-2 +0x1.0b962ep-2 +0x1.10f6bep-2 +-0x1.b74be6p+5 +0x1.17beep-2 +-0x1.4c166p+0 +0x1.17f47cp-2 +-0x1.4c1c4ep+0 +0x1.17f446p-2 +-0x1.b74be6p+5 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +0x1.9aa496p+3 +0x1.0b962ep-2 +0x1.9aa496p+3 +0x1.0b962ep-2 +0x1.9aa496p+3 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +-0x1.38150ep+5 +0x1.3e53dp+2 +-0x1.38150ep+5 +0x1.3e53dp+2 +0x1.3e53dp+2 +0x1.0bab92p-2 +0x1.3e53dp+2 +0x1.0bab92p-2 +0x1.07be0ep-2 +0x1.3e53dp+2 +0x1.07be0ep-2 +0x1.3e53dp+2 +0x1.07be0ep-2 +-0x1.38150ep+5 +0x1.07bf42p-2 +-0x1.381516p+5 +-0x1.f30a78p+4 +0x1.f1af5p-3 +-0x1.f309bap+4 +0x1.f618aep-3 +-0x1.299eaap+4 +0x1.f78204p-3 +-0x1.299f7ep+4 +0x1.f9de9p-3 +-0x1.f309b6p+4 +0x1.45e2acp-3 +-0x1.f30b0ep+4 +0x1.3e025p-3 +-0x1.1e9cc8p+4 +0x1.3e025p-3 +-0x1.11d1bep+4 +0x1.473468p-3 +-0x1.11d36ep+4 +0x1.4e9952p-3 +-0x1.f834e4p+2 +0x1.a0f532p-7 +-0x1.f83834p+2 +0x1.d2307p-7 +-0x1.609e98p+3 +0x1.511b8p-7 +-0x1.6098cap+3 +0x1.074874p-6 +-0x1.1e9e14p+4 +0x1.1a4f6ap-6 +-0x1.60991cp+3 +-0x1.30fc72p-3 +-0x1.609be4p+3 +-0x1.3cba42p-3 +-0x1.30515cp+4 +-0x1.408372p-3 +-0x1.30542ap+4 +-0x1.3b3bc2p-3 +-0x1.278556p+4 +-0x1.13292p-2 +-0x1.31a58cp+4 +-0x1.11f002p-2 +-0x1.31a6bp+4 +-0x1.0ea42cp-2 +-0x1.d786b4p+4 +-0x1.0ebbbp-2 +-0x1.1d151ep+4 +-0x1.81a31ap-2 +-0x1.1d0f26p+4 +-0x1.72108cp-2 +-0x1.cfecf6p+3 +-0x1.72108cp-2 +-0x1.cfeeep+3 +-0x1.71ac44p-2 +-0x1.278556p+4 +-0x1.72a19ap-2 +-0x1.1d0f26p+4 +-0x1.e3efep-2 +-0x1.1d0f58p+4 +-0x1.e558a2p-2 +-0x1.1d0f58p+4 +-0x1.d7d338p+4 +-0x1.1d120ep+4 +-0x1.18cb4p+5 +-0x1.1d1524p+4 +-0x1.18ca2p+5 +-0x1.d7879p+4 +-0x1.2fb41ap+3 +-0x1.d7887ap+4 +-0x1.53430ep+3 +-0x1.3051a2p+4 +-0x1.53467cp+3 +-0x1.305108p+4 +-0x1.46319cp+4 +-0x1.14db3p+4 +-0x1.463272p+4 +-0x1.14db3p+4 +-0x1.f828aap+2 +-0x1.14db84p+4 +-0x1.f829e6p+2 +-0x1.14dbc8p+4 +-0x1.609c56p+3 +-0x1.14dccp+4 +-0x1.609a68p+3 +-0x1.9357bp+4 +-0x1.f82b24p+2 +-0x1.31a594p+4 +-0x1.2fb2aap+3 +-0x1.278556p+4 +-0x1.09e2b6p+5 +-0x1.31a5fcp+4 +-0x1.09e2dcp+5 +-0x1.31a562p+4 +-0x1.09e2c6p+5 +-0x1.609dc8p+3 +-0x1.f83556p+2 +-0x1.609cdcp+3 +-0x1.f837p+2 +0x1.489e3ep+3 +-0x1.11d15cp+4 +-0x1.1e9c4ep+4 +-0x1.69a054p+1 +-0x1.32fdaep+2 +0x1.48a0fcp+3 +0x1.489e7p+3 +-0x1.f30b0ep+4 +-0x1.32fdaep+2 +-0x1.f30b0cp+4 +-0x1.7263cap+1 +-0x1.299eecp+4 +-0x1.72665ap+1 +-0x1.299eeap+4 +0x1.10f6bep-2 +0x1.0c0c22p-2 +0x1.0c5852p-2 +0x1.f82756p-3 +0x1.17f198p-2 +0x1.1025e4p-2 +0x0p+0 +0x1.177cb6p-2 +0x1.ff4aa6p-3 +0x1.4b84aap-3 +0x1.67362cp-3 +0x1.66e05ap-7 +0x1.13ac3cp-5 +-0x1.45604ep-3 +-0x1.16ed06p-3 +-0x1.19ee7ep-2 +-0x1.061854p-2 +-0x1.733e0ep-2 +-0x1.66ed46p-2 +-0x1.e558a2p-2 +-0x1.e315cap-2 +0x0p+0 +-0x1.bf0a3p+1 +-0x1.cfee1cp+3 +-0x1.bf042ep+1 +-0x1.1d142cp+4 +-0x1.6e2f54p-4 +-0x1.18cac8p+5 +-0x1.6cc43ap-4 +-0x1.d7d2bep+4 +-0x1.75f1cp-3 +-0x1.d786c8p+4 +-0x1.758b76p-3 +-0x1.31a562p+4 +-0x1.8451d8p+1 +-0x1.5342fcp+3 +-0x1.8458d4p+1 +-0x1.463272p+4 +-0x1.9137p+1 +-0x1.14db1p+4 +-0x1.91406p+1 +-0x1.935776p+4 +-0x1.92b0d2p-3 +-0x1.2fb36p+3 +-0x1.925caap-3 +-0x1.09e2c6p+5 +-0x1.a0c198p+1 +-0x1.3050dp+4 +-0x1.a0ca6ap+1 +-0x1.609e42p+3 +-0x1.8eeef6p+3 +-0x1.f833fp+2 +-0x1.8ef0b6p+3 +-0x1.1e9be2p+4 +-0x1.4b0df8p+3 +-0x1.11d158p+4 +-0x1.4b0cdcp+3 +-0x1.699f4p+1 +-0x1.733066p+1 +-0x1.f30b1cp+4 +-0x1.7334fcp+1 +-0x1.299eeep+4 +-0x1.5100dcp+0 +-0x1.299eeep+4 +-0x1.5100dcp+0 +-0x1.72611cp+1 +-0x1.5100dcp+0 +-0x1.72611cp+1 +-0x1.5100dcp+0 +0x1.f1e8b6p-3 +-0x1.5100dcp+0 +0x1.07bf42p-2 +-0x1.5100dcp+0 +0x1.07bf42p-2 +-0x1.50faaep+0 +0x1.0c38c4p-2 +-0x1.50faaep+0 +0x1.0c38c4p-2 +-0x1.50faaep+0 +0x1.6835ecp+3 +-0x1.50faa2p+0 +0x1.6835e8p+3 +0x1.6835e8p+3 +0x1.07a674p-2 +0x1.0bab92p-2 +0x1.0c38c4p-2 +0x1.0b9b8cp-2 +0x1.0c364cp-2 +0x1.3e53dp+2 +0x1.0c2af2p-2 +0x1.3e53dp+2 +0x1.0c2af2p-2 +0x1.07a674p-2 +0x1.0c2a94p-2 +0x1.07a674p-2 +0x1.0c2a94p-2 +-0x1.cf574ep+4 +0x1.1173e2p-2 +-0x1.8886f8p+5 +0x1.112abap-2 +0x1.9aa3eap+3 +0x1.11145cp-2 +0x1.9aa296p+3 +0x1.1121eap-2 +0x1.0bae1p-2 +0x1.112946p-2 +0x1.0baf98p-2 +0x1.1129c6p-2 +-0x1.b74be6p+5 +0x1.17b67ap-2 +-0x1.4c198cp+0 +0x1.17ec4ap-2 +-0x1.4c1f8cp+0 +0x1.17ec12p-2 +-0x1.b74be6p+5 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +0x1.9aa548p+3 +0x1.0baf98p-2 +0x1.9aa548p+3 +0x1.0baf98p-2 +0x1.9aa548p+3 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +-0x1.381516p+5 +0x1.3e53f8p+2 +-0x1.381516p+5 +0x1.3e53f8p+2 +0x1.3e53f8p+2 +0x1.0bc32p-2 +0x1.3e53f8p+2 +0x1.0bc32p-2 +0x1.07a674p-2 +0x1.3e53f8p+2 +0x1.07a674p-2 +0x1.3e53f8p+2 +0x1.07a674p-2 +-0x1.381516p+5 +0x1.07a798p-2 +-0x1.38151ep+5 +-0x1.f30b1cp+4 +0x1.f1e8b6p-3 +-0x1.f30a6p+4 +0x1.f640ep-3 +-0x1.299eeep+4 +0x1.f7981ap-3 +-0x1.299fcp+4 +0x1.f9ea5ap-3 +-0x1.f30a5cp+4 +0x1.469e36p-3 +-0x1.f30bb6p+4 +0x1.3eb064p-3 +-0x1.1e9be2p+4 +0x1.3eb064p-3 +-0x1.11d158p+4 +0x1.47f9a8p-3 +-0x1.11d304p+4 +0x1.4f4d9ep-3 +-0x1.f833fp+2 +0x1.8b6286p-7 +-0x1.f83744p+2 +0x1.bce1cap-7 +-0x1.609e42p+3 +0x1.3d6822p-7 +-0x1.609872p+3 +0x1.fb0688p-7 +-0x1.1e9d34p+4 +0x1.116ff6p-6 +-0x1.6098c8p+3 +-0x1.30c33ap-3 +-0x1.609b92p+3 +-0x1.3c84e4p-3 +-0x1.3050dp+4 +-0x1.4051cp-3 +-0x1.30539ep+4 +-0x1.3b0d2ep-3 +-0x1.278556p+4 +-0x1.12efe6p-2 +-0x1.31a562p+4 +-0x1.11bbeep-2 +-0x1.31a686p+4 +-0x1.0e743cp-2 +-0x1.d786c8p+4 +-0x1.0e8c1cp-2 +-0x1.1d142cp+4 +-0x1.81dcb8p-2 +-0x1.1d0e32p+4 +-0x1.724966p-2 +-0x1.cfee1cp+3 +-0x1.724966p-2 +-0x1.cff008p+3 +-0x1.71e4eap-2 +-0x1.278556p+4 +-0x1.72d8bep-2 +-0x1.1d0e32p+4 +-0x1.e39ca8p-2 +-0x1.1d0e68p+4 +-0x1.e5190ep-2 +-0x1.1d0e68p+4 +-0x1.d7d2bep+4 +-0x1.1d112p+4 +-0x1.18cac8p+5 +-0x1.1d1436p+4 +-0x1.18c9a8p+5 +-0x1.d787a6p+4 +-0x1.2fb36p+3 +-0x1.d7888cp+4 +-0x1.5342fcp+3 +-0x1.305118p+4 +-0x1.53466ap+3 +-0x1.30507ep+4 +-0x1.463272p+4 +-0x1.14db1p+4 +-0x1.463348p+4 +-0x1.14db1p+4 +-0x1.f827ecp+2 +-0x1.14db64p+4 +-0x1.f82926p+2 +-0x1.14dba8p+4 +-0x1.609c04p+3 +-0x1.14dc9ep+4 +-0x1.609a18p+3 +-0x1.935776p+4 +-0x1.f82a64p+2 +-0x1.31a568p+4 +-0x1.2fb1f6p+3 +-0x1.278556p+4 +-0x1.09e2c6p+5 +-0x1.31a5d4p+4 +-0x1.09e2ecp+5 +-0x1.31a53ap+4 +-0x1.09e2d6p+5 +-0x1.609d78p+3 +-0x1.f83482p+2 +-0x1.609c8ap+3 +-0x1.f83634p+2 +0x1.489e48p+3 +-0x1.11d0fp+4 +-0x1.1e9b78p+4 +-0x1.699f4p+1 +-0x1.32fdaep+2 +0x1.48a0dp+3 +0x1.489df6p+3 +-0x1.f30bb6p+4 +-0x1.32fdaep+2 +-0x1.f30bb4p+4 +-0x1.72611cp+1 +-0x1.299f3p+4 +-0x1.72644cp+1 +-0x1.299f2ep+4 +0x1.1129c6p-2 +0x1.0c2a94p-2 +0x1.0c602cp-2 +0x1.f83664p-3 +0x1.17e92ap-2 +0x1.103db4p-2 +0x0p+0 +0x1.176368p-2 +0x1.ff5eccp-3 +0x1.4c35bp-3 +0x1.6773d8p-3 +0x1.599dbp-7 +0x1.11cdaap-5 +-0x1.452d12p-3 +-0x1.16dd64p-3 +-0x1.19c378p-2 +-0x1.060bfap-2 +-0x1.73709ap-2 +-0x1.671496p-2 +-0x1.e5190ep-2 +-0x1.e3026cp-2 +0x0p+0 +-0x1.bf0c5cp+1 +-0x1.cfef46p+3 +-0x1.bf067p+1 +-0x1.1d133ep+4 +-0x1.6da9e2p-4 +-0x1.18ca5p+5 +-0x1.6c3ddp-4 +-0x1.d7d244p+4 +-0x1.75da58p-3 +-0x1.d786dap+4 +-0x1.75771p-3 +-0x1.31a53ap+4 +-0x1.845422p+1 +-0x1.5342ecp+3 +-0x1.845b18p+1 +-0x1.463348p+4 +-0x1.9136f2p+1 +-0x1.14daeep+4 +-0x1.914052p+1 +-0x1.93573ep+4 +-0x1.929e1cp-3 +-0x1.2fb2bp+3 +-0x1.924992p-3 +-0x1.09e2d6p+5 +-0x1.a0c184p+1 +-0x1.305046p+4 +-0x1.a0ca74p+1 +-0x1.609dfp+3 +-0x1.8eeedcp+3 +-0x1.f83322p+2 +-0x1.8ef09ap+3 +-0x1.1e9b0ap+4 +-0x1.4b0d86p+3 +-0x1.11d0ecp+4 +-0x1.4b0c5ap+3 +-0x1.699e2cp+1 +-0x1.732db8p+1 +-0x1.f30bc4p+4 +-0x1.73356p+1 +-0x1.299f32p+4 +-0x1.50faa2p+0 +-0x1.299f32p+4 +-0x1.50faa2p+0 +-0x1.725f8ap+1 +-0x1.50faa2p+0 +-0x1.725f8ap+1 +-0x1.50faa2p+0 +0x1.f19f76p-3 +-0x1.50faa2p+0 +0x1.07a798p-2 +-0x1.50faa2p+0 +0x1.07a798p-2 +-0x1.50f5aep+0 +0x1.0c40e2p-2 +-0x1.50f5aep+0 +0x1.0c40e2p-2 +-0x1.50f5aep+0 +0x1.6835e8p+3 +-0x1.50f5aep+0 +0x1.6835e8p+3 +0x1.6835e8p+3 +0x1.0793b8p-2 +0x1.0bc32p-2 +0x1.0c40e2p-2 +0x1.0bae44p-2 +0x1.0c3daap-2 +0x1.3e53f8p+2 +0x1.0c3194p-2 +0x1.3e53f8p+2 +0x1.0c3194p-2 +0x1.0793b8p-2 +0x1.0c3074p-2 +0x1.0793b8p-2 +0x1.0c3074p-2 +-0x1.cf574ep+4 +0x1.117404p-2 +-0x1.8886f8p+5 +0x1.1126e8p-2 +0x1.9aa4aap+3 +0x1.11107p-2 +0x1.9aa32ep+3 +0x1.111f94p-2 +0x1.0bc1f8p-2 +0x1.11270cp-2 +0x1.0bc82ep-2 +0x1.112912p-2 +-0x1.b74be6p+5 +0x1.17a288p-2 +-0x1.4c1c8ep+0 +0x1.17da38p-2 +-0x1.4c22f4p+0 +0x1.17d9fep-2 +-0x1.b74be6p+5 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +0x1.9aa5eap+3 +0x1.0bc82ep-2 +0x1.9aa5eap+3 +0x1.0bc82ep-2 +0x1.9aa5eap+3 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +-0x1.38151ep+5 +0x1.3e547p+2 +-0x1.38151ep+5 +0x1.3e547p+2 +0x1.3e547p+2 +0x1.0bd9eep-2 +0x1.3e547p+2 +0x1.0bd9eep-2 +0x1.079684p-2 +0x1.3e547p+2 +0x1.079684p-2 +0x1.3e547p+2 +0x1.079684p-2 +-0x1.38151ep+5 +0x1.079794p-2 +-0x1.381526p+5 +-0x1.f30bc4p+4 +0x1.f19f76p-3 +-0x1.f30b06p+4 +0x1.f5ffb4p-3 +-0x1.299f32p+4 +0x1.f75bf4p-3 +-0x1.29a004p+4 +0x1.f9ad5p-3 +-0x1.f30b02p+4 +0x1.471496p-3 +-0x1.f30c5cp+4 +0x1.3f28eep-3 +-0x1.1e9b0ap+4 +0x1.3f28eep-3 +-0x1.11d0ecp+4 +0x1.487b3cp-3 +-0x1.11d294p+4 +0x1.4fbd36p-3 +-0x1.f83322p+2 +0x1.852c2ep-7 +-0x1.f83674p+2 +0x1.b6737ap-7 +-0x1.609dfp+3 +0x1.37a0c6p-7 +-0x1.60982p+3 +0x1.f4dbeep-7 +-0x1.1e9c5ep+4 +0x1.0e84aap-6 +-0x1.609876p+3 +-0x1.30d994p-3 +-0x1.609b3ep+3 +-0x1.3c959p-3 +-0x1.305046p+4 +-0x1.405d7ep-3 +-0x1.305314p+4 +-0x1.3b18f2p-3 +-0x1.278556p+4 +-0x1.12e08cp-2 +-0x1.31a53ap+4 +-0x1.11ad78p-2 +-0x1.31a65ep+4 +-0x1.0e673cp-2 +-0x1.d786dap+4 +-0x1.0e7f48p-2 +-0x1.1d133ep+4 +-0x1.82054cp-2 +-0x1.1d0d42p+4 +-0x1.7271d6p-2 +-0x1.cfef46p+3 +-0x1.7271d6p-2 +-0x1.cff134p+3 +-0x1.720ce6p-2 +-0x1.278556p+4 +-0x1.730196p-2 +-0x1.1d0d42p+4 +-0x1.e36ebp-2 +-0x1.1d0d78p+4 +-0x1.e4f4b4p-2 +-0x1.1d0d78p+4 +-0x1.d7d244p+4 +-0x1.1d102ep+4 +-0x1.18ca5p+5 +-0x1.1d1346p+4 +-0x1.18c92ep+5 +-0x1.d787b8p+4 +-0x1.2fb2bp+3 +-0x1.d7889cp+4 +-0x1.5342ecp+3 +-0x1.30509p+4 +-0x1.53465ap+3 +-0x1.304ff6p+4 +-0x1.463348p+4 +-0x1.14daeep+4 +-0x1.46341ep+4 +-0x1.14daeep+4 +-0x1.f82734p+2 +-0x1.14db42p+4 +-0x1.f8286cp+2 +-0x1.14db86p+4 +-0x1.609bbp+3 +-0x1.14dc7ap+4 +-0x1.6099c6p+3 +-0x1.93573ep+4 +-0x1.f829a6p+2 +-0x1.31a542p+4 +-0x1.2fb14ap+3 +-0x1.278556p+4 +-0x1.09e2d6p+5 +-0x1.31a5aep+4 +-0x1.09e2fap+5 +-0x1.31a514p+4 +-0x1.09e2e4p+5 +-0x1.609d26p+3 +-0x1.f833bp+2 +-0x1.609c38p+3 +-0x1.f8356p+2 +0x1.489dccp+3 +-0x1.11d084p+4 +-0x1.1e9aa8p+4 +-0x1.699e2cp+1 +-0x1.32fdaep+2 +0x1.48a02ep+3 +0x1.489d24p+3 +-0x1.f30c5cp+4 +-0x1.32fdaep+2 +-0x1.f30c5ap+4 +-0x1.725f8ap+1 +-0x1.299f74p+4 +-0x1.72633cp+1 +-0x1.299f72p+4 +0x1.112912p-2 +0x1.0c30b4p-2 +0x1.0c6cd6p-2 +0x1.f7fc5p-3 +0x1.17d702p-2 +0x1.104498p-2 +0x0p+0 +0x1.17507ap-2 +0x1.ff411ap-3 +0x1.4ca7fp-3 +0x1.67b434p-3 +0x1.564daap-7 +0x1.10ddb8p-5 +-0x1.45317p-3 +-0x1.16edbap-3 +-0x1.19b5eap-2 +-0x1.0604a6p-2 +-0x1.73972p-2 +-0x1.6736d4p-2 +-0x1.e4f4b4p-2 +-0x1.e2efp-2 +0x0p+0 +-0x1.bf0eb2p+1 +-0x1.cff072p+3 +-0x1.bf08bap+1 +-0x1.1d124cp+4 +-0x1.6d20b8p-4 +-0x1.18c9d6p+5 +-0x1.6bb4fep-4 +-0x1.d7d1ccp+4 +-0x1.75c55ep-3 +-0x1.d786eap+4 +-0x1.7561b4p-3 +-0x1.31a514p+4 +-0x1.845648p+1 +-0x1.5342dep+3 +-0x1.845d44p+1 +-0x1.46341ep+4 +-0x1.9136fcp+1 +-0x1.14dacap+4 +-0x1.91404cp+1 +-0x1.935706p+4 +-0x1.928b4cp-3 +-0x1.2fb206p+3 +-0x1.9236ecp-3 +-0x1.09e2e4p+5 +-0x1.a0c17p+1 +-0x1.304fbep+4 +-0x1.a0ca68p+1 +-0x1.609d9ap+3 +-0x1.8eeeb6p+3 +-0x1.f83256p+2 +-0x1.8ef076p+3 +-0x1.1e9a3ap+4 +-0x1.4b0d16p+3 +-0x1.11d08p+4 +-0x1.4b0be6p+3 +-0x1.699d16p+1 +-0x1.732f9p+1 +-0x1.f30c6ap+4 +-0x1.7336bap+1 +-0x1.299f74p+4 +-0x1.50f5aep+0 +0x1.6835e8p+3 +0x1.0c50d2p-2 +0x1.11751ap-2 +0x1.178fc4p-2 +0x0p+0 +-0x1.4c1fe2p+0 +-0x1.b74be6p+5 +0x1.9aa55cp+3 +-0x1.8886f8p+5 +-0x1.cf574ep+4 +0x1.3e547p+2 +-0x1.381526p+5 +0x1.0bd9eep-2 +0x1.079794p-2 +0x1.f170c4p-3 +0x1.473dfap-3 +0x1.81fd9ep-7 +-0x1.30e164p-3 +-0x1.12d4fap-2 +-0x1.8221acp-2 +-0x1.e34cfep-2 +-0x1.cff072p+3 +-0x1.bf1102p+1 +-0x1.1d124cp+4 +-0x1.18c9d6p+5 +-0x1.6c97fcp-4 +-0x1.d7d1ccp+4 +-0x1.d786eap+4 +-0x1.75afd2p-3 +-0x1.5342dep+3 +-0x1.84587p+1 +-0x1.46341ep+4 +-0x1.14dacap+4 +-0x1.913708p+1 +-0x1.935706p+4 +-0x1.2fb206p+3 +-0x1.927884p-3 +-0x1.09e2e4p+5 +-0x1.31a514p+4 +-0x1.278556p+4 +-0x1.304fbep+4 +-0x1.a0c15ep+1 +-0x1.609d9ap+3 +-0x1.f83256p+2 +-0x1.8eee94p+3 +-0x1.11d08p+4 +-0x1.4b0ca2p+3 +-0x1.699d16p+1 +0x1.489cf8p+3 +-0x1.32fdaep+2 +-0x1.1e9a3ap+4 +-0x1.f30c6ap+4 +-0x1.73311cp+1 +-0x1.725edp+1 +-0x1.299f74p+4 +-0x1.50d12p+0 +0x1.683ceep+3 +-0x1.724654p+1 +0x1.48a372p+3 +0x1.09079ap-2 +-0x1.3812b8p+5 +0x1.3e6652p+2 +0x1.0cea9p-2 +0x1.9aaf0cp+3 +-0x1.4be064p+0 +-0x1.b74266p+5 +-0x1.cf5c2p+4 +-0x1.8883dp+5 +-0x1.278a44p+4 +-0x1.32de98p+2 +-0x1.9164bep+1 +-0x1.14e0e4p+4 +-0x1.935d14p+4 +-0x1.77f3c4p-3 +-0x1.d78d1p+4 +-0x1.31aa2p+4 +-0x1.bf3af4p+1 +-0x1.1d1b7p+4 +-0x1.cff96p+3 +-0x1.757a72p-4 +-0x1.18ce68p+5 +-0x1.d7dbb2p+4 +-0x1.94ef38p-3 +-0x1.2fbbb4p+3 +-0x1.09e5p+5 +-0x1.a0f5a2p+1 +-0x1.30572ap+4 +-0x1.60aa1p+3 +-0x1.7312bcp+1 +-0x1.f3070ap+4 +-0x1.299afcp+4 +-0x1.8485bcp+1 +-0x1.535014p+3 +-0x1.463876p+4 +-0x1.8f00dap+3 +-0x1.1ea278p+4 +-0x1.f84bd2p+2 +-0x1.4b0baap+3 +-0x1.68fd44p+1 +-0x1.11cd32p+4 +0x1.1896dp-2 +0x1.12a558p-2 +0x1.0d78b8p-2 +0x1.f37c5ep-3 +0x1.4838dp-3 +0x1.5d1fdap-7 +-0x1.33f8ap-3 +-0x1.14243ap-2 +-0x1.833dep-2 +-0x1.e38b0cp-2 +0x0p+0 +0x1.5d1fdap-7 +0x0p+0 +0x1.81fd9ep-7 +0x0p+0 +0x1.166c62p+2 +0x0p+0 +0x1.167e3ep+2 +0x0p+0 +0x1.887ffp+2 +0x0p+0 +0x1.8898aap+2 +0x0p+0 +0x1.09079ap-2 +0x0p+0 +0x1.079794p-2 +0x0p+0 +0x1.a428d8p+0 +0x0p+0 +0x1.a2f8d8p+0 +0x0p+0 +0x1.3f279cp+2 +0x0p+0 +0x1.3f17bep+2 +0x0p+0 +0x1.3a5c1cp+1 +0x0p+0 +0x1.3a82acp+1 +0x0p+0 +0x1.337ccp+0 +0x0p+0 +0x1.3317cp+0 +0x0p+0 +0x1.83612p-2 +0x0p+0 +0x1.849cap-2 +0x0p+0 +0x1.8c49ccp+2 +0x0p+0 +0x1.8c6d56p+2 +0x0p+0 +0x1.ecbf18p+0 +0x0p+0 +0x1.ed5d78p+0 +0x0p+0 +0x1.4c9608p+1 +0x0p+0 +0x1.4cdf28p+1 +0x0p+0 +0x1.866018p+2 +0x0p+0 +0x1.867238p+2 +0x0p+0 +0x1.81d658p+2 +0x0p+0 +0x1.81ea88p+2 +0x0p+0 +0x1.0d78b8p-2 +0x0p+0 +0x1.0c50d2p-2 +0x0p+0 +0x1.07c588p+0 +0x0p+0 +0x1.0857c8p+0 +0x0p+0 +0x1.f1a938p+0 +0x0p+0 +0x1.f20b98p+0 +0x0p+0 +0x1.650478p+1 +0x0p+0 +0x1.652e6ap+1 +0x0p+0 +0x1.79ebd8p+2 +0x0p+0 +0x1.79fd9cp+2 +0x0p+0 +0x1.80dd72p+2 +0x0p+0 +0x1.80f266p+2 +0x0p+0 +0x1.12a558p-2 +0x0p+0 +0x1.11751ap-2 +0x0p+0 +0x1.79ebd8p+2 +0x0p+0 +0x1.79fd9cp+2 +-0x1.50f5aep+0 +-0x1.299f74p+4 +-0x1.50f5aep+0 +-0x1.725edp+1 +-0x1.50f5aep+0 +0x1.f170c4p-3 +-0x1.50f5aep+0 +0x1.079794p-2 +-0x1.50f5aep+0 +0x1.0c50d2p-2 +-0x1.50f5aep+0 +0x1.6835e8p+3 +0x1.6835e8p+3 +0x1.079794p-2 +0x1.0bd9eep-2 +0x1.0c50d2p-2 +0x1.3e547p+2 +0x1.0c50d2p-2 +0x1.079794p-2 +0x1.0c50d2p-2 +-0x1.cf574ep+4 +0x1.11751ap-2 +-0x1.8886f8p+5 +0x1.11751ap-2 +0x1.9aa55cp+3 +0x1.11751ap-2 +0x1.0bd9eep-2 +0x1.11751ap-2 +-0x1.b74be6p+5 +0x1.178fc4p-2 +-0x1.4c1fe2p+0 +0x1.178fc4p-2 +-0x1.b74be6p+5 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +0x1.9aa55cp+3 +0x1.0bd9eep-2 +0x1.9aa55cp+3 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +-0x1.381526p+5 +0x1.3e547p+2 +0x1.3e547p+2 +0x1.0bd9eep-2 +0x1.079794p-2 +0x1.3e547p+2 +0x1.079794p-2 +-0x1.381526p+5 +-0x1.f30c6ap+4 +0x1.f170c4p-3 +-0x1.299f74p+4 +0x1.f170c4p-3 +-0x1.f30c6ap+4 +0x1.473dfap-3 +-0x1.1e9a3ap+4 +0x1.473dfap-3 +-0x1.11d08p+4 +0x1.473dfap-3 +-0x1.f83256p+2 +0x1.81fd9ep-7 +-0x1.609d9ap+3 +0x1.81fd9ep-7 +-0x1.1e9a3ap+4 +0x1.81fd9ep-7 +-0x1.609d9ap+3 +-0x1.30e164p-3 +-0x1.304fbep+4 +-0x1.30e164p-3 +-0x1.278556p+4 +-0x1.12d4fap-2 +-0x1.31a514p+4 +-0x1.12d4fap-2 +-0x1.d786eap+4 +-0x1.12d4fap-2 +-0x1.1d124cp+4 +-0x1.8221acp-2 +-0x1.cff072p+3 +-0x1.8221acp-2 +-0x1.278556p+4 +-0x1.8221acp-2 +-0x1.1d124cp+4 +-0x1.e34cfep-2 +-0x1.1d124cp+4 +-0x1.d7d1ccp+4 +-0x1.1d124cp+4 +-0x1.18c9d6p+5 +-0x1.d786eap+4 +-0x1.2fb206p+3 +-0x1.d786eap+4 +-0x1.5342dep+3 +-0x1.304fbep+4 +-0x1.5342dep+3 +-0x1.304fbep+4 +-0x1.46341ep+4 +-0x1.14dacap+4 +-0x1.46341ep+4 +-0x1.14dacap+4 +-0x1.f83256p+2 +-0x1.14dacap+4 +-0x1.609d9ap+3 +-0x1.935706p+4 +-0x1.f83256p+2 +-0x1.31a514p+4 +-0x1.2fb206p+3 +-0x1.278556p+4 +-0x1.09e2e4p+5 +-0x1.31a514p+4 +-0x1.09e2e4p+5 +-0x1.609d9ap+3 +-0x1.f83256p+2 +0x1.489cf8p+3 +-0x1.11d08p+4 +-0x1.1e9a3ap+4 +-0x1.699d16p+1 +-0x1.32fdaep+2 +0x1.489cf8p+3 +0x1.489cf8p+3 +-0x1.f30c6ap+4 +-0x1.32fdaep+2 +-0x1.f30c6ap+4 +-0x1.725edp+1 +-0x1.299f74p+4 +0x1.0c50d2p-2 +0x1.11751ap-2 +0x1.f170c4p-3 +0x1.0c50d2p-2 +0x1.11751ap-2 +0x1.178fc4p-2 +0x1.178fc4p-2 +0x0p+0 +0x1.473dfap-3 +0x1.f170c4p-3 +0x1.81fd9ep-7 +0x1.473dfap-3 +-0x1.30e164p-3 +0x1.81fd9ep-7 +-0x1.12d4fap-2 +-0x1.30e164p-3 +-0x1.8221acp-2 +-0x1.12d4fap-2 +-0x1.e34cfep-2 +-0x1.8221acp-2 +0x0p+0 +-0x1.e34cfep-2 +-0x1.cff072p+3 +-0x1.bf1102p+1 +-0x1.1d124cp+4 +-0x1.bf1102p+1 +-0x1.18c9d6p+5 +-0x1.6c97fcp-4 +-0x1.d7d1ccp+4 +-0x1.6c97fcp-4 +-0x1.d786eap+4 +-0x1.75afd2p-3 +-0x1.31a514p+4 +-0x1.75afd2p-3 +-0x1.5342dep+3 +-0x1.84587p+1 +-0x1.46341ep+4 +-0x1.84587p+1 +-0x1.14dacap+4 +-0x1.913708p+1 +-0x1.935706p+4 +-0x1.913708p+1 +-0x1.2fb206p+3 +-0x1.927884p-3 +-0x1.09e2e4p+5 +-0x1.927884p-3 +-0x1.304fbep+4 +-0x1.a0c15ep+1 +-0x1.609d9ap+3 +-0x1.a0c15ep+1 +-0x1.f83256p+2 +-0x1.8eee94p+3 +-0x1.1e9a3ap+4 +-0x1.8eee94p+3 +-0x1.11d08p+4 +-0x1.4b0ca2p+3 +-0x1.699d16p+1 +-0x1.4b0ca2p+3 +-0x1.f30c6ap+4 +-0x1.73311cp+1 +-0x1.299f74p+4 +-0x1.73311cp+1 +-0x1.514ab2p+0 +-0x1.29a1eep+4 +-0x1.514e52p+0 +-0x1.7233a4p+1 +-0x1.515262p+0 +-0x1.7235b4p+1 +-0x1.515518p+0 +0x1.f03256p-3 +-0x1.515518p+0 +0x1.065782p-2 +-0x1.515518p+0 +0x1.065782p-2 +-0x1.514bf6p+0 +0x1.0ad006p-2 +-0x1.514bf6p+0 +0x1.682b48p+3 +-0x1.514bf6p+0 +0x1.682b48p+3 +0x1.682b48p+3 +0x1.0632d2p-2 +0x1.0a9576p-2 +0x1.0ad006p-2 +0x1.0a8faep-2 +0x1.0acf22p-2 +0x1.3e3ff8p+2 +0x1.0acabp-2 +0x1.3e3ff8p+2 +0x1.0acabp-2 +0x1.0632d2p-2 +0x1.0acabp-2 +0x1.0632d2p-2 +0x1.0acabp-2 +-0x1.cf50cap+4 +0x1.0ff8e6p-2 +-0x1.888a94p+5 +0x1.0fcb3p-2 +0x1.9a99f4p+3 +0x1.0fb40ep-2 +0x1.9a9888p+3 +0x1.0fc294p-2 +0x1.0a96f4p-2 +0x1.0fc9b8p-2 +0x1.0a9b7ap-2 +0x1.0fcb3p-2 +-0x1.b756ep+5 +0x1.16c284p-2 +-0x1.4c5332p+0 +0x1.16fbbp-2 +-0x1.4c59dcp+0 +0x1.16fb72p-2 +-0x1.b756ep+5 +-0x1.cf50cap+4 +-0x1.888a94p+5 +0x1.9a9b26p+3 +0x1.0a9b7ap-2 +0x1.9a9b26p+3 +0x1.0a9b7ap-2 +0x1.9a9b26p+3 +-0x1.cf50cap+4 +-0x1.888a94p+5 +-0x1.3817a6p+5 +0x1.3e3ff8p+2 +-0x1.3817a6p+5 +0x1.3e3ff8p+2 +0x1.3e3ff8p+2 +0x1.0ab832p-2 +0x1.3e3ff8p+2 +0x1.0ab832p-2 +0x1.063598p-2 +0x1.3e3ff8p+2 +0x1.063598p-2 +0x1.3e3ff8p+2 +0x1.063598p-2 +-0x1.3817a6p+5 +0x1.0636b4p-2 +-0x1.3817aep+5 +-0x1.f31074p+4 +0x1.f03256p-3 +-0x1.f30fb6p+4 +0x1.f49328p-3 +-0x1.29a1ecp+4 +0x1.f5e314p-3 +-0x1.29a2bep+4 +0x1.f83688p-3 +-0x1.f30fb2p+4 +0x1.445e24p-3 +-0x1.f31104p+4 +0x1.3ca2dep-3 +-0x1.1e95bp+4 +0x1.3ca2dep-3 +-0x1.11d61ep+4 +0x1.45e8dap-3 +-0x1.11d7c6p+4 +0x1.4d24d4p-3 +-0x1.f81a7ap+2 +0x1.c87fe8p-7 +-0x1.f81dc2p+2 +0x1.f92138p-7 +-0x1.6091acp+3 +0x1.7913ccp-7 +-0x1.608be4p+3 +0x1.1aa154p-6 +-0x1.1e9702p+4 +0x1.2da454p-6 +-0x1.608c36p+3 +-0x1.2dc49ep-3 +-0x1.608ef8p+3 +-0x1.396bc8p-3 +-0x1.30499ap+4 +-0x1.3d2baap-3 +-0x1.304c68p+4 +-0x1.37e79p-3 +-0x1.277fc4p+4 +-0x1.11c9ap-2 +-0x1.31a078p+4 +-0x1.1095ap-2 +-0x1.31a19ap+4 +-0x1.0d4fccp-2 +-0x1.d7818p+4 +-0x1.0d67a6p-2 +-0x1.1d0c1ap+4 +-0x1.809f1cp-2 +-0x1.1d061ep+4 +-0x1.710f9cp-2 +-0x1.cfe494p+3 +-0x1.710f9cp-2 +-0x1.cfe684p+3 +-0x1.70aa38p-2 +-0x1.277fc4p+4 +-0x1.71a196p-2 +-0x1.1d061ep+4 +-0x1.e3a62p-2 +-0x1.1d0654p+4 +-0x1.e526ap-2 +-0x1.1d0654p+4 +-0x1.d7c982p+4 +-0x1.1d090ep+4 +-0x1.18c6bcp+5 +-0x1.1d0c24p+4 +-0x1.18c59ap+5 +-0x1.d7825ep+4 +-0x1.2fa9fcp+3 +-0x1.d78342p+4 +-0x1.533784p+3 +-0x1.3049e4p+4 +-0x1.533af2p+3 +-0x1.30494ap+4 +-0x1.462c9p+4 +-0x1.14d4d6p+4 +-0x1.462d68p+4 +-0x1.14d4d6p+4 +-0x1.f80e66p+2 +-0x1.14d52ap+4 +-0x1.f80fcap+2 +-0x1.14d56ap+4 +-0x1.608f6ap+3 +-0x1.14d65ep+4 +-0x1.608d84p+3 +-0x1.935142p+4 +-0x1.f810a6p+2 +-0x1.31a08p+4 +-0x1.2fa896p+3 +-0x1.277fc4p+4 +-0x1.09e096p+5 +-0x1.31a0eap+4 +-0x1.09e0bap+5 +-0x1.31a05p+4 +-0x1.09e0a4p+5 +-0x1.6090e2p+3 +-0x1.f81aa8p+2 +-0x1.608ff4p+3 +-0x1.f81c58p+2 +0x1.489556p+3 +-0x1.11d5b8p+4 +-0x1.1e9552p+4 +-0x1.6a313p+1 +-0x1.33304p+2 +0x1.489844p+3 +0x1.4896aap+3 +-0x1.f31104p+4 +-0x1.33304p+2 +-0x1.f31102p+4 +-0x1.72372ap+1 +-0x1.29a22ep+4 +-0x1.723ad6p+1 +-0x1.29a22cp+4 +0x1.0fcb3p-2 +0x1.0acafp-2 +0x1.0b20dcp-2 +0x1.f685fep-3 +0x1.16f86ap-2 +0x1.0f023ap-2 +0x0p+0 +0x1.166ed2p-2 +0x1.fd5748p-3 +0x1.4a10a8p-3 +0x1.656b9ep-3 +0x1.972eaap-7 +0x1.1c8398p-5 +-0x1.41fd12p-3 +-0x1.13cbdap-3 +-0x1.189ddap-2 +-0x1.04e33ap-2 +-0x1.7234f6p-2 +-0x1.65dec6p-2 +-0x1.e526ap-2 +-0x1.e2d16ep-2 +0x0p+0 +-0x1.bee2c6p+1 +-0x1.cfe5cp+3 +-0x1.bedcaep+1 +-0x1.1d0b2ap+4 +-0x1.65754p-4 +-0x1.18c642p+5 +-0x1.640b5ep-4 +-0x1.d7c908p+4 +-0x1.7397cap-3 +-0x1.d7819p+4 +-0x1.7333b4p-3 +-0x1.31a05p+4 +-0x1.84243ap+1 +-0x1.533776p+3 +-0x1.842b6p+1 +-0x1.462d68p+4 +-0x1.910796p+1 +-0x1.14d4bp+4 +-0x1.9110bep+1 +-0x1.93510ap+4 +-0x1.903512p-3 +-0x1.2fa94ep+3 +-0x1.8fe2ecp-3 +-0x1.09e0a4p+5 +-0x1.a08946p+1 +-0x1.304912p+4 +-0x1.a0924ep+1 +-0x1.60915p+3 +-0x1.8edbbep+3 +-0x1.f8195ep+2 +-0x1.8edd88p+3 +-0x1.1e94e4p+4 +-0x1.4b0d1ep+3 +-0x1.11d5b4p+4 +-0x1.4b0c2p+3 +-0x1.6a3026p+1 +-0x1.734b56p+1 +-0x1.f31112p+4 +-0x1.735202p+1 +-0x1.29a22cp+4 +-0x1.514bf6p+0 +-0x1.29a22cp+4 +-0x1.51501p+0 +-0x1.723ad6p+1 +-0x1.5152dp+0 +-0x1.723c3cp+1 +-0x1.51547cp+0 +0x1.f00582p-3 +-0x1.51547cp+0 +0x1.0636b4p-2 +-0x1.51547cp+0 +0x1.0636b4p-2 +-0x1.514c46p+0 +0x1.0af824p-2 +-0x1.514c46p+0 +0x1.682b48p+3 +-0x1.514c46p+0 +0x1.682b48p+3 +0x1.682b48p+3 +0x1.0615b6p-2 +0x1.0ab832p-2 +0x1.0af824p-2 +0x1.0aa31ap-2 +0x1.0af4e6p-2 +0x1.3e3ff8p+2 +0x1.0aeb9ep-2 +0x1.3e3ff8p+2 +0x1.0aeb9ep-2 +0x1.0615b6p-2 +0x1.0aea4p-2 +0x1.0615b6p-2 +0x1.0aea4p-2 +-0x1.cf50cap+4 +0x1.103fe2p-2 +-0x1.888a94p+5 +0x1.10052ep-2 +0x1.9a9a3ep+3 +0x1.0fedc2p-2 +0x1.9a9914p+3 +0x1.0ff9a6p-2 +0x1.0ab24cp-2 +0x1.1000ap-2 +0x1.0ab24cp-2 +0x1.1000ap-2 +-0x1.b756ep+5 +0x1.16b2e2p-2 +-0x1.4c56bcp+0 +0x1.16ed8p-2 +-0x1.4c5dbcp+0 +0x1.16ed4p-2 +-0x1.b756ep+5 +-0x1.cf50cap+4 +-0x1.888a94p+5 +0x1.9a9ba4p+3 +0x1.0ab24cp-2 +0x1.9a9ba4p+3 +0x1.0ab24cp-2 +0x1.9a9ba4p+3 +-0x1.cf50cap+4 +-0x1.888a94p+5 +-0x1.3817aep+5 +0x1.3e408ap+2 +-0x1.3817aep+5 +0x1.3e408ap+2 +0x1.3e408ap+2 +0x1.0acc64p-2 +0x1.3e408ap+2 +0x1.0acc64p-2 +0x1.06212ap-2 +0x1.3e408ap+2 +0x1.06212ap-2 +0x1.3e408ap+2 +0x1.06212ap-2 +-0x1.3817aep+5 +0x1.062262p-2 +-0x1.3817b6p+5 +-0x1.f31112p+4 +0x1.f00582p-3 +-0x1.f31056p+4 +0x1.f4614cp-3 +-0x1.29a22ap+4 +0x1.f5ac36p-3 +-0x1.29a2fap+4 +0x1.f7f766p-3 +-0x1.f31052p+4 +0x1.45905ep-3 +-0x1.f311a6p+4 +0x1.3dbfa8p-3 +-0x1.1e94e4p+4 +0x1.3dbfa8p-3 +-0x1.11d5b4p+4 +0x1.47108ap-3 +-0x1.11d756p+4 +0x1.4e2dbcp-3 +-0x1.f8195ep+2 +0x1.b54914p-7 +-0x1.f81cacp+2 +0x1.e63d52p-7 +-0x1.60915p+3 +0x1.6796b2p-7 +-0x1.608b86p+3 +0x1.11f684p-6 +-0x1.1e963ap+4 +0x1.25c982p-6 +-0x1.608bdcp+3 +-0x1.2dd23ap-3 +-0x1.608e9ep+3 +-0x1.39779ep-3 +-0x1.304912p+4 +-0x1.3d35bp-3 +-0x1.304be2p+4 +-0x1.37f0acp-3 +-0x1.277fc4p+4 +-0x1.11a43ep-2 +-0x1.31a05p+4 +-0x1.107474p-2 +-0x1.31a172p+4 +-0x1.0d31b2p-2 +-0x1.d7819p+4 +-0x1.0d49a2p-2 +-0x1.1d0b2ap+4 +-0x1.80d248p-2 +-0x1.1d052ep+4 +-0x1.714286p-2 +-0x1.cfe5cp+3 +-0x1.714286p-2 +-0x1.cfe7b2p+3 +-0x1.70dcfap-2 +-0x1.277fc4p+4 +-0x1.71d392p-2 +-0x1.1d052ep+4 +-0x1.e354eep-2 +-0x1.1d0566p+4 +-0x1.e4e7e4p-2 +-0x1.1d0566p+4 +-0x1.d7c908p+4 +-0x1.1d081ep+4 +-0x1.18c642p+5 +-0x1.1d0b36p+4 +-0x1.18c52p+5 +-0x1.d7826ep+4 +-0x1.2fa94ep+3 +-0x1.d7835p+4 +-0x1.533776p+3 +-0x1.30496p+4 +-0x1.533ae8p+3 +-0x1.3048c6p+4 +-0x1.462d68p+4 +-0x1.14d4bp+4 +-0x1.462e4p+4 +-0x1.14d4bp+4 +-0x1.f80d7ep+2 +-0x1.14d502p+4 +-0x1.f80edcp+2 +-0x1.14d542p+4 +-0x1.608f1p+3 +-0x1.14d634p+4 +-0x1.608d2cp+3 +-0x1.93510ap+4 +-0x1.f80fb4p+2 +-0x1.31a058p+4 +-0x1.2fa7ecp+3 +-0x1.277fc4p+4 +-0x1.09e0a4p+5 +-0x1.31a0c4p+4 +-0x1.09e0c8p+5 +-0x1.31a02ap+4 +-0x1.09e0b2p+5 +-0x1.609088p+3 +-0x1.f819aap+2 +-0x1.608f9ep+3 +-0x1.f81b54p+2 +0x1.48967cp+3 +-0x1.11d548p+4 +-0x1.1e9492p+4 +-0x1.6a3026p+1 +-0x1.33304p+2 +0x1.489918p+3 +0x1.4896fcp+3 +-0x1.f311a6p+4 +-0x1.33304p+2 +-0x1.f311a4p+4 +-0x1.723d22p+1 +-0x1.29a26ep+4 +-0x1.7240c4p+1 +-0x1.29a26cp+4 +0x1.1000ap-2 +0x1.0aeb44p-2 +0x1.0b2658p-2 +0x1.f65044p-3 +0x1.16e9f4p-2 +0x1.0f180cp-2 +0x0p+0 +0x1.1655aep-2 +0x1.fd4fd2p-3 +0x1.4b16cap-3 +0x1.65e196p-3 +0x1.8b6d74p-7 +0x1.1a33f6p-5 +-0x1.420162p-3 +-0x1.13d32ep-3 +-0x1.18817cp-2 +-0x1.04da4ap-2 +-0x1.72631ap-2 +-0x1.66028p-2 +-0x1.e4e7e4p-2 +-0x1.e2bd26p-2 +0x0p+0 +-0x1.bee4ecp+1 +-0x1.cfe6eep+3 +-0x1.bedeeep+1 +-0x1.1d0a3cp+4 +-0x1.64f10ap-4 +-0x1.18c5cap+5 +-0x1.63838ap-4 +-0x1.d7c88ep+4 +-0x1.73809ep-3 +-0x1.d7819cp+4 +-0x1.731d02p-3 +-0x1.31a02ap+4 +-0x1.842688p+1 +-0x1.53377p+3 +-0x1.842d88p+1 +-0x1.462e4p+4 +-0x1.910756p+1 +-0x1.14d486p+4 +-0x1.9110a6p+1 +-0x1.9350d2p+4 +-0x1.9022a6p-3 +-0x1.2fa8a6p+3 +-0x1.8fcf8ap-3 +-0x1.09e0b2p+5 +-0x1.a0896ep+1 +-0x1.30488ep+4 +-0x1.a09258p+1 +-0x1.6090f2p+3 +-0x1.8edbaep+3 +-0x1.f8186ap+2 +-0x1.8edd6cp+3 +-0x1.1e9426p+4 +-0x1.4b0cb4p+3 +-0x1.11d544p+4 +-0x1.4b0b96p+3 +-0x1.6a2f2p+1 +-0x1.734ccp+1 +-0x1.f311b4p+4 +-0x1.7353a2p+1 +-0x1.29a26cp+4 +-0x1.514c46p+0 +-0x1.29a26cp+4 +-0x1.5150f6p+0 +-0x1.7240c4p+1 +-0x1.5152b8p+0 +-0x1.7241aap+1 +-0x1.51539ap+0 +0x1.ef9eacp-3 +-0x1.51539ap+0 +0x1.062262p-2 +-0x1.51539ap+0 +0x1.062262p-2 +-0x1.514c1ap+0 +0x1.0b0acap-2 +-0x1.514c1ap+0 +0x1.682b48p+3 +-0x1.514c1ap+0 +0x1.682b48p+3 +0x1.682b48p+3 +0x1.060446p-2 +0x1.0acc64p-2 +0x1.0b0acap-2 +0x1.0ab1c8p-2 +0x1.0b06bp-2 +0x1.3e408ap+2 +0x1.0afbd2p-2 +0x1.3e408ap+2 +0x1.0afbd2p-2 +0x1.060446p-2 +0x1.0af9c2p-2 +0x1.060446p-2 +0x1.0af9c2p-2 +-0x1.cf50cap+4 +0x1.1043a6p-2 +-0x1.888a94p+5 +0x1.100428p-2 +0x1.9a9ad2p+3 +0x1.0fecbp-2 +0x1.9a9984p+3 +0x1.0ff9fep-2 +0x1.0ac39p-2 +0x1.100128p-2 +0x1.0ac5bep-2 +0x1.1001dep-2 +-0x1.b756ep+5 +0x1.169c3p-2 +-0x1.4c5a56p+0 +0x1.16d908p-2 +-0x1.4c61c2p+0 +0x1.16d8c4p-2 +-0x1.b756ep+5 +-0x1.cf50cap+4 +-0x1.888a94p+5 +0x1.9a9c26p+3 +0x1.0ac5bep-2 +0x1.9a9c26p+3 +0x1.0ac5bep-2 +0x1.9a9c26p+3 +-0x1.cf50cap+4 +-0x1.888a94p+5 +-0x1.3817b6p+5 +0x1.3e4166p+2 +-0x1.3817b6p+5 +0x1.3e4166p+2 +0x1.3e4166p+2 +0x1.0addcep-2 +0x1.3e4166p+2 +0x1.0addcep-2 +0x1.061408p-2 +0x1.3e4166p+2 +0x1.061408p-2 +0x1.3e4166p+2 +0x1.061408p-2 +-0x1.3817b6p+5 +0x1.06155ap-2 +-0x1.3817cp+5 +-0x1.f311b4p+4 +0x1.ef9eacp-3 +-0x1.f310f6p+4 +0x1.f4067cp-3 +-0x1.29a26ap+4 +0x1.f55aap-3 +-0x1.29a33ap+4 +0x1.f7a61cp-3 +-0x1.f310f2p+4 +0x1.46108ap-3 +-0x1.f31246p+4 +0x1.3e433ap-3 +-0x1.1e9426p+4 +0x1.3e433ap-3 +-0x1.11d544p+4 +0x1.479cbep-3 +-0x1.11d6e2p+4 +0x1.4ea4eep-3 +-0x1.f8186ap+2 +0x1.ade252p-7 +-0x1.f81bb6p+2 +0x1.deb24ep-7 +-0x1.6090f2p+3 +0x1.60b9d4p-7 +-0x1.608b28p+3 +0x1.0e5c14p-6 +-0x1.1e957ep+4 +0x1.226b46p-6 +-0x1.608b7ep+3 +-0x1.2dccecp-3 +-0x1.608e4p+3 +-0x1.397312p-3 +-0x1.30488ep+4 +-0x1.3d317ep-3 +-0x1.304b6p+4 +-0x1.37eba6p-3 +-0x1.277fc4p+4 +-0x1.119992p-2 +-0x1.31a02ap+4 +-0x1.106a26p-2 +-0x1.31a14cp+4 +-0x1.0d2888p-2 +-0x1.d7819cp+4 +-0x1.0d40ap-2 +-0x1.1d0a3cp+4 +-0x1.80f92p-2 +-0x1.1d043ep+4 +-0x1.716966p-2 +-0x1.cfe6eep+3 +-0x1.716966p-2 +-0x1.cfe8e2p+3 +-0x1.710372p-2 +-0x1.277fc4p+4 +-0x1.71fb1p-2 +-0x1.1d043ep+4 +-0x1.e32928p-2 +-0x1.1d0478p+4 +-0x1.e4c518p-2 +-0x1.1d0478p+4 +-0x1.d7c88ep+4 +-0x1.1d072ep+4 +-0x1.18c5cap+5 +-0x1.1d0a46p+4 +-0x1.18c4a8p+5 +-0x1.d7827ap+4 +-0x1.2fa8a6p+3 +-0x1.d7835ap+4 +-0x1.53377p+3 +-0x1.3048ep+4 +-0x1.533ae2p+3 +-0x1.304846p+4 +-0x1.462e4p+4 +-0x1.14d486p+4 +-0x1.462f18p+4 +-0x1.14d486p+4 +-0x1.f80ca2p+2 +-0x1.14d4d8p+4 +-0x1.f80dfep+2 +-0x1.14d516p+4 +-0x1.608eb2p+3 +-0x1.14d608p+4 +-0x1.608cdp+3 +-0x1.9350d2p+4 +-0x1.f80ed4p+2 +-0x1.31a034p+4 +-0x1.2fa746p+3 +-0x1.277fc4p+4 +-0x1.09e0b2p+5 +-0x1.31a0ap+4 +-0x1.09e0d6p+5 +-0x1.31a006p+4 +-0x1.09e0cp+5 +-0x1.60902cp+3 +-0x1.f818bcp+2 +-0x1.608f46p+3 +-0x1.f81a6p+2 +0x1.4896cap+3 +-0x1.11d4d8p+4 +-0x1.1e93dcp+4 +-0x1.6a2f2p+1 +-0x1.33304p+2 +0x1.48992ep+3 +0x1.4896bep+3 +-0x1.f31246p+4 +-0x1.33304p+2 +-0x1.f31244p+4 +-0x1.724224p+1 +-0x1.29a2bp+4 +-0x1.7245d8p+1 +-0x1.29a2aep+4 +0x1.1001dep-2 +0x1.0afb28p-2 +0x1.0b380ap-2 +0x1.f60312p-3 +0x1.16d56p-2 +0x1.0f1db8p-2 +0x0p+0 +0x1.164252p-2 +0x1.fd2302p-3 +0x1.4b9178p-3 +0x1.662c74p-3 +0x1.879a46p-7 +0x1.19196ep-5 +-0x1.41f82ep-3 +-0x1.13e72ep-3 +-0x1.187714p-2 +-0x1.04d3e2p-2 +-0x1.72887cp-2 +-0x1.66240ep-2 +-0x1.e4c518p-2 +-0x1.e2aaap-2 +0x0p+0 +-0x1.bee738p+1 +-0x1.cfe81ep+3 +-0x1.bee134p+1 +-0x1.1d094ap+4 +-0x1.64678p-4 +-0x1.18c552p+5 +-0x1.62f9f6p-4 +-0x1.d7c814p+4 +-0x1.736aacp-3 +-0x1.d781a6p+4 +-0x1.730694p-3 +-0x1.31a006p+4 +-0x1.8428bp+1 +-0x1.53376cp+3 +-0x1.842facp+1 +-0x1.462f18p+4 +-0x1.91076ap+1 +-0x1.14d45ap+4 +-0x1.9110a8p+1 +-0x1.93509ap+4 +-0x1.901078p-3 +-0x1.2fa802p+3 +-0x1.8fbd4ap-3 +-0x1.09e0cp+5 +-0x1.a08958p+1 +-0x1.30480ep+4 +-0x1.a0925p+1 +-0x1.609094p+3 +-0x1.8edb9p+3 +-0x1.f81784p+2 +-0x1.8edd4cp+3 +-0x1.1e937p+4 +-0x1.4b0c4ap+3 +-0x1.11d4d4p+4 +-0x1.4b0b2p+3 +-0x1.6a2e1cp+1 +-0x1.734e2p+1 +-0x1.f31254p+4 +-0x1.73551cp+1 +-0x1.29a2aep+4 +-0x1.514c1ap+0 +0x1.682b48p+3 +0x1.0b1e5ep-2 +0x1.10458ep-2 +0x1.1687b8p-2 +0x0p+0 +-0x1.4c5e46p+0 +-0x1.b756ep+5 +0x1.9a9b64p+3 +-0x1.888a94p+5 +-0x1.cf50cap+4 +0x1.3e4166p+2 +-0x1.3817cp+5 +0x1.0addcep-2 +0x1.06155ap-2 +0x1.ef6a7ep-3 +0x1.4639b8p-3 +0x1.aa5654p-7 +-0x1.2dd16cp-3 +-0x1.118f74p-2 +-0x1.81137cp-2 +-0x1.e30946p-2 +-0x1.cfe81ep+3 +-0x1.bee98cp+1 +-0x1.1d094ap+4 +-0x1.18c552p+5 +-0x1.63dde4p-4 +-0x1.d7c814p+4 +-0x1.d781a6p+4 +-0x1.735446p-3 +-0x1.53376cp+3 +-0x1.842ad6p+1 +-0x1.462f18p+4 +-0x1.14d45ap+4 +-0x1.91077cp+1 +-0x1.93509ap+4 +-0x1.2fa802p+3 +-0x1.8ffdfp-3 +-0x1.09e0cp+5 +-0x1.31a006p+4 +-0x1.277fc4p+4 +-0x1.30480ep+4 +-0x1.a0894ap+1 +-0x1.609094p+3 +-0x1.f81784p+2 +-0x1.8edb74p+3 +-0x1.11d4d4p+4 +-0x1.4b0bdap+3 +-0x1.6a2e1cp+1 +0x1.48968cp+3 +-0x1.33304p+2 +-0x1.1e937p+4 +-0x1.f31254p+4 +-0x1.734f96p+1 +-0x1.7245d8p+1 +-0x1.29a2aep+4 +-0x1.50f5aep+0 +0x1.6835e8p+3 +-0x1.725edp+1 +0x1.489cf8p+3 +0x1.079794p-2 +-0x1.381526p+5 +0x1.3e547p+2 +0x1.0bd9eep-2 +0x1.9aa55cp+3 +-0x1.4c1fe2p+0 +-0x1.b74be6p+5 +-0x1.cf574ep+4 +-0x1.8886f8p+5 +-0x1.278556p+4 +-0x1.32fdaep+2 +-0x1.913708p+1 +-0x1.14dacap+4 +-0x1.935706p+4 +-0x1.75afd2p-3 +-0x1.d786eap+4 +-0x1.31a514p+4 +-0x1.bf1102p+1 +-0x1.1d124cp+4 +-0x1.cff072p+3 +-0x1.6c97fcp-4 +-0x1.18c9d6p+5 +-0x1.d7d1ccp+4 +-0x1.927884p-3 +-0x1.2fb206p+3 +-0x1.09e2e4p+5 +-0x1.a0c15ep+1 +-0x1.304fbep+4 +-0x1.609d9ap+3 +-0x1.73311cp+1 +-0x1.f30c6ap+4 +-0x1.299f74p+4 +-0x1.84587p+1 +-0x1.5342dep+3 +-0x1.46341ep+4 +-0x1.8eee94p+3 +-0x1.1e9a3ap+4 +-0x1.f83256p+2 +-0x1.4b0ca2p+3 +-0x1.699d16p+1 +-0x1.11d08p+4 +0x1.178fc4p-2 +0x1.11751ap-2 +0x1.0c50d2p-2 +0x1.f170c4p-3 +0x1.473dfap-3 +0x1.81fd9ep-7 +-0x1.30e164p-3 +-0x1.12d4fap-2 +-0x1.8221acp-2 +-0x1.e34cfep-2 +0x0p+0 +0x1.81fd9ep-7 +0x0p+0 +0x1.aa5654p-7 +0x0p+0 +0x1.167e3ep+2 +0x0p+0 +0x1.168ee6p+2 +0x0p+0 +0x1.079794p-2 +0x0p+0 +0x1.06155ap-2 +0x0p+0 +0x1.a2f8d8p+0 +0x0p+0 +0x1.a19998p+0 +0x0p+0 +0x1.3f17bep+2 +0x0p+0 +0x1.3f0824p+2 +0x0p+0 +0x1.3a82acp+1 +0x0p+0 +0x1.3ab6ccp+1 +0x0p+0 +0x1.3317cp+0 +0x0p+0 +0x1.32a44p+0 +0x0p+0 +0x1.849cap-2 +0x0p+0 +0x1.86012p-2 +0x0p+0 +0x1.8c6d56p+2 +0x0p+0 +0x1.8c903ep+2 +0x0p+0 +0x1.ed5d78p+0 +0x0p+0 +0x1.edf8f8p+0 +0x0p+0 +0x1.4cdf28p+1 +0x0p+0 +0x1.4d2768p+1 +0x0p+0 +0x1.867238p+2 +0x0p+0 +0x1.868514p+2 +0x0p+0 +0x1.81ea88p+2 +0x0p+0 +0x1.81fecp+2 +0x0p+0 +0x1.0c50d2p-2 +0x0p+0 +0x1.0b1e5ep-2 +0x0p+0 +0x1.0857c8p+0 +0x0p+0 +0x1.08e7e8p+0 +0x0p+0 +0x1.f20b98p+0 +0x0p+0 +0x1.f25fd8p+0 +0x0p+0 +0x1.652e6ap+1 +0x0p+0 +0x1.6555ep+1 +0x0p+0 +0x1.79fd9cp+2 +0x0p+0 +0x1.7a0e7ep+2 +0x0p+0 +0x1.80f266p+2 +0x0p+0 +0x1.8106bep+2 +0x0p+0 +0x1.11751ap-2 +0x0p+0 +0x1.10458ep-2 +0x0p+0 +0x1.79fd9cp+2 +0x0p+0 +0x1.7a0e7ep+2 +-0x1.514c1ap+0 +-0x1.29a2aep+4 +-0x1.514c1ap+0 +-0x1.7245d8p+1 +-0x1.514c1ap+0 +0x1.ef6a7ep-3 +-0x1.514c1ap+0 +0x1.06155ap-2 +-0x1.514c1ap+0 +0x1.682b48p+3 +0x1.06155ap-2 +-0x1.3817cp+5 +0x1.06155ap-2 +0x1.3e4166p+2 +0x1.06155ap-2 +0x1.0b1e5ep-2 +0x1.0addcep-2 +0x1.0b1e5ep-2 +0x1.3e4166p+2 +0x1.0b1e5ep-2 +-0x1.cf50cap+4 +0x1.10458ep-2 +-0x1.888a94p+5 +0x1.10458ep-2 +0x1.9a9b64p+3 +0x1.10458ep-2 +0x1.0addcep-2 +0x1.10458ep-2 +-0x1.b756ep+5 +0x1.1687b8p-2 +-0x1.4c5e46p+0 +0x1.1687b8p-2 +-0x1.b756ep+5 +-0x1.cf50cap+4 +-0x1.888a94p+5 +0x1.9a9b64p+3 +0x1.0addcep-2 +0x1.9a9b64p+3 +-0x1.cf50cap+4 +-0x1.888a94p+5 +0x1.3e4166p+2 +0x1.0addcep-2 +-0x1.3817cp+5 +0x1.3e4166p+2 +-0x1.f31254p+4 +0x1.ef6a7ep-3 +-0x1.29a2aep+4 +0x1.ef6a7ep-3 +-0x1.f31254p+4 +0x1.4639b8p-3 +-0x1.1e937p+4 +0x1.4639b8p-3 +-0x1.11d4d4p+4 +0x1.4639b8p-3 +-0x1.f81784p+2 +0x1.aa5654p-7 +-0x1.609094p+3 +0x1.aa5654p-7 +-0x1.1e937p+4 +0x1.aa5654p-7 +-0x1.609094p+3 +-0x1.2dd16cp-3 +-0x1.30480ep+4 +-0x1.2dd16cp-3 +-0x1.277fc4p+4 +-0x1.118f74p-2 +-0x1.31a006p+4 +-0x1.118f74p-2 +-0x1.d781a6p+4 +-0x1.118f74p-2 +-0x1.1d094ap+4 +-0x1.81137cp-2 +-0x1.cfe81ep+3 +-0x1.81137cp-2 +-0x1.277fc4p+4 +-0x1.81137cp-2 +-0x1.1d094ap+4 +-0x1.e30946p-2 +-0x1.1d094ap+4 +-0x1.d7c814p+4 +-0x1.1d094ap+4 +-0x1.18c552p+5 +-0x1.d781a6p+4 +-0x1.2fa802p+3 +-0x1.d781a6p+4 +-0x1.53376cp+3 +-0x1.30480ep+4 +-0x1.53376cp+3 +-0x1.30480ep+4 +-0x1.462f18p+4 +-0x1.14d45ap+4 +-0x1.462f18p+4 +-0x1.14d45ap+4 +-0x1.f81784p+2 +-0x1.14d45ap+4 +-0x1.609094p+3 +-0x1.93509ap+4 +-0x1.f81784p+2 +-0x1.31a006p+4 +-0x1.2fa802p+3 +-0x1.277fc4p+4 +-0x1.09e0cp+5 +-0x1.31a006p+4 +-0x1.09e0cp+5 +-0x1.609094p+3 +-0x1.f81784p+2 +0x1.48968cp+3 +-0x1.11d4d4p+4 +-0x1.1e937p+4 +-0x1.6a2e1cp+1 +-0x1.33304p+2 +0x1.48968cp+3 +0x1.48968cp+3 +-0x1.f31254p+4 +-0x1.33304p+2 +-0x1.f31254p+4 +-0x1.7245d8p+1 +-0x1.29a2aep+4 +0x1.0b1e5ep-2 +0x1.10458ep-2 +0x1.ef6a7ep-3 +0x1.0b1e5ep-2 +0x1.10458ep-2 +0x1.1687b8p-2 +0x1.1687b8p-2 +0x0p+0 +0x1.4639b8p-3 +0x1.ef6a7ep-3 +0x1.aa5654p-7 +0x1.4639b8p-3 +-0x1.2dd16cp-3 +0x1.aa5654p-7 +-0x1.118f74p-2 +-0x1.2dd16cp-3 +-0x1.81137cp-2 +-0x1.118f74p-2 +-0x1.e30946p-2 +-0x1.81137cp-2 +0x0p+0 +-0x1.e30946p-2 +-0x1.cfe81ep+3 +-0x1.bee98cp+1 +-0x1.1d094ap+4 +-0x1.bee98cp+1 +-0x1.18c552p+5 +-0x1.63dde4p-4 +-0x1.d7c814p+4 +-0x1.63dde4p-4 +-0x1.d781a6p+4 +-0x1.735446p-3 +-0x1.31a006p+4 +-0x1.735446p-3 +-0x1.53376cp+3 +-0x1.842ad6p+1 +-0x1.462f18p+4 +-0x1.842ad6p+1 +-0x1.14d45ap+4 +-0x1.91077cp+1 +-0x1.93509ap+4 +-0x1.91077cp+1 +-0x1.2fa802p+3 +-0x1.8ffdfp-3 +-0x1.09e0cp+5 +-0x1.8ffdfp-3 +-0x1.30480ep+4 +-0x1.a0894ap+1 +-0x1.609094p+3 +-0x1.a0894ap+1 +-0x1.f81784p+2 +-0x1.8edb74p+3 +-0x1.1e937p+4 +-0x1.8edb74p+3 +-0x1.11d4d4p+4 +-0x1.4b0bdap+3 +-0x1.6a2e1cp+1 +-0x1.4b0bdap+3 +-0x1.f31254p+4 +-0x1.734f96p+1 +-0x1.29a2aep+4 +-0x1.734f96p+1 +-0x1.51b546p+0 +-0x1.29a458p+4 +-0x1.51c86cp+0 +-0x1.7243b8p+1 +-0x1.51cf64p+0 +-0x1.72474p+1 +-0x1.51d48ap+0 +0x1.ee972cp-3 +-0x1.51d48ap+0 +0x1.04a154p-2 +-0x1.51d48ap+0 +0x1.04a154p-2 +-0x1.51c698p+0 +0x1.681e22p+3 +-0x1.51c662p+0 +0x1.681e1p+3 +0x1.046958p-2 +-0x1.381a3ep+5 +0x1.046d14p-2 +-0x1.381a58p+5 +0x1.046d14p-2 +0x1.3e2fd2p+2 +0x1.046d14p-2 +0x1.3e2fd2p+2 +0x1.04823p-2 +0x1.09abdap-2 +0x1.04823p-2 +0x1.09abdap-2 +0x1.09b5fap-2 +0x1.09ada4p-2 +0x1.09a4e6p-2 +0x1.09ab02p-2 +0x1.3e2e7ep+2 +0x1.09a644p-2 +0x1.3e2e7ep+2 +0x1.09a644p-2 +-0x1.cf47c4p+4 +0x1.0eab82p-2 +-0x1.888f22p+5 +0x1.0e91b8p-2 +0x1.9a9042p+3 +0x1.0e7a12p-2 +0x1.9a8f26p+3 +0x1.0e856ap-2 +0x1.09acacp-2 +0x1.0e8b4ep-2 +0x1.09acacp-2 +0x1.0e8b4ep-2 +-0x1.b7636ep+5 +0x1.15c126p-2 +-0x1.4c8feap+0 +0x1.15ff82p-2 +-0x1.4c978ep+0 +0x1.15ff3cp-2 +-0x1.b7636ep+5 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +0x1.9a915p+3 +0x1.09acacp-2 +0x1.9a9146p+3 +0x1.09acacp-2 +0x1.9a9146p+3 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +0x1.3e2f0ap+2 +0x1.09d7c6p-2 +0x1.3e2f0ap+2 +0x1.09d7c6p-2 +-0x1.381a58p+5 +0x1.3e2f0ap+2 +-0x1.381a58p+5 +0x1.3e2f0ap+2 +-0x1.f316e2p+4 +0x1.ee972cp-3 +-0x1.f31622p+4 +0x1.f3001p-3 +-0x1.29a452p+4 +0x1.f4402cp-3 +-0x1.29a524p+4 +0x1.f68da6p-3 +-0x1.f3161ep+4 +0x1.42f6f6p-3 +-0x1.f3176ap+4 +0x1.3b55c8p-3 +-0x1.1e8fc8p+4 +0x1.3b55c8p-3 +-0x1.11db36p+4 +0x1.44b7acp-3 +-0x1.11dcd2p+4 +0x1.4bb62cp-3 +-0x1.f7fdf2p+2 +0x1.f23d1ep-7 +-0x1.f80134p+2 +0x1.113812p-6 +-0x1.6083ccp+3 +0x1.a36432p-7 +-0x1.607e0ap+3 +0x1.2f315p-6 +-0x1.1e9122p+4 +0x1.42442ep-6 +-0x1.607e5cp+3 +-0x1.2a8f36p-3 +-0x1.60811ap+3 +-0x1.3624dap-3 +-0x1.30418ap+4 +-0x1.39dff6p-3 +-0x1.30445cp+4 +-0x1.349a7p-3 +-0x1.2779b8p+4 +-0x1.1073a2p-2 +-0x1.319b56p+4 +-0x1.0f436ep-2 +-0x1.319c78p+4 +-0x1.0c02bp-2 +-0x1.d77ceep+4 +-0x1.0c1ac6p-2 +-0x1.1d034cp+4 +-0x1.7fb03cp-2 +-0x1.1cfd4ep+4 +-0x1.702462p-2 +-0x1.cfdcbep+3 +-0x1.702462p-2 +-0x1.cfdeb2p+3 +-0x1.6fbe4p-2 +-0x1.2779b8p+4 +-0x1.70b656p-2 +-0x1.1cfd4ep+4 +-0x1.e3551ap-2 +-0x1.1cfd86p+4 +-0x1.e4ebeep-2 +-0x1.1cfd86p+4 +-0x1.d7c002p+4 +-0x1.1d0042p+4 +-0x1.18c254p+5 +-0x1.1d035cp+4 +-0x1.18c132p+5 +-0x1.d77dccp+4 +-0x1.2f9f76p+3 +-0x1.d77ea8p+4 +-0x1.532d3cp+3 +-0x1.3041dcp+4 +-0x1.5330acp+3 +-0x1.304142p+4 +-0x1.462778p+4 +-0x1.14ce04p+4 +-0x1.462852p+4 +-0x1.14ce04p+4 +-0x1.f7f20ap+2 +-0x1.14ce56p+4 +-0x1.f7f366p+2 +-0x1.14ce94p+4 +-0x1.60818cp+3 +-0x1.14cf84p+4 +-0x1.607facp+3 +-0x1.934a68p+4 +-0x1.f7f43cp+2 +-0x1.319b62p+4 +-0x1.2f9e1cp+3 +-0x1.2779b8p+4 +-0x1.09de68p+5 +-0x1.319bcep+4 +-0x1.09de8cp+5 +-0x1.319b34p+4 +-0x1.09de76p+5 +-0x1.608308p+3 +-0x1.f7fe1ap+2 +-0x1.608224p+3 +-0x1.f7ffb8p+2 +0x1.488ccp+3 +-0x1.11daccp+4 +-0x1.1e8f86p+4 +-0x1.6ab298p+1 +-0x1.3372e8p+2 +0x1.488fbap+3 +0x1.488f42p+3 +-0x1.f3176ap+4 +-0x1.3372e8p+2 +-0x1.f31768p+4 +-0x1.724a04p+1 +-0x1.29a49ap+4 +-0x1.724d32p+1 +-0x1.29a498p+4 +0x1.0e8b4ep-2 +0x1.09a4f4p-2 +0x1.09ee38p-2 +0x1.f4eafep-3 +0x1.15fbcep-2 +0x1.0dbd22p-2 +0x0p+0 +0x1.156d16p-2 +0x1.fb749cp-3 +0x1.48a4a2p-3 +0x1.6382e6p-3 +0x1.c9ebcep-7 +0x1.25bc9ap-5 +-0x1.3ea2ep-3 +-0x1.10b766p-3 +-0x1.175068p-2 +-0x1.03b35ep-2 +-0x1.7142bp-2 +-0x1.64e6bep-2 +-0x1.e4ebeep-2 +-0x1.e28642p-2 +0x0p+0 +-0x1.bebd36p+1 +-0x1.cfddecp+3 +-0x1.beb712p+1 +-0x1.1d026p+4 +-0x1.5cf18cp-4 +-0x1.18c1dcp+5 +-0x1.5b87a2p-4 +-0x1.d7bf88p+4 +-0x1.7122bcp-3 +-0x1.d77cf6p+4 +-0x1.70bf0ap-3 +-0x1.319b34p+4 +-0x1.83f77ap+1 +-0x1.532d36p+3 +-0x1.83feb2p+1 +-0x1.462852p+4 +-0x1.90d452p+1 +-0x1.14cdd6p+4 +-0x1.90dd88p+1 +-0x1.934a3p+4 +-0x1.8dafe6p-3 +-0x1.2f9ed8p+3 +-0x1.8d5f98p-3 +-0x1.09de76p+5 +-0x1.a04fd8p+1 +-0x1.30410ap+4 +-0x1.a0590ep+1 +-0x1.60836ap+3 +-0x1.8ec81ap+3 +-0x1.f7fcecp+2 +-0x1.8ec9dcp+3 +-0x1.1e8f1cp+4 +-0x1.4b0af6p+3 +-0x1.11dac8p+4 +-0x1.4b0a1p+3 +-0x1.6ab19cp+1 +-0x1.73663p+1 +-0x1.f3177ap+4 +-0x1.736d1cp+1 +-0x1.29a498p+4 +-0x1.51c662p+0 +-0x1.29a498p+4 +-0x1.51d676p+0 +-0x1.724d32p+1 +-0x1.51da64p+0 +-0x1.724f3p+1 +-0x1.51dd2cp+0 +0x1.ee26p-3 +-0x1.51dd2cp+0 +0x1.049662p-2 +-0x1.51dd2cp+0 +0x1.049662p-2 +-0x1.51cedcp+0 +0x1.681e1p+3 +-0x1.51ce98p+0 +0x1.681dfap+3 +0x1.045cecp-2 +-0x1.381a58p+5 +0x1.046058p-2 +-0x1.381a7p+5 +0x1.046058p-2 +0x1.3e2f0ap+2 +0x1.046058p-2 +0x1.3e2f0ap+2 +0x1.04761p-2 +0x1.09bd24p-2 +0x1.04761p-2 +0x1.09bd24p-2 +0x1.09d7c6p-2 +0x1.09bf96p-2 +0x1.09bc0ep-2 +0x1.09bb5p-2 +0x1.3e2daep+2 +0x1.09b41ap-2 +0x1.3e2d8ap+2 +0x1.09b448p-2 +-0x1.cf47c4p+4 +0x1.0f0148p-2 +-0x1.888f22p+5 +0x1.0ed64cp-2 +0x1.9a8fecp+3 +0x1.0ebdcap-2 +0x1.9a8f12p+3 +0x1.0ec67ap-2 +0x1.09c7dep-2 +0x1.0eccbp-2 +0x1.09c7dep-2 +0x1.0eccbp-2 +-0x1.b7636ep+5 +0x1.15b3b6p-2 +-0x1.4c9406p+0 +0x1.15f2ep-2 +-0x1.4c9bc6p+0 +0x1.15f29ap-2 +-0x1.b7636ep+5 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +0x1.9a915cp+3 +0x1.09c7dep-2 +0x1.9a9154p+3 +0x1.09c7dep-2 +0x1.9a9154p+3 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +0x1.3e2ea8p+2 +0x1.09f006p-2 +0x1.3e2ea8p+2 +0x1.09f006p-2 +-0x1.381a7p+5 +0x1.3e2ea8p+2 +-0x1.381a7p+5 +0x1.3e2ea8p+2 +-0x1.f3177ap+4 +0x1.ee26p-3 +-0x1.f316bap+4 +0x1.f2915p-3 +-0x1.29a492p+4 +0x1.f3d4dp-3 +-0x1.29a562p+4 +0x1.f61bc2p-3 +-0x1.f316b6p+4 +0x1.448606p-3 +-0x1.f31806p+4 +0x1.3ccc7p-3 +-0x1.1e8f1cp+4 +0x1.3ccc7p-3 +-0x1.11dac8p+4 +0x1.4631dap-3 +-0x1.11dc5ap+4 +0x1.4d039p-3 +-0x1.f7fcecp+2 +0x1.e124ccp-7 +-0x1.f80034p+2 +0x1.08cf36p-6 +-0x1.60836ap+3 +0x1.93cafep-7 +-0x1.607da4p+3 +0x1.277104p-6 +-0x1.1e9078p+4 +0x1.3b3e4p-6 +-0x1.607dfap+3 +-0x1.2ae23p-3 +-0x1.6080b4p+3 +-0x1.366e16p-3 +-0x1.30410ap+4 +-0x1.3a202ep-3 +-0x1.3043ep+4 +-0x1.34d7b8p-3 +-0x1.2779b8p+4 +-0x1.10613p-2 +-0x1.319b34p+4 +-0x1.0f33ccp-2 +-0x1.319c54p+4 +-0x1.0bf4ecp-2 +-0x1.d77cf6p+4 +-0x1.0c0ceap-2 +-0x1.1d026p+4 +-0x1.7fd80cp-2 +-0x1.1cfc6p+4 +-0x1.704d02p-2 +-0x1.cfddecp+3 +-0x1.704d02p-2 +-0x1.cfdfe2p+3 +-0x1.6fe6cep-2 +-0x1.2779b8p+4 +-0x1.70df2cp-2 +-0x1.1cfc6p+4 +-0x1.e30502p-2 +-0x1.1cfc9cp+4 +-0x1.e4ad4ap-2 +-0x1.1cfc9cp+4 +-0x1.d7bf88p+4 +-0x1.1cff54p+4 +-0x1.18c1dcp+5 +-0x1.1d026ep+4 +-0x1.18c0bap+5 +-0x1.d77dd4p+4 +-0x1.2f9ed8p+3 +-0x1.d77eaep+4 +-0x1.532d36p+3 +-0x1.304164p+4 +-0x1.5330a8p+3 +-0x1.3040cap+4 +-0x1.462852p+4 +-0x1.14cdd6p+4 +-0x1.46292cp+4 +-0x1.14cdd6p+4 +-0x1.f7f132p+2 +-0x1.14ce26p+4 +-0x1.f7f284p+2 +-0x1.14ce62p+4 +-0x1.608124p+3 +-0x1.14cf52p+4 +-0x1.607f46p+3 +-0x1.934a3p+4 +-0x1.f7f352p+2 +-0x1.319b3ep+4 +-0x1.2f9d8p+3 +-0x1.2779b8p+4 +-0x1.09de76p+5 +-0x1.319bacp+4 +-0x1.09de98p+5 +-0x1.319b12p+4 +-0x1.09de82p+5 +-0x1.6082a2p+3 +-0x1.f7fd26p+2 +-0x1.6081c8p+3 +-0x1.f7feb4p+2 +0x1.488f0cp+3 +-0x1.11da56p+4 +-0x1.1e8ee4p+4 +-0x1.6ab19cp+1 +-0x1.3372e8p+2 +0x1.48919ap+3 +0x1.48906ep+3 +-0x1.f31806p+4 +-0x1.3372e8p+2 +-0x1.f31804p+4 +-0x1.7250aep+1 +-0x1.29a4dcp+4 +-0x1.7253c6p+1 +-0x1.29a4dap+4 +0x1.0eccbp-2 +0x1.09b198p-2 +0x1.09eb2ep-2 +0x1.f486aap-3 +0x1.15eef2p-2 +0x1.0de388p-2 +0x0p+0 +0x1.154c76p-2 +0x1.fb59dcp-3 +0x1.49f0c6p-3 +0x1.6433a2p-3 +0x1.bfab26p-7 +0x1.23231p-5 +-0x1.3ed97ep-3 +-0x1.10d264p-3 +-0x1.1741b2p-2 +-0x1.03af24p-2 +-0x1.7168cep-2 +-0x1.65052p-2 +-0x1.e4ad4ap-2 +-0x1.e271dap-2 +0x0p+0 +-0x1.bebf5ap+1 +-0x1.cfdf1cp+3 +-0x1.beb954p+1 +-0x1.1d0172p+4 +-0x1.5c6d5ep-4 +-0x1.18c164p+5 +-0x1.5afeccp-4 +-0x1.d7bf0ep+4 +-0x1.710abcp-3 +-0x1.d77cfap+4 +-0x1.70a6a2p-3 +-0x1.319b12p+4 +-0x1.83f9aep+1 +-0x1.532d36p+3 +-0x1.8400b4p+1 +-0x1.46292cp+4 +-0x1.90d43ep+1 +-0x1.14cda4p+4 +-0x1.90dd7ap+1 +-0x1.9349f8p+4 +-0x1.8d9e4ep-3 +-0x1.2f9e3ep+3 +-0x1.8d4caep-3 +-0x1.09de82p+5 +-0x1.a05014p+1 +-0x1.304092p+4 +-0x1.a0590ap+1 +-0x1.608304p+3 +-0x1.8ec808p+3 +-0x1.f7fc02p+2 +-0x1.8ec9c2p+3 +-0x1.1e8e7cp+4 +-0x1.4b0a96p+3 +-0x1.11da52p+4 +-0x1.4b0982p+3 +-0x1.6ab0a6p+1 +-0x1.73680cp+1 +-0x1.f31816p+4 +-0x1.736ed6p+1 +-0x1.29a4dap+4 +-0x1.51ce98p+0 +-0x1.29a4dap+4 +-0x1.51dd76p+0 +-0x1.7253c6p+1 +-0x1.51df9ep+0 +-0x1.7254dep+1 +-0x1.51e106p+0 +0x1.eda3e4p-3 +-0x1.51e106p+0 +0x1.0491a6p-2 +-0x1.51e106p+0 +0x1.0491a6p-2 +-0x1.51d2bcp+0 +0x1.681dfap+3 +-0x1.51d278p+0 +0x1.681de4p+3 +0x1.04584ep-2 +-0x1.381a7p+5 +0x1.045b88p-2 +-0x1.381a86p+5 +0x1.045b88p-2 +0x1.3e2ea8p+2 +0x1.045b88p-2 +0x1.3e2ea8p+2 +0x1.0471b6p-2 +0x1.09d4b8p-2 +0x1.0471b6p-2 +0x1.09d4b8p-2 +0x1.09f006p-2 +0x1.09d73ep-2 +0x1.09cf3p-2 +0x1.09d22cp-2 +0x1.3e2d44p+2 +0x1.09c976p-2 +0x1.3e2d28p+2 +0x1.09c99ap-2 +-0x1.cf47c4p+4 +0x1.0f09d8p-2 +-0x1.888f22p+5 +0x1.0ed86ep-2 +0x1.9a901p+3 +0x1.0ebfc2p-2 +0x1.9a8f12p+3 +0x1.0ec9dap-2 +0x1.09dd76p-2 +0x1.0ed088p-2 +0x1.09dd76p-2 +0x1.0ed088p-2 +-0x1.b7636ep+5 +0x1.159a32p-2 +-0x1.4c9802p+0 +0x1.15dbf8p-2 +-0x1.4ca03ep+0 +0x1.15dbacp-2 +-0x1.b7636ep+5 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +0x1.9a918ap+3 +0x1.09dd76p-2 +0x1.9a9182p+3 +0x1.09dd76p-2 +0x1.9a9182p+3 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +0x1.3e2e9p+2 +0x1.0a035cp-2 +0x1.3e2e9p+2 +0x1.0a035cp-2 +-0x1.381a86p+5 +0x1.3e2e9p+2 +-0x1.381a86p+5 +0x1.3e2e9p+2 +-0x1.f31816p+4 +0x1.eda3e4p-3 +-0x1.f31754p+4 +0x1.f21ee6p-3 +-0x1.29a4d6p+4 +0x1.f36f8p-3 +-0x1.29a5a6p+4 +0x1.f5b7cep-3 +-0x1.f3175p+4 +0x1.45084ap-3 +-0x1.f318ap+4 +0x1.3d5428p-3 +-0x1.1e8e7cp+4 +0x1.3d5428p-3 +-0x1.11da52p+4 +0x1.46c28ap-3 +-0x1.11dbep+4 +0x1.4d7cf8p-3 +-0x1.f7fc02p+2 +0x1.d8fe18p-7 +-0x1.f7ff48p+2 +0x1.04aaf8p-6 +-0x1.608304p+3 +0x1.8c336ep-7 +-0x1.607d4p+3 +0x1.237b04p-6 +-0x1.1e8fdap+4 +0x1.378faep-6 +-0x1.607d96p+3 +-0x1.2ac9d6p-3 +-0x1.608052p+3 +-0x1.365a78p-3 +-0x1.304092p+4 +-0x1.3a102ep-3 +-0x1.304368p+4 +-0x1.34c6fp-3 +-0x1.2779b8p+4 +-0x1.105bd4p-2 +-0x1.319b12p+4 +-0x1.0f2e24p-2 +-0x1.319c32p+4 +-0x1.0bf002p-2 +-0x1.d77cfap+4 +-0x1.0c082ap-2 +-0x1.1d0172p+4 +-0x1.7ffc3p-2 +-0x1.1cfb72p+4 +-0x1.70719p-2 +-0x1.cfdf1cp+3 +-0x1.70719p-2 +-0x1.cfe114p+3 +-0x1.700b08p-2 +-0x1.2779b8p+4 +-0x1.71049ap-2 +-0x1.1cfb72p+4 +-0x1.e2dca8p-2 +-0x1.1cfbaep+4 +-0x1.e48ce8p-2 +-0x1.1cfbaep+4 +-0x1.d7bf0ep+4 +-0x1.1cfe64p+4 +-0x1.18c164p+5 +-0x1.1d017ep+4 +-0x1.18c042p+5 +-0x1.d77dd6p+4 +-0x1.2f9e3ep+3 +-0x1.d77ebp+4 +-0x1.532d36p+3 +-0x1.3040ecp+4 +-0x1.5330a8p+3 +-0x1.304054p+4 +-0x1.46292cp+4 +-0x1.14cda4p+4 +-0x1.462a06p+4 +-0x1.14cda4p+4 +-0x1.f7f062p+2 +-0x1.14cdf2p+4 +-0x1.f7f1bp+2 +-0x1.14ce2ep+4 +-0x1.6080c2p+3 +-0x1.14cf1cp+4 +-0x1.607ee4p+3 +-0x1.9349f8p+4 +-0x1.f7f27cp+2 +-0x1.319b1cp+4 +-0x1.2f9ce8p+3 +-0x1.2779b8p+4 +-0x1.09de82p+5 +-0x1.319b8ap+4 +-0x1.09dea4p+5 +-0x1.319af2p+4 +-0x1.09de8ep+5 +-0x1.60823ep+3 +-0x1.f7fc44p+2 +-0x1.60816ap+3 +-0x1.f7fdc6p+2 +0x1.489036p+3 +-0x1.11d9ep+4 +-0x1.1e8e4ep+4 +-0x1.6ab0a6p+1 +-0x1.3372e8p+2 +0x1.48927ep+3 +0x1.4890dep+3 +-0x1.f318ap+4 +-0x1.3372e8p+2 +-0x1.f3189ep+4 +-0x1.72559ep+1 +-0x1.29a522p+4 +-0x1.7258d4p+1 +-0x1.29a52p+4 +0x1.0ed088p-2 +0x1.09c636p-2 +0x1.0a0136p-2 +0x1.f427aap-3 +0x1.15d7e8p-2 +0x1.0dec3p-2 +0x0p+0 +0x1.1536d8p-2 +0x1.fb1e6p-3 +0x1.4a6eap-3 +0x1.648944p-3 +0x1.bb9392p-7 +0x1.21f526p-5 +-0x1.3ec68cp-3 +-0x1.10e836p-3 +-0x1.173ae8p-2 +-0x1.03aabep-2 +-0x1.718c48p-2 +-0x1.65255p-2 +-0x1.e48ce8p-2 +-0x1.e260d4p-2 +0x0p+0 +-0x1.bec1a8p+1 +-0x1.cfe04ep+3 +-0x1.bebb96p+1 +-0x1.1d0082p+4 +-0x1.5be31cp-4 +-0x1.18c0ecp+5 +-0x1.5a745cp-4 +-0x1.d7be94p+4 +-0x1.70f3aep-3 +-0x1.d77cfcp+4 +-0x1.708f0ep-3 +-0x1.319af2p+4 +-0x1.83fbd6p+1 +-0x1.532d3ap+3 +-0x1.8402cep+1 +-0x1.462a06p+4 +-0x1.90d45ap+1 +-0x1.14cd7p+4 +-0x1.90dd88p+1 +-0x1.9349c2p+4 +-0x1.8d8c84p-3 +-0x1.2f9da6p+3 +-0x1.8d3aacp-3 +-0x1.09de8ep+5 +-0x1.a0500ep+1 +-0x1.30401cp+4 +-0x1.a05906p+1 +-0x1.60829ep+3 +-0x1.8ec7eep+3 +-0x1.f7fb24p+2 +-0x1.8ec9a6p+3 +-0x1.1e8de6p+4 +-0x1.4b0a3p+3 +-0x1.11d9dcp+4 +-0x1.4b090ep+3 +-0x1.6aafbp+1 +-0x1.73696ep+1 +-0x1.f318bp+4 +-0x1.73705ap+1 +-0x1.29a52p+4 +-0x1.51d278p+0 +0x1.681de4p+3 +0x1.048e36p-2 +0x1.09eb28p-2 +0x1.0f0dcap-2 +0x1.15834ep-2 +0x0p+0 +-0x1.4c9c5ep+0 +-0x1.b7636ep+5 +0x1.9a9052p+3 +-0x1.888f22p+5 +-0x1.cf47c4p+4 +0x1.0a035cp-2 +0x1.3e2e9p+2 +-0x1.381a86p+5 +0x1.ed6978p-3 +0x1.452f42p-3 +0x1.d5309cp-7 +-0x1.2acbeep-3 +-0x1.105386p-2 +-0x1.8013a4p-2 +-0x1.e2bef6p-2 +-0x1.cfe04ep+3 +-0x1.bec3f2p+1 +-0x1.1d0082p+4 +-0x1.18c0ecp+5 +-0x1.5b57d2p-4 +-0x1.d7be94p+4 +-0x1.d77cfcp+4 +-0x1.70dc0cp-3 +-0x1.532d3ap+3 +-0x1.83fdfp+1 +-0x1.462a06p+4 +-0x1.14cd7p+4 +-0x1.90d474p+1 +-0x1.9349c2p+4 +-0x1.2f9da6p+3 +-0x1.8d7a96p-3 +-0x1.09de8ep+5 +-0x1.319af2p+4 +-0x1.2779b8p+4 +-0x1.30401cp+4 +-0x1.a05002p+1 +-0x1.60829ep+3 +-0x1.f7fb24p+2 +-0x1.8ec7d6p+3 +-0x1.11d9dcp+4 +-0x1.4b09c2p+3 +-0x1.6aafbp+1 +0x1.4890a6p+3 +-0x1.3372e8p+2 +-0x1.1e8de6p+4 +-0x1.f318bp+4 +-0x1.736ae8p+1 +-0x1.7258d4p+1 +-0x1.29a52p+4 +-0x1.514c1ap+0 +0x1.682b48p+3 +-0x1.7245d8p+1 +0x1.48968cp+3 +0x1.06155ap-2 +-0x1.3817cp+5 +0x1.3e4166p+2 +0x1.0addcep-2 +0x1.9a9b64p+3 +-0x1.4c5e46p+0 +-0x1.b756ep+5 +-0x1.cf50cap+4 +-0x1.888a94p+5 +-0x1.277fc4p+4 +-0x1.33304p+2 +-0x1.91077cp+1 +-0x1.14d45ap+4 +-0x1.93509ap+4 +-0x1.735446p-3 +-0x1.d781a6p+4 +-0x1.31a006p+4 +-0x1.bee98cp+1 +-0x1.1d094ap+4 +-0x1.cfe81ep+3 +-0x1.63dde4p-4 +-0x1.18c552p+5 +-0x1.d7c814p+4 +-0x1.8ffdfp-3 +-0x1.2fa802p+3 +-0x1.09e0cp+5 +-0x1.a0894ap+1 +-0x1.30480ep+4 +-0x1.609094p+3 +-0x1.734f96p+1 +-0x1.f31254p+4 +-0x1.29a2aep+4 +-0x1.842ad6p+1 +-0x1.53376cp+3 +-0x1.462f18p+4 +-0x1.8edb74p+3 +-0x1.1e937p+4 +-0x1.f81784p+2 +-0x1.4b0bdap+3 +-0x1.6a2e1cp+1 +-0x1.11d4d4p+4 +0x1.1687b8p-2 +0x1.10458ep-2 +0x1.0b1e5ep-2 +0x1.ef6a7ep-3 +0x1.4639b8p-3 +0x1.aa5654p-7 +-0x1.2dd16cp-3 +-0x1.118f74p-2 +-0x1.81137cp-2 +-0x1.e30946p-2 +0x0p+0 +0x1.aa5654p-7 +0x0p+0 +0x1.d5309cp-7 +0x0p+0 +0x1.168ee6p+2 +0x0p+0 +0x1.169e86p+2 +0x0p+0 +0x1.06155ap-2 +0x0p+0 +0x1.048e36p-2 +0x0p+0 +0x1.a19998p+0 +0x0p+0 +0x1.a007d8p+0 +0x0p+0 +0x1.3f0824p+2 +0x0p+0 +0x1.3ef89ep+2 +0x0p+0 +0x1.3ab6ccp+1 +0x0p+0 +0x1.3afefcp+1 +0x0p+0 +0x1.32a44p+0 +0x0p+0 +0x1.32128p+0 +0x0p+0 +0x1.86012p-2 +0x0p+0 +0x1.87842p-2 +0x0p+0 +0x1.8c903ep+2 +0x0p+0 +0x1.8cb256p+2 +0x0p+0 +0x1.edf8f8p+0 +0x0p+0 +0x1.ee90f8p+0 +0x0p+0 +0x1.4d2768p+1 +0x0p+0 +0x1.4d6dc8p+1 +0x0p+0 +0x1.868514p+2 +0x0p+0 +0x1.8698d6p+2 +0x0p+0 +0x1.81fecp+2 +0x0p+0 +0x1.82131p+2 +0x0p+0 +0x1.0b1e5ep-2 +0x0p+0 +0x1.09eb28p-2 +0x0p+0 +0x1.08e7e8p+0 +0x0p+0 +0x1.097468p+0 +0x0p+0 +0x1.f25fd8p+0 +0x0p+0 +0x1.f2aa78p+0 +0x0p+0 +0x1.6555ep+1 +0x0p+0 +0x1.657b7ap+1 +0x0p+0 +0x1.7a0e7ep+2 +0x0p+0 +0x1.7a1e7cp+2 +0x0p+0 +0x1.8106bep+2 +0x0p+0 +0x1.811a7ep+2 +0x0p+0 +0x1.10458ep-2 +0x0p+0 +0x1.0f0dcap-2 +0x0p+0 +0x1.7a0e7ep+2 +0x0p+0 +0x1.7a1e7cp+2 +-0x1.51d278p+0 +-0x1.29a52p+4 +-0x1.51d278p+0 +-0x1.7258d4p+1 +-0x1.51d278p+0 +0x1.ed6978p-3 +-0x1.51d278p+0 +0x1.048e36p-2 +-0x1.51d278p+0 +0x1.09eb28p-2 +-0x1.51d278p+0 +0x1.681de4p+3 +0x1.681de4p+3 +0x1.048e36p-2 +0x1.0a035cp-2 +0x1.09eb28p-2 +0x1.3e2e9p+2 +0x1.09eb28p-2 +0x1.048e36p-2 +0x1.09eb28p-2 +-0x1.cf47c4p+4 +0x1.0f0dcap-2 +-0x1.888f22p+5 +0x1.0f0dcap-2 +0x1.9a9052p+3 +0x1.0f0dcap-2 +0x1.0a035cp-2 +0x1.0f0dcap-2 +-0x1.b7636ep+5 +0x1.15834ep-2 +-0x1.4c9c5ep+0 +0x1.15834ep-2 +-0x1.b7636ep+5 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +0x1.9a9052p+3 +0x1.0a035cp-2 +0x1.9a9052p+3 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +-0x1.381a86p+5 +0x1.3e2e9p+2 +0x1.3e2e9p+2 +0x1.0a035cp-2 +0x1.048e36p-2 +0x1.3e2e9p+2 +0x1.048e36p-2 +-0x1.381a86p+5 +-0x1.f318bp+4 +0x1.ed6978p-3 +-0x1.29a52p+4 +0x1.ed6978p-3 +-0x1.f318bp+4 +0x1.452f42p-3 +-0x1.1e8de6p+4 +0x1.452f42p-3 +-0x1.11d9dcp+4 +0x1.452f42p-3 +-0x1.f7fb24p+2 +0x1.d5309cp-7 +-0x1.60829ep+3 +0x1.d5309cp-7 +-0x1.1e8de6p+4 +0x1.d5309cp-7 +-0x1.60829ep+3 +-0x1.2acbeep-3 +-0x1.30401cp+4 +-0x1.2acbeep-3 +-0x1.2779b8p+4 +-0x1.105386p-2 +-0x1.319af2p+4 +-0x1.105386p-2 +-0x1.d77cfcp+4 +-0x1.105386p-2 +-0x1.1d0082p+4 +-0x1.8013a4p-2 +-0x1.cfe04ep+3 +-0x1.8013a4p-2 +-0x1.2779b8p+4 +-0x1.8013a4p-2 +-0x1.1d0082p+4 +-0x1.e2bef6p-2 +-0x1.1d0082p+4 +-0x1.d7be94p+4 +-0x1.1d0082p+4 +-0x1.18c0ecp+5 +-0x1.d77cfcp+4 +-0x1.2f9da6p+3 +-0x1.d77cfcp+4 +-0x1.532d3ap+3 +-0x1.30401cp+4 +-0x1.532d3ap+3 +-0x1.30401cp+4 +-0x1.462a06p+4 +-0x1.14cd7p+4 +-0x1.462a06p+4 +-0x1.14cd7p+4 +-0x1.f7fb24p+2 +-0x1.14cd7p+4 +-0x1.60829ep+3 +-0x1.9349c2p+4 +-0x1.f7fb24p+2 +-0x1.319af2p+4 +-0x1.2f9da6p+3 +-0x1.2779b8p+4 +-0x1.09de8ep+5 +-0x1.319af2p+4 +-0x1.09de8ep+5 +-0x1.60829ep+3 +-0x1.f7fb24p+2 +0x1.4890a6p+3 +-0x1.11d9dcp+4 +-0x1.1e8de6p+4 +-0x1.6aafbp+1 +-0x1.3372e8p+2 +0x1.4890a6p+3 +0x1.4890a6p+3 +-0x1.f318bp+4 +-0x1.3372e8p+2 +-0x1.f318bp+4 +-0x1.7258d4p+1 +-0x1.29a52p+4 +0x1.09eb28p-2 +0x1.0f0dcap-2 +0x1.ed6978p-3 +0x1.09eb28p-2 +0x1.0f0dcap-2 +0x1.15834ep-2 +0x1.15834ep-2 +0x0p+0 +0x1.452f42p-3 +0x1.ed6978p-3 +0x1.d5309cp-7 +0x1.452f42p-3 +-0x1.2acbeep-3 +0x1.d5309cp-7 +-0x1.105386p-2 +-0x1.2acbeep-3 +-0x1.8013a4p-2 +-0x1.105386p-2 +-0x1.e2bef6p-2 +-0x1.8013a4p-2 +0x0p+0 +-0x1.e2bef6p-2 +-0x1.cfe04ep+3 +-0x1.bec3f2p+1 +-0x1.1d0082p+4 +-0x1.bec3f2p+1 +-0x1.18c0ecp+5 +-0x1.5b57d2p-4 +-0x1.d7be94p+4 +-0x1.5b57d2p-4 +-0x1.d77cfcp+4 +-0x1.70dc0cp-3 +-0x1.319af2p+4 +-0x1.70dc0cp-3 +-0x1.532d3ap+3 +-0x1.83fdfp+1 +-0x1.462a06p+4 +-0x1.83fdfp+1 +-0x1.14cd7p+4 +-0x1.90d474p+1 +-0x1.9349c2p+4 +-0x1.90d474p+1 +-0x1.2f9da6p+3 +-0x1.8d7a96p-3 +-0x1.09de8ep+5 +-0x1.8d7a96p-3 +-0x1.30401cp+4 +-0x1.a05002p+1 +-0x1.60829ep+3 +-0x1.a05002p+1 +-0x1.f7fb24p+2 +-0x1.8ec7d6p+3 +-0x1.1e8de6p+4 +-0x1.8ec7d6p+3 +-0x1.11d9dcp+4 +-0x1.4b09c2p+3 +-0x1.6aafbp+1 +-0x1.4b09c2p+3 +-0x1.f318bp+4 +-0x1.736ae8p+1 +-0x1.29a52p+4 +-0x1.736ae8p+1 +-0x1.520d5ap+0 +-0x1.29a67cp+4 +-0x1.52271ap+0 +-0x1.29a674p+4 +-0x1.52271ap+0 +-0x1.7263bap+1 +-0x1.522d44p+0 +-0x1.7266dap+1 +-0x1.5231d6p+0 +0x1.ecbd0ep-3 +-0x1.5231d6p+0 +0x1.030ad8p-2 +-0x1.5231d6p+0 +0x1.030ad8p-2 +-0x1.521d14p+0 +0x1.083df8p-2 +-0x1.521d14p+0 +0x1.681688p+3 +-0x1.521cacp+0 +0x1.681668p+3 +0x1.681668p+3 +0x1.02b79ap-2 +0x1.08aaeep-2 +0x1.083df8p-2 +0x1.0893a2p-2 +0x1.083a6p-2 +0x1.3e15ep+2 +0x1.08386ap-2 +0x1.3e15c4p+2 +0x1.08388ep-2 +0x1.02b79ap-2 +0x1.0835e8p-2 +0x1.02b79ap-2 +0x1.0835e8p-2 +-0x1.cf3b28p+4 +0x1.0d925ap-2 +-0x1.889556p+5 +0x1.0d7da2p-2 +0x1.9a8768p+3 +0x1.0d630ep-2 +0x1.9a868ep+3 +0x1.0d6bb6p-2 +0x1.0896d6p-2 +0x1.0d70a6p-2 +0x1.0896d6p-2 +0x1.0d70a6p-2 +-0x1.b771acp+5 +0x1.14c03ap-2 +-0x1.4ccd24p+0 +0x1.1503cep-2 +-0x1.4cd5a2p+0 +0x1.15038p-2 +-0x1.b771acp+5 +-0x1.cf3b28p+4 +-0x1.889556p+5 +0x1.9a8864p+3 +0x1.0896d6p-2 +0x1.9a884ep+3 +0x1.0896d6p-2 +0x1.9a884ep+3 +-0x1.cf3b28p+4 +-0x1.889556p+5 +-0x1.381d8cp+5 +0x1.3e16dep+2 +-0x1.381d8cp+5 +0x1.3e16dep+2 +0x1.3e16dep+2 +0x1.08d146p-2 +0x1.3e16dep+2 +0x1.08d146p-2 +0x1.02d4fp-2 +0x1.3e16dep+2 +0x1.02d4fp-2 +0x1.3e16dep+2 +0x1.02ece8p-2 +-0x1.381d8cp+5 +0x1.02f04ap-2 +-0x1.381da4p+5 +-0x1.f31d92p+4 +0x1.ecbd0ep-3 +-0x1.f31cdp+4 +0x1.f13462p-3 +-0x1.29a674p+4 +0x1.f26998p-3 +-0x1.29a746p+4 +0x1.f4b51cp-3 +-0x1.f31cccp+4 +0x1.41cdaap-3 +-0x1.f31e16p+4 +0x1.3a3e3p-3 +-0x1.1e8a8ap+4 +0x1.3a3e3p-3 +-0x1.11e082p+4 +0x1.43c646p-3 +-0x1.11e20cp+4 +0x1.4a744cp-3 +-0x1.f7dffep+2 +0x1.0f4a98p-6 +-0x1.f7e33ap+2 +0x1.27274ep-6 +-0x1.60750ap+3 +0x1.d03b56p-7 +-0x1.606f4cp+3 +0x1.450054p-6 +-0x1.1e8becp+4 +0x1.58273ap-6 +-0x1.606fap+3 +-0x1.276078p-3 +-0x1.60725ap+3 +-0x1.32e9dcp-3 +-0x1.303912p+4 +-0x1.36a57ep-3 +-0x1.303beap+4 +-0x1.315c7cp-3 +-0x1.27739p+4 +-0x1.0f291ep-2 +-0x1.31962cp+4 +-0x1.0dfad4p-2 +-0x1.31974cp+4 +-0x1.0abdcep-2 +-0x1.d7789cp+4 +-0x1.0ad616p-2 +-0x1.1cfadep+4 +-0x1.7ed5bp-2 +-0x1.1cf4dcp+4 +-0x1.6f4dd8p-2 +-0x1.cfd578p+3 +-0x1.6f4dd8p-2 +-0x1.cfd76ep+3 +-0x1.6ee784p-2 +-0x1.27739p+4 +-0x1.6fdebap-2 +-0x1.1cf4dcp+4 +-0x1.e2fb0cp-2 +-0x1.1cf518p+4 +-0x1.e4a696p-2 +-0x1.1cf518p+4 +-0x1.d7b6b6p+4 +-0x1.1cf7d4p+4 +-0x1.18be1ap+5 +-0x1.1cfaeep+4 +-0x1.18bcf8p+5 +-0x1.d77978p+4 +-0x1.2f949ep+3 +-0x1.d77a4ep+4 +-0x1.5323a4p+3 +-0x1.30397p+4 +-0x1.53271p+3 +-0x1.3038d6p+4 +-0x1.4622c8p+4 +-0x1.14c6a2p+4 +-0x1.4623a4p+4 +-0x1.14c6a2p+4 +-0x1.f7d444p+2 +-0x1.14c6fp+4 +-0x1.f7d59p+2 +-0x1.14c72ap+4 +-0x1.6072ccp+3 +-0x1.14c818p+4 +-0x1.6070fp+3 +-0x1.93430ep+4 +-0x1.f7d65ap+2 +-0x1.319638p+4 +-0x1.2f934ep+3 +-0x1.27739p+4 +-0x1.09dc2ap+5 +-0x1.3196a6p+4 +-0x1.09dc4cp+5 +-0x1.31960ep+4 +-0x1.09dc36p+5 +-0x1.607446p+3 +-0x1.f7e012p+2 +-0x1.607376p+3 +-0x1.f7e18ep+2 +0x1.4885aap+3 +-0x1.11e01p+4 +-0x1.1e8a66p+4 +-0x1.6b26c8p+1 +-0x1.33ba3ap+2 +0x1.488868p+3 +0x1.488868p+3 +-0x1.f31e16p+4 +-0x1.33ba3ap+2 +-0x1.f31e14p+4 +-0x1.72694ep+1 +-0x1.29a6c4p+4 +-0x1.726c2ep+1 +-0x1.29a6c2p+4 +0x1.0d70a6p-2 +0x1.08388p-2 +0x1.08960cp-2 +0x1.f325b4p-3 +0x1.14ffaep-2 +0x1.0ca814p-2 +0x0p+0 +0x1.14547ep-2 +0x1.f9b26p-3 +0x1.4768b2p-3 +0x1.61a056p-3 +0x1.ff649cp-7 +0x1.2f733ep-5 +-0x1.3b543cp-3 +-0x1.0db0ccp-3 +-0x1.160794p-2 +-0x1.02867cp-2 +-0x1.7066b8p-2 +-0x1.64058p-2 +-0x1.e4a696p-2 +-0x1.e2331p-2 +0x0p+0 +-0x1.be9936p+1 +-0x1.cfd6aap+3 +-0x1.be9326p+1 +-0x1.1cf9f2p+4 +-0x1.54b5fap-4 +-0x1.18bda2p+5 +-0x1.534c3ap-4 +-0x1.d7b63cp+4 +-0x1.6e90eep-3 +-0x1.d7789cp+4 +-0x1.6e2cb4p-3 +-0x1.31960ep+4 +-0x1.83cb82p+1 +-0x1.5323a2p+3 +-0x1.83d2c6p+1 +-0x1.4623a4p+4 +-0x1.909f1cp+1 +-0x1.14c66ep+4 +-0x1.90a726p+1 +-0x1.9342d8p+4 +-0x1.8b1f5p-3 +-0x1.2f940cp+3 +-0x1.8ad038p-3 +-0x1.09dc36p+5 +-0x1.a0173p+1 +-0x1.30389ep+4 +-0x1.a02098p+1 +-0x1.6074a4p+3 +-0x1.8eb3f8p+3 +-0x1.f7defap+2 +-0x1.8eb5eep+3 +-0x1.1e89fcp+4 +-0x1.4b080ep+3 +-0x1.11e00cp+4 +-0x1.4b072ep+3 +-0x1.6b25d6p+1 +-0x1.738272p+1 +-0x1.f31e26p+4 +-0x1.738972p+1 +-0x1.29a6c2p+4 +-0x1.521cacp+0 +-0x1.29a6c2p+4 +-0x1.523396p+0 +-0x1.29a6bap+4 +-0x1.523396p+0 +-0x1.726c2ep+1 +-0x1.52370ap+0 +-0x1.726deep+1 +-0x1.52398p+0 +0x1.ec2de6p-3 +-0x1.52398p+0 +0x1.02f04ap-2 +-0x1.52398p+0 +0x1.02f04ap-2 +-0x1.5224fp+0 +0x1.08888ap-2 +-0x1.5224fp+0 +0x1.681668p+3 +-0x1.522484p+0 +0x1.681646p+3 +0x1.681646p+3 +0x1.029dd8p-2 +0x1.08d146p-2 +0x1.08888ap-2 +0x1.08a9fap-2 +0x1.088278p-2 +0x1.3e155cp+2 +0x1.087a06p-2 +0x1.3e155cp+2 +0x1.087a06p-2 +0x1.029dd8p-2 +0x1.0875ap-2 +0x1.029dd8p-2 +0x1.0875ap-2 +-0x1.cf3b28p+4 +0x1.0dd192p-2 +-0x1.889556p+5 +0x1.0daffp-2 +0x1.9a8678p+3 +0x1.0d954ap-2 +0x1.9a85dap+3 +0x1.0d9b96p-2 +0x1.08b7c4p-2 +0x1.0da0fep-2 +0x1.08b7c4p-2 +0x1.0da0fep-2 +-0x1.b771acp+5 +0x1.14a7f8p-2 +-0x1.4cd1b2p+0 +0x1.14ee06p-2 +-0x1.4cdaa8p+0 +0x1.14edb4p-2 +-0x1.b771acp+5 +-0x1.cf3b28p+4 +-0x1.889556p+5 +0x1.9a87dcp+3 +0x1.08b7c4p-2 +0x1.9a87c8p+3 +0x1.08b7c4p-2 +0x1.9a87c8p+3 +-0x1.cf3b28p+4 +-0x1.889556p+5 +-0x1.381da4p+5 +0x1.3e172ep+2 +-0x1.381da4p+5 +0x1.3e172ep+2 +0x1.3e172ep+2 +0x1.08eeap-2 +0x1.3e172ep+2 +0x1.08eeap-2 +0x1.02bc1ep-2 +0x1.3e172ep+2 +0x1.02bc1ep-2 +0x1.3e172ep+2 +0x1.02d73cp-2 +-0x1.381da4p+5 +0x1.02da96p-2 +-0x1.381dbcp+5 +-0x1.f31e26p+4 +0x1.ec2de6p-3 +-0x1.f31d62p+4 +0x1.f0b06ap-3 +-0x1.29a6bap+4 +0x1.f1f06ep-3 +-0x1.29a78cp+4 +0x1.f4399p-3 +-0x1.f31d5ep+4 +0x1.4376a6p-3 +-0x1.f31eaap+4 +0x1.3bd23ep-3 +-0x1.1e89fcp+4 +0x1.3bd23ep-3 +-0x1.11e00cp+4 +0x1.45565cp-3 +-0x1.11e18cp+4 +0x1.4bd05ap-3 +-0x1.f7defap+2 +0x1.072124p-6 +-0x1.f7e23ep+2 +0x1.1f2da8p-6 +-0x1.6074a4p+3 +0x1.c15b7ap-7 +-0x1.606ee2p+3 +0x1.3da214p-6 +-0x1.1e8b6p+4 +0x1.518154p-6 +-0x1.606f38p+3 +-0x1.27ef6cp-3 +-0x1.6071ecp+3 +-0x1.336698p-3 +-0x1.30389ep+4 +-0x1.3711c8p-3 +-0x1.303b7ap+4 +-0x1.31c52p-3 +-0x1.27739p+4 +-0x1.0f2708p-2 +-0x1.31960ep+4 +-0x1.0df9c4p-2 +-0x1.31972ep+4 +-0x1.0abd3ep-2 +-0x1.d7789cp+4 +-0x1.0ad55ep-2 +-0x1.1cf9f2p+4 +-0x1.7eee66p-2 +-0x1.1cf3fp+4 +-0x1.6f68e2p-2 +-0x1.cfd6aap+3 +-0x1.6f68e2p-2 +-0x1.cfd8a2p+3 +-0x1.6f0298p-2 +-0x1.27739p+4 +-0x1.6ffb72p-2 +-0x1.1cf3fp+4 +-0x1.e2acb6p-2 +-0x1.1cf42ep+4 +-0x1.e46898p-2 +-0x1.1cf42ep+4 +-0x1.d7b63cp+4 +-0x1.1cf6e6p+4 +-0x1.18bda2p+5 +-0x1.1cfap+4 +-0x1.18bc8p+5 +-0x1.d77978p+4 +-0x1.2f940cp+3 +-0x1.d77a4ep+4 +-0x1.5323a2p+3 +-0x1.303904p+4 +-0x1.532712p+3 +-0x1.30386cp+4 +-0x1.4623a4p+4 +-0x1.14c66ep+4 +-0x1.46248p+4 +-0x1.14c66ep+4 +-0x1.f7d36ep+2 +-0x1.14c6b8p+4 +-0x1.f7d4aap+2 +-0x1.14c6fp+4 +-0x1.60725cp+3 +-0x1.14c7dep+4 +-0x1.607082p+3 +-0x1.9342d8p+4 +-0x1.f7d56ap+2 +-0x1.31961cp+4 +-0x1.2f92bep+3 +-0x1.27739p+4 +-0x1.09dc36p+5 +-0x1.31968ap+4 +-0x1.09dc58p+5 +-0x1.3195fp+4 +-0x1.09dc42p+5 +-0x1.6073d6p+3 +-0x1.f7df1ap+2 +-0x1.607312p+3 +-0x1.f7e07ep+2 +0x1.48882cp+3 +-0x1.11df92p+4 +-0x1.1e89e2p+4 +-0x1.6b25d6p+1 +-0x1.33ba3ap+2 +0x1.488a82p+3 +0x1.488a38p+3 +-0x1.f31eaap+4 +-0x1.33ba3ap+2 +-0x1.f31ea8p+4 +-0x1.726f4p+1 +-0x1.29a70ep+4 +-0x1.72722ap+1 +-0x1.29a70cp+4 +0x1.0da0fep-2 +0x1.08784cp-2 +0x1.08b138p-2 +0x1.f2b4dap-3 +0x1.14e9a8p-2 +0x1.0cb69ep-2 +0x0p+0 +0x1.143b8p-2 +0x1.f96f8ap-3 +0x1.48c622p-3 +0x1.6272b2p-3 +0x1.f5c98cp-7 +0x1.2ca1ap-5 +-0x1.3bb39ep-3 +-0x1.0dd8b8p-3 +-0x1.160432p-2 +-0x1.0286aap-2 +-0x1.70821cp-2 +-0x1.641d62p-2 +-0x1.e46898p-2 +-0x1.e21fb6p-2 +0x0p+0 +-0x1.be9b7p+1 +-0x1.cfd7dcp+3 +-0x1.be9566p+1 +-0x1.1cf902p+4 +-0x1.543214p-4 +-0x1.18bd2cp+5 +-0x1.52c244p-4 +-0x1.d7b5c2p+4 +-0x1.6e7828p-3 +-0x1.d7789cp+4 +-0x1.6e134ep-3 +-0x1.3195fp+4 +-0x1.83cdc2p+1 +-0x1.5323a8p+3 +-0x1.83d4bcp+1 +-0x1.46248p+4 +-0x1.909e38p+1 +-0x1.14c634p+4 +-0x1.90a746p+1 +-0x1.9342a2p+4 +-0x1.8b0e5cp-3 +-0x1.2f937ep+3 +-0x1.8abe0ap-3 +-0x1.09dc42p+5 +-0x1.a0178ap+1 +-0x1.303834p+4 +-0x1.a0208ep+1 +-0x1.607432p+3 +-0x1.8eb40ep+3 +-0x1.f7de08p+2 +-0x1.8eb5cep+3 +-0x1.1e897cp+4 +-0x1.4b07aep+3 +-0x1.11df8ep+4 +-0x1.4b06a2p+3 +-0x1.6b24ecp+1 +-0x1.73847cp+1 +-0x1.f31ebap+4 +-0x1.738b36p+1 +-0x1.29a70cp+4 +-0x1.522484p+0 +-0x1.29a70cp+4 +-0x1.523a4p+0 +-0x1.29a704p+4 +-0x1.523a4p+0 +-0x1.72722ap+1 +-0x1.523c0ep+0 +-0x1.727314p+1 +-0x1.523d3ap+0 +0x1.eb9f4p-3 +-0x1.523d3ap+0 +0x1.02da96p-2 +-0x1.523d3ap+0 +0x1.02da96p-2 +-0x1.522926p+0 +0x1.08a7dep-2 +-0x1.522926p+0 +0x1.681646p+3 +-0x1.5228c2p+0 +0x1.681626p+3 +0x1.681626p+3 +0x1.028a1ap-2 +0x1.08eeap-2 +0x1.08a7dep-2 +0x1.08c3b2p-2 +0x1.08a13ap-2 +0x1.3e157ap+2 +0x1.089798p-2 +0x1.3e157ap+2 +0x1.089798p-2 +0x1.028a1ap-2 +0x1.0892d2p-2 +0x1.028a1ap-2 +0x1.0892d2p-2 +-0x1.cf3b28p+4 +0x1.0dd63ep-2 +-0x1.889556p+5 +0x1.0dae96p-2 +0x1.9a860ep+3 +0x1.0d93f8p-2 +0x1.9a854cp+3 +0x1.0d9ba8p-2 +0x1.08d36ep-2 +0x1.0da1c2p-2 +0x1.08d36ep-2 +0x1.0da1c2p-2 +-0x1.b771acp+5 +0x1.148e78p-2 +-0x1.4cd67ep+0 +0x1.14d6dp-2 +-0x1.4cdfc2p+0 +0x1.14d67cp-2 +-0x1.b771acp+5 +-0x1.cf3b28p+4 +-0x1.889556p+5 +0x1.9a879p+3 +0x1.08d36ep-2 +0x1.9a878p+3 +0x1.08d36ep-2 +0x1.9a878p+3 +-0x1.cf3b28p+4 +-0x1.889556p+5 +-0x1.381dbcp+5 +0x1.3e1774p+2 +-0x1.381dbcp+5 +0x1.3e1774p+2 +0x1.3e1774p+2 +0x1.090756p-2 +0x1.3e1774p+2 +0x1.090756p-2 +0x1.02a7d4p-2 +0x1.3e1788p+2 +0x1.02a7d4p-2 +0x1.3e1788p+2 +0x1.02c59ap-2 +-0x1.381dbcp+5 +0x1.02c8e4p-2 +-0x1.381dd2p+5 +-0x1.f31ebap+4 +0x1.eb9f4p-3 +-0x1.f31df4p+4 +0x1.f0331ap-3 +-0x1.29a704p+4 +0x1.f1822p-3 +-0x1.29a7d6p+4 +0x1.f3cd0ep-3 +-0x1.f31dfp+4 +0x1.43f7cp-3 +-0x1.f31f3cp+4 +0x1.3c5a56p-3 +-0x1.1e897cp+4 +0x1.3c5a56p-3 +-0x1.11df8ep+4 +0x1.45e794p-3 +-0x1.11e108p+4 +0x1.4c491ep-3 +-0x1.f7de08p+2 +0x1.02ee1p-6 +-0x1.f7e14ap+2 +0x1.1aec1p-6 +-0x1.607432p+3 +0x1.b98668p-7 +-0x1.606e7p+3 +0x1.398d3ap-6 +-0x1.1e8ae2p+4 +0x1.4db97ep-6 +-0x1.606ec8p+3 +-0x1.27cccep-3 +-0x1.60717ep+3 +-0x1.334ad2p-3 +-0x1.303834p+4 +-0x1.36fb6p-3 +-0x1.303b1p+4 +-0x1.31ae3ep-3 +-0x1.27739p+4 +-0x1.0f25fcp-2 +-0x1.3195fp+4 +-0x1.0df7c6p-2 +-0x1.31971p+4 +-0x1.0abb7ap-2 +-0x1.d7789cp+4 +-0x1.0ad3cap-2 +-0x1.1cf902p+4 +-0x1.7f0ecep-2 +-0x1.1cf2fep+4 +-0x1.6f8a56p-2 +-0x1.cfd7dcp+3 +-0x1.6f8a56p-2 +-0x1.cfd9d4p+3 +-0x1.6f23dp-2 +-0x1.27739p+4 +-0x1.701e1p-2 +-0x1.1cf2fep+4 +-0x1.e287fcp-2 +-0x1.1cf33ep+4 +-0x1.e44acp-2 +-0x1.1cf33ep+4 +-0x1.d7b5c2p+4 +-0x1.1cf5f2p+4 +-0x1.18bd2cp+5 +-0x1.1cf90ep+4 +-0x1.18bc0ap+5 +-0x1.d77978p+4 +-0x1.2f937ep+3 +-0x1.d77a4ep+4 +-0x1.5323a8p+3 +-0x1.30389ap+4 +-0x1.532716p+3 +-0x1.303802p+4 +-0x1.46248p+4 +-0x1.14c634p+4 +-0x1.46255cp+4 +-0x1.14c634p+4 +-0x1.f7d296p+2 +-0x1.14c67ep+4 +-0x1.f7d3dp+2 +-0x1.14c6b6p+4 +-0x1.6071eep+3 +-0x1.14c7a2p+4 +-0x1.607014p+3 +-0x1.9342a2p+4 +-0x1.f7d48ep+2 +-0x1.3195fep+4 +-0x1.2f923p+3 +-0x1.27739p+4 +-0x1.09dc42p+5 +-0x1.31966cp+4 +-0x1.09dc64p+5 +-0x1.3195d2p+4 +-0x1.09dc4ep+5 +-0x1.607366p+3 +-0x1.f7de34p+2 +-0x1.6072aap+3 +-0x1.f7df8ap+2 +0x1.4889fap+3 +-0x1.11df14p+4 +-0x1.1e896cp+4 +-0x1.6b24ecp+1 +-0x1.33ba3ap+2 +0x1.488c02p+3 +0x1.488b3p+3 +-0x1.f31f3cp+4 +-0x1.33ba3ap+2 +-0x1.f31f3ap+4 +-0x1.7273b6p+1 +-0x1.29a758p+4 +-0x1.7276d4p+1 +-0x1.29a756p+4 +0x1.0da1c2p-2 +0x1.08957p-2 +0x1.08ce7ep-2 +0x1.f24d76p-3 +0x1.14d25cp-2 +0x1.0cbd6p-2 +0x0p+0 +0x1.1426fp-2 +0x1.f92632p-3 +0x1.49442cp-3 +0x1.62cf6ep-3 +0x1.f1ace8p-7 +0x1.2b6a5cp-5 +-0x1.3b9be8p-3 +-0x1.0def38p-3 +-0x1.160038p-2 +-0x1.028482p-2 +-0x1.70a2eep-2 +-0x1.643b6cp-2 +-0x1.e44acp-2 +-0x1.e2103ap-2 +0x0p+0 +-0x1.be9dbep+1 +-0x1.cfd90ep+3 +-0x1.be97aap+1 +-0x1.1cf81p+4 +-0x1.53a702p-4 +-0x1.18bcb6p+5 +-0x1.5237eap-4 +-0x1.d7b548p+4 +-0x1.6e5ff8p-3 +-0x1.d7789cp+4 +-0x1.6dfaaap-3 +-0x1.3195d2p+4 +-0x1.83cfdcp+1 +-0x1.5323bp+3 +-0x1.83d6c8p+1 +-0x1.46255cp+4 +-0x1.909e4cp+1 +-0x1.14c5f8p+4 +-0x1.90a75ap+1 +-0x1.93426cp+4 +-0x1.8afce2p-3 +-0x1.2f92fp+3 +-0x1.8aac2ap-3 +-0x1.09dc4ep+5 +-0x1.a01786p+1 +-0x1.3037cap+4 +-0x1.a02086p+1 +-0x1.6073c2p+3 +-0x1.8eb3fep+3 +-0x1.f7dd24p+2 +-0x1.8eb5b4p+3 +-0x1.1e8906p+4 +-0x1.4b074cp+3 +-0x1.11df1p+4 +-0x1.4b0632p+3 +-0x1.6b24p+1 +-0x1.7385dap+1 +-0x1.f31f4cp+4 +-0x1.738cc2p+1 +-0x1.29a756p+4 +-0x1.5228c2p+0 +0x1.681626p+3 +0x1.08c04cp-2 +0x1.0dda04p-2 +0x1.1477f8p-2 +0x0p+0 +-0x1.4cdb82p+0 +-0x1.b771acp+5 +0x1.9a85dep+3 +-0x1.889556p+5 +-0x1.cf3b28p+4 +0x1.3e15aap+2 +-0x1.381dd2p+5 +0x1.090606p-2 +0x1.02c8e4p-2 +0x1.eb5e7ap-3 +0x1.441becp-3 +0x1.00f19p-6 +-0x1.27cd0ep-3 +-0x1.0f1f3p-2 +-0x1.7f2328p-2 +-0x1.e26d0ap-2 +-0x1.cfd90ep+3 +-0x1.bea012p+1 +-0x1.1cf81p+4 +-0x1.18bcb6p+5 +-0x1.531bcep-4 +-0x1.d7b548p+4 +-0x1.d7789cp+4 +-0x1.6e475cp-3 +-0x1.5323bp+3 +-0x1.83d1ecp+1 +-0x1.46255cp+4 +-0x1.14c5f8p+4 +-0x1.909e68p+1 +-0x1.93426cp+4 +-0x1.2f92fp+3 +-0x1.8aeb4p-3 +-0x1.09dc4ep+5 +-0x1.3195d2p+4 +-0x1.27739p+4 +-0x1.3037cap+4 +-0x1.a0177cp+1 +-0x1.6073c2p+3 +-0x1.f7dd24p+2 +-0x1.8eb3ecp+3 +-0x1.11df1p+4 +-0x1.4b06e2p+3 +-0x1.6b24p+1 +0x1.488af2p+3 +-0x1.33ba3ap+2 +-0x1.1e8906p+4 +-0x1.f31f4cp+4 +-0x1.73875ap+1 +-0x1.7276d4p+1 +-0x1.29a756p+4 +-0x1.51d278p+0 +0x1.681de4p+3 +-0x1.7258d4p+1 +0x1.4890a6p+3 +0x1.048e36p-2 +-0x1.381a86p+5 +0x1.3e2e9p+2 +0x1.0a035cp-2 +0x1.9a9052p+3 +-0x1.4c9c5ep+0 +-0x1.b7636ep+5 +-0x1.cf47c4p+4 +-0x1.888f22p+5 +-0x1.2779b8p+4 +-0x1.3372e8p+2 +-0x1.90d474p+1 +-0x1.14cd7p+4 +-0x1.9349c2p+4 +-0x1.70dc0cp-3 +-0x1.d77cfcp+4 +-0x1.319af2p+4 +-0x1.bec3f2p+1 +-0x1.1d0082p+4 +-0x1.cfe04ep+3 +-0x1.5b57d2p-4 +-0x1.18c0ecp+5 +-0x1.d7be94p+4 +-0x1.8d7a96p-3 +-0x1.2f9da6p+3 +-0x1.09de8ep+5 +-0x1.a05002p+1 +-0x1.30401cp+4 +-0x1.60829ep+3 +-0x1.736ae8p+1 +-0x1.f318bp+4 +-0x1.29a52p+4 +-0x1.83fdfp+1 +-0x1.532d3ap+3 +-0x1.462a06p+4 +-0x1.8ec7d6p+3 +-0x1.1e8de6p+4 +-0x1.f7fb24p+2 +-0x1.4b09c2p+3 +-0x1.6aafbp+1 +-0x1.11d9dcp+4 +0x1.15834ep-2 +0x1.0f0dcap-2 +0x1.09eb28p-2 +0x1.ed6978p-3 +0x1.452f42p-3 +0x1.d5309cp-7 +-0x1.2acbeep-3 +-0x1.105386p-2 +-0x1.8013a4p-2 +-0x1.e2bef6p-2 +0x0p+0 +0x1.169e86p+2 +0x0p+0 +0x1.16ad06p+2 +0x0p+0 +0x1.048e36p-2 +0x0p+0 +0x1.02c8e4p-2 +0x0p+0 +0x1.a007d8p+0 +0x0p+0 +0x1.9e4018p+0 +0x0p+0 +0x1.3ef89ep+2 +0x0p+0 +0x1.3ee8d6p+2 +0x0p+0 +0x1.3afefcp+1 +0x0p+0 +0x1.3b63dcp+1 +0x0p+0 +0x1.32128p+0 +0x0p+0 +0x1.314cp+0 +0x0p+0 +0x1.87842p-2 +0x0p+0 +0x1.890e2p-2 +0x0p+0 +0x1.8cb256p+2 +0x0p+0 +0x1.8cd346p+2 +0x0p+0 +0x1.ee90f8p+0 +0x0p+0 +0x1.ef25b8p+0 +0x0p+0 +0x1.4d6dc8p+1 +0x0p+0 +0x1.4db128p+1 +0x0p+0 +0x1.8698d6p+2 +0x0p+0 +0x1.86ad7cp+2 +0x0p+0 +0x1.82131p+2 +0x0p+0 +0x1.82279p+2 +0x0p+0 +0x1.09eb28p-2 +0x0p+0 +0x1.08c04cp-2 +0x0p+0 +0x1.097468p+0 +0x0p+0 +0x1.09fb88p+0 +0x0p+0 +0x1.f2aa78p+0 +0x0p+0 +0x1.f2f078p+0 +0x0p+0 +0x1.657b7ap+1 +0x0p+0 +0x1.659f5ap+1 +0x0p+0 +0x1.7a1e7cp+2 +0x0p+0 +0x1.7a2d84p+2 +0x0p+0 +0x1.811a7ep+2 +0x0p+0 +0x1.812dc4p+2 +0x0p+0 +0x1.0f0dcap-2 +0x0p+0 +0x1.0dda04p-2 +0x0p+0 +0x1.7a1e7cp+2 +0x0p+0 +0x1.7a2d84p+2 +-0x1.5228c2p+0 +-0x1.29a756p+4 +-0x1.5228c2p+0 +-0x1.7276d4p+1 +-0x1.5228c2p+0 +0x1.eb5e7ap-3 +-0x1.5228c2p+0 +0x1.02c8e4p-2 +-0x1.5228c2p+0 +0x1.681626p+3 +0x1.681626p+3 +0x1.02c8e4p-2 +0x1.02c8e4p-2 +-0x1.381dd2p+5 +0x1.02c8e4p-2 +0x1.3e15aap+2 +0x1.02c8e4p-2 +0x1.08c04cp-2 +0x1.090606p-2 +0x1.08c04cp-2 +0x1.3e15aap+2 +0x1.08c04cp-2 +-0x1.cf3b28p+4 +0x1.0dda04p-2 +-0x1.889556p+5 +0x1.0dda04p-2 +0x1.9a85dep+3 +0x1.0dda04p-2 +0x1.090606p-2 +0x1.0dda04p-2 +-0x1.b771acp+5 +0x1.1477f8p-2 +-0x1.4cdb82p+0 +0x1.1477f8p-2 +-0x1.b771acp+5 +-0x1.cf3b28p+4 +-0x1.889556p+5 +0x1.9a85dep+3 +0x1.090606p-2 +0x1.9a85dep+3 +-0x1.cf3b28p+4 +-0x1.889556p+5 +0x1.3e15aap+2 +0x1.090606p-2 +-0x1.381dd2p+5 +0x1.3e15aap+2 +-0x1.f31f4cp+4 +0x1.eb5e7ap-3 +-0x1.29a756p+4 +0x1.eb5e7ap-3 +-0x1.f31f4cp+4 +0x1.441becp-3 +-0x1.1e8906p+4 +0x1.441becp-3 +-0x1.11df1p+4 +0x1.441becp-3 +-0x1.f7dd24p+2 +0x1.00f19p-6 +-0x1.6073c2p+3 +0x1.00f19p-6 +-0x1.1e8906p+4 +0x1.00f19p-6 +-0x1.6073c2p+3 +-0x1.27cd0ep-3 +-0x1.3037cap+4 +-0x1.27cd0ep-3 +-0x1.27739p+4 +-0x1.0f1f3p-2 +-0x1.3195d2p+4 +-0x1.0f1f3p-2 +-0x1.d7789cp+4 +-0x1.0f1f3p-2 +-0x1.1cf81p+4 +-0x1.7f2328p-2 +-0x1.cfd90ep+3 +-0x1.7f2328p-2 +-0x1.27739p+4 +-0x1.7f2328p-2 +-0x1.1cf81p+4 +-0x1.e26d0ap-2 +-0x1.1cf81p+4 +-0x1.d7b548p+4 +-0x1.1cf81p+4 +-0x1.18bcb6p+5 +-0x1.d7789cp+4 +-0x1.2f92fp+3 +-0x1.d7789cp+4 +-0x1.5323bp+3 +-0x1.3037cap+4 +-0x1.5323bp+3 +-0x1.3037cap+4 +-0x1.46255cp+4 +-0x1.14c5f8p+4 +-0x1.46255cp+4 +-0x1.14c5f8p+4 +-0x1.f7dd24p+2 +-0x1.14c5f8p+4 +-0x1.6073c2p+3 +-0x1.93426cp+4 +-0x1.f7dd24p+2 +-0x1.3195d2p+4 +-0x1.2f92fp+3 +-0x1.27739p+4 +-0x1.09dc4ep+5 +-0x1.3195d2p+4 +-0x1.09dc4ep+5 +-0x1.6073c2p+3 +-0x1.f7dd24p+2 +0x1.488af2p+3 +-0x1.11df1p+4 +-0x1.1e8906p+4 +-0x1.6b24p+1 +-0x1.33ba3ap+2 +0x1.488af2p+3 +0x1.488af2p+3 +-0x1.f31f4cp+4 +-0x1.33ba3ap+2 +-0x1.f31f4cp+4 +-0x1.7276d4p+1 +-0x1.29a756p+4 +0x1.08c04cp-2 +0x1.0dda04p-2 +0x1.eb5e7ap-3 +0x1.08c04cp-2 +0x1.0dda04p-2 +0x1.1477f8p-2 +0x1.1477f8p-2 +0x0p+0 +0x1.441becp-3 +0x1.eb5e7ap-3 +0x1.00f19p-6 +0x1.441becp-3 +-0x1.27cd0ep-3 +0x1.00f19p-6 +-0x1.0f1f3p-2 +-0x1.27cd0ep-3 +-0x1.7f2328p-2 +-0x1.0f1f3p-2 +-0x1.e26d0ap-2 +-0x1.7f2328p-2 +0x0p+0 +-0x1.e26d0ap-2 +-0x1.cfd90ep+3 +-0x1.bea012p+1 +-0x1.1cf81p+4 +-0x1.bea012p+1 +-0x1.18bcb6p+5 +-0x1.531bcep-4 +-0x1.d7b548p+4 +-0x1.531bcep-4 +-0x1.d7789cp+4 +-0x1.6e475cp-3 +-0x1.3195d2p+4 +-0x1.6e475cp-3 +-0x1.5323bp+3 +-0x1.83d1ecp+1 +-0x1.46255cp+4 +-0x1.83d1ecp+1 +-0x1.14c5f8p+4 +-0x1.909e68p+1 +-0x1.93426cp+4 +-0x1.909e68p+1 +-0x1.2f92fp+3 +-0x1.8aeb4p-3 +-0x1.09dc4ep+5 +-0x1.8aeb4p-3 +-0x1.3037cap+4 +-0x1.a0177cp+1 +-0x1.6073c2p+3 +-0x1.a0177cp+1 +-0x1.f7dd24p+2 +-0x1.8eb3ecp+3 +-0x1.1e8906p+4 +-0x1.8eb3ecp+3 +-0x1.11df1p+4 +-0x1.4b06e2p+3 +-0x1.6b24p+1 +-0x1.4b06e2p+3 +-0x1.f31f4cp+4 +-0x1.73875ap+1 +-0x1.29a756p+4 +-0x1.73875ap+1 +-0x1.526982p+0 +-0x1.29adaap+4 +-0x1.528c38p+0 +-0x1.29ad9ep+4 +-0x1.528c38p+0 +-0x1.72a978p+1 +-0x1.528ffcp+0 +-0x1.72ab6p+1 +-0x1.52929ep+0 +0x1.e82bc8p-3 +-0x1.52929ep+0 +0x1.00fbeap-2 +-0x1.52943ep+0 +0x1.010268p-2 +-0x1.527d34p+0 +0x1.680ed6p+3 +0x1.680ea8p+3 +0x1.00a63ap-2 +0x1.00a63ap-2 +-0x1.38202cp+5 +0x1.00aa96p-2 +-0x1.38204ap+5 +0x1.00aa96p-2 +0x1.3dfdbap+2 +0x1.00aa96p-2 +0x1.3dfdbap+2 +0x1.00e21p-2 +0x1.0777aap-2 +0x1.07f852p-2 +0x1.077a76p-2 +0x1.07d31p-2 +0x1.0774b2p-2 +0x1.3dfa4p+2 +0x1.076f5p-2 +0x1.3dfa4p+2 +0x1.076f5p-2 +-0x1.cf27c8p+4 +0x1.0c591cp-2 +-0x1.889e7ep+5 +0x1.0c56d4p-2 +0x1.9a7e8p+3 +0x1.0c3bd2p-2 +0x1.9a7e52p+3 +0x1.0c3dap-2 +0x1.07dbdp-2 +0x1.0c3fe4p-2 +0x1.07dbdp-2 +0x1.0c3fe4p-2 +-0x1.b782a4p+5 +0x1.13a226p-2 +-0x1.4d10f6p+0 +0x1.13ec0cp-2 +-0x1.4d1a4cp+0 +0x1.13ebb6p-2 +-0x1.b782a4p+5 +-0x1.cf27c8p+4 +-0x1.889e7ep+5 +0x1.9a7f2ap+3 +0x1.07dbdp-2 +0x1.9a7f18p+3 +0x1.07dbdp-2 +0x1.9a7f18p+3 +-0x1.cf27c8p+4 +-0x1.889e7ep+5 +0x1.3dfcbp+2 +0x1.08234p-2 +0x1.3dfcbp+2 +0x1.08234p-2 +-0x1.38204ap+5 +0x1.3dfe06p+2 +-0x1.38204ap+5 +0x1.3dfe06p+2 +-0x1.f32428p+4 +0x1.e82bc8p-3 +-0x1.f32356p+4 +0x1.ed0166p-3 +-0x1.29ad9ep+4 +0x1.ee8276p-3 +-0x1.29ae6ep+4 +0x1.f0c286p-3 +-0x1.f32352p+4 +0x1.412d14p-3 +-0x1.f3249ap+4 +0x1.399e9p-3 +-0x1.1e847ap+4 +0x1.399e9p-3 +-0x1.11e4d8p+4 +0x1.434c84p-3 +-0x1.11e65p+4 +0x1.49a0ep-3 +-0x1.f7c044p+2 +0x1.261b2ep-6 +-0x1.f7c38p+2 +0x1.3ddc12p-6 +-0x1.606552p+3 +0x1.fe9d5cp-7 +-0x1.605f96p+3 +0x1.5bab4cp-6 +-0x1.1e85e6p+4 +0x1.6f098cp-6 +-0x1.605feap+3 +-0x1.242d6p-3 +-0x1.6062a2p+3 +-0x1.2fb1cep-3 +-0x1.303072p+4 +-0x1.33745ap-3 +-0x1.30334ep+4 +-0x1.2e288cp-3 +-0x1.276dacp+4 +-0x1.0de95p-2 +-0x1.3190f4p+4 +-0x1.0cbadp-2 +-0x1.319214p+4 +-0x1.097f8ap-2 +-0x1.d77428p+4 +-0x1.09980ap-2 +-0x1.1cf2dcp+4 +-0x1.7e0bb6p-2 +-0x1.1cecd8p+4 +-0x1.6e88d6p-2 +-0x1.cfced6p+3 +-0x1.6e88d6p-2 +-0x1.cfd0ccp+3 +-0x1.6e22ecp-2 +-0x1.276dacp+4 +-0x1.6f181p-2 +-0x1.1cecd8p+4 +-0x1.e29736p-2 +-0x1.1ced16p+4 +-0x1.e4558ap-2 +-0x1.1ced16p+4 +-0x1.d7adaep+4 +-0x1.1cefd2p+4 +-0x1.18ba1cp+5 +-0x1.1cf2eep+4 +-0x1.18b8fap+5 +-0x1.d77504p+4 +-0x1.2f8976p+3 +-0x1.d775d6p+4 +-0x1.531a5p+3 +-0x1.3030dap+4 +-0x1.531db8p+3 +-0x1.303042p+4 +-0x1.461ebp+4 +-0x1.14bee2p+4 +-0x1.461f8ep+4 +-0x1.14bee2p+4 +-0x1.f7b4bep+2 +-0x1.14bf2cp+4 +-0x1.f7b5fap+2 +-0x1.14bf64p+4 +-0x1.606316p+3 +-0x1.14c05p+4 +-0x1.60614p+3 +-0x1.933b22p+4 +-0x1.f7b6b8p+2 +-0x1.319102p+4 +-0x1.2f882cp+3 +-0x1.276dacp+4 +-0x1.09d9dep+5 +-0x1.31917p+4 +-0x1.09dap+5 +-0x1.3190d8p+4 +-0x1.09d9eap+5 +-0x1.606496p+3 +-0x1.f7c04ap+2 +-0x1.6063dcp+3 +-0x1.f7c19ep+2 +0x1.487ad6p+3 +-0x1.11e46p+4 +-0x1.1e8476p+4 +-0x1.6b93e6p+1 +-0x1.33fab8p+2 +0x1.487d04p+3 +0x1.487d04p+3 +-0x1.f3249ap+4 +-0x1.33fab8p+2 +-0x1.f32498p+4 +-0x1.72accap+1 +-0x1.29adf2p+4 +-0x1.72afd2p+1 +-0x1.29adfp+4 +0x1.0c3fe4p-2 +0x1.07696ep-2 +0x1.079a0ep-2 +0x1.ef44cep-3 +0x1.13e79p-2 +0x1.0b61d6p-2 +0x0p+0 +0x1.1359b4p-2 +0x1.f682aap-3 +0x1.46a022p-3 +0x1.6059a4p-3 +0x1.1b73bcp-6 +0x1.3933d2p-5 +-0x1.380c7ap-3 +-0x1.0a9beap-3 +-0x1.14c2eap-2 +-0x1.015b7ap-2 +-0x1.6f9ec8p-2 +-0x1.63384cp-2 +-0x1.e4558ap-2 +-0x1.e1d74p-2 +0x0p+0 +-0x1.be771ep+1 +-0x1.cfd00ap+3 +-0x1.be7118p+1 +-0x1.1cf1fp+4 +-0x1.4cd672p-4 +-0x1.18b9a6p+5 +-0x1.4b6a66p-4 +-0x1.d7ad34p+4 +-0x1.6be49ep-3 +-0x1.d77426p+4 +-0x1.6b8p-3 +-0x1.3190d8p+4 +-0x1.83a0eap+1 +-0x1.531a52p+3 +-0x1.83a808p+1 +-0x1.461f8ep+4 +-0x1.906436p+1 +-0x1.14bea6p+4 +-0x1.906d66p+1 +-0x1.933aecp+4 +-0x1.88804p-3 +-0x1.2f88ecp+3 +-0x1.883178p-3 +-0x1.09d9eap+5 +-0x1.9fe0b4p+1 +-0x1.303008p+4 +-0x1.9fe9e4p+1 +-0x1.6064eep+3 +-0x1.8ea076p+3 +-0x1.f7bf46p+2 +-0x1.8ea232p+3 +-0x1.1e840ep+4 +-0x1.4b03eap+3 +-0x1.11e45cp+4 +-0x1.4b02e8p+3 +-0x1.6b92fep+1 +-0x1.73a0f2p+1 +-0x1.f324aap+4 +-0x1.73a844p+1 +-0x1.29adfp+4 +-0x1.527ca2p+0 +-0x1.29adfp+4 +-0x1.529d28p+0 +-0x1.29ade6p+4 +-0x1.529d28p+0 +-0x1.72afd2p+1 +-0x1.529e54p+0 +-0x1.72b06ap+1 +-0x1.529ef4p+0 +0x1.e948f2p-3 +-0x1.529ef4p+0 +0x1.0101d2p-2 +-0x1.529fb4p+0 +0x1.0104d2p-2 +-0x1.5287eap+0 +0x1.680ea8p+3 +0x1.680e78p+3 +0x1.00a5ap-2 +0x1.00a5ap-2 +-0x1.38204ap+5 +0x1.00a9a6p-2 +-0x1.382066p+5 +0x1.00a9a6p-2 +0x1.3dfe06p+2 +0x1.00a9a6p-2 +0x1.3dfe06p+2 +0x1.00e1ccp-2 +0x1.07b64p-2 +0x1.080dcap-2 +0x1.07b848p-2 +0x1.07e4cep-2 +0x1.07b1fp-2 +0x1.3dfa8p+2 +0x1.07a99p-2 +0x1.3dfa8p+2 +0x1.07a99p-2 +-0x1.cf27c8p+4 +0x1.0cadecp-2 +-0x1.889e7ep+5 +0x1.0c9778p-2 +0x1.9a7cdap+3 +0x1.0c7b28p-2 +0x1.9a7ccep+3 +0x1.0c7b9ep-2 +0x1.07f26ap-2 +0x1.0c7f4cp-2 +0x1.07f26ap-2 +0x1.0c7f4cp-2 +-0x1.b782a4p+5 +0x1.13a0e8p-2 +-0x1.4d1606p+0 +0x1.13e916p-2 +-0x1.4d1ec2p+0 +0x1.13e8c6p-2 +-0x1.b782a4p+5 +-0x1.cf27c8p+4 +-0x1.889e7ep+5 +0x1.9a7e2ep+3 +0x1.07f26ap-2 +0x1.9a7e1ep+3 +0x1.07f26ap-2 +0x1.9a7e1ep+3 +-0x1.cf27c8p+4 +-0x1.889e7ep+5 +0x1.3dfd04p+2 +0x1.083546p-2 +0x1.3dfd04p+2 +0x1.083546p-2 +-0x1.382066p+5 +0x1.3dfe9ap+2 +-0x1.382066p+5 +0x1.3dfe9ap+2 +-0x1.f324aap+4 +0x1.e948f2p-3 +-0x1.f323dep+4 +0x1.edf47p-3 +-0x1.29ade6p+4 +0x1.ef487cp-3 +-0x1.29aebp+4 +0x1.f17a24p-3 +-0x1.f323dap+4 +0x1.42b39cp-3 +-0x1.f32526p+4 +0x1.3b12b4p-3 +-0x1.1e840ep+4 +0x1.3b12b4p-3 +-0x1.11e45cp+4 +0x1.44bc6ep-3 +-0x1.11e5cap+4 +0x1.4ae076p-3 +-0x1.f7bf46p+2 +0x1.1d7d9p-6 +-0x1.f7c28ap+2 +0x1.3577a8p-6 +-0x1.6064eep+3 +0x1.eee756p-7 +-0x1.605f2ep+3 +0x1.53ebc2p-6 +-0x1.1e857cp+4 +0x1.68129ap-6 +-0x1.605f86p+3 +-0x1.24ea64p-3 +-0x1.606236p+3 +-0x1.30562cp-3 +-0x1.303008p+4 +-0x1.3402bp-3 +-0x1.3032e8p+4 +-0x1.2eb24cp-3 +-0x1.276dacp+4 +-0x1.0df61ap-2 +-0x1.3190d8p+4 +-0x1.0cc676p-2 +-0x1.3191f8p+4 +-0x1.098a3p-2 +-0x1.d77426p+4 +-0x1.09a28ep-2 +-0x1.1cf1fp+4 +-0x1.7e14aep-2 +-0x1.1cebecp+4 +-0x1.6e9592p-2 +-0x1.cfd00ap+3 +-0x1.6e9592p-2 +-0x1.cfd2p+3 +-0x1.6e2fbcp-2 +-0x1.276dacp+4 +-0x1.6f280ep-2 +-0x1.1cebecp+4 +-0x1.e24b72p-2 +-0x1.1cec2cp+4 +-0x1.e418f2p-2 +-0x1.1cec3p+4 +-0x1.d7ad34p+4 +-0x1.1ceee8p+4 +-0x1.18b9a6p+5 +-0x1.1cf206p+4 +-0x1.18b882p+5 +-0x1.d77502p+4 +-0x1.2f88ecp+3 +-0x1.d775d4p+4 +-0x1.531a52p+3 +-0x1.303078p+4 +-0x1.531dbap+3 +-0x1.302fep+4 +-0x1.461f8ep+4 +-0x1.14bea6p+4 +-0x1.46206cp+4 +-0x1.14bea6p+4 +-0x1.f7b3eep+2 +-0x1.14beecp+4 +-0x1.f7b516p+2 +-0x1.14bf2p+4 +-0x1.6062a6p+3 +-0x1.14c00cp+4 +-0x1.6060cep+3 +-0x1.933aecp+4 +-0x1.f7b5c6p+2 +-0x1.3190e8p+4 +-0x1.2f87a2p+3 +-0x1.276dacp+4 +-0x1.09d9eap+5 +-0x1.319156p+4 +-0x1.09da0cp+5 +-0x1.3190bcp+4 +-0x1.09d9f6p+5 +-0x1.606422p+3 +-0x1.f7bf56p+2 +-0x1.606378p+3 +-0x1.f7c08ap+2 +0x1.487cc4p+3 +-0x1.11e3dep+4 +-0x1.1e8414p+4 +-0x1.6b92fep+1 +-0x1.33fab8p+2 +0x1.487ea6p+3 +0x1.487ea6p+3 +-0x1.f32526p+4 +-0x1.33fab8p+2 +-0x1.f32524p+4 +-0x1.72b0cp+1 +-0x1.29ae3p+4 +-0x1.72b3f8p+1 +-0x1.29ae2ep+4 +0x1.0c7f4cp-2 +0x1.07a37ap-2 +0x1.07c004p-2 +0x1.eff16cp-3 +0x1.13e46cp-2 +0x1.0b8bfep-2 +0x0p+0 +0x1.133648p-2 +0x1.f6afeap-3 +0x1.47e1dp-3 +0x1.60eefcp-3 +0x1.166d5cp-6 +0x1.368f4ap-5 +-0x1.388afcp-3 +-0x1.0ad8eep-3 +-0x1.14c976p-2 +-0x1.015cf2p-2 +-0x1.6faef6p-2 +-0x1.634a7ep-2 +-0x1.e4253p-2 +-0x1.e1c8bp-2 +0x0p+0 +-0x1.be7966p+1 +-0x1.cfd13ap+3 +-0x1.be7358p+1 +-0x1.1cf108p+4 +-0x1.4c5184p-4 +-0x1.18b92ep+5 +-0x1.4ae088p-4 +-0x1.d7acbap+4 +-0x1.6bcb12p-3 +-0x1.d77424p+4 +-0x1.6b65cap-3 +-0x1.3190bcp+4 +-0x1.83a2f8p+1 +-0x1.531a58p+3 +-0x1.83a9eep+1 +-0x1.46206cp+4 +-0x1.906454p+1 +-0x1.14be62p+4 +-0x1.906d6cp+1 +-0x1.933ab6p+4 +-0x1.886fcp-3 +-0x1.2f8862p+3 +-0x1.881fdap-3 +-0x1.09d9f6p+5 +-0x1.9fe0b8p+1 +-0x1.302fa6p+4 +-0x1.9fe9c2p+1 +-0x1.60647ap+3 +-0x1.8ea06cp+3 +-0x1.f7be56p+2 +-0x1.8ea22p+3 +-0x1.1e83bp+4 +-0x1.4b0368p+3 +-0x1.11e3dcp+4 +-0x1.4b0262p+3 +-0x1.6b921ep+1 +-0x1.73a2fp+1 +-0x1.f32538p+4 +-0x1.73a9dap+1 +-0x1.29ae2ep+4 +-0x1.528752p+0 +-0x1.29ae2ep+4 +-0x1.52a6c8p+0 +-0x1.29ae24p+4 +-0x1.52a6c8p+0 +-0x1.72b3f8p+1 +-0x1.52a6c8p+0 +-0x1.72b3f8p+1 +-0x1.52a6c8p+0 +0x1.e8f29ep-3 +-0x1.52a6c8p+0 +0x1.00f8f8p-2 +-0x1.52a70cp+0 +0x1.00fa0ap-2 +-0x1.528f14p+0 +0x1.680e78p+3 +0x1.680e4ap+3 +0x1.009a28p-2 +0x1.009a28p-2 +-0x1.382066p+5 +0x1.009ddap-2 +-0x1.38208p+5 +0x1.009ddap-2 +0x1.3dfe9ap+2 +0x1.009ddap-2 +0x1.3dfe9ap+2 +0x1.00d79cp-2 +0x1.07a688p-2 +0x1.081bccp-2 +0x1.07a8bcp-2 +0x1.07f71p-2 +0x1.07a30ap-2 +0x1.3dfafap+2 +0x1.079d4ep-2 +0x1.3dfafap+2 +0x1.079d4ep-2 +-0x1.cf27c8p+4 +0x1.0caf48p-2 +-0x1.889e7ep+5 +0x1.0c9196p-2 +0x1.9a7c04p+3 +0x1.0c751p-2 +0x1.9a7bbap+3 +0x1.0c77f6p-2 +0x1.08006p-2 +0x1.0c7cdcp-2 +0x1.08006p-2 +0x1.0c7cdcp-2 +-0x1.b782a4p+5 +0x1.1388dap-2 +-0x1.4d1a46p+0 +0x1.13d2e2p-2 +-0x1.4d2348p+0 +0x1.13d29p-2 +-0x1.b782a4p+5 +-0x1.cf27c8p+4 +-0x1.889e7ep+5 +0x1.9a7d9p+3 +0x1.08006p-2 +0x1.9a7d8p+3 +0x1.08006p-2 +0x1.9a7d8p+3 +-0x1.cf27c8p+4 +-0x1.889e7ep+5 +0x1.3dfd4p+2 +0x1.084014p-2 +0x1.3dfd4p+2 +0x1.084014p-2 +-0x1.38208p+5 +0x1.3dff0cp+2 +-0x1.38208p+5 +0x1.3dff0cp+2 +-0x1.f32538p+4 +0x1.e8f29ep-3 +-0x1.f3246cp+4 +0x1.eda684p-3 +-0x1.29ae24p+4 +0x1.ef0104p-3 +-0x1.29aeeep+4 +0x1.f1321cp-3 +-0x1.f32468p+4 +0x1.4310b4p-3 +-0x1.f325b2p+4 +0x1.3b7c96p-3 +-0x1.1e83bp+4 +0x1.3b7c96p-3 +-0x1.11e3dcp+4 +0x1.4532f6p-3 +-0x1.11e544p+4 +0x1.4b3ee2p-3 +-0x1.f7be56p+2 +0x1.19dcbap-6 +-0x1.f7c198p+2 +0x1.31c2fp-6 +-0x1.60647ap+3 +0x1.e819d8p-7 +-0x1.605ebap+3 +0x1.505478p-6 +-0x1.1e852p+4 +0x1.64bac6p-6 +-0x1.605f14p+3 +-0x1.24cb5cp-3 +-0x1.6061c6p+3 +-0x1.303d9ap-3 +-0x1.302fa6p+4 +-0x1.33ef1ep-3 +-0x1.303288p+4 +-0x1.2e9e68p-3 +-0x1.276dacp+4 +-0x1.0df662p-2 +-0x1.3190bcp+4 +-0x1.0cc56ap-2 +-0x1.3191dcp+4 +-0x1.0988d6p-2 +-0x1.d77424p+4 +-0x1.09a16ap-2 +-0x1.1cf108p+4 +-0x1.7e2c1ap-2 +-0x1.1ceb04p+4 +-0x1.6eaf52p-2 +-0x1.cfd13ap+3 +-0x1.6eaf52p-2 +-0x1.cfd332p+3 +-0x1.6e497p-2 +-0x1.276dacp+4 +-0x1.6f438ep-2 +-0x1.1ceb04p+4 +-0x1.e22d88p-2 +-0x1.1ceb46p+4 +-0x1.e3ffd6p-2 +-0x1.1ceb4cp+4 +-0x1.d7acbap+4 +-0x1.1ceep+4 +-0x1.18b92ep+5 +-0x1.1cf11ep+4 +-0x1.18b80ap+5 +-0x1.d775p+4 +-0x1.2f8862p+3 +-0x1.d775d2p+4 +-0x1.531a58p+3 +-0x1.303018p+4 +-0x1.531dbep+3 +-0x1.302f8p+4 +-0x1.46206cp+4 +-0x1.14be62p+4 +-0x1.46214ap+4 +-0x1.14be62p+4 +-0x1.f7b318p+2 +-0x1.14bea6p+4 +-0x1.f7b43ep+2 +-0x1.14bed8p+4 +-0x1.606238p+3 +-0x1.14bfc4p+4 +-0x1.60605ep+3 +-0x1.933ab6p+4 +-0x1.f7b4eep+2 +-0x1.3190ccp+4 +-0x1.2f8718p+3 +-0x1.276dacp+4 +-0x1.09d9f6p+5 +-0x1.31913ap+4 +-0x1.09da18p+5 +-0x1.3190ap+4 +-0x1.09da02p+5 +-0x1.6063bp+3 +-0x1.f7be76p+2 +-0x1.60631p+3 +-0x1.f7bf9ap+2 +0x1.487e6p+3 +-0x1.11e35ep+4 +-0x1.1e83cp+4 +-0x1.6b921ep+1 +-0x1.33fab8p+2 +0x1.488004p+3 +0x1.487fd6p+3 +-0x1.f325b2p+4 +-0x1.33fab8p+2 +-0x1.f325bp+4 +-0x1.72b3f8p+1 +-0x1.29ae7p+4 +-0x1.72b774p+1 +-0x1.29ae6ep+4 +0x1.0c7cdcp-2 +0x1.0797cep-2 +0x1.07ccc8p-2 +0x1.efad48p-3 +0x1.13ce34p-2 +0x1.0b9f7ep-2 +0x0p+0 +0x1.131d58p-2 +0x1.f686bep-3 +0x1.48472cp-3 +0x1.6137c2p-3 +-0x1.7ab8b4p+2 +-0x1.dae87ep+2 +-0x1.c6536p+3 +0x0p+0 +-0x1.940296p+3 +0x0p+0 +-0x1.be9d74p-1 +-0x1.940296p+3 +-0x1.bbbf34p-1 +-0x1.7a1d02p+2 +-0x1.a8ce58p-1 +-0x1.db9db8p+2 +-0x1.9f889ep-1 +-0x1.c6536p+3 +-0x1.7a1d02p+2 +-0x1.db9db8p+2 +-0x1.c6536p+3 +0x0p+0 +-0x1.940296p+3 +0x0p+0 +-0x1.bc381ap-1 +-0x1.940296p+3 +-0x1.bc0ca4p-1 +-0x1.79a376p+2 +-0x1.a2df9ap-1 +-0x1.dc2d1p+2 +-0x1.a12ea6p-1 +-0x1.c6536p+3 +-0x1.bbaf2p-1 +-0x1.79a376p+2 +-0x1.dc2d1p+2 +-0x1.a1c9bap-1 +-0x1.c6536p+3 +0x0p+0 +-0x1.940296p+3 +-0x1.47c066p+1 +-0x1.f1c8bp+1 +-0x1.677a5p-2 +-0x1.f1c8bp+1 +-0x1.f29abcp+1 +-0x1.4ba1b8p+1 +-0x1.f29ab8p+1 +-0x1.4c3b8ep-2 +-0x1.f29ab8p+1 +-0x1.4c3b8ep-2 +-0x1.4ba1b8p+1 +-0x1.56232cp+2 +-0x1.f55b0cp-1 +-0x1.3c216cp+3 +-0x1.f55b0cp-1 +-0x1.002fccp+0 +-0x1.64324cp+2 +-0x1.002c52p+0 +-0x1.3fe928p+3 +-0x1.002d72p+0 +-0x1.3fe928p+3 +-0x1.64324cp+2 +-0x1.9ec7c6p+2 +-0x1.356612p+3 +-0x1.09fcacp+0 +-0x1.356612p+3 +-0x1.38c556p+3 +-0x1.a15ff8p+2 +-0x1.38c1d6p+3 +-0x1.118b2ap+0 +-0x1.38c118p+3 +-0x1.a15ff8p+2 +-0x1.38c15cp+3 +-0x1.118b2ap+0 +-0x1.38c144p+3 +-0x1.a15ff8p+2 +-0x1.38c14cp+3 +-0x1.118b2ap+0 +-0x1.38c14ap+3 +-0x1.118b2ap+0 +-0x1.a15ff8p+2 +-0x1.bf323ap-11 +0x1.93e3p-10 +0x1.edcf54p-9 +0x1.e4912ep-8 +0x1.c906d2p-7 +0x1.8206f8p-6 +0x1.257304p-5 +0x1.802988p-4 +0x1.cd5c8cp-3 +0x1.be6b0ap+0 +0x1.889c7cp+0 +-0x1.784d72p+1 +0x1.045cbp+4 +-0x1.18a858p+2 +-0x1.6321d4p+0 +-0x1.6aad42p-1 +-0x1.cd8362p+2 +-0x1.7aff5ap+3 +-0x1.1a1d8ap-3 +-0x1.7934d6p+3 +-0x1.25d52ep+1 +-0x1.d5ea3cp+1 +-0x1.3b1d06p+2 +-0x1.a4ca4cp+1 +-0x1.c8f42ap-1 +-0x1.8f8772p+3 +-0x1.7cd8dap+2 +-0x1.8d3da2p-1 +-0x1.d94f76p+2 +-0x1.c0fed6p+3 +-0x1.ead0aap+1 +-0x1.1d2676p+2 +-0x1.6a04eep+1 +-0x1.f1c8bp+1 +-0x1.47c066p+1 +-0x1.677a5p-2 +-0x1.f55b0cp-1 +-0x1.56232cp+2 +-0x1.3c216cp+3 +-0x1.356612p+3 +-0x1.9ec7c6p+2 +-0x1.09fcacp+0 +-0x1.280d96p+2 +0x1.211a5ap+1 +-0x1.1452acp+3 +0x1.eff00ap-5 +0x1.d68454p-5 +0x1.3d4f26p-3 +0x1.b93bfep-3 +0x1.5e25c4p-3 +0x1.653c04p-6 +-0x1.cc14dep-5 +-0x1.bd2826p-9 +-0x1.871af4p-3 +-0x1.1d6bbap-1 +0x0p+0 +0x1.ba3a7ep+1 +0x0p+0 +0x1.89c6bep+1 +0x0p+0 +0x1.8e878cp+2 +0x0p+0 +0x1.9169ep+2 +0x0p+0 +0x1.91e81p+2 +0x0p+0 +0x1.956d16p+2 +0x0p+0 +0x1.537454p+2 +0x0p+0 +0x1.52145ap+2 +0x0p+0 +0x1.85e6dep+2 +0x0p+0 +0x1.84b74cp+2 +0x0p+0 +0x1.abf1fap+1 +0x0p+0 +0x1.a739bp+1 +0x0p+0 +0x1.72e69p+1 +0x0p+0 +0x1.6579bp+1 +0x0p+0 +0x1.4fa08cp+2 +0x0p+0 +0x1.4dbcecp+2 +0x0p+0 +0x1.dfe45p-1 +0x0p+0 +0x1.6f6b5p-1 +0x0p+0 +0x1.a7a7dp-1 +0x0p+0 +0x1.7772b8p-1 +0x0p+0 +0x1.6f6b5p-1 +0x0p+0 +0x1.8577a6p+2 +0x0p+0 +0x1.82df74p+2 +0x0p+0 +0x1.546dcp-2 +0x0p+0 +0x1.87c4p-2 +0x0p+0 +0x1.211a5ap+1 +0x0p+0 +0x1.203da6p+1 +0x0p+0 +0x1.396ec2p+1 +0x0p+0 +0x1.44761ap+1 +0x0p+0 +0x1.59013p+2 +0x0p+0 +0x1.5aa9d2p+2 +0x0p+0 +0x1.ba3a7ep+1 +0x0p+0 +0x1.89c6bep+1 +0x0p+0 +0x1.a8488p+0 +0x0p+0 +0x1.9872b8p+0 +0x0p+0 +0x1.d3e5p+0 +0x0p+0 +0x1.8d7d8p+0 +0x0p+0 +0x1.7205cp-1 +0x0p+0 +0x1.092cp-1 +0x0p+0 +0x1.f73428p+1 +0x0p+0 +0x1.f4f5p+1 +0x0p+0 +0x1.4e553p+1 +0x0p+0 +0x1.49aaf8p+1 +0x0p+0 +0x1.4c22p-4 +0x0p+0 +-0x1.e2ep-5 +0x0p+0 +0x1.e5dd78p+0 +0x0p+0 +0x1.b7605p+0 +0x0p+0 +0x1.5c0acp+0 +0x0p+0 +0x1.445e28p+0 +0x0p+0 +0x1.7f752p+1 +0x0p+0 +0x1.87c6fap+1 +0x0p+0 +0x1.fe6a3ep+1 +0x0p+0 +0x1.f86be8p+1 +0x0p+0 +0x1.64ca0ep+2 +0x0p+0 +0x1.65d946p+2 +0x0p+0 +0x1.56bc0ap+2 +0x0p+0 +0x1.4f966cp+2 +0x0p+0 +0x1.537454p+2 +0x0p+0 +0x1.52145ap+2 +0x0p+0 +0x1.346176p+2 +0x0p+0 +0x1.29b862p+2 +0x0p+0 +0x1.894ecap+2 +0x0p+0 +0x1.89f056p+2 +0x0p+0 +0x1.8eaep-1 +0x0p+0 +0x1.39884p-1 +0x0p+0 +0x1.57f928p+1 +0x0p+0 +0x1.48da38p+1 +0x0p+0 +0x1.607802p+2 +0x0p+0 +0x1.5de67ep+2 +0x0p+0 +0x1.4aeff6p+2 +0x0p+0 +0x1.48125cp+2 +0x0p+0 +0x1.dfe45p-1 +0x0p+0 +0x1.6f6b5p-1 +0x0p+0 +0x1.546dcp-2 +0x0p+0 +0x1.87c4p-2 +0x0p+0 +0x1.59013p+2 +0x0p+0 +0x1.5aa9d2p+2 +0x0p+0 +0x1.d68454p-5 +0x0p+0 +0x1.99b3cap-4 +0x0p+0 +0x1.85e6dep+2 +0x0p+0 +0x1.84b74cp+2 +0x0p+0 +0x1.854f14p+2 +0x0p+0 +0x1.85aa5ap+2 +0x0p+0 +-0x1.8eab72p-3 +0x0p+0 +-0x1.8eab72p-3 +0x0p+0 +-0x1.97339p-3 +0x0p+0 +-0x1.9953fp-3 +0x0p+0 +0x0p+0 +-0x1.2666f4p-2 +-0x1.9953fp-3 +0x0p+0 +0x1.855516p+2 +0x0p+0 +0x1.7fb946p+2 +0x0p+0 +0x1.855516p+2 +0x0p+0 +0x1.7fb946p+2 +-0x1.7b8502p-8 +-0x1.cef40ap-10 +-0x1.cef40ap-10 +0x1.ec421ep-10 +0x1.ec421ep-10 +0x1.77972p-8 +0x1.77972p-8 +0x1.cee5dp-7 +0x1.cee5dp-7 +0x1.8e5f8p-6 +0x1.8e5f8p-6 +0x1.19b8a6p-5 +0x1.19b8a6p-5 +0x1.a037dep-4 +0x1.a037dep-4 +0x1.04f4fcp-2 +-0x1.658062p-7 +-0x1.76711ep-8 +-0x1.658062p-7 +-0x1.76711ep-8 +-0x1.77b7c6p-8 +-0x1.9b198cp-11 +-0x1.77b7c6p-8 +-0x1.9b198cp-11 +-0x1.018004p-10 +0x1.ec989cp-9 +-0x1.074fbcp-10 +0x1.ef7f06p-9 +0x1.a1c7b4p-9 +0x1.b2f986p-7 +0x1.a1c7b4p-9 +0x1.b2f986p-7 +0x1.a5cb72p-7 +0x1.89ac9ep-6 +0x1.a5cb72p-7 +0x1.89ac9ep-6 +0x1.7e73c4p-6 +0x1.105cfap-5 +0x1.7e73c4p-6 +0x1.105cfap-5 +0x1.0741c2p-5 +0x1.cb8dfap-4 +0x1.c77f0cp-4 +0x1.24a31ep-2 +-0x1.64dccep-7 +-0x1.6aa8b4p-8 +-0x1.b0c2cp-12 +0x1.d54802p-9 +0x1.bb634p-7 +0x1.8fa2b6p-6 +0x1.0fc5a4p-5 +0x1.c77f0cp-4 +0x1.24a31ep-2 +0x1.10b4ccp+1 +0x1.16ae0ap+0 +0x1.119ff2p-3 +-0x1.9a78aep+1 +-0x1.2666f4p-2 +-0x1.9a78aep+1 +-0x1.102bb6p-1 +-0x1.2ec056p+2 +-0x1.102bb6p-1 +0x1.119ff2p-3 +0x1.a8386cp-3 +-0x1.f88a4ep-7 +0x1.119ff2p-3 +-0x1.6babfp-7 +-0x1.f88a4ep-7 +0x1.a6af88p-5 +-0x1.6babfp-7 +-0x1.2666f4p-2 +0x1.a6af88p-5 +-0x1.102bb6p-1 +-0x1.2666f4p-2 +0x0p+0 +-0x1.102bb6p-1 +-0x1.2ec056p+2 +-0x1.dfc952p+1 +-0x1.9a78aep+1 +-0x1.dfc952p+1 +0x1.a8386cp-3 +0x1.661ddcp-3 +0x1.661ddcp-3 +0x1.99b3cap-4 +0x1.99b3cap-4 +0x1.a04db4p-5 +0x1.a04db4p-5 +0x0p+0 +0x1.42c444p-1 +0x1.7be57p-4 +-0x1.c68dd4p+1 +-0x1.9a19eep-2 +-0x1.c68dd4p+1 +-0x1.9a19eep-2 +-0x1.c68dd4p+1 +-0x1.2293dap-1 +-0x1.4052ap+2 +-0x1.22ed0cp-1 +0x1.808acp-3 +0x1.8227aap-4 +0x1.bfd3aep-4 +-0x1.54001ep-5 +-0x1.1576d2p-5 +0x1.9d1524p-6 +0x1.da10f2p-7 +0x1.71ed16p-3 +0x1.5f4712p-3 +-0x1.9a19eep-2 +-0x1.3c670cp-2 +-0x1.22ed0cp-1 +-0x1.1833e8p-1 +0x0p+0 +-0x1.e160a8p+1 +-0x1.4052ap+2 +-0x1.e17f8ep+1 +-0x1.c676p+1 +0x1.81bc6p-3 +0x1.7ec44cp-3 +0x1.303248p-3 +0x1.84d7d2p-3 +0x1.96cf64p-5 +0x1.37e15ap-3 +0x0p+0 +0x1.dc372ap-5 +0x1.42c444p-1 +0x1.786e8cp-4 +-0x1.c676p+1 +-0x1.51288ap-2 +-0x1.c676p+1 +-0x1.51288ap-2 +-0x1.c67488p+1 +-0x1.1dde76p-1 +-0x1.4052ap+2 +-0x1.1e2e7p-1 +0x1.8262bcp-3 +0x1.80027p-4 +0x1.b534a6p-4 +-0x1.20fe96p-5 +-0x1.da2c66p-6 +0x1.04892ep-5 +0x1.5101bp-6 +0x1.799886p-3 +0x1.5ed6a8p-3 +-0x1.50eeap-2 +-0x1.26981ep-2 +-0x1.1e2e7p-1 +-0x1.18888ap-1 +0x0p+0 +-0x1.e16e26p+1 +-0x1.4052ap+2 +-0x1.e17454p+1 +-0x1.c65d48p+1 +0x1.7dad9cp-3 +0x1.7c2e0ap-3 +0x1.245bcap-3 +0x1.8129aap-3 +0x1.b6a76p-5 +0x1.30bcccp-3 +0x0p+0 +0x1.f716e4p-5 +0x1.42c444p-1 +0x1.70dcb2p-4 +-0x1.c65d48p+1 +-0x1.42ce98p-2 +-0x1.c65d48p+1 +-0x1.42ce98p-2 +-0x1.c64e06p+1 +-0x1.1b7c86p-1 +-0x1.4052ap+2 +-0x1.1bc7f8p-1 +0x1.7fec2p-3 +0x1.797232p-4 +0x1.adcef6p-4 +-0x1.f2e09cp-6 +-0x1.971e9p-6 +0x1.0ad4dap-5 +0x1.7dc58cp-6 +0x1.2ba5fcp-3 +0x1.2c0edp-3 +-0x1.406758p-2 +-0x1.1b8ffap-2 +-0x1.1bc7f8p-1 +-0x1.17868ep-1 +0x0p+0 +-0x1.e17094p+1 +-0x1.4052ap+2 +-0x1.e171eep+1 +-0x1.c6375p+1 +0x1.7d6d6ep-3 +0x1.7994b2p-3 +0x1.1ef9d2p-3 +0x1.7fd218p-3 +0x1.d43f82p-5 +0x1.2b6d66p-3 +0x0p+0 +0x1.076b7p-4 +0x1.42c444p-1 +0x1.6ac1c4p-4 +-0x1.9afd3ep-6 +0x1.4f36b8p-5 +0x1.ff986p-4 +-0x1.37f0bcp-2 +-0x1.19bc64p-1 +0x0p+0 +-0x1.4052ap+2 +-0x1.e16c3cp+1 +-0x1.c6375p+1 +0x1.7ca0f2p-3 +0x1.7ba3c8p-3 +0x1.1ab8d6p-3 +0x1.ef2eb4p-5 +-0x1.81be06p+1 +0x1.fb683p+3 +-0x1.2447a2p+2 +-0x1.14e276p+3 +-0x1.14e276p+3 +-0x1.2c0308p+2 +0x1.203da6p+1 +-0x1.2c0308p+2 +-0x1.2fe6ecp+2 +-0x1.1594cp+3 +-0x1.300e48p+2 +-0x1.1594cp+3 +-0x1.300b82p+2 +0x1.1f60f2p+1 +-0x1.2fe6ecp+2 +-0x1.1594cp+3 +-0x1.300bap+2 +0x1.1f60f2p+1 +-0x1.4198cp+0 +-0x1.d4a9p+2 +-0x1.62337ap-1 +-0x1.818cf6p+3 +-0x1.62337ap-1 +-0x1.59b94p-1 +-0x1.dbce9ep+2 +-0x1.59b9cep-1 +-0x1.881a92p+3 +-0x1.59b9d2p-1 +-0x1.881a92p+3 +-0x1.dbce9ep+2 +-0x1.2bd384p+1 +0x0p+0 +-0x1.7e8732p+3 +-0x1.05ecp-3 +-0x1.2bd384p+1 +-0x1.05ecp-3 +-0x1.354328p+1 +0x0p+0 +-0x1.f080c4p-4 +-0x1.83d98ep+3 +-0x1.f12b68p-4 +-0x1.354328p+1 +-0x1.f2d50cp-4 +-0x1.354328p+1 +0x0p+0 +-0x1.83d98ep+3 +-0x1.41082cp+2 +-0x1.da9474p+1 +-0x1.9c7872p+1 +-0x1.da9474p+1 +-0x1.df3fb6p+1 +-0x1.46f352p+2 +-0x1.df3e6ep+1 +-0x1.942698p+1 +-0x1.df3e9ap+1 +-0x1.942698p+1 +-0x1.46f352p+2 +-0x1.79a376p+2 +-0x1.dc2d1p+2 +-0x1.940296p+3 +0x0p+0 +-0x1.940296p+3 +-0x1.bbaf2p-1 +-0x1.79a376p+2 +-0x1.bbaf2p-1 +-0x1.dc2d1p+2 +-0x1.a1c9bap-1 +-0x1.c6536p+3 +-0x1.a1c9bap-1 +-0x1.79b6c8p+2 +-0x1.dc4062p+2 +-0x1.7955b8p+2 +-0x1.dcb474p+2 +-0x1.987dbap+3 +0x0p+0 +-0x1.ba133cp-1 +-0x1.987dbap+3 +-0x1.ba30e8p-1 +-0x1.798da2p+2 +-0x1.a4b692p-1 +-0x1.dc85b4p+2 +-0x1.a3fb72p-1 +-0x1.cba7eap+3 +-0x1.798da2p+2 +-0x1.dc85b4p+2 +-0x1.793c94p+2 +-0x1.dce724p+2 +-0x1.987dbap+3 +0x0p+0 +-0x1.b9b016p-1 +-0x1.987dbap+3 +-0x1.b9de14p-1 +-0x1.796eeap+2 +-0x1.a43e26p-1 +-0x1.dcbd3ap+2 +-0x1.a3af6ep-1 +-0x1.cba7eap+3 +-0x1.796eeap+2 +-0x1.dcbd3ap+2 +-0x1.792964p+2 +-0x1.dd1136p+2 +-0x1.987dbap+3 +0x0p+0 +-0x1.b963e2p-1 +-0x1.987dbap+3 +-0x1.b98f46p-1 +-0x1.79588p+2 +-0x1.a3e212p-1 +-0x1.dcea26p+2 +-0x1.a36746p-1 +-0x1.cba7eap+3 +-0x1.b922c6p-1 +-0x1.79588p+2 +-0x1.dcea26p+2 +-0x1.a392d6p-1 +-0x1.cba7eap+3 +-0x1.987dbap+3 +0x0p+0 +-0x1.4ba1b8p+1 +-0x1.f29ab8p+1 +-0x1.4c3b8ep-2 +-0x1.f29ab8p+1 +-0x1.f36cc2p+1 +-0x1.4f830ap+1 +-0x1.f36cbep+1 +-0x1.30fcccp-2 +-0x1.f36ccp+1 +-0x1.30fcccp-2 +-0x1.4f830ap+1 +-0x1.64324cp+2 +-0x1.002d72p+0 +-0x1.3fe928p+3 +-0x1.002d72p+0 +-0x1.05af64p+0 +-0x1.72416cp+2 +-0x1.05aeap+0 +-0x1.43b0e4p+3 +-0x1.05aeccp+0 +-0x1.43b0e4p+3 +-0x1.72416cp+2 +-0x1.a15ff8p+2 +-0x1.38c14ap+3 +-0x1.118b2ap+0 +-0x1.38c14ap+3 +-0x1.3c1c22p+3 +-0x1.a3f82ap+2 +-0x1.3c18aep+3 +-0x1.1919a8p+0 +-0x1.3c17f4p+3 +-0x1.a3f82ap+2 +-0x1.3c1838p+3 +-0x1.1919a8p+0 +-0x1.3c181ep+3 +-0x1.a3f82ap+2 +-0x1.3c1828p+3 +-0x1.1919a8p+0 +-0x1.3c1826p+3 +-0x1.1919a8p+0 +-0x1.a3f82ap+2 +-0x1.7b8502p-8 +-0x1.cef40ap-10 +0x1.ec421ep-10 +0x1.77972p-8 +0x1.cee5dp-7 +0x1.8e5f8p-6 +0x1.19b8a6p-5 +0x1.a037dep-4 +0x1.04f4fcp-2 +0x1.efea52p+0 +0x1.16ae0ap+0 +-0x1.7d05bcp+1 +0x1.010864p+4 +-0x1.2447a2p+2 +-0x1.525d4ap+0 +-0x1.62337ap-1 +-0x1.d4a9p+2 +-0x1.818cf6p+3 +-0x1.05ecp-3 +-0x1.7e8732p+3 +-0x1.2bd384p+1 +-0x1.da9474p+1 +-0x1.41082cp+2 +-0x1.9c7872p+1 +-0x1.bbaf2p-1 +-0x1.940296p+3 +-0x1.79a376p+2 +-0x1.a1c9bap-1 +-0x1.dc2d1p+2 +-0x1.c6536p+3 +-0x1.dfc952p+1 +-0x1.2ec056p+2 +-0x1.9a78aep+1 +-0x1.f29ab8p+1 +-0x1.4ba1b8p+1 +-0x1.4c3b8ep-2 +-0x1.002d72p+0 +-0x1.64324cp+2 +-0x1.3fe928p+3 +-0x1.38c14ap+3 +-0x1.a15ff8p+2 +-0x1.118b2ap+0 +-0x1.2c0308p+2 +0x1.203da6p+1 +-0x1.14e276p+3 +0x1.a04db4p-5 +0x1.99b3cap-4 +0x1.661ddcp-3 +0x1.a8386cp-3 +0x1.119ff2p-3 +-0x1.f88a4ep-7 +-0x1.6babfp-7 +0x1.a6af88p-5 +-0x1.2666f4p-2 +-0x1.102bb6p-1 +0x0p+0 +0x1.89c6bep+1 +0x0p+0 +0x1.5e081cp+1 +0x0p+0 +0x1.9169ep+2 +0x0p+0 +0x1.94be24p+2 +0x0p+0 +0x1.a6af88p-5 +0x0p+0 +0x1.ff986p-4 +0x0p+0 +0x1.52145ap+2 +0x0p+0 +0x1.50b404p+2 +0x0p+0 +0x1.7fb946p+2 +0x0p+0 +0x1.7ea0aap+2 +0x0p+0 +0x1.a739bp+1 +0x0p+0 +0x1.a28166p+1 +0x0p+0 +0x1.6579bp+1 +0x0p+0 +0x1.581e4p+1 +0x0p+0 +0x1.4dbcecp+2 +0x0p+0 +0x1.4bd94cp+2 +0x0p+0 +0x1.6f6b5p-1 +0x0p+0 +0x1.fde4ap-2 +0x0p+0 +0x1.82df74p+2 +0x0p+0 +0x1.804742p+2 +0x0p+0 +0x1.87c4p-2 +0x0p+0 +0x1.8c736p-2 +0x0p+0 +0x1.203da6p+1 +0x0p+0 +0x1.1f60f2p+1 +0x0p+0 +0x1.44761ap+1 +0x0p+0 +0x1.42d33p+1 +0x0p+0 +0x1.5aa9d2p+2 +0x0p+0 +0x1.5afb5ep+2 +0x0p+0 +0x1.89c6bep+1 +0x0p+0 +0x1.5e081cp+1 +0x0p+0 +0x1.9872b8p+0 +0x0p+0 +0x1.885058p+0 +0x0p+0 +0x1.8d7d8p+0 +0x0p+0 +0x1.473458p+0 +0x0p+0 +0x1.092cp-1 +0x0p+0 +0x1.40a48p-2 +0x0p+0 +0x1.f4f5p+1 +0x0p+0 +0x1.f22bd8p+1 +0x0p+0 +0x1.49aaf8p+1 +0x0p+0 +0x1.4500d2p+1 +0x0p+0 +0x1.8e59f6p+2 +0x0p+0 +0x1.8563aep+2 +0x0p+0 +0x1.b7605p+0 +0x0p+0 +0x1.88e328p+0 +0x0p+0 +0x1.445e28p+0 +0x0p+0 +0x1.2cb19p+0 +0x0p+0 +0x1.87c6fap+1 +0x0p+0 +0x1.9018d4p+1 +0x0p+0 +0x1.f86be8p+1 +0x0p+0 +0x1.eefc44p+1 +0x0p+0 +0x1.f3b416p+1 +0x0p+0 +0x1.f1685p+1 +0x0p+0 +0x1.65d946p+2 +0x0p+0 +0x1.66e87cp+2 +0x0p+0 +0x1.4f966cp+2 +0x0p+0 +0x1.4870cep+2 +0x0p+0 +0x1.52145ap+2 +0x0p+0 +0x1.50b404p+2 +0x0p+0 +0x1.29b862p+2 +0x0p+0 +0x1.1f0f4ep+2 +0x0p+0 +0x1.89f056p+2 +0x0p+0 +0x1.8a5462p+2 +0x0p+0 +0x1.39884p-1 +0x0p+0 +0x1.c8c5p-2 +0x0p+0 +0x1.48da38p+1 +0x0p+0 +0x1.39bb48p+1 +0x0p+0 +0x1.5de67ep+2 +0x0p+0 +0x1.5dad5cp+2 +0x0p+0 +0x1.48125cp+2 +0x0p+0 +0x1.475546p+2 +0x0p+0 +0x1.6f6b5p-1 +0x0p+0 +0x1.fde4ap-2 +0x0p+0 +0x1.87c4p-2 +0x0p+0 +0x1.8c736p-2 +0x0p+0 +0x1.5aa9d2p+2 +0x0p+0 +0x1.5afb5ep+2 +0x0p+0 +0x1.99b3cap-4 +0x0p+0 +0x1.1ab8d6p-3 +0x0p+0 +0x1.7fb946p+2 +0x0p+0 +0x1.7ea0aap+2 +0x0p+0 +0x1.7f2cf8p+2 +0x0p+0 +0x1.7f94aap+2 +0x0p+0 +-0x1.28b0b2p-2 +0x0p+0 +-0x1.28b0b2p-2 +0x0p+0 +-0x1.2ce13p-2 +0x0p+0 +-0x1.2decacp-2 +0x0p+0 +0x0p+0 +-0x1.c87364p-2 +-0x1.2decacp-2 +0x0p+0 +0x1.7f40ecp+2 +0x0p+0 +0x1.75988p+2 +0x0p+0 +0x1.7a6cb6p+2 +0x0p+0 +0x1.76143cp+2 +0x0p+0 +0x1.75988p+2 +0x0p+0 +0x1.7f40ecp+2 +0x0p+0 +0x1.75988p+2 +0x0p+0 +-0x1.32d71cp+1 +-0x1.32d71cp+1 +0x0p+0 +-0x1.31acc8p+1 +0x0p+0 +-0x1.3162f6p+1 +0x0p+0 +0x0p+0 +-0x1.34f674p+1 +-0x1.3162f6p+1 +0x0p+0 +0x1.f2dc76p+1 +0x0p+0 +0x1.ef48f8p+1 +-0x1.64dccep-7 +-0x1.6aa8b4p-8 +-0x1.6aa8b4p-8 +-0x1.b0c2cp-12 +-0x1.b0c2cp-12 +0x1.d54802p-9 +0x1.d54802p-9 +0x1.bb634p-7 +0x1.bb634p-7 +0x1.8fa2b6p-6 +0x1.8fa2b6p-6 +0x1.0fc5a4p-5 +0x1.0fc5a4p-5 +0x1.c77f0cp-4 +0x1.c77f0cp-4 +0x1.24a31ep-2 +-0x1.064d58p-6 +-0x1.36ae68p-7 +-0x1.36ae68p-7 +-0x1.92ffcap-9 +-0x1.36ae68p-7 +-0x1.92ffcap-9 +-0x1.a29e5ap-9 +0x1.a564bcp-10 +-0x1.a29e5ap-9 +0x1.a564bcp-10 +0x1.1c40bap-10 +0x1.9f76f6p-7 +0x1.9b1e9ep-7 +0x1.8aefd4p-6 +0x1.856cb6p-6 +0x1.0669f8p-5 +0x1.856cb6p-6 +0x1.0669f8p-5 +0x1.001ap-5 +0x1.f2d528p-4 +0x1.efedecp-4 +0x1.44514p-2 +-0x1.064d58p-6 +-0x1.32c27ap-7 +-0x1.5e1dbp-9 +0x1.3e4242p-10 +0x1.a5be3ap-7 +0x1.915feap-6 +0x1.0646f2p-5 +0x1.efedecp-4 +0x1.44514p-2 +0x1.29747p+1 +0x1.42c444p-1 +0x1.6ac1c4p-4 +-0x1.c6375p+1 +-0x1.c87364p-2 +0x1.6ac1c4p-4 +0x1.7ca0f2p-3 +-0x1.9afd3ep-6 +0x1.6ac1c4p-4 +0x1.4f36b8p-5 +-0x1.9afd3ep-6 +0x1.ff986p-4 +0x1.4f36b8p-5 +-0x1.c87364p-2 +0x1.ff986p-4 +-0x1.19bc64p-1 +-0x1.c87364p-2 +0x0p+0 +-0x1.19bc64p-1 +-0x1.c6375p+1 +-0x1.e16c3cp+1 +-0x1.4052ap+2 +-0x1.e16c3cp+1 +0x1.7ca0f2p-3 +0x1.7ba3c8p-3 +0x1.7ba3c8p-3 +0x1.1ab8d6p-3 +0x1.1ab8d6p-3 +0x1.ef2eb4p-5 +0x1.ef2eb4p-5 +0x0p+0 +0x1.7dbd24p-3 +0x1.76b20ep-5 +-0x1.f878f2p+1 +-0x1.930b96p-2 +-0x1.f878f2p+1 +-0x1.930b96p-2 +0x1.305e7ap-3 +0x1.79d9a4p-5 +0x1.050feap-4 +-0x1.0dd8d2p-6 +-0x1.095f14p-6 +0x1.d81cc2p-4 +0x1.8ef74p-4 +0x1.390f2ep-4 +0x1.753a7ep-4 +-0x1.91257p-2 +-0x1.239a9p-2 +-0x1.46f0a4p-1 +-0x1.3415bep-1 +0x0p+0 +-0x1.e239d6p+1 +-0x1.f86d8ap+1 +-0x1.e239dep+1 +-0x1.51e4eap+2 +0x1.842e3cp-3 +0x1.2c35e2p-3 +0x1.5c563cp-3 +0x1.7dd8bcp-3 +0x1.650a68p-4 +0x1.64e1aap-3 +0x0p+0 +0x1.8631b4p-4 +0x1.7dbd24p-3 +0x1.96a892p-5 +-0x1.f86d8ap+1 +-0x1.2c99f8p-2 +-0x1.f86d8ap+1 +-0x1.2c99f8p-2 +0x1.373662p-3 +0x1.9a6564p-5 +0x1.0499d2p-4 +-0x1.940258p-7 +-0x1.8ce0a8p-7 +0x1.bdfc04p-4 +0x1.87f05p-4 +0x1.09562p-3 +0x1.ebc456p-4 +-0x1.2ba7d2p-2 +-0x1.0a37b8p-2 +-0x1.3e045ap-1 +-0x1.3456b4p-1 +0x0p+0 +-0x1.e23c04p+1 +-0x1.f867ep+1 +-0x1.e239c6p+1 +-0x1.51e4eap+2 +0x1.7faf76p-3 +0x1.2bc382p-3 +0x1.519c5p-3 +0x1.7a3b3ep-3 +0x1.7402aep-4 +0x1.5c5d32p-3 +0x0p+0 +0x1.9352d8p-4 +0x1.7dbd24p-3 +0x1.9d644ep-5 +-0x1.f867ep+1 +-0x1.266122p-2 +-0x1.f867ep+1 +-0x1.266122p-2 +0x1.3692a2p-3 +0x1.a1a68ap-5 +0x1.064b3ap-4 +-0x1.69f276p-8 +-0x1.b3ee78p-8 +0x1.7751e6p-4 +0x1.5b57fcp-4 +0x1.8ef00ep-4 +0x1.ab2556p-4 +-0x1.236caap-2 +-0x1.03d538p-2 +-0x1.39760ep-1 +-0x1.324084p-1 +0x0p+0 +-0x1.e23a92p+1 +-0x1.f8568p+1 +-0x1.e235aep+1 +-0x1.51e4eap+2 +0x1.7cf874p-3 +0x1.2b45e8p-3 +0x1.4bb734p-3 +0x1.77904p-3 +0x1.823138p-4 +0x1.55fe04p-3 +0x0p+0 +0x1.9e6c1p-4 +0x1.7dbd24p-3 +0x1.a07412p-5 +0x1.7069ap-9 +0x1.7f406ep-4 +0x1.5ad766p-4 +-0x1.21be96p-2 +-0x1.360e08p-1 +0x0p+0 +-0x1.f8568p+1 +-0x1.e2376ep+1 +-0x1.51e4eap+2 +0x1.357468p-3 +0x1.794c4p-3 +0x1.46e01p-3 +0x1.8eff2p-4 +-0x1.86765p+1 +0x1.f4bf98p+3 +-0x1.3b8636p+2 +-0x1.30d436p+0 +-0x1.dbce9ep+2 +-0x1.59b9d2p-1 +-0x1.881a92p+3 +-0x1.59b9d2p-1 +-0x1.513fdep-1 +-0x1.e2f43cp+2 +-0x1.51405cp-1 +-0x1.8ea82ep+3 +-0x1.514074p-1 +-0x1.8ea82ep+3 +-0x1.e2f43cp+2 +-0x1.34f674p+1 +0x0p+0 +-0x1.34f674p+1 +-0x1.942698p+1 +-0x1.83d98ep+3 +-0x1.f2d50cp-4 +-0x1.34f674p+1 +-0x1.f2d50cp-4 +-0x1.942698p+1 +-0x1.df3e9ap+1 +-0x1.46f352p+2 +-0x1.df3e9ap+1 +-0x1.45057ap+1 +0x0p+0 +-0x1.45057ap+1 +-0x1.79635ep+1 +-0x1.a62374p-3 +-0x1.892beap+3 +-0x1.a36d52p-3 +-0x1.45057ap+1 +-0x1.e08956p+1 +-0x1.79635ep+1 +-0x1.e07452p+1 +-0x1.4cde78p+2 +-0x1.45057ap+1 +0x0p+0 +-0x1.45057ap+1 +-0x1.79635ep+1 +-0x1.e5ef2cp-3 +-0x1.892beap+3 +-0x1.cda272p-3 +-0x1.45057ap+1 +-0x1.e07b54p+1 +-0x1.79635ep+1 +-0x1.e078d8p+1 +-0x1.4cde78p+2 +-0x1.45057ap+1 +0x0p+0 +-0x1.45057ap+1 +-0x1.79635ep+1 +-0x1.d6753ap-3 +-0x1.892beap+3 +-0x1.d34302p-3 +-0x1.45057ap+1 +-0x1.e079bcp+1 +-0x1.79635ep+1 +-0x1.e0796ep+1 +-0x1.4cde78p+2 +-0x1.d46a72p-3 +-0x1.45057ap+1 +-0x1.79635ep+1 +-0x1.e07984p+1 +-0x1.4cde78p+2 +0x0p+0 +-0x1.892beap+3 +-0x1.79588p+2 +-0x1.dcea26p+2 +-0x1.987dbap+3 +-0x1.b922c6p-1 +-0x1.79588p+2 +-0x1.b922c6p-1 +-0x1.dcea26p+2 +-0x1.a392d6p-1 +-0x1.cba7eap+3 +-0x1.a392d6p-1 +-0x1.79747ep+2 +-0x1.dd0624p+2 +-0x1.7937c2p+2 +-0x1.dd4fd2p+2 +-0x1.b76ae6p-1 +-0x1.9cf8dep+3 +-0x1.b7883ep-1 +-0x1.79648cp+2 +-0x1.a658d2p-1 +-0x1.dd2adp+2 +-0x1.a602a4p-1 +-0x1.d0fc74p+3 +-0x1.79648cp+2 +-0x1.dd2adp+2 +-0x1.793066p+2 +-0x1.dd6a4p+2 +-0x1.b73908p-1 +-0x1.9cf8dep+3 +-0x1.b754fep-1 +-0x1.795932p+2 +-0x1.a62136p-1 +-0x1.dd489cp+2 +-0x1.a5c4bap-1 +-0x1.d0fc74p+3 +-0x1.795932p+2 +-0x1.dd489cp+2 +-0x1.792b78p+2 +-0x1.dd805ep+2 +-0x1.b700c2p-1 +-0x1.9cf8dep+3 +-0x1.b71ebp-1 +-0x1.795178p+2 +-0x1.a5e596p-1 +-0x1.dd6116p+2 +-0x1.a59098p-1 +-0x1.d0fc74p+3 +-0x1.b6d18p-1 +-0x1.795178p+2 +-0x1.dd6116p+2 +-0x1.a5aec2p-1 +-0x1.d0fc74p+3 +-0x1.9cf8dep+3 +-0x1.4f830ap+1 +-0x1.f36ccp+1 +-0x1.30fcccp-2 +-0x1.f36ccp+1 +-0x1.f43ec8p+1 +-0x1.53645cp+1 +-0x1.f43ec6p+1 +-0x1.15be0ap-2 +-0x1.f43ec8p+1 +-0x1.15be0ap-2 +-0x1.53645cp+1 +-0x1.72416cp+2 +0x0p+0 +-0x1.72416cp+2 +-0x1.05aeccp+0 +-0x1.43b0e4p+3 +-0x1.05aeccp+0 +-0x1.7ff3e6p+2 +0x0p+0 +-0x1.f3146p-1 +-0x1.7ff3e6p+2 +-0x1.f1e878p-1 +-0x1.4778ap+3 +-0x1.7ff3e6p+2 +0x0p+0 +-0x1.f2550ep-1 +-0x1.7ff3e6p+2 +-0x1.f22e94p-1 +-0x1.4778ap+3 +-0x1.f23c5ep-1 +-0x1.4778ap+3 +-0x1.7ff3e6p+2 +0x0p+0 +-0x1.a3f82ap+2 +-0x1.3c1826p+3 +-0x1.1919a8p+0 +-0x1.3c1826p+3 +-0x1.3f6ea6p+3 +-0x1.a6905cp+2 +-0x1.3f6b3ep+3 +-0x1.20a826p+0 +-0x1.3f6a86p+3 +-0x1.a6905cp+2 +-0x1.3f6ac8p+3 +-0x1.20a826p+0 +-0x1.3f6abp+3 +-0x1.a6905cp+2 +-0x1.3f6ab8p+3 +-0x1.20a826p+0 +-0x1.3f6ab6p+3 +-0x1.20a826p+0 +-0x1.a6905cp+2 +0x1.1f60f2p+1 +-0x1.300bap+2 +-0x1.1594cp+3 +-0x1.300bap+2 +-0x1.3414aep+2 +0x1.1e843ep+1 +-0x1.3413c6p+2 +-0x1.16470ap+3 +-0x1.34111ap+2 +0x1.1e843ep+1 +-0x1.341214p+2 +-0x1.16470ap+3 +-0x1.3411bap+2 +-0x1.16470ap+3 +0x1.1e843ep+1 +-0x1.64dccep-7 +-0x1.6aa8b4p-8 +-0x1.b0c2cp-12 +0x1.d54802p-9 +0x1.bb634p-7 +0x1.8fa2b6p-6 +0x1.0fc5a4p-5 +0x1.c77f0cp-4 +0x1.24a31ep-2 +0x1.10b4ccp+1 +0x1.42c444p-1 +-0x1.81be06p+1 +0x1.fb683p+3 +-0x1.2fe6ecp+2 +-0x1.4198cp+0 +-0x1.59b9d2p-1 +-0x1.dbce9ep+2 +-0x1.881a92p+3 +-0x1.f2d50cp-4 +-0x1.83d98ep+3 +-0x1.34f674p+1 +-0x1.df3e9ap+1 +-0x1.46f352p+2 +-0x1.942698p+1 +-0x1.b922c6p-1 +-0x1.987dbap+3 +-0x1.79588p+2 +-0x1.a392d6p-1 +-0x1.dcea26p+2 +-0x1.cba7eap+3 +-0x1.e16c3cp+1 +-0x1.4052ap+2 +-0x1.c6375p+1 +-0x1.f36ccp+1 +-0x1.4f830ap+1 +-0x1.30fcccp-2 +-0x1.05aeccp+0 +-0x1.72416cp+2 +-0x1.43b0e4p+3 +-0x1.3c1826p+3 +-0x1.a3f82ap+2 +-0x1.1919a8p+0 +-0x1.300bap+2 +0x1.1f60f2p+1 +-0x1.1594cp+3 +0x1.ef2eb4p-5 +0x1.1ab8d6p-3 +0x1.7ba3c8p-3 +0x1.7ca0f2p-3 +0x1.6ac1c4p-4 +-0x1.9afd3ep-6 +0x1.4f36b8p-5 +0x1.ff986p-4 +-0x1.c87364p-2 +-0x1.19bc64p-1 +0x0p+0 +0x1.7f0feap+2 +0x0p+0 +0x1.80c3d6p+2 +0x0p+0 +0x1.4f36b8p-5 +0x0p+0 +0x1.7f406ep-4 +0x0p+0 +0x1.ff986p-4 +0x0p+0 +0x1.5ad766p-4 +0x0p+0 +0x1.50b404p+2 +0x0p+0 +0x1.53d82ap+2 +0x0p+0 +0x1.75988p+2 +0x0p+0 +0x1.8003ccp+2 +0x0p+0 +0x1.7ace26p+2 +0x0p+0 +0x1.7dca5p+2 +0x0p+0 +0x1.8003ccp+2 +0x0p+0 +0x1.a28166p+1 +0x0p+0 +0x1.9dc91cp+1 +0x0p+0 +0x1.581e4p+1 +0x0p+0 +0x1.4ad4p+1 +0x0p+0 +0x1.4bd94cp+2 +0x0p+0 +0x1.49f5acp+2 +0x0p+0 +0x1.fde4ap-2 +0x0p+0 +0x1.22bdp-2 +0x0p+0 +0x1.804742p+2 +0x0p+0 +0x1.7daf1p+2 +0x0p+0 +0x1.8c736p-2 +0x0p+0 +0x1.8ce3ep-2 +0x0p+0 +0x1.1f60f2p+1 +0x0p+0 +0x1.1e843ep+1 +0x0p+0 +0x1.42d33p+1 +0x0p+0 +0x1.4207fep+1 +0x0p+0 +0x1.5afb5ep+2 +0x0p+0 +0x1.5b4586p+2 +0x0p+0 +0x1.5e081cp+1 +0x0p+0 +0x1.2be8ecp+1 +0x0p+0 +0x1.885058p+0 +0x0p+0 +0x1.7837fp+0 +0x0p+0 +0x1.473458p+0 +0x0p+0 +0x1.00eb3p+0 +0x0p+0 +0x1.40a48p-2 +0x0p+0 +0x1.bbc4p-4 +0x0p+0 +0x1.f22bd8p+1 +0x0p+0 +0x1.ef62bp+1 +0x0p+0 +0x1.4500d2p+1 +0x0p+0 +0x1.43c5e8p+1 +0x0p+0 +0x1.8563aep+2 +0x0p+0 +0x1.7c6d66p+2 +0x0p+0 +0x1.88e328p+0 +0x0p+0 +0x1.5a66p+0 +0x0p+0 +0x1.2cb19p+0 +0x0p+0 +0x1.1504f8p+0 +0x0p+0 +0x1.9018d4p+1 +0x0p+0 +0x1.aadc0ep+1 +0x0p+0 +0x1.ef48f8p+1 +0x0p+0 +0x1.df39f2p+1 +0x0p+0 +0x1.66e87cp+2 +0x0p+0 +0x1.67f7a8p+2 +0x0p+0 +0x1.4870cep+2 +0x0p+0 +0x1.414b3p+2 +0x0p+0 +0x1.50b404p+2 +0x0p+0 +0x1.53d82ap+2 +0x0p+0 +0x1.1f0f4ep+2 +0x0p+0 +0x1.14663ap+2 +0x0p+0 +0x1.8a5462p+2 +0x0p+0 +0x1.837c62p+2 +0x0p+0 +0x1.c8c5p-2 +0x0p+0 +0x1.1e798p-2 +0x0p+0 +0x1.39bb48p+1 +0x0p+0 +0x1.2a9c58p+1 +0x0p+0 +0x1.5dad5cp+2 +0x0p+0 +0x1.5d69dep+2 +0x0p+0 +0x1.475546p+2 +0x0p+0 +0x1.46de56p+2 +0x0p+0 +0x1.fde4ap-2 +0x0p+0 +0x1.22bdp-2 +0x0p+0 +0x1.8c736p-2 +0x0p+0 +0x1.8ce3ep-2 +0x0p+0 +0x1.1ab8d6p-3 +0x0p+0 +0x1.46e01p-3 +0x0p+0 +0x1.75988p+2 +0x0p+0 +0x1.8003ccp+2 +0x0p+0 +0x1.7ace26p+2 +0x0p+0 +0x1.761eb4p+2 +0x0p+0 +-0x1.c01032p-2 +0x0p+0 +-0x1.c01032p-2 +0x0p+0 +-0x1.c4350ap-2 +0x0p+0 +-0x1.c53de4p-2 +0x0p+0 +-0x1.c58014p-2 +0x0p+0 +0x0p+0 +-0x1.08311p-1 +-0x1.c58014p-2 +0x0p+0 +0x1.75c7b4p+2 +0x0p+0 +0x1.711994p+2 +0x0p+0 +0x1.7370a4p+2 +0x0p+0 +0x1.73552cp+2 +0x0p+0 +0x1.75c7b4p+2 +0x0p+0 +0x1.711994p+2 +0x0p+0 +-0x1.eca8a2p-2 +-0x1.eca8a2p-2 +0x0p+0 +-0x1.e891acp-2 +0x0p+0 +-0x1.e9911cp-2 +0x0p+0 +-0x1.e82d42p-2 +0x0p+0 +-0x1.e8f074p-2 +0x0p+0 +-0x1.e84f5ap-2 +0x0p+0 +-0x1.e8bbb4p-2 +0x0p+0 +-0x1.e8bbb4p-2 +0x0p+0 +0x0p+0 +-0x1.e86cbap-2 +-0x1.e8bbb4p-2 +0x0p+0 +0x1.7393fap+2 +0x0p+0 +0x1.7398eap+2 +0x0p+0 +0x1.7393fap+2 +0x0p+0 +0x1.7398eap+2 +-0x1.064d58p-6 +-0x1.32c27ap-7 +-0x1.32c27ap-7 +-0x1.5e1dbp-9 +-0x1.5e1dbp-9 +0x1.3e4242p-10 +0x1.3e4242p-10 +0x1.a5be3ap-7 +0x1.a5be3ap-7 +0x1.915feap-6 +0x1.915feap-6 +0x1.0646f2p-5 +0x1.0646f2p-5 +0x1.efedecp-4 +0x1.efedecp-4 +0x1.44514p-2 +-0x1.5a2c48p-6 +-0x1.b41c88p-7 +-0x1.b41c88p-7 +-0x1.5d829p-8 +-0x1.60af42p-8 +-0x1.8dd20cp-11 +-0x1.60af42p-8 +-0x1.8dd20cp-11 +-0x1.3891eap-10 +0x1.89d1fp-7 +0x1.89d1fp-7 +0x1.8cad08p-6 +0x1.8c7fdap-6 +0x1.f9d68cp-6 +0x1.8c7fdap-6 +0x1.f9d68cp-6 +0x1.f2b324p-6 +0x1.0da204p-3 +0x1.0cb77ap-3 +0x1.63ff62p-2 +-0x1.5a2c48p-6 +-0x1.b284f4p-7 +-0x1.4441fp-8 +-0x1.3891eap-10 +0x1.8a2924p-7 +0x1.934702p-6 +0x1.fa9a5ep-6 +0x1.0cb77ap-3 +0x1.63ff62p-2 +0x1.423414p+1 +0x1.7dbd24p-3 +0x1.a07412p-5 +-0x1.e86cbap-2 +0x0p+0 +-0x1.f8568p+1 +-0x1.e86cbap-2 +-0x1.e86cbap-2 +0x0p+0 +0x1.a07412p-5 +0x1.357468p-3 +0x1.7069ap-9 +0x1.a07412p-5 +0x1.7f406ep-4 +0x1.7069ap-9 +0x1.5ad766p-4 +0x1.7f406ep-4 +-0x1.e86cbap-2 +0x1.5ad766p-4 +-0x1.360e08p-1 +-0x1.e86cbap-2 +0x0p+0 +-0x1.360e08p-1 +-0x1.f8568p+1 +-0x1.e2376ep+1 +-0x1.51e4eap+2 +-0x1.e2376ep+1 +0x1.357468p-3 +0x1.794c4p-3 +0x1.794c4p-3 +0x1.46e01p-3 +0x1.46e01p-3 +0x1.8eff2p-4 +0x1.8eff2p-4 +0x0p+0 +-0x1.9deaccp-3 +0x1.eae95cp-6 +-0x1.e6af1p-2 +0x0p+0 +-0x1.157ebcp+2 +-0x1.e6af1p-2 +-0x1.cfb076p-2 +0x0p+0 +0x1.972508p-4 +0x1.d97b3cp-6 +0x1.55266p-5 +0x1.64d19ap-5 +0x1.1e264cp-5 +0x1.23697p-3 +0x1.10dbf6p-3 +-0x1.fa416p-7 +0x1.90bd94p-9 +-0x1.d5b5f6p-2 +-0x1.5fd3bap-2 +-0x1.3e7072p-1 +-0x1.1e283p-1 +0x0p+0 +-0x1.e0f4a6p+1 +-0x1.157a1cp+2 +-0x1.e092aap+1 +-0x1.637734p+2 +0x1.630646p-3 +0x1.95375p-4 +0x1.6272f8p-3 +0x1.547b62p-3 +0x1.326d8p-3 +0x1.68a30cp-3 +0x0p+0 +0x1.35b5c6p-3 +-0x1.9deaccp-3 +0x1.1134eap-5 +-0x1.336c2cp-2 +0x0p+0 +-0x1.157a1cp+2 +-0x1.336c2cp-2 +-0x1.28e08ep-2 +0x0p+0 +0x1.b48132p-4 +0x1.08d8dap-5 +0x1.5446f8p-5 +0x1.6495fcp-5 +0x1.31692ep-5 +0x1.06ea58p-3 +0x1.fadbb8p-4 +0x1.fb886ap-5 +0x1.abf7aep-5 +-0x1.452bfep-2 +-0x1.332058p-2 +-0x1.2eb75cp-1 +-0x1.22467ep-1 +0x0p+0 +-0x1.e0b602p+1 +-0x1.157d7ep+2 +-0x1.e09d78p+1 +-0x1.637734p+2 +0x1.5d84c2p-3 +0x1.a1a62p-4 +0x1.6098bcp-3 +0x1.50136ap-3 +0x1.33d44p-3 +0x1.64d322p-3 +0x0p+0 +0x1.383b5p-3 +-0x1.9deaccp-3 +0x1.23f54p-5 +-0x1.340538p-2 +0x0p+0 +-0x1.157d7ep+2 +-0x1.340538p-2 +-0x1.282964p-2 +0x0p+0 +0x1.bd82dep-4 +0x1.1c5ad6p-5 +0x1.6295ecp-5 +0x1.86b48p-5 +0x1.4fb39ap-5 +0x1.ad4a08p-4 +0x1.b40362p-4 +0x1.038ccap-5 +0x1.56975cp-5 +-0x1.43335p-2 +-0x1.2cace6p-2 +-0x1.28b91ap-1 +-0x1.20248ep-1 +0x0p+0 +-0x1.e0a64ap+1 +-0x1.158136p+2 +-0x1.e09614p+1 +-0x1.637734p+2 +0x1.57a2bcp-3 +0x1.a8993p-4 +0x1.5f129cp-3 +0x1.4be2ap-3 +0x1.35d05ap-3 +0x1.61f4c4p-3 +0x0p+0 +0x1.3a295cp-3 +-0x1.9deaccp-3 +0x1.31e448p-5 +0x1.b12f0ap-5 +0x1.b52fa4p-4 +0x1.c9dfd4p-6 +-0x1.363338p-2 +-0x1.249a34p-1 +-0x1.158136p+2 +-0x1.e09be2p+1 +-0x1.637734p+2 +0x0p+0 +0x1.c3be5ap-4 +0x1.529b2ep-3 +0x1.5d5134p-3 +0x1.37c71ep-3 +-0x1.8b2e9ap+1 +0x1.ee17p+3 +-0x1.47258p+2 +-0x1.200facp+0 +-0x1.e2f43cp+2 +-0x1.514074p-1 +-0x1.8ea82ep+3 +-0x1.514074p-1 +-0x1.48c6c8p-1 +-0x1.ea19dap+2 +-0x1.48c75ep-1 +-0x1.9535cap+3 +-0x1.48c75ap-1 +-0x1.9535cap+3 +-0x1.ea19dap+2 +-0x1.45057ap+1 +0x0p+0 +-0x1.892beap+3 +-0x1.d46a72p-3 +-0x1.45057ap+1 +-0x1.d46a72p-3 +-0x1.55148p+1 +0x0p+0 +-0x1.4064b2p-2 +-0x1.8e7e46p+3 +-0x1.3fea9ap-2 +-0x1.55148p+1 +-0x1.55148p+1 +0x0p+0 +-0x1.3ff618p-2 +-0x1.8e7e46p+3 +-0x1.3ff216p-2 +-0x1.55148p+1 +-0x1.3ff364p-2 +-0x1.55148p+1 +0x0p+0 +-0x1.8e7e46p+3 +-0x1.4cde78p+2 +-0x1.e07984p+1 +-0x1.79635ep+1 +-0x1.e07984p+1 +-0x1.e1b4bep+1 +-0x1.52c99ep+2 +-0x1.e1b4aap+1 +-0x1.5ea024p+1 +-0x1.e1b4c2p+1 +-0x1.5ea024p+1 +-0x1.52c99ep+2 +-0x1.795178p+2 +-0x1.dd6116p+2 +-0x1.9cf8dep+3 +-0x1.b6d18p-1 +-0x1.795178p+2 +-0x1.b6d18p-1 +-0x1.dd6116p+2 +-0x1.a5aec2p-1 +-0x1.d0fc74p+3 +-0x1.a5aec2p-1 +-0x1.796d76p+2 +-0x1.dd7d14p+2 +-0x1.794856p+2 +-0x1.ddaa62p+2 +-0x1.b51fc2p-1 +-0x1.a17402p+3 +-0x1.b53a46p-1 +-0x1.7967a8p+2 +-0x1.a88424p-1 +-0x1.dd909ap+2 +-0x1.a83f84p-1 +-0x1.d650fep+3 +-0x1.7967a8p+2 +-0x1.dd909ap+2 +-0x1.79464ep+2 +-0x1.ddb95ep+2 +-0x1.b4f96ep-1 +-0x1.a17402p+3 +-0x1.b51078p-1 +-0x1.79641cp+2 +-0x1.a857eap-1 +-0x1.dda0dep+2 +-0x1.a818f8p-1 +-0x1.d650fep+3 +-0x1.79641cp+2 +-0x1.dda0dep+2 +-0x1.7946p+2 +-0x1.ddc5bap+2 +-0x1.b4d59p-1 +-0x1.a17402p+3 +-0x1.b4eaaep-1 +-0x1.79624p+2 +-0x1.a82f36p-1 +-0x1.ddae88p+2 +-0x1.a7f542p-1 +-0x1.d650fep+3 +-0x1.b4b46ap-1 +-0x1.79624p+2 +-0x1.ddae88p+2 +-0x1.a809fp-1 +-0x1.d650fep+3 +-0x1.a17402p+3 +-0x1.53645cp+1 +-0x1.f43ec8p+1 +-0x1.15be0ap-2 +-0x1.f43ec8p+1 +-0x1.f510dp+1 +-0x1.5745aep+1 +-0x1.f510ccp+1 +-0x1.f4fe8ep-3 +-0x1.f510d2p+1 +-0x1.f4fe8ep-3 +-0x1.5745aep+1 +-0x1.7ff3e6p+2 +-0x1.f23c5ep-1 +-0x1.4778ap+3 +-0x1.f23c5ep-1 +-0x1.d9183p-1 +-0x1.8da66p+2 +-0x1.d90c16p-1 +-0x1.4b405cp+3 +-0x1.d913c8p-1 +-0x1.4b405cp+3 +-0x1.8da66p+2 +-0x1.a6905cp+2 +-0x1.3f6ab6p+3 +-0x1.20a826p+0 +-0x1.3f6ab6p+3 +-0x1.42bcecp+3 +-0x1.a9288ep+2 +-0x1.42b994p+3 +-0x1.2836a4p+0 +-0x1.42b8dep+3 +-0x1.a9288ep+2 +-0x1.42b92p+3 +-0x1.2836a4p+0 +-0x1.42b908p+3 +-0x1.a9288ep+2 +-0x1.42b91p+3 +-0x1.2836a4p+0 +-0x1.42b90cp+3 +-0x1.2836a4p+0 +-0x1.a9288ep+2 +0x1.1e843ep+1 +-0x1.3411bap+2 +-0x1.16470ap+3 +-0x1.3411bap+2 +-0x1.3818dep+2 +0x1.1da78ap+1 +-0x1.381656p+2 +-0x1.16f954p+3 +-0x1.381668p+2 +-0x1.16f954p+3 +0x1.1da78ap+1 +-0x1.064d58p-6 +-0x1.32c27ap-7 +-0x1.5e1dbp-9 +0x1.3e4242p-10 +0x1.a5be3ap-7 +0x1.915feap-6 +0x1.0646f2p-5 +0x1.efedecp-4 +0x1.44514p-2 +0x1.29747p+1 +0x1.7dbd24p-3 +-0x1.86765p+1 +0x1.f4bf98p+3 +-0x1.3b8636p+2 +-0x1.30d436p+0 +-0x1.514074p-1 +-0x1.e2f43cp+2 +-0x1.8ea82ep+3 +-0x1.d46a72p-3 +-0x1.892beap+3 +-0x1.45057ap+1 +-0x1.e07984p+1 +-0x1.4cde78p+2 +-0x1.79635ep+1 +-0x1.b6d18p-1 +-0x1.9cf8dep+3 +-0x1.795178p+2 +-0x1.a5aec2p-1 +-0x1.dd6116p+2 +-0x1.d0fc74p+3 +-0x1.e2376ep+1 +-0x1.51e4eap+2 +-0x1.f8568p+1 +-0x1.f43ec8p+1 +-0x1.53645cp+1 +-0x1.15be0ap-2 +-0x1.f23c5ep-1 +-0x1.7ff3e6p+2 +-0x1.4778ap+3 +-0x1.3f6ab6p+3 +-0x1.a6905cp+2 +-0x1.20a826p+0 +-0x1.3411bap+2 +0x1.1e843ep+1 +-0x1.16470ap+3 +0x1.8eff2p-4 +0x1.46e01p-3 +0x1.794c4p-3 +0x1.357468p-3 +0x1.a07412p-5 +0x1.7069ap-9 +0x1.7f406ep-4 +0x1.5ad766p-4 +-0x1.e86cbap-2 +-0x1.360e08p-1 +0x0p+0 +0x1.3000a4p+1 +0x0p+0 +0x1.2f2e9ap+1 +0x0p+0 +0x1.45eaa8p+2 +0x0p+0 +0x1.4a1bccp+2 +0x0p+0 +0x1.80c3d6p+2 +0x0p+0 +0x1.8277c2p+2 +0x0p+0 +0x1.7f406ep-4 +0x0p+0 +0x1.b52fa4p-4 +0x0p+0 +0x1.5ad766p-4 +0x0p+0 +0x1.c9dfd4p-6 +0x0p+0 +0x1.53d82ap+2 +0x0p+0 +0x1.56fd3cp+2 +0x0p+0 +0x1.7398eap+2 +0x0p+0 +0x1.7ebc82p+2 +0x0p+0 +0x1.9dc91cp+1 +0x0p+0 +0x1.9910d2p+1 +0x0p+0 +0x1.4ad4p+1 +0x0p+0 +0x1.3d9aa8p+1 +0x0p+0 +0x1.49f5acp+2 +0x0p+0 +0x1.48120cp+2 +0x0p+0 +0x1.22bdp-2 +0x0p+0 +0x1.1e558p-4 +0x0p+0 +0x1.7daf1p+2 +0x0p+0 +0x1.7b16dep+2 +0x0p+0 +0x1.8ce3ep-2 +0x0p+0 +0x1.8bd76p-2 +0x0p+0 +0x1.1e843ep+1 +0x0p+0 +0x1.1da78ap+1 +0x0p+0 +0x1.4207fep+1 +0x0p+0 +0x1.43a38ap+1 +0x0p+0 +0x1.5b4586p+2 +0x0p+0 +0x1.5b8928p+2 +0x0p+0 +0x1.2be8ecp+1 +0x0p+0 +0x1.f27ap+0 +0x0p+0 +0x1.7837fp+0 +0x0p+0 +0x1.682538p+0 +0x0p+0 +0x1.00eb3p+0 +0x0p+0 +0x1.75441p-1 +0x0p+0 +0x1.bbc4p-4 +0x0p+0 +-0x1.8b0ap-4 +0x0p+0 +0x1.ef62bp+1 +0x0p+0 +0x1.ec9988p+1 +0x0p+0 +0x1.43c5e8p+1 +0x0p+0 +0x1.428aaap+1 +0x0p+0 +0x1.7c6d66p+2 +0x0p+0 +0x1.73771ep+2 +0x0p+0 +0x1.5a66p+0 +0x0p+0 +0x1.2be8d8p+0 +0x0p+0 +0x1.1504f8p+0 +0x0p+0 +0x1.fab0cp-1 +0x0p+0 +0x1.aadc0ep+1 +0x0p+0 +0x1.c59f48p+1 +0x0p+0 +0x1.df39f2p+1 +0x0p+0 +0x1.cf2aecp+1 +0x0p+0 +0x1.67f7a8p+2 +0x0p+0 +0x1.6906cap+2 +0x0p+0 +0x1.414b3p+2 +0x0p+0 +0x1.3a2592p+2 +0x0p+0 +0x1.53d82ap+2 +0x0p+0 +0x1.56fd3cp+2 +0x0p+0 +0x1.14663ap+2 +0x0p+0 +0x1.09bd26p+2 +0x0p+0 +0x1.837c62p+2 +0x0p+0 +0x1.7e208p+2 +0x0p+0 +0x1.1e798p-2 +0x0p+0 +0x1.d0b8p-4 +0x0p+0 +0x1.2a9c58p+1 +0x0p+0 +0x1.1b7d68p+1 +0x0p+0 +0x1.5d69dep+2 +0x0p+0 +0x1.5d1e78p+2 +0x0p+0 +0x1.46de56p+2 +0x0p+0 +0x1.4690e4p+2 +0x0p+0 +0x1.22bdp-2 +0x0p+0 +0x1.1e558p-4 +0x0p+0 +0x1.8ce3ep-2 +0x0p+0 +0x1.8bd76p-2 +0x0p+0 +0x1.46e01p-3 +0x0p+0 +0x1.5d5134p-3 +0x0p+0 +0x1.7398eap+2 +0x0p+0 +0x1.7ebc82p+2 +0x0p+0 +0x1.792ab6p+2 +0x0p+0 +0x1.7424bep+2 +0x0p+0 +-0x1.dfaf7ap-2 +0x0p+0 +-0x1.dfaf7ap-2 +0x0p+0 +-0x1.e3d106p-2 +0x0p+0 +-0x1.e4d914p-2 +0x0p+0 +-0x1.e51b24p-2 +0x0p+0 +0x0p+0 +-0x1.e37354p-2 +-0x1.e51b24p-2 +0x0p+0 +0x1.73ce04p+2 +0x0p+0 +0x1.73e88p+2 +0x0p+0 +0x1.73ce04p+2 +0x0p+0 +0x1.73e88p+2 +-0x1.5a2c48p-6 +-0x1.b284f4p-7 +-0x1.b284f4p-7 +-0x1.4441fp-8 +-0x1.4441fp-8 +-0x1.3891eap-10 +-0x1.3891eap-10 +0x1.8a2924p-7 +0x1.8a2924p-7 +0x1.934702p-6 +0x1.934702p-6 +0x1.fa9a5ep-6 +0x1.fa9a5ep-6 +0x1.0cb77ap-3 +-0x1.ae0b38p-6 +-0x1.19ef8p-6 +-0x1.19ef8p-6 +-0x1.f2b5a8p-8 +-0x1.f2b5a8p-8 +-0x1.9ede98p-9 +-0x1.f2b5a8p-8 +-0x1.9ede98p-9 +-0x1.cbf1c6p-9 +0x1.6e3cdap-7 +0x1.6e3cdap-7 +0x1.8e942p-6 +0x1.8e942p-6 +0x1.e7e306p-6 +0x1.8e942p-6 +0x1.e7e306p-6 +0x1.e59e3cp-6 +0x1.226288p-3 +-0x1.ae0b38p-6 +-0x1.19ef8p-6 +-0x1.dc20ecp-8 +-0x1.cbf1c6p-9 +0x1.6e3cdap-7 +0x1.90bd3ep-6 +0x1.e94d9ep-6 +0x1.21f6bp-3 +0x1.83ad84p-2 +0x1.5af3b8p+1 +-0x1.9deaccp-3 +0x1.31e448p-5 +-0x1.158136p+2 +-0x1.e37354p-2 +-0x1.e37354p-2 +0x0p+0 +0x1.31e448p-5 +0x1.c3be5ap-4 +0x1.b12f0ap-5 +0x1.31e448p-5 +0x1.b52fa4p-4 +0x1.b12f0ap-5 +0x1.c9dfd4p-6 +0x1.b52fa4p-4 +-0x1.e37354p-2 +0x1.c9dfd4p-6 +-0x1.249a34p-1 +-0x1.e37354p-2 +0x0p+0 +-0x1.249a34p-1 +-0x1.158136p+2 +-0x1.e09be2p+1 +-0x1.637734p+2 +-0x1.e09be2p+1 +0x1.c3be5ap-4 +0x1.529b2ep-3 +0x1.529b2ep-3 +0x1.5d5134p-3 +0x1.5d5134p-3 +0x1.37c71ep-3 +0x1.37c71ep-3 +0x0p+0 +-0x1.202beep-1 +0x1.8763ecp-5 +-0x1.2de902p+2 +-0x1.9d80bcp-2 +-0x1.8bebf8p-2 +0x0p+0 +0x1.c8debp-5 +0x1.75430cp-5 +0x1.97c6fap-5 +0x1.a959bp-4 +0x1.7c3f56p-4 +0x1.d33cc2p-4 +0x1.d73aa8p-4 +-0x1.a6cf78p-4 +-0x1.5423ap-4 +-0x1.904e3ep-2 +-0x1.2f51d4p-2 +-0x1.27454cp-1 +-0x1.16e60ep-1 +0x0p+0 +-0x1.dceb1ep+1 +-0x1.2dfbep+2 +-0x1.dcd716p+1 +-0x1.75097ep+2 +0x1.1ad15p-3 +0x1.db610ap-5 +0x1.68ebcp-3 +0x1.09083p-3 +0x1.b45e6p-3 +0x1.652e84p-3 +0x0p+0 +0x1.aac4fep-3 +-0x1.202beep-1 +0x1.8d5eb6p-5 +-0x1.2dfbep+2 +-0x1.1062d8p-2 +-0x1.094cf4p-2 +0x0p+0 +0x1.0ae0ecp-4 +0x1.7ddd64p-5 +0x1.8f88a4p-5 +0x1.8e0a54p-4 +0x1.731deap-4 +0x1.b2ef46p-4 +0x1.beca74p-4 +-0x1.60f766p-5 +-0x1.5cfbf4p-5 +-0x1.1ca3f2p-2 +-0x1.1440f8p-2 +-0x1.1f0b7cp-1 +-0x1.17370ap-1 +0x0p+0 +-0x1.dcde8p+1 +-0x1.2e0502p+2 +-0x1.dcd4fp+1 +-0x1.75097ep+2 +0x1.18816p-3 +0x1.055d5ep-4 +0x1.6bbdfep-3 +0x1.06970ap-3 +0x1.afee7ap-3 +0x1.64d65ep-3 +0x0p+0 +0x1.a8c9d8p-3 +-0x1.202beep-1 +0x1.9e7bcep-5 +-0x1.2e0502p+2 +-0x1.1202f6p-2 +-0x1.0a2cdp-2 +0x0p+0 +0x1.1bb04p-4 +0x1.91e9aep-5 +0x1.9e7dd4p-5 +0x1.88c016p-4 +0x1.6f6fa6p-4 +0x1.5ae96p-4 +0x1.7e4d28p-4 +-0x1.bfdedep-5 +-0x1.678554p-5 +-0x1.1c1fep-2 +-0x1.11584cp-2 +-0x1.1b315ap-1 +-0x1.149536p-1 +0x0p+0 +-0x1.dcd862p+1 +-0x1.2e0ecap+2 +-0x1.dccfc6p+1 +-0x1.75097ep+2 +0x1.13cdbep-3 +0x1.12c55ap-4 +0x1.6d0538p-3 +0x1.04521p-3 +0x1.acb4bep-3 +0x1.64c13ap-3 +0x0p+0 +0x1.a6b4c6p-3 +-0x1.202beep-1 +0x1.aa4932p-5 +0x1.8f7006p-4 +0x1.5ed81ap-4 +-0x1.ac6decp-5 +-0x1.15f2dcp-2 +-0x1.17f7d4p-1 +0x0p+0 +-0x1.2e0ecap+2 +-0x1.dcd2dep+1 +-0x1.75097ep+2 +0x1.28a6cp-4 +0x1.10b62ep-3 +0x1.6d2fd2p-3 +0x1.a9fdb6p-3 +-0x1.8fe6e4p+1 +0x1.e76e68p+3 +-0x1.52c4cap+2 +-0x1.0f4b22p+0 +-0x1.ea19dap+2 +-0x1.48c75ap-1 +-0x1.9535cap+3 +-0x1.48c75ap-1 +-0x1.404df4p-1 +-0x1.f13f78p+2 +-0x1.404e8cp-1 +-0x1.9bc366p+3 +-0x1.404e88p-1 +-0x1.9bc366p+3 +-0x1.f13f78p+2 +-0x1.8e7e46p+3 +-0x1.3ff364p-2 +-0x1.55148p+1 +-0x1.3ff364p-2 +-0x1.95e88ep-2 +-0x1.93d0a2p+3 +-0x1.95999ap-2 +-0x1.652386p+1 +-0x1.9595ep-2 +-0x1.93d0a2p+3 +-0x1.959718p-2 +-0x1.652386p+1 +-0x1.9596a8p-2 +-0x1.652386p+1 +-0x1.93d0a2p+3 +-0x1.52c99ep+2 +-0x1.e1b4c2p+1 +-0x1.5ea024p+1 +-0x1.e1b4c2p+1 +-0x1.e2efecp+1 +-0x1.58b4c4p+2 +-0x1.e2efdp+1 +-0x1.43dceap+1 +-0x1.e2efd6p+1 +-0x1.43dceap+1 +-0x1.58b4c4p+2 +-0x1.79624p+2 +-0x1.ddae88p+2 +-0x1.a17402p+3 +-0x1.b4b46ap-1 +-0x1.79624p+2 +-0x1.b4b46ap-1 +-0x1.ddae88p+2 +-0x1.a809fp-1 +-0x1.d650fep+3 +-0x1.a809fp-1 +-0x1.797e3ep+2 +-0x1.ddca86p+2 +-0x1.7993f2p+2 +-0x1.ddb8ecp+2 +-0x1.b302b2p-1 +-0x1.a5ef26p+3 +-0x1.b31526p-1 +-0x1.797bf6p+2 +-0x1.aadf4cp-1 +-0x1.ddd654p+2 +-0x1.aab2b4p-1 +-0x1.dba588p+3 +-0x1.797bf6p+2 +-0x1.ddd654p+2 +-0x1.7990dep+2 +-0x1.ddc55cp+2 +-0x1.b2ea28p-1 +-0x1.a5ef26p+3 +-0x1.b2f962p-1 +-0x1.797af2p+2 +-0x1.aac2a6p-1 +-0x1.dde038p+2 +-0x1.aa991ep-1 +-0x1.dba588p+3 +-0x1.797af2p+2 +-0x1.dde038p+2 +-0x1.798ed6p+2 +-0x1.ddd012p+2 +-0x1.b2d1d8p-1 +-0x1.a5ef26p+3 +-0x1.b2dffp-1 +-0x1.797ad8p+2 +-0x1.aaa7dcp-1 +-0x1.dde88cp+2 +-0x1.aa8138p-1 +-0x1.dba588p+3 +-0x1.b2bb0ap-1 +-0x1.797ad8p+2 +-0x1.dde88cp+2 +-0x1.aa8edp-1 +-0x1.dba588p+3 +-0x1.a5ef26p+3 +-0x1.5745aep+1 +-0x1.f510d2p+1 +-0x1.f4fe8ep-3 +-0x1.f510d2p+1 +-0x1.f5e2d8p+1 +-0x1.5b27p+1 +-0x1.f5e2dap+1 +-0x1.be8108p-3 +-0x1.f5e2d8p+1 +-0x1.be8108p-3 +-0x1.5b27p+1 +-0x1.8da66p+2 +-0x1.d913c8p-1 +-0x1.4b405cp+3 +-0x1.d913c8p-1 +-0x1.bff9d6p-1 +-0x1.9b58dap+2 +-0x1.bffb7ep-1 +-0x1.4f0818p+3 +-0x1.bffe5cp-1 +-0x1.4f0818p+3 +-0x1.9b58dap+2 +-0x1.a9288ep+2 +-0x1.42b90cp+3 +-0x1.2836a4p+0 +-0x1.42b90cp+3 +-0x1.46070ap+3 +-0x1.abc0cp+2 +-0x1.4603cp+3 +-0x1.2fc522p+0 +-0x1.46030cp+3 +-0x1.abc0cp+2 +-0x1.46034ep+3 +-0x1.2fc522p+0 +-0x1.460336p+3 +-0x1.abc0cp+2 +-0x1.46034p+3 +-0x1.2fc522p+0 +-0x1.46033cp+3 +-0x1.2fc522p+0 +-0x1.abc0cp+2 +0x1.1da78ap+1 +-0x1.381668p+2 +-0x1.16f954p+3 +-0x1.381668p+2 +-0x1.3c1ba8p+2 +0x1.1ccad6p+1 +-0x1.3c1816p+2 +-0x1.17ab9ep+3 +-0x1.3c188cp+2 +-0x1.17ab9ep+3 +0x1.1ccad6p+1 +-0x1.5a2c48p-6 +-0x1.b284f4p-7 +-0x1.4441fp-8 +-0x1.3891eap-10 +0x1.8a2924p-7 +0x1.934702p-6 +0x1.fa9a5ep-6 +0x1.0cb77ap-3 +0x1.63ff62p-2 +0x1.423414p+1 +-0x1.9deaccp-3 +-0x1.8b2e9ap+1 +0x1.ee17p+3 +-0x1.47258p+2 +-0x1.200facp+0 +-0x1.48c75ap-1 +-0x1.ea19dap+2 +-0x1.9535cap+3 +-0x1.3ff364p-2 +-0x1.8e7e46p+3 +-0x1.55148p+1 +-0x1.e1b4c2p+1 +-0x1.52c99ep+2 +-0x1.5ea024p+1 +-0x1.b4b46ap-1 +-0x1.a17402p+3 +-0x1.79624p+2 +-0x1.a809fp-1 +-0x1.ddae88p+2 +-0x1.d650fep+3 +-0x1.e09be2p+1 +-0x1.637734p+2 +-0x1.158136p+2 +-0x1.f510d2p+1 +-0x1.5745aep+1 +-0x1.f4fe8ep-3 +-0x1.d913c8p-1 +-0x1.8da66p+2 +-0x1.4b405cp+3 +-0x1.42b90cp+3 +-0x1.a9288ep+2 +-0x1.2836a4p+0 +-0x1.381668p+2 +0x1.1da78ap+1 +-0x1.16f954p+3 +0x1.37c71ep-3 +0x1.5d5134p-3 +0x1.529b2ep-3 +0x1.c3be5ap-4 +0x1.31e448p-5 +0x1.b12f0ap-5 +0x1.b52fa4p-4 +0x1.c9dfd4p-6 +-0x1.e37354p-2 +-0x1.249a34p-1 +0x0p+0 +0x1.d0b8p-4 +0x0p+0 +-0x1.b0ecp-5 +0x0p+0 +0x1.2f2e9ap+1 +0x0p+0 +0x1.2e5c94p+1 +0x0p+0 +0x1.4a1bccp+2 +0x0p+0 +0x1.4e4ceep+2 +0x0p+0 +0x1.8277c2p+2 +0x0p+0 +0x1.842baep+2 +0x0p+0 +0x1.b52fa4p-4 +0x0p+0 +0x1.5ed81ap-4 +0x0p+0 +0x1.c9dfd4p-6 +0x0p+0 +-0x1.ac6decp-5 +0x0p+0 +0x1.56fd3cp+2 +0x0p+0 +0x1.5a1feap+2 +0x0p+0 +0x1.73e88p+2 +0x0p+0 +0x1.80c088p+2 +0x0p+0 +0x1.9910d2p+1 +0x0p+0 +0x1.945888p+1 +0x0p+0 +0x1.3d9aa8p+1 +0x0p+0 +0x1.3071e8p+1 +0x0p+0 +0x1.48120cp+2 +0x0p+0 +0x1.462e6ep+2 +0x0p+0 +0x1.1e558p-4 +0x0p+0 +-0x1.27248p-3 +0x0p+0 +0x1.7b16dep+2 +0x0p+0 +0x1.787eacp+2 +0x0p+0 +0x1.8bd76p-2 +0x0p+0 +0x1.8a4dep-2 +0x0p+0 +0x1.1da78ap+1 +0x0p+0 +0x1.1ccad6p+1 +0x0p+0 +0x1.43a38ap+1 +0x0p+0 +0x1.476c8ep+1 +0x0p+0 +0x1.5b8928p+2 +0x0p+0 +0x1.5bc854p+2 +0x0p+0 +0x1.f27ap+0 +0x0p+0 +0x1.9043bp+0 +0x0p+0 +0x1.682538p+0 +0x0p+0 +0x1.581ca8p+0 +0x0p+0 +0x1.75441p-1 +0x0p+0 +0x1.d1638p-2 +0x0p+0 +0x1.8bf38ep+2 +0x0p+0 +0x1.7ed856p+2 +0x0p+0 +0x1.ec9988p+1 +0x0p+0 +0x1.e9d06p+1 +0x0p+0 +0x1.428aaap+1 +0x0p+0 +0x1.414f96p+1 +0x0p+0 +0x1.73771ep+2 +0x0p+0 +0x1.6a80d6p+2 +0x0p+0 +0x1.2be8d8p+0 +0x0p+0 +0x1.fad76p-1 +0x0p+0 +0x1.14aa44p+0 +0x0p+0 +0x1.24957p+0 +0x0p+0 +0x1.fab0cp-1 +0x0p+0 +0x1.cb579p-1 +0x0p+0 +0x1.c59f48p+1 +0x0p+0 +0x1.e06282p+1 +0x0p+0 +0x1.cf2aecp+1 +0x0p+0 +0x1.bf1be6p+1 +0x0p+0 +0x1.6906cap+2 +0x0p+0 +0x1.6a15e4p+2 +0x0p+0 +0x1.3a2592p+2 +0x0p+0 +0x1.32fff4p+2 +0x0p+0 +0x1.56fd3cp+2 +0x0p+0 +0x1.5a1feap+2 +0x0p+0 +0x1.09bd26p+2 +0x0p+0 +0x1.fe2824p+1 +0x0p+0 +0x1.7e208p+2 +0x0p+0 +0x1.78c64cp+2 +0x0p+0 +0x1.d0b8p-4 +0x0p+0 +-0x1.b0ecp-5 +0x0p+0 +0x1.1b7d68p+1 +0x0p+0 +0x1.0c5e78p+1 +0x0p+0 +0x1.5d1e78p+2 +0x0p+0 +0x1.5ccddcp+2 +0x0p+0 +0x1.4690e4p+2 +0x0p+0 +0x1.4656ep+2 +0x0p+0 +0x1.1e558p-4 +0x0p+0 +-0x1.27248p-3 +0x0p+0 +0x1.8bd76p-2 +0x0p+0 +0x1.8a4dep-2 +0x0p+0 +0x1.5d5134p-3 +0x0p+0 +0x1.6d2fd2p-3 +0x0p+0 +0x1.73e88p+2 +0x0p+0 +0x1.80c088p+2 +0x0p+0 +0x1.7a5484p+2 +0x0p+0 +0x1.74e0bap+2 +0x0p+0 +-0x1.d3efc4p-2 +0x0p+0 +-0x1.d3efc4p-2 +0x0p+0 +-0x1.d81cfp-2 +0x0p+0 +-0x1.d927d6p-2 +0x0p+0 +-0x1.d96a94p-2 +0x0p+0 +0x0p+0 +-0x1.98bfcep-2 +-0x1.d96a94p-2 +0x0p+0 +0x1.74890cp+2 +0x0p+0 +0x1.7893bap+2 +0x0p+0 +0x1.74890cp+2 +0x0p+0 +0x1.7893bap+2 +0x0p+0 +-0x1.48fa5ap+2 +-0x1.48fa5ap+2 +0x0p+0 +-0x1.48fa5ap+2 +0x0p+0 +-0x1.48fa5ap+2 +0x0p+0 +0x0p+0 +-0x1.58cc0ep+2 +-0x1.48fa5ap+2 +0x0p+0 +0x1.24957p+0 +0x0p+0 +0x1.ca9d4p-1 +-0x1.ae0b38p-6 +-0x1.19ef8p-6 +-0x1.19ef8p-6 +-0x1.dc20ecp-8 +-0x1.dc20ecp-8 +-0x1.cbf1c6p-9 +-0x1.cbf1c6p-9 +0x1.6e3cdap-7 +0x1.6e3cdap-7 +0x1.90bd3ep-6 +0x1.90bd3ep-6 +0x1.e94d9ep-6 +0x1.e94d9ep-6 +0x1.21f6bp-3 +-0x1.00f514p-5 +-0x1.5a9c88p-6 +-0x1.5a9c88p-6 +-0x1.454a52p-7 +-0x1.454a52p-7 +-0x1.6743b4p-8 +-0x1.454a52p-7 +-0x1.6743b4p-8 +-0x1.791484p-8 +0x1.52509p-7 +0x1.52509p-7 +0x1.8c0a5cp-6 +0x1.8c0a5cp-6 +0x1.d69646p-6 +0x1.8c0a5cp-6 +0x1.d69646p-6 +0x1.d69646p-6 +0x1.37a1bep-3 +-0x1.00f514p-5 +-0x1.5a9c88p-6 +-0x1.3c5a7ap-7 +-0x1.791484p-8 +0x1.52509p-7 +0x1.8c0a5cp-6 +0x1.d69646p-6 +0x1.37a1bep-3 +0x1.a35ba6p-2 +0x1.73b35cp+1 +-0x1.202beep-1 +0x1.aa4932p-5 +-0x1.2e0ecap+2 +-0x1.98bfcep-2 +-0x1.98bfcep-2 +0x0p+0 +0x1.aa4932p-5 +0x1.28a6cp-4 +0x1.8f7006p-4 +0x1.aa4932p-5 +0x1.5ed81ap-4 +0x1.8f7006p-4 +-0x1.ac6decp-5 +0x1.5ed81ap-4 +-0x1.98bfcep-2 +-0x1.ac6decp-5 +-0x1.17f7d4p-1 +-0x1.98bfcep-2 +0x0p+0 +-0x1.17f7d4p-1 +-0x1.2e0ecap+2 +-0x1.dcd2dep+1 +-0x1.75097ep+2 +-0x1.dcd2dep+1 +0x1.28a6cp-4 +0x1.10b62ep-3 +0x1.10b62ep-3 +0x1.6d2fd2p-3 +0x1.6d2fd2p-3 +0x1.a9fdb6p-3 +0x1.a9fdb6p-3 +0x0p+0 +-0x1.d8dd28p-1 +0x1.6b18a8p-4 +-0x1.44e35ap+2 +-0x1.0520fcp-2 +-0x1.fd9a34p-3 +0x0p+0 +0x1.e3e1c8p-6 +0x1.632fdcp-4 +0x1.4d637ap-4 +0x1.072d0ep-3 +0x1.f8abcap-4 +0x1.06071ap-4 +0x1.248546p-4 +-0x1.b2ac98p-3 +-0x1.8a0f08p-3 +-0x1.ff9b48p-3 +-0x1.a64426p-3 +-0x1.18ede4p-1 +-0x1.0889ap-1 +0x0p+0 +-0x1.d7e5d4p+1 +-0x1.44f14ep+2 +-0x1.d81322p+1 +-0x1.869bc8p+2 +0x1.91a804p-4 +0x1.1af612p-5 +0x1.75198cp-3 +0x1.7092d4p-4 +0x1.0b1756p-2 +0x1.64ff02p-3 +0x0p+0 +0x1.02d73ap-2 +-0x1.d8dd28p-1 +0x1.58f10cp-4 +-0x1.44f14ep+2 +-0x1.594c4ep-3 +-0x1.594c4ep-3 +0x0p+0 +0x1.3b3ab6p-5 +0x1.53f4dap-4 +0x1.3fe59ep-4 +0x1.f49b76p-4 +0x1.ebe3f6p-4 +0x1.eaaff4p-5 +0x1.15920cp-4 +-0x1.4b347p-3 +-0x1.3b980ep-3 +-0x1.6a2a7ap-3 +-0x1.7afb02p-3 +-0x1.10983ap-1 +-0x1.07cd56p-1 +0x0p+0 +-0x1.d8032ap+1 +-0x1.44f14ep+2 +-0x1.d808eap+1 +-0x1.869bc8p+2 +0x1.99427ep-4 +0x1.54dbf4p-5 +0x1.773f32p-3 +0x1.74a38ap-4 +0x1.0751d8p-2 +0x1.655c4p-3 +0x0p+0 +0x1.00576cp-2 +-0x1.d8dd28p-1 +0x1.544eap-4 +-0x1.44f14ep+2 +-0x1.6b54e8p-3 +-0x1.6b54e8p-3 +0x0p+0 +0x1.649282p-5 +0x1.5194c6p-4 +0x1.3e2572p-4 +0x1.eaadbep-4 +0x1.e25bc4p-4 +0x1.2a3e64p-5 +0x1.a91c5cp-5 +-0x1.5024bp-3 +-0x1.36c11ap-3 +-0x1.781eap-3 +-0x1.7cd61ap-3 +-0x1.0c3a6ep-1 +-0x1.04cd76p-1 +0x0p+0 +-0x1.d806dap+1 +-0x1.44f14ep+2 +-0x1.d80798p+1 +-0x1.869bc8p+2 +0x1.98dae2p-4 +0x1.74fa82p-5 +0x1.785dbap-3 +0x1.78ce7ep-4 +0x1.0426e6p-2 +0x1.660db2p-3 +0x0p+0 +0x1.fbd1e4p-3 +-0x1.d8dd28p-1 +0x1.5078e8p-4 +0x1.ec1598p-4 +0x1.3c375ep-5 +-0x1.403b46p-3 +-0x1.7e1b76p-3 +-0x1.089306p-1 +0x0p+0 +-0x1.44f14ep+2 +-0x1.d80754p+1 +-0x1.869bc8p+2 +0x1.85b03ep-5 +0x1.9aaf96p-4 +0x1.787cccp-3 +0x1.014fccp-2 +-0x1.949f2ep+1 +0x1.e0c5dp+3 +-0x1.6b934ap+2 +-0x1.fd0d3p-1 +-0x1.f13f78p+2 +-0x1.404e88p-1 +-0x1.9bc366p+3 +-0x1.404e88p-1 +-0x1.37d568p-1 +-0x1.f86516p+2 +-0x1.37d604p-1 +-0x1.a25102p+3 +-0x1.37d6p-1 +-0x1.a25102p+3 +-0x1.f86516p+2 +-0x1.652386p+1 +-0x1.43dceap+1 +-0x1.93d0a2p+3 +-0x1.9596a8p-2 +-0x1.652386p+1 +-0x1.9596a8p-2 +-0x1.43dceap+1 +-0x1.e2efd6p+1 +-0x1.58b4c4p+2 +-0x1.e2efd6p+1 +-0x1.60147p+1 +-0x1.3d889ap+1 +-0x1.d12426p-2 +-0x1.9922fep+3 +-0x1.d123e6p-2 +-0x1.5f1fc2p+1 +-0x1.e1e26cp+1 +-0x1.3ee14cp+1 +-0x1.e1c5cep+1 +-0x1.5e9feap+2 +-0x1.5f1fc2p+1 +-0x1.3ee14cp+1 +-0x1.cfadap-2 +-0x1.9922fep+3 +-0x1.d03332p-2 +-0x1.5e526p+1 +-0x1.e1cff4p+1 +-0x1.3ff9dap+1 +-0x1.e1b4d2p+1 +-0x1.5e9feap+2 +-0x1.5e526p+1 +-0x1.3ff9dap+1 +-0x1.cee262p-2 +-0x1.9922fep+3 +-0x1.cf5a4ep-2 +-0x1.5da418p+1 +-0x1.e1be6cp+1 +-0x1.40e254p+1 +-0x1.e1a6f6p+1 +-0x1.5e9feap+2 +-0x1.ce3bd2p-2 +-0x1.5da418p+1 +-0x1.40e254p+1 +-0x1.e1af4p+1 +-0x1.5e9feap+2 +-0x1.9922fep+3 +-0x1.797ad8p+2 +-0x1.dde88cp+2 +-0x1.a5ef26p+3 +-0x1.b2bb0ap-1 +-0x1.797ad8p+2 +-0x1.b2bb0ap-1 +-0x1.dde88cp+2 +-0x1.aa8edp-1 +-0x1.dba588p+3 +-0x1.aa8edp-1 +-0x1.7996d6p+2 +-0x1.de048ap+2 +-0x1.79a506p+2 +-0x1.ddf8fep+2 +-0x1.b10952p-1 +-0x1.aa6a4ap+3 +-0x1.b115e2p-1 +-0x1.799692p+2 +-0x1.ad642cp-1 +-0x1.de0aa4p+2 +-0x1.ad4862p-1 +-0x1.e0fa12p+3 +-0x1.b0fa24p-1 +-0x1.799692p+2 +-0x1.de0aa4p+2 +-0x1.ad5238p-1 +-0x1.e0fa12p+3 +-0x1.aa6a4ap+3 +-0x1.5b27p+1 +-0x1.f5e2d8p+1 +-0x1.be8108p-3 +-0x1.f5e2d8p+1 +-0x1.f6b4dep+1 +-0x1.5f0852p+1 +-0x1.f6b4dep+1 +-0x1.880382p-3 +-0x1.f6b4dep+1 +-0x1.880382p-3 +-0x1.5f0852p+1 +-0x1.9b58dap+2 +-0x1.bffe5cp-1 +-0x1.4f0818p+3 +-0x1.bffe5cp-1 +-0x1.a6ec1p-1 +-0x1.a90b54p+2 +-0x1.a6f528p-1 +-0x1.52cfd4p+3 +-0x1.a6f526p-1 +-0x1.52cfd4p+3 +-0x1.a90b54p+2 +-0x1.abc0cp+2 +-0x1.46033cp+3 +-0x1.2fc522p+0 +-0x1.46033cp+3 +-0x1.494d1p+3 +-0x1.ae58f2p+2 +-0x1.4949dp+3 +-0x1.3753ap+0 +-0x1.49491ep+3 +-0x1.ae58f2p+2 +-0x1.49496p+3 +-0x1.3753ap+0 +-0x1.494946p+3 +-0x1.ae58f2p+2 +-0x1.49495p+3 +-0x1.3753ap+0 +-0x1.49494ep+3 +-0x1.3753ap+0 +-0x1.ae58f2p+2 +0x1.1ccad6p+1 +-0x1.3c188cp+2 +-0x1.17ab9ep+3 +-0x1.3c188cp+2 +-0x1.401becp+2 +0x1.1bee22p+1 +-0x1.4017c4p+2 +-0x1.185de8p+3 +-0x1.401872p+2 +0x1.1bee22p+1 +-0x1.40183p+2 +-0x1.185de8p+3 +-0x1.401844p+2 +-0x1.185de8p+3 +0x1.1bee22p+1 +-0x1.ae0b38p-6 +-0x1.19ef8p-6 +-0x1.dc20ecp-8 +-0x1.cbf1c6p-9 +0x1.6e3cdap-7 +0x1.90bd3ep-6 +0x1.e94d9ep-6 +0x1.21f6bp-3 +0x1.83ad84p-2 +0x1.5af3b8p+1 +-0x1.202beep-1 +-0x1.8fe6e4p+1 +0x1.e76e68p+3 +-0x1.58cc0ep+2 +-0x1.0f4b22p+0 +-0x1.404e88p-1 +-0x1.f13f78p+2 +-0x1.9bc366p+3 +-0x1.9596a8p-2 +-0x1.93d0a2p+3 +-0x1.652386p+1 +-0x1.e2efd6p+1 +-0x1.58b4c4p+2 +-0x1.43dceap+1 +-0x1.b2bb0ap-1 +-0x1.a5ef26p+3 +-0x1.797ad8p+2 +-0x1.aa8edp-1 +-0x1.dde88cp+2 +-0x1.dba588p+3 +-0x1.dcd2dep+1 +-0x1.75097ep+2 +-0x1.2e0ecap+2 +-0x1.f5e2d8p+1 +-0x1.5b27p+1 +-0x1.be8108p-3 +-0x1.bffe5cp-1 +-0x1.9b58dap+2 +-0x1.4f0818p+3 +-0x1.46033cp+3 +-0x1.abc0cp+2 +-0x1.2fc522p+0 +-0x1.3c188cp+2 +0x1.1ccad6p+1 +-0x1.17ab9ep+3 +0x1.a9fdb6p-3 +0x1.6d2fd2p-3 +0x1.10b62ep-3 +0x1.28a6cp-4 +0x1.aa4932p-5 +0x1.8f7006p-4 +0x1.5ed81ap-4 +-0x1.ac6decp-5 +-0x1.98bfcep-2 +-0x1.17f7d4p-1 +0x0p+0 +0x1.4656ep+2 +0x0p+0 +0x1.4634c8p+2 +0x0p+0 +0x1.8ebddep+2 +0x0p+0 +0x1.841926p+2 +0x0p+0 +0x1.2e5c94p+1 +0x0p+0 +0x1.2d8a8ep+1 +0x0p+0 +0x1.4e4ceep+2 +0x0p+0 +0x1.527e1p+2 +0x0p+0 +0x1.842baep+2 +0x0p+0 +0x1.85df9ap+2 +0x0p+0 +0x1.5ed81ap-4 +0x0p+0 +0x1.3c375ep-5 +0x0p+0 +0x1.8ec6dap+2 +0x0p+0 +0x1.881ddcp+2 +0x0p+0 +0x1.5a1feap+2 +0x0p+0 +0x1.5d4112p+2 +0x0p+0 +0x1.7893bap+2 +0x0p+0 +0x1.862edap+2 +0x0p+0 +0x1.945888p+1 +0x0p+0 +0x1.8fa03ep+1 +0x0p+0 +0x1.3071e8p+1 +0x0p+0 +0x1.2359ap+1 +0x0p+0 +0x1.462e6ep+2 +0x0p+0 +0x1.444acep+2 +0x0p+0 +0x1.88e692p+2 +0x0p+0 +0x1.7b3418p+2 +0x0p+0 +0x1.787eacp+2 +0x0p+0 +0x1.75e67ap+2 +0x0p+0 +0x1.8a4dep-2 +0x0p+0 +0x1.88924p-2 +0x0p+0 +0x1.1ccad6p+1 +0x0p+0 +0x1.1bee22p+1 +0x0p+0 +0x1.476c8ep+1 +0x0p+0 +0x1.4c3818p+1 +0x0p+0 +0x1.5bc854p+2 +0x0p+0 +0x1.5c0072p+2 +0x0p+0 +0x1.9043bp+0 +0x0p+0 +0x1.34b9ap+0 +0x0p+0 +0x1.581ca8p+0 +0x0p+0 +0x1.481dc8p+0 +0x0p+0 +0x1.d1638p-2 +0x0p+0 +0x1.707dcp-3 +0x0p+0 +0x1.7ed856p+2 +0x0p+0 +0x1.71bd1ep+2 +0x0p+0 +0x1.e9d06p+1 +0x0p+0 +0x1.e70738p+1 +0x0p+0 +0x1.414f96p+1 +0x0p+0 +0x1.42902cp+1 +0x0p+0 +0x1.6a80d6p+2 +0x0p+0 +0x1.618a8ep+2 +0x0p+0 +0x1.ca9d4p-1 +0x0p+0 +0x1.34636p-1 +0x0p+0 +0x1.cb579p-1 +0x0p+0 +0x1.9bfe6p-1 +0x0p+0 +0x1.e06282p+1 +0x0p+0 +0x1.e35d18p+1 +0x0p+0 +0x1.bf1be6p+1 +0x0p+0 +0x1.c69b54p+1 +0x0p+0 +0x1.6a15e4p+2 +0x0p+0 +0x1.6b24f6p+2 +0x0p+0 +0x1.32fff4p+2 +0x0p+0 +0x1.2bda56p+2 +0x0p+0 +0x1.5a1feap+2 +0x0p+0 +0x1.5d4112p+2 +0x0p+0 +0x1.fe2824p+1 +0x0p+0 +0x1.e8d5fcp+1 +0x0p+0 +0x1.78c64cp+2 +0x0p+0 +0x1.753bf8p+2 +0x0p+0 +0x1.0c5e78p+1 +0x0p+0 +0x1.fa7f1p+0 +0x0p+0 +0x1.5ccddcp+2 +0x0p+0 +0x1.5c757p+2 +0x0p+0 +0x1.4656ep+2 +0x0p+0 +0x1.4634c8p+2 +0x0p+0 +0x1.8a4dep-2 +0x0p+0 +0x1.88924p-2 +0x0p+0 +0x1.6d2fd2p-3 +0x0p+0 +0x1.787cccp-3 +0x0p+0 +0x1.7893bap+2 +0x0p+0 +0x1.862edap+2 +0x0p+0 +0x1.7f614ap+2 +0x0p+0 +0x1.7be99ep+2 +0x0p+0 +-0x1.63618p-2 +0x0p+0 +-0x1.63618p-2 +0x0p+0 +-0x1.67c7e4p-2 +0x0p+0 +-0x1.68e0e6p-2 +0x0p+0 +-0x1.692728p-2 +0x0p+0 +0x0p+0 +-0x1.f371ap-3 +-0x1.692728p-2 +0x0p+0 +0x1.7b8d44p+2 +0x0p+0 +0x1.828428p+2 +0x0p+0 +0x1.7b8d44p+2 +0x0p+0 +0x1.828428p+2 +-0x1.00f514p-5 +-0x1.5a9c88p-6 +-0x1.5a9c88p-6 +-0x1.3c5a7ap-7 +-0x1.3c5a7ap-7 +-0x1.791484p-8 +-0x1.2ae48cp-5 +-0x1.9b499p-6 +-0x1.9b499p-6 +-0x1.939456p-7 +-0x1.939456p-7 +-0x1.fa5f56p-8 +-0x1.939456p-7 +-0x1.fa5f56p-8 +-0x1.2ae48cp-5 +-0x1.9b499p-6 +-0x1.8c8aeep-7 +-0x1.043116p-7 +0x1.366446p-7 +0x1.8c0a5cp-6 +0x1.d69646p-6 +0x1.d69646p-6 +0x1.37a1bep-3 +0x1.87577ap-6 +0x1.c3deeep-6 +0x1.c3deeep-6 +0x1.4d4cccp-3 +0x1.87577ap-6 +0x1.c3deeep-6 +0x1.4d4cccp-3 +0x1.c309c8p-2 +0x1.8c73p+1 +-0x1.d8dd28p-1 +0x1.5078e8p-4 +-0x1.44f14ep+2 +-0x1.f371ap-3 +-0x1.f371ap-3 +0x0p+0 +-0x1.869bc8p+2 +-0x1.880382p-3 +0x1.5078e8p-4 +0x1.85b03ep-5 +0x1.ec1598p-4 +0x1.5078e8p-4 +0x1.3c375ep-5 +0x1.ec1598p-4 +-0x1.403b46p-3 +0x1.3c375ep-5 +-0x1.f371ap-3 +-0x1.403b46p-3 +-0x1.089306p-1 +-0x1.f371ap-3 +0x0p+0 +-0x1.089306p-1 +-0x1.44f14ep+2 +-0x1.d80754p+1 +-0x1.869bc8p+2 +-0x1.d80754p+1 +-0x1.880382p-3 +-0x1.f6b4dep+1 +-0x1.5f0852p+1 +-0x1.f6b4dep+1 +0x1.85b03ep-5 +0x1.9aaf96p-4 +0x1.9aaf96p-4 +0x1.787cccp-3 +0x1.787cccp-3 +0x1.014fccp-2 +0x1.014fccp-2 +0x0p+0 +-0x1.48c73p+0 +0x1.d8dd96p-4 +-0x1.5681c8p+2 +-0x1.16a4eap-2 +-0x1.5681c8p+2 +-0x1.16a4eap-2 +-0x1.1f9bf6p-2 +0x0p+0 +-0x1.98a434p+2 +-0x1.3c9424p-3 +0x1.22c3c2p-5 +0x1.d8dd96p-4 +0x1.b60f6ap-4 +0x1.161716p-3 +0x1.13d1e2p-3 +-0x1.4a3bap-4 +-0x1.e7b248p-5 +-0x1.78811cp-5 +-0x1.b16b38p-5 +-0x1.207578p-2 +-0x1.cb6644p-3 +-0x1.084f08p-1 +-0x1.04b9c8p-1 +0x0p+0 +-0x1.cc1328p+1 +-0x1.5663dap+2 +-0x1.cbfee6p+1 +-0x1.98a434p+2 +-0x1.f2759p+1 +-0x1.3c9424p-3 +-0x1.f274eep+1 +-0x1.62e9a4p+1 +0x1.1dbab6p-4 +0x1.468584p-5 +0x1.7c60eap-3 +0x1.08b434p-4 +0x1.248322p-2 +0x1.650abap-3 +0x0p+0 +0x1.1c0be2p-2 +-0x1.48c73p+0 +0x1.c44348p-4 +-0x1.5663dap+2 +-0x1.cc2b06p-3 +-0x1.5663dap+2 +-0x1.cc2b06p-3 +-0x1.d8c4aap-3 +0x0p+0 +-0x1.98a434p+2 +-0x1.3c9424p-3 +0x1.45eedcp-5 +0x1.c44348p-4 +0x1.a8b282p-4 +0x1.01979ep-3 +0x1.06a92p-3 +-0x1.0991a6p-4 +-0x1.a1133ep-5 +-0x1.61fe7cp-5 +-0x1.9b32bcp-5 +-0x1.e3eabcp-3 +-0x1.b30ac4p-3 +-0x1.06876ep-1 +-0x1.04d298p-1 +0x0p+0 +-0x1.cc0b3ap+1 +-0x1.564662p+2 +-0x1.cbe77p+1 +-0x1.98a434p+2 +-0x1.f2757p+1 +-0x1.3c9424p-3 +-0x1.f27544p+1 +-0x1.62e9a4p+1 +0x1.2fd584p-4 +0x1.6d5cfap-5 +0x1.7c0fd6p-3 +0x1.15d8ecp-4 +0x1.209ee2p-2 +0x1.64e24ap-3 +0x0p+0 +0x1.19097ep-2 +-0x1.48c73p+0 +0x1.c08552p-4 +-0x1.564662p+2 +-0x1.d2d55ep-3 +-0x1.564662p+2 +-0x1.d2d55ep-3 +-0x1.dd4c62p-3 +0x0p+0 +-0x1.98a434p+2 +-0x1.3c9424p-3 +0x1.621b1p-5 +0x1.c08552p-4 +0x1.a5c174p-4 +0x1.dd3edp-4 +0x1.ed0b6ap-4 +-0x1.cf70b8p-5 +-0x1.5d01fep-5 +-0x1.702bcp-5 +-0x1.98cbp-5 +-0x1.e793acp-3 +-0x1.b419eap-3 +-0x1.05b2aep-1 +-0x1.03be26p-1 +0x0p+0 +-0x1.cbf45p+1 +-0x1.562a2ap+2 +-0x1.cbd208p+1 +-0x1.98a434p+2 +-0x1.f2755p+1 +-0x1.3c9424p-3 +-0x1.f2754cp+1 +-0x1.62e9a4p+1 +0x1.39bddp-4 +0x1.83109ap-5 +0x1.7bc996p-3 +0x1.21ce0ep-4 +0x1.1d22dp-2 +0x1.653c46p-3 +0x0p+0 +0x1.1614dp-2 +-0x1.48c73p+0 +0x1.bda56p-4 +0x1.b588e6p-4 +-0x1.8815b2p-5 +-0x1.5e00c6p-5 +-0x1.dc3832p-3 +-0x1.04c0e2p-1 +0x0p+0 +-0x1.562a2ap+2 +-0x1.cbde58p+1 +-0x1.98a434p+2 +-0x1.3c9424p-3 +-0x1.f2755p+1 +-0x1.62e9a4p+1 +0x1.7ad04ep-5 +0x1.4382f6p-4 +0x1.7b34e8p-3 +0x1.19e37ep-2 +-0x1.995778p+1 +0x1.da1d38p+3 +-0x1.7e5a86p+2 +-0x1.db841cp-1 +-0x1.f86516p+2 +-0x1.37d6p-1 +-0x1.a25102p+3 +-0x1.37d6p-1 +-0x1.2f5d28p-1 +-0x1.ff8ab4p+2 +-0x1.2f5dep-1 +-0x1.a8de9ep+3 +-0x1.2f5db8p-1 +-0x1.a8de9ep+3 +-0x1.ff8ab4p+2 +-0x1.5da418p+1 +-0x1.40e254p+1 +-0x1.9922fep+3 +-0x1.ce3bd2p-2 +-0x1.5da418p+1 +-0x1.ce3bd2p-2 +-0x1.40e254p+1 +-0x1.e1af4p+1 +-0x1.5e9feap+2 +-0x1.e1af4p+1 +-0x1.58afap+1 +-0x1.3ac766p+1 +-0x1.04f408p-1 +-0x1.9e755ap+3 +-0x1.051fa6p-1 +-0x1.581f7p+1 +-0x1.e0a6c4p+1 +-0x1.3b86fap+1 +-0x1.e09532p+1 +-0x1.648b1p+2 +-0x1.581f7p+1 +-0x1.3b86fap+1 +-0x1.04bfap-1 +-0x1.9e755ap+3 +-0x1.04e1eep-1 +-0x1.57a8cep+1 +-0x1.e09b76p+1 +-0x1.3c21fap+1 +-0x1.e08dp+1 +-0x1.648b1p+2 +-0x1.57a8cep+1 +-0x1.3c21fap+1 +-0x1.049354p-1 +-0x1.9e755ap+3 +-0x1.04af7ap-1 +-0x1.574576p+1 +-0x1.e0921ep+1 +-0x1.3ca21cp+1 +-0x1.e085fap+1 +-0x1.648b1p+2 +-0x1.046dd2p-1 +-0x1.574576p+1 +-0x1.3ca21cp+1 +-0x1.e08a56p+1 +-0x1.648b1p+2 +-0x1.9e755ap+3 +-0x1.799692p+2 +-0x1.de0aa4p+2 +-0x1.aa6a4ap+3 +-0x1.b0fa24p-1 +-0x1.799692p+2 +-0x1.b0fa24p-1 +-0x1.de0aa4p+2 +-0x1.ad5238p-1 +-0x1.e0fa12p+3 +-0x1.ad5238p-1 +-0x1.79b29p+2 +-0x1.de26a2p+2 +-0x1.79bb94p+2 +-0x1.de1f4ap+2 +-0x1.af486cp-1 +-0x1.aee56ep+3 +-0x1.af51c2p-1 +-0x1.79b20ep+2 +-0x1.b0279p-1 +-0x1.de2ae4p+2 +-0x1.b015cap-1 +-0x1.e64e9cp+3 +-0x1.af3f3ap-1 +-0x1.79b20ep+2 +-0x1.de2ae4p+2 +-0x1.b01c2ap-1 +-0x1.e64e9cp+3 +-0x1.aee56ep+3 +-0x1.a90b54p+2 +-0x1.a6f526p-1 +-0x1.52cfd4p+3 +-0x1.a6f526p-1 +-0x1.8de9fap-1 +-0x1.b6bdcep+2 +-0x1.8df738p-1 +-0x1.56979p+3 +-0x1.8df5aap-1 +-0x1.56979p+3 +-0x1.b6bdcep+2 +-0x1.ae58f2p+2 +-0x1.49494ep+3 +-0x1.3753ap+0 +-0x1.49494ep+3 +-0x1.4c8f0ap+3 +-0x1.b0f124p+2 +-0x1.4c8bd4p+3 +-0x1.3ee21ep+0 +-0x1.4c8b26p+3 +-0x1.b0f124p+2 +-0x1.4c8b64p+3 +-0x1.3ee21ep+0 +-0x1.4c8b4ep+3 +-0x1.b0f124p+2 +-0x1.4c8b54p+3 +-0x1.3ee21ep+0 +-0x1.4c8b54p+3 +-0x1.3ee21ep+0 +-0x1.b0f124p+2 +0x1.1bee22p+1 +-0x1.401844p+2 +-0x1.185de8p+3 +-0x1.401844p+2 +-0x1.4419c6p+2 +0x1.1b116ep+1 +-0x1.441702p+2 +-0x1.191032p+3 +-0x1.44172ap+2 +-0x1.191032p+3 +0x1.1b116ep+1 +-0x1.00f514p-5 +-0x1.5a9c88p-6 +-0x1.3c5a7ap-7 +-0x1.791484p-8 +0x1.52509p-7 +0x1.8c0a5cp-6 +0x1.d69646p-6 +0x1.37a1bep-3 +0x1.a35ba6p-2 +0x1.73b35cp+1 +-0x1.d8dd28p-1 +-0x1.949f2ep+1 +0x1.e0c5dp+3 +-0x1.6b934ap+2 +-0x1.fd0d3p-1 +-0x1.37d6p-1 +-0x1.f86516p+2 +-0x1.a25102p+3 +-0x1.ce3bd2p-2 +-0x1.9922fep+3 +-0x1.5da418p+1 +-0x1.e1af4p+1 +-0x1.5e9feap+2 +-0x1.40e254p+1 +-0x1.b0fa24p-1 +-0x1.aa6a4ap+3 +-0x1.799692p+2 +-0x1.ad5238p-1 +-0x1.de0aa4p+2 +-0x1.e0fa12p+3 +-0x1.d80754p+1 +-0x1.869bc8p+2 +-0x1.44f14ep+2 +-0x1.f6b4dep+1 +-0x1.5f0852p+1 +-0x1.880382p-3 +-0x1.a6f526p-1 +-0x1.a90b54p+2 +-0x1.52cfd4p+3 +-0x1.49494ep+3 +-0x1.ae58f2p+2 +-0x1.3753ap+0 +-0x1.401844p+2 +0x1.1bee22p+1 +-0x1.185de8p+3 +0x1.014fccp-2 +0x1.787cccp-3 +0x1.9aaf96p-4 +0x1.85b03ep-5 +0x1.5078e8p-4 +0x1.ec1598p-4 +0x1.3c375ep-5 +-0x1.403b46p-3 +-0x1.f371ap-3 +-0x1.089306p-1 +0x0p+0 +0x1.753bf8p+2 +0x0p+0 +0x1.7191fcp+2 +0x0p+0 +0x1.fa7f1p+0 +0x0p+0 +0x1.dc413p+0 +0x0p+0 +0x1.4634c8p+2 +0x0p+0 +0x1.461488p+2 +0x0p+0 +0x1.841926p+2 +0x0p+0 +0x1.79746ep+2 +0x0p+0 +0x1.2d8a8ep+1 +0x0p+0 +0x1.31ca1cp+1 +0x0p+0 +0x1.527e1p+2 +0x0p+0 +0x1.56af32p+2 +0x0p+0 +0x1.85df9ap+2 +0x0p+0 +0x1.883b14p+2 +0x0p+0 +0x1.3c375ep-5 +0x0p+0 +-0x1.8815b2p-5 +0x0p+0 +0x1.881ddcp+2 +0x0p+0 +0x1.8f63b4p+2 +0x0p+0 +0x1.5d4112p+2 +0x0p+0 +0x1.6061p+2 +0x0p+0 +0x1.828428p+2 +0x0p+0 +0x1.833df4p+2 +0x0p+0 +0x1.8fa03ep+1 +0x0p+0 +0x1.8ae7f4p+1 +0x0p+0 +0x1.2359ap+1 +0x0p+0 +0x1.165188p+1 +0x0p+0 +0x1.444acep+2 +0x0p+0 +0x1.42672ep+2 +0x0p+0 +0x1.7b3418p+2 +0x0p+0 +0x1.6d819ep+2 +0x0p+0 +0x1.75e67ap+2 +0x0p+0 +0x1.734e48p+2 +0x0p+0 +0x1.88924p-2 +0x0p+0 +0x1.86da8p-2 +0x0p+0 +0x1.1bee22p+1 +0x0p+0 +0x1.1b116ep+1 +0x0p+0 +0x1.4c3818p+1 +0x0p+0 +0x1.586114p+1 +0x0p+0 +0x1.5c0072p+2 +0x0p+0 +0x1.5c37cep+2 +0x0p+0 +0x1.34b9ap+0 +0x0p+0 +0x1.dfac6p-1 +0x0p+0 +0x1.481dc8p+0 +0x0p+0 +0x1.38223p+0 +0x0p+0 +0x1.707dcp-3 +0x0p+0 +-0x1.a11f8p-4 +0x0p+0 +0x1.71bd1ep+2 +0x0p+0 +0x1.64a1e6p+2 +0x0p+0 +0x1.e70738p+1 +0x0p+0 +0x1.e43e1p+1 +0x0p+0 +0x1.42902cp+1 +0x0p+0 +0x1.43b516p+1 +0x0p+0 +0x1.618a8ep+2 +0x0p+0 +0x1.589446p+2 +0x0p+0 +0x1.34636p-1 +0x0p+0 +0x1.3c53p-2 +0x0p+0 +0x1.9bfe6p-1 +0x0p+0 +0x1.6ca53p-1 +0x0p+0 +0x1.e35d18p+1 +0x0p+0 +0x1.e79d5p+1 +0x0p+0 +0x1.c69b54p+1 +0x0p+0 +0x1.ccf9f6p+1 +0x0p+0 +0x1.6b24f6p+2 +0x0p+0 +0x1.6c34p+2 +0x0p+0 +0x1.2bda56p+2 +0x0p+0 +0x1.24b4b8p+2 +0x0p+0 +0x1.5d4112p+2 +0x0p+0 +0x1.6061p+2 +0x0p+0 +0x1.e8d5fcp+1 +0x0p+0 +0x1.d383d4p+1 +0x0p+0 +0x1.753bf8p+2 +0x0p+0 +0x1.7191fcp+2 +0x0p+0 +0x1.fa7f1p+0 +0x0p+0 +0x1.dc413p+0 +0x0p+0 +0x1.5c757p+2 +0x0p+0 +0x1.5c1c3p+2 +0x0p+0 +0x1.4634c8p+2 +0x0p+0 +0x1.461488p+2 +0x0p+0 +0x1.787cccp-3 +0x0p+0 +0x1.7b34e8p-3 +0x0p+0 +0x1.828428p+2 +0x0p+0 +0x1.833df4p+2 +0x0p+0 +0x1.82e10ep+2 +0x0p+0 +0x1.82ea64p+2 +0x0p+0 +-0x1.e6aa12p-3 +0x0p+0 +-0x1.e6aa12p-3 +0x0p+0 +-0x1.ef1e8cp-3 +0x0p+0 +-0x1.f13a2cp-3 +0x0p+0 +0x0p+0 +-0x1.05a024p-2 +-0x1.f13a2cp-3 +0x0p+0 +0x1.8295e4p+2 +0x0p+0 +0x1.81c5b4p+2 +0x0p+0 +0x1.8295e4p+2 +0x0p+0 +0x1.81c5b4p+2 +-0x1.2ae48cp-5 +-0x1.9b499p-6 +-0x1.9b499p-6 +-0x1.8c8aeep-7 +-0x1.8c8aeep-7 +-0x1.043116p-7 +-0x1.54d404p-5 +-0x1.dbf698p-6 +-0x1.dbf698p-6 +-0x1.e3c4cap-7 +-0x1.e3c4cap-7 +-0x1.44d68p-7 +-0x1.e3c4cap-7 +-0x1.44d68p-7 +-0x1.54d404p-5 +-0x1.dbf698p-6 +-0x1.de410ap-7 +-0x1.4a527cp-7 +0x1.1a77fcp-7 +0x1.87577ap-6 +0x1.c3deeep-6 +0x1.c3deeep-6 +0x1.4d4cccp-3 +0x1.82a498p-6 +0x1.b12796p-6 +0x1.b12796p-6 +0x1.62f7dap-3 +0x1.82a498p-6 +0x1.b12796p-6 +0x1.62f7dap-3 +0x1.e2b7eap-2 +0x1.a532a4p+1 +-0x1.a51fccp+0 +-0x1.9e0fc2p+1 +0x1.d374ap+3 +-0x1.7e5a86p+2 +-0x1.191032p+3 +-0x1.191032p+3 +-0x1.44172ap+2 +0x1.1b116ep+1 +-0x1.44172ap+2 +-0x1.8abe38p+2 +-0x1.1978a6p+3 +-0x1.47896p+2 +-0x1.1978a6p+3 +-0x1.478904p+2 +0x1.1a34bap+1 +-0x1.8abe38p+2 +-0x1.1978a6p+3 +-0x1.47863cp+2 +0x1.1a34bap+1 +-0x1.b9fb08p-1 +-0x1.ff8ab4p+2 +-0x1.2f5db8p-1 +-0x1.a8de9ep+3 +-0x1.2f5db8p-1 +-0x1.26e526p-1 +-0x1.03582ap+3 +-0x1.26e5d2p-1 +-0x1.af6c3ap+3 +-0x1.26e5cap-1 +-0x1.af6c3ap+3 +-0x1.03582ap+3 +-0x1.574576p+1 +-0x1.3ca21cp+1 +-0x1.9e755ap+3 +-0x1.046dd2p-1 +-0x1.574576p+1 +-0x1.046dd2p-1 +-0x1.3ca21cp+1 +-0x1.e08a56p+1 +-0x1.648b1p+2 +-0x1.e08a56p+1 +-0x1.5250fep+1 +-0x1.36872ep+1 +-0x1.222da8p-1 +-0x1.a3c7b6p+3 +-0x1.224878p-1 +-0x1.5217c4p+1 +-0x1.df8294p+1 +-0x1.36d136p+1 +-0x1.df7b6ep+1 +-0x1.6a7636p+2 +-0x1.5217c4p+1 +-0x1.36d136p+1 +-0x1.22215cp-1 +-0x1.a3c7b6p+3 +-0x1.222f5cp-1 +-0x1.51e836p+1 +-0x1.df7dfcp+1 +-0x1.370e5ap+1 +-0x1.df78bap+1 +-0x1.6a7636p+2 +-0x1.51e836p+1 +-0x1.370e5ap+1 +-0x1.221658p-1 +-0x1.a3c7b6p+3 +-0x1.221f4cp-1 +-0x1.51c022p+1 +-0x1.df7a92p+1 +-0x1.37419cp+1 +-0x1.df763p+1 +-0x1.6a7636p+2 +-0x1.220b1ap-1 +-0x1.51c022p+1 +-0x1.37419cp+1 +-0x1.df77c4p+1 +-0x1.6a7636p+2 +-0x1.a3c7b6p+3 +-0x1.79b20ep+2 +-0x1.de2ae4p+2 +-0x1.aee56ep+3 +-0x1.af3f3ap-1 +-0x1.79b20ep+2 +-0x1.af3f3ap-1 +-0x1.de2ae4p+2 +-0x1.b01c2ap-1 +-0x1.e64e9cp+3 +-0x1.b01c2ap-1 +-0x1.79ce0cp+2 +-0x1.de46e2p+2 +-0x1.79d246p+2 +-0x1.de437p+2 +-0x1.ad8d82p-1 +-0x1.b36092p+3 +-0x1.ad93c6p-1 +-0x1.79cd3ap+2 +-0x1.b2f18p-1 +-0x1.de4994p+2 +-0x1.b2e818p-1 +-0x1.eba326p+3 +-0x1.ad896ep-1 +-0x1.79cd3ap+2 +-0x1.de4994p+2 +-0x1.b2eb62p-1 +-0x1.eba326p+3 +-0x1.b36092p+3 +-0x1.562a2ap+2 +-0x1.05a024p-2 +-0x1.05a024p-2 +0x0p+0 +-0x1.98a434p+2 +-0x1.cbde58p+1 +-0x1.562a2ap+2 +-0x1.cbde58p+1 +-0x1.05a024p-2 +-0x1.5e00c6p-5 +-0x1.04c0e2p-1 +-0x1.05a024p-2 +0x0p+0 +-0x1.04c0e2p-1 +-0x1.5e00c6p-5 +-0x1.8815b2p-5 +-0x1.8815b2p-5 +0x1.b588e6p-4 +0x1.b588e6p-4 +0x1.bda56p-4 +0x1.bda56p-4 +0x1.7ad04ep-5 +0x1.7ad04ep-5 +0x1.4382f6p-4 +0x1.4382f6p-4 +0x1.7b34e8p-3 +0x1.7b34e8p-3 +0x1.19e37ep-2 +0x1.19e37ep-2 +0x0p+0 +-0x1.65461cp+2 +-0x1.1d8a9ep-2 +-0x1.22cc68p-2 +0x0p+0 +-0x1.bf3d06p+1 +-0x1.aaacap+2 +-0x1.bf44ccp+1 +-0x1.65395ap+2 +0x1.452204p-6 +-0x1.22cc68p-2 +-0x1.00404ep-2 +-0x1.f6cb8ap-2 +-0x1.f57494p-2 +0x0p+0 +-0x1.509798p-4 +0x1.5ea602p-6 +0x1.93f616p-5 +-0x1.411ed6p-4 +0x1.0c2306p-3 +0x1.4e1196p-5 +0x1.0a721ep-4 +0x1.0b014p-3 +0x1.0d2312p-4 +0x1.21eb1p-4 +0x1.75fb18p-3 +0x1.014018p-4 +0x1.26d2acp-2 +0x1.5cd4dap-3 +0x0p+0 +0x1.1f290cp-2 +-0x1.65395ap+2 +-0x1.08f3e4p-2 +-0x1.0d283p-2 +0x0p+0 +-0x1.bf2b5cp+1 +-0x1.aaacap+2 +-0x1.bf3498p+1 +-0x1.652dep+2 +0x1.cf11b6p-7 +-0x1.0d283p-2 +-0x1.ebc1ccp-3 +-0x1.f62322p-2 +-0x1.f88d6p-2 +0x0p+0 +-0x1.262552p-4 +0x1.10492p-6 +0x1.ad8c52p-5 +-0x1.1f93bcp-4 +0x1.f32c9cp-4 +0x1.59cda8p-5 +0x1.1225aep-4 +0x1.eef9a4p-4 +0x1.225284p-4 +0x1.2aac98p-4 +0x1.746c6p-3 +0x1.137ba2p-4 +0x1.2347b6p-2 +0x1.5c6f16p-3 +0x0p+0 +0x1.1bd686p-2 +-0x1.652dep+2 +-0x1.07126ap-2 +-0x1.0addcap-2 +0x0p+0 +-0x1.bf172ap+1 +-0x1.aaacap+2 +-0x1.bf21c6p+1 +-0x1.6522ecp+2 +0x1.4068b8p-7 +-0x1.0addcap-2 +-0x1.e47ddcp-3 +-0x1.f750fp-2 +-0x1.f95804p-2 +0x0p+0 +-0x1.0ff534p-4 +0x1.b30006p-7 +0x1.bd2444p-5 +-0x1.08f414p-4 +0x1.e0b05ep-4 +0x1.640e4cp-5 +0x1.1a646p-4 +0x1.da3f3ap-4 +0x1.3174e6p-4 +0x1.2fd10cp-4 +0x1.73afaap-3 +0x1.237c72p-4 +0x1.1fd78ep-2 +0x1.5cf048p-3 +0x0p+0 +0x1.18a92p-2 +-0x1.bf04e8p+1 +-0x1.6522ecp+2 +-0x1.05c64ep-2 +-0x1.f84d18p-2 +0x1.e3e7aep-8 +-0x1.ed0d64p-5 +0x1.b31d3cp-5 +0x1.d09168p-4 +0x1.221d76p-4 +0x1.3f6ad4p-4 +0x1.733d22p-3 +0x1.1c85a6p-2 +0x0p+0 +-0x1.aaacap+2 +-0x1.62e9a4p+1 +-0x1.f2755p+1 +-0x1.3c9424p-3 +-0x1.f2755p+1 +-0x1.ee35eap+1 +-0x1.66caf6p+1 +-0x1.ee3656p+1 +-0x1.e2498cp-4 +-0x1.ee3694p+1 +-0x1.e2498cp-4 +-0x1.66caf6p+1 +-0x1.b6bdcep+2 +-0x1.8df5aap-1 +-0x1.56979p+3 +-0x1.8df5aap-1 +-0x1.74f19ap-1 +-0x1.c47048p+2 +-0x1.75015p-1 +-0x1.5a5f4cp+3 +-0x1.74fed4p-1 +-0x1.5a5f4cp+3 +-0x1.c47048p+2 +-0x1.b0f124p+2 +-0x1.4c8b54p+3 +-0x1.3ee21ep+0 +-0x1.4c8b54p+3 +-0x1.4fcd06p+3 +-0x1.b38956p+2 +-0x1.4fc9dcp+3 +-0x1.46709cp+0 +-0x1.4fc93p+3 +-0x1.b38956p+2 +-0x1.4fc96ep+3 +-0x1.46709cp+0 +-0x1.4fc958p+3 +-0x1.b38956p+2 +-0x1.4fc96p+3 +-0x1.46709cp+0 +-0x1.4fc95cp+3 +-0x1.46709cp+0 +-0x1.b38956p+2 +-0x1.2ae48cp-5 +-0x1.9b499p-6 +-0x1.8c8aeep-7 +-0x1.043116p-7 +0x1.366446p-7 +0x1.87577ap-6 +0x1.c3deeep-6 +0x1.4d4cccp-3 +0x1.c309c8p-2 +0x1.8c73p+1 +-0x1.48c73p+0 +-0x1.995778p+1 +0x1.da1d38p+3 +-0x1.7e5a86p+2 +-0x1.db841cp-1 +-0x1.2f5db8p-1 +-0x1.ff8ab4p+2 +-0x1.a8de9ep+3 +-0x1.046dd2p-1 +-0x1.9e755ap+3 +-0x1.574576p+1 +-0x1.e08a56p+1 +-0x1.648b1p+2 +-0x1.3ca21cp+1 +-0x1.af3f3ap-1 +-0x1.aee56ep+3 +-0x1.79b20ep+2 +-0x1.b01c2ap-1 +-0x1.de2ae4p+2 +-0x1.e64e9cp+3 +-0x1.cbde58p+1 +-0x1.98a434p+2 +-0x1.562a2ap+2 +-0x1.f2755p+1 +-0x1.62e9a4p+1 +-0x1.3c9424p-3 +-0x1.8df5aap-1 +-0x1.b6bdcep+2 +-0x1.56979p+3 +-0x1.4c8b54p+3 +-0x1.b0f124p+2 +-0x1.3ee21ep+0 +-0x1.44172ap+2 +0x1.1b116ep+1 +-0x1.191032p+3 +0x1.19e37ep-2 +0x1.7b34e8p-3 +0x1.4382f6p-4 +0x1.7ad04ep-5 +0x1.bda56p-4 +0x1.b588e6p-4 +-0x1.8815b2p-5 +-0x1.5e00c6p-5 +-0x1.05a024p-2 +-0x1.04c0e2p-1 +0x0p+0 +0x1.7191fcp+2 +0x0p+0 +0x1.6dde52p+2 +0x0p+0 +0x1.dc413p+0 +0x0p+0 +0x1.be035p+0 +0x0p+0 +0x1.461488p+2 +0x0p+0 +0x1.45f5d8p+2 +0x0p+0 +0x1.79746ep+2 +0x0p+0 +0x1.6ecfb6p+2 +0x0p+0 +0x1.31ca1cp+1 +0x0p+0 +0x1.3608d8p+1 +0x0p+0 +0x1.56af32p+2 +0x0p+0 +0x1.5ae054p+2 +0x0p+0 +0x1.883b14p+2 +0x0p+0 +0x1.8a969p+2 +0x0p+0 +0x1.8f0f8ap+2 +0x0p+0 +0x1.8e459cp+2 +0x0p+0 +0x1.8f63b4p+2 +0x0p+0 +0x1.9298bp+2 +0x0p+0 +0x1.6061p+2 +0x0p+0 +0x1.637fdcp+2 +0x0p+0 +0x1.81c5b4p+2 +0x0p+0 +0x1.81c352p+2 +0x0p+0 +0x1.165188p+1 +0x0p+0 +0x1.095968p+1 +0x0p+0 +0x1.42672ep+2 +0x0p+0 +0x1.40839p+2 +0x0p+0 +0x1.6d819ep+2 +0x0p+0 +0x1.5fcf24p+2 +0x0p+0 +0x1.734e48p+2 +0x0p+0 +0x1.70b616p+2 +0x0p+0 +0x1.86da8p-2 +0x0p+0 +0x1.8527cp-2 +0x0p+0 +0x1.1b116ep+1 +0x0p+0 +0x1.1a34bap+1 +0x0p+0 +0x1.586114p+1 +0x0p+0 +0x1.653a84p+1 +0x0p+0 +0x1.5c37cep+2 +0x0p+0 +0x1.5c6e88p+2 +0x0p+0 +0x1.dfac6p-1 +0x0p+0 +0x1.67e65p-1 +0x0p+0 +0x1.38223p+0 +0x0p+0 +0x1.2a65e8p+0 +0x0p+0 +0x1.8b9b38p+2 +0x0p+0 +0x1.7992ccp+2 +0x0p+0 +0x1.64a1e6p+2 +0x0p+0 +0x1.5786aep+2 +0x0p+0 +0x1.e43e1p+1 +0x0p+0 +0x1.e29c4p+1 +0x0p+0 +0x1.43b516p+1 +0x0p+0 +0x1.44c7a8p+1 +0x0p+0 +0x1.589446p+2 +0x0p+0 +0x1.4f9dfep+2 +0x0p+0 +0x1.3c53p-2 +0x0p+0 +0x1.d85f8p-4 +0x0p+0 +0x1.6ca53p-1 +0x0p+0 +0x1.3d4cp-1 +0x0p+0 +0x1.e79d5p+1 +0x0p+0 +0x1.ecfddp+1 +0x0p+0 +0x1.ccf9f6p+1 +0x0p+0 +0x1.d27f4ap+1 +0x0p+0 +0x1.6c34p+2 +0x0p+0 +0x1.6d42fcp+2 +0x0p+0 +0x1.24b4b8p+2 +0x0p+0 +0x1.1d8f18p+2 +0x0p+0 +0x1.6061p+2 +0x0p+0 +0x1.637fdcp+2 +0x0p+0 +0x1.d383d4p+1 +0x0p+0 +0x1.be31acp+1 +0x0p+0 +0x1.7191fcp+2 +0x0p+0 +0x1.6dde52p+2 +0x0p+0 +0x1.dc413p+0 +0x0p+0 +0x1.be035p+0 +0x0p+0 +0x1.5c1c3p+2 +0x0p+0 +0x1.5bc24ap+2 +0x0p+0 +0x1.461488p+2 +0x0p+0 +0x1.45f5d8p+2 +0x0p+0 +0x1.7b34e8p-3 +0x0p+0 +0x1.733d22p-3 +0x0p+0 +0x1.81c5b4p+2 +0x0p+0 +0x1.81c352p+2 +-0x1.54d404p-5 +-0x1.dbf698p-6 +-0x1.dbf698p-6 +-0x1.de410ap-7 +-0x1.de410ap-7 +-0x1.4a527cp-7 +-0x1.7ec37cp-5 +-0x1.0e51dp-5 +-0x1.0e51dp-5 +-0x1.1abd74p-6 +-0x1.1abd74p-6 +-0x1.8af7e4p-7 +-0x1.1abd74p-6 +-0x1.8af7e4p-7 +-0x1.7ec37cp-5 +-0x1.0e51dp-5 +-0x1.189986p-6 +-0x1.8f38a6p-7 +0x1.fd1764p-8 +0x1.7df1b6p-6 +0x1.b12796p-6 +0x1.62f7dap-3 +0x1.9e703ep-6 +0x1.78a2e8p-3 +0x1.9e703ep-6 +0x1.78a2e8p-3 +0x1.013306p-1 +0x1.bdf248p+1 +-0x1.00bc34p+1 +-0x1.a2c80cp+1 +0x1.cccc08p+3 +-0x1.9721eap+2 +-0x1.9871f4p-1 +-0x1.af6c3ap+3 +0x0p+0 +-0x1.03582ap+3 +-0x1.26e5cap-1 +-0x1.af6c3ap+3 +-0x1.26e5cap-1 +-0x1.b468ap+3 +0x0p+0 +-0x1.49f84ap-1 +-0x1.06eafap+3 +-0x1.4971c8p-1 +-0x1.b46722p+3 +-0x1.b46722p+3 +0x0p+0 +-0x1.4a0d28p-1 +-0x1.06eafap+3 +-0x1.49d4aap-1 +-0x1.b465fp+3 +-0x1.b465fp+3 +0x0p+0 +-0x1.49f29p-1 +-0x1.06eafap+3 +-0x1.49e7cp-1 +-0x1.b46512p+3 +-0x1.49f2aep-1 +-0x1.b46512p+3 +0x0p+0 +-0x1.06eafap+3 +-0x1.51c022p+1 +-0x1.37419cp+1 +-0x1.a3c7b6p+3 +-0x1.220b1ap-1 +-0x1.51c022p+1 +-0x1.220b1ap-1 +-0x1.37419cp+1 +-0x1.df77c4p+1 +-0x1.6a7636p+2 +-0x1.df77c4p+1 +-0x1.4ccbaap+1 +-0x1.3126aep+1 +-0x1.3fbea6p-1 +-0x1.a91a12p+3 +-0x1.3fc3fcp-1 +-0x1.4ccbaap+1 +-0x1.de7006p+1 +-0x1.3126aep+1 +-0x1.de6f48p+1 +-0x1.70615cp+2 +-0x1.3fbcbep-1 +-0x1.4ccbaap+1 +-0x1.3126aep+1 +-0x1.de6f9p+1 +-0x1.70615cp+2 +-0x1.a91a12p+3 +-0x1.79cd3ap+2 +-0x1.de4994p+2 +-0x1.b36092p+3 +-0x1.ad896ep-1 +-0x1.79cd3ap+2 +-0x1.ad896ep-1 +-0x1.de4994p+2 +-0x1.b2eb62p-1 +-0x1.eba326p+3 +-0x1.b2eb62p-1 +-0x1.79e938p+2 +-0x1.de6592p+2 +-0x1.79e938p+2 +-0x1.de6592p+2 +-0x1.abd7b6p-1 +-0x1.b7dbb6p+3 +-0x1.abdb3cp-1 +-0x1.79e84p+2 +-0x1.b5c0b6p-1 +-0x1.de66bep+2 +-0x1.b5bee8p-1 +-0x1.f0f7bp+3 +-0x1.abd916p-1 +-0x1.79e84p+2 +-0x1.de66bep+2 +-0x1.b5bfd4p-1 +-0x1.f0f7bp+3 +-0x1.b7dbb6p+3 +-0x1.6522ecp+2 +-0x1.05c64ep-2 +-0x1.aaacap+2 +-0x1.bf04e8p+1 +-0x1.6522ecp+2 +-0x1.bf04e8p+1 +-0x1.05c64ep-2 +0x1.e3e7aep-8 +-0x1.f84d18p-2 +-0x1.05c64ep-2 +0x0p+0 +-0x1.f84d18p-2 +0x1.e3e7aep-8 +-0x1.ed0d64p-5 +-0x1.ed0d64p-5 +0x1.b31d3cp-5 +0x1.b31d3cp-5 +0x1.d09168p-4 +0x1.d09168p-4 +0x1.221d76p-4 +0x1.221d76p-4 +0x1.3f6ad4p-4 +0x1.3f6ad4p-4 +0x1.733d22p-3 +0x1.733d22p-3 +0x1.1c85a6p-2 +0x1.1c85a6p-2 +0x0p+0 +-0x1.72c3bcp+2 +-0x1.fa10dep-3 +-0x1.b1a1ecp+1 +-0x1.bcb50cp+2 +-0x1.b1b6fap+1 +-0x1.72c652p+2 +-0x1.86bcbp-11 +-0x1.ff9532p-3 +-0x1.d540f8p-3 +-0x1.e83fd2p-2 +-0x1.e80f88p-2 +0x0p+0 +-0x1.5dfedp-7 +0x1.394064p-9 +-0x1.2433c4p-5 +-0x1.a12d0ep-7 +0x1.b48546p-4 +-0x1.1b0a2ap-5 +0x1.b3495ap-4 +0x1.8e75e6p-4 +0x1.714242p-4 +0x1.bb7c44p-4 +0x1.6690bap-3 +0x1.6cb25ap-4 +0x1.13a036p-2 +0x1.54d236p-3 +0x0p+0 +0x1.0d75a2p-2 +-0x1.72c652p+2 +-0x1.f96216p-3 +-0x1.b1a3c4p+1 +-0x1.bcb50cp+2 +-0x1.b1aabcp+1 +-0x1.72c8e4p+2 +-0x1.de373cp-11 +-0x1.fec4f6p-3 +-0x1.d20d52p-3 +-0x1.e828c2p-2 +-0x1.e7ba84p-2 +0x0p+0 +-0x1.dad45ep-7 +0x1.f141bap-13 +-0x1.8a2ea8p-6 +-0x1.bd4b26p-7 +0x1.9c0ae4p-4 +-0x1.b1aee8p-6 +0x1.abec1cp-4 +0x1.793e4ap-4 +0x1.7d3bep-4 +0x1.b5cd3p-4 +0x1.67695ap-3 +0x1.7a3bf2p-4 +0x1.10c0bep-2 +0x1.5689eap-3 +0x0p+0 +0x1.0ac434p-2 +-0x1.72c8e4p+2 +-0x1.f8a77cp-3 +-0x1.b1933ep+1 +-0x1.bcb50cp+2 +-0x1.b19bb8p+1 +-0x1.72cb7ep+2 +-0x1.a9ad4ap-12 +-0x1.fdd768p-3 +-0x1.cff59ep-3 +-0x1.e7f36cp-2 +-0x1.e6dee6p-2 +0x0p+0 +-0x1.1b202cp-6 +-0x1.082d5cp-11 +-0x1.28650ep-6 +-0x1.f92f12p-7 +0x1.8a3ce8p-4 +-0x1.52408ep-6 +0x1.aaa812p-4 +0x1.6a38b2p-4 +0x1.89da4p-4 +0x1.b1c56ep-4 +0x1.680c4ep-3 +0x1.869502p-4 +0x1.0df602p-2 +0x1.581fbp-3 +0x0p+0 +0x1.083d18p-2 +-0x1.b183b2p+1 +-0x1.72cb7ep+2 +-0x1.f86f4cp-3 +-0x1.e76e24p-2 +0x0p+0 +-0x1.c63b5ap-12 +-0x1.2bb1a4p-6 +-0x1.b6a86ep-7 +0x1.7a1ffcp-4 +0x1.a8e2c2p-4 +0x1.95adbap-4 +0x1.68b658p-3 +0x1.0b49f8p-2 +-0x1.bcb50cp+2 +-0x1.66caf6p+1 +-0x1.ee3694p+1 +-0x1.e2498cp-4 +-0x1.ee3694p+1 +-0x1.e9f7dcp+1 +-0x1.6aac48p+1 +-0x1.e9f8b8p+1 +-0x1.4b6adp-4 +-0x1.e9f8aap+1 +-0x1.4b6adp-4 +-0x1.6aac48p+1 +-0x1.c47048p+2 +-0x1.74fed4p-1 +-0x1.5a5f4cp+3 +-0x1.74fed4p-1 +-0x1.5c01dap-1 +-0x1.d222c2p+2 +-0x1.5c12dcp-1 +-0x1.5e2708p+3 +-0x1.5c0feep-1 +-0x1.5e2708p+3 +-0x1.d222c2p+2 +-0x1.b38956p+2 +-0x1.4fc95cp+3 +-0x1.46709cp+0 +-0x1.4fc95cp+3 +-0x1.530712p+3 +-0x1.b62188p+2 +-0x1.5303f8p+3 +-0x1.4dff1ap+0 +-0x1.53034ep+3 +-0x1.b62188p+2 +-0x1.53038ap+3 +-0x1.4dff1ap+0 +-0x1.530378p+3 +-0x1.b62188p+2 +-0x1.53037ep+3 +-0x1.4dff1ap+0 +-0x1.53037cp+3 +-0x1.4dff1ap+0 +-0x1.b62188p+2 +0x1.1a34bap+1 +-0x1.47863cp+2 +-0x1.1978a6p+3 +-0x1.47863cp+2 +-0x1.4af766p+2 +0x1.195806p+1 +-0x1.4af6b6p+2 +-0x1.19e11ap+3 +-0x1.4af4c4p+2 +0x1.195806p+1 +-0x1.4af57cp+2 +-0x1.19e11ap+3 +-0x1.4af53cp+2 +-0x1.19e11ap+3 +0x1.195806p+1 +-0x1.54d404p-5 +-0x1.dbf698p-6 +-0x1.de410ap-7 +-0x1.4a527cp-7 +0x1.1a77fcp-7 +0x1.82a498p-6 +0x1.b12796p-6 +0x1.62f7dap-3 +0x1.e2b7eap-2 +0x1.a532a4p+1 +-0x1.a51fccp+0 +-0x1.9e0fc2p+1 +0x1.d374ap+3 +-0x1.8abe38p+2 +-0x1.b9fb08p-1 +-0x1.26e5cap-1 +-0x1.03582ap+3 +-0x1.af6c3ap+3 +-0x1.220b1ap-1 +-0x1.a3c7b6p+3 +-0x1.51c022p+1 +-0x1.df77c4p+1 +-0x1.6a7636p+2 +-0x1.37419cp+1 +-0x1.ad896ep-1 +-0x1.b36092p+3 +-0x1.79cd3ap+2 +-0x1.b2eb62p-1 +-0x1.de4994p+2 +-0x1.eba326p+3 +-0x1.bf04e8p+1 +-0x1.aaacap+2 +-0x1.6522ecp+2 +-0x1.ee3694p+1 +-0x1.66caf6p+1 +-0x1.e2498cp-4 +-0x1.74fed4p-1 +-0x1.c47048p+2 +-0x1.5a5f4cp+3 +-0x1.4fc95cp+3 +-0x1.b38956p+2 +-0x1.46709cp+0 +-0x1.47863cp+2 +0x1.1a34bap+1 +-0x1.1978a6p+3 +0x1.1c85a6p-2 +0x1.733d22p-3 +0x1.3f6ad4p-4 +0x1.221d76p-4 +0x1.d09168p-4 +0x1.b31d3cp-5 +-0x1.ed0d64p-5 +0x1.e3e7aep-8 +-0x1.05c64ep-2 +-0x1.f84d18p-2 +0x0p+0 +0x1.bd7476p+1 +0x0p+0 +0x1.b99324p+1 +0x0p+0 +0x1.6dde52p+2 +0x0p+0 +0x1.6a281ep+2 +0x0p+0 +0x1.be035p+0 +0x0p+0 +0x1.9fc57p+0 +0x0p+0 +0x1.45f5d8p+2 +0x0p+0 +0x1.45d8aep+2 +0x0p+0 +0x1.6ecfb6p+2 +0x0p+0 +0x1.642afep+2 +0x0p+0 +0x1.3608d8p+1 +0x0p+0 +0x1.3a46c2p+1 +0x0p+0 +0x1.5ae054p+2 +0x0p+0 +0x1.5f1178p+2 +0x0p+0 +0x1.8a969p+2 +0x0p+0 +0x1.8cf20ap+2 +0x0p+0 +0x1.e3e7aep-8 +0x0p+0 +-0x1.c63b5ap-12 +0x0p+0 +0x1.637fdcp+2 +0x0p+0 +0x1.669db8p+2 +0x0p+0 +0x1.81c352p+2 +0x0p+0 +0x1.825c3cp+2 +0x0p+0 +0x1.095968p+1 +0x0p+0 +0x1.f8e1dp+0 +0x0p+0 +0x1.40839p+2 +0x0p+0 +0x1.3e9ffp+2 +0x0p+0 +0x1.5fcf24p+2 +0x0p+0 +0x1.521caap+2 +0x0p+0 +0x1.70b616p+2 +0x0p+0 +0x1.6e1de4p+2 +0x0p+0 +0x1.8527cp-2 +0x0p+0 +0x1.83776p-2 +0x0p+0 +0x1.1a34bap+1 +0x0p+0 +0x1.195806p+1 +0x0p+0 +0x1.653a84p+1 +0x0p+0 +0x1.72bbbap+1 +0x0p+0 +0x1.5c6e88p+2 +0x0p+0 +0x1.5ca494p+2 +0x0p+0 +0x1.67e65p-1 +0x0p+0 +0x1.f5438p-2 +0x0p+0 +0x1.7992ccp+2 +0x0p+0 +0x1.678a6p+2 +0x0p+0 +0x1.5786aep+2 +0x0p+0 +0x1.4d94fep+2 +0x0p+0 +0x1.e29c4p+1 +0x0p+0 +0x1.e0fa7p+1 +0x0p+0 +0x1.44c7a8p+1 +0x0p+0 +0x1.45cfdcp+1 +0x0p+0 +0x1.4f9dfep+2 +0x0p+0 +0x1.46a7b6p+2 +0x0p+0 +0x1.d85f8p-4 +0x0p+0 +-0x1.408dp-4 +0x0p+0 +0x1.3d4cp-1 +0x0p+0 +0x1.0df2dp-1 +0x0p+0 +0x1.ecfddp+1 +0x0p+0 +0x1.f318bep+1 +0x0p+0 +0x1.d27f4ap+1 +0x0p+0 +0x1.d773c2p+1 +0x0p+0 +0x1.6d42fcp+2 +0x0p+0 +0x1.68e16p+2 +0x0p+0 +0x1.1d8f18p+2 +0x0p+0 +0x1.166978p+2 +0x0p+0 +0x1.637fdcp+2 +0x0p+0 +0x1.669db8p+2 +0x0p+0 +0x1.be31acp+1 +0x0p+0 +0x1.a8df84p+1 +0x0p+0 +0x1.6dde52p+2 +0x0p+0 +0x1.6a281ep+2 +0x0p+0 +0x1.be035p+0 +0x0p+0 +0x1.9fc57p+0 +0x0p+0 +0x1.5bc24ap+2 +0x0p+0 +0x1.5b67bcp+2 +0x0p+0 +0x1.45f5d8p+2 +0x0p+0 +0x1.45d8aep+2 +0x0p+0 +0x1.733d22p-3 +0x0p+0 +0x1.68b658p-3 +0x0p+0 +0x1.81c352p+2 +0x0p+0 +0x1.825c3cp+2 +-0x1.7ec37cp-5 +-0x1.0e51dp-5 +-0x1.0e51dp-5 +-0x1.189986p-6 +-0x1.189986p-6 +-0x1.8f38a6p-7 +-0x1.a8b2f4p-5 +-0x1.2ea854p-5 +-0x1.2ea854p-5 +-0x1.443674p-6 +-0x1.443674p-6 +-0x1.cfde1p-7 +-0x1.443674p-6 +-0x1.cfde1p-7 +-0x1.a8b2f4p-5 +-0x1.2ea854p-5 +-0x1.42929p-6 +-0x1.d31fa2p-7 +0x1.c53edp-8 +0x1.793ed4p-6 +0x1.9e703ep-6 +0x1.78a2e8p-3 +0x1.8bb8e6p-6 +0x1.8e4df6p-3 +0x1.8bb8e6p-6 +0x1.8e4df6p-3 +0x1.110a18p-1 +0x1.d6b1ecp+1 +-0x1.2ee882p+1 +-0x1.a78056p+1 +0x1.c6237p+3 +-0x1.a3859cp+2 +-0x1.76e8ep-1 +-0x1.b46512p+3 +0x0p+0 +-0x1.06eafap+3 +-0x1.49f2aep-1 +-0x1.b46512p+3 +-0x1.49f2aep-1 +-0x1.b96178p+3 +0x0p+0 +-0x1.6ce2cap-1 +-0x1.0a7dcap+3 +-0x1.6cdceap-1 +-0x1.b96178p+3 +-0x1.6cd63cp-1 +-0x1.b96178p+3 +0x0p+0 +-0x1.0a7dcap+3 +-0x1.4ccbaap+1 +-0x1.4dff1ap+0 +-0x1.4ccbaap+1 +-0x1.3126aep+1 +-0x1.a91a12p+3 +-0x1.3fbcbep-1 +-0x1.4ccbaap+1 +-0x1.3fbcbep-1 +-0x1.3126aep+1 +-0x1.de6f9p+1 +-0x1.70615cp+2 +-0x1.de6f9p+1 +-0x1.4dff1ap+0 +-0x1.53037cp+3 +-0x1.b62188p+2 +-0x1.53037cp+3 +-0x1.5a8a66p+1 +-0x1.5feb86p+0 +-0x1.5b6edap+1 +-0x1.2b0e5p+1 +-0x1.42ae5cp-1 +-0x1.ae6c6ep+3 +-0x1.42dbep-1 +-0x1.5b6edap+1 +-0x1.dbcdbp+1 +-0x1.2b0e5p+1 +-0x1.dbc4bap+1 +-0x1.764c82p+2 +-0x1.555538p+3 +-0x1.5e56f8p+0 +-0x1.554218p+3 +-0x1.b8b9bap+2 +-0x1.5b6edap+1 +-0x1.5e56f8p+0 +-0x1.5c25b8p+1 +-0x1.2b0e5p+1 +-0x1.417df4p-1 +-0x1.ae6c6ep+3 +-0x1.41fad8p-1 +-0x1.5c25b8p+1 +-0x1.dbc806p+1 +-0x1.2b0e5p+1 +-0x1.dbc6dap+1 +-0x1.764c82p+2 +-0x1.554764p+3 +-0x1.5d0d2cp+0 +-0x1.553624p+3 +-0x1.b8b9bap+2 +-0x1.5c25b8p+1 +-0x1.5d0d2cp+0 +-0x1.5cb89ep+1 +-0x1.2b0e5p+1 +-0x1.40f79ap-1 +-0x1.ae6c6ep+3 +-0x1.41545cp-1 +-0x1.5cb43ap+1 +-0x1.dbc74ap+1 +-0x1.2b1624p+1 +-0x1.dbc6b8p+1 +-0x1.764c82p+2 +-0x1.553c54p+3 +-0x1.5bffb6p+0 +-0x1.552dc6p+3 +-0x1.b8b9bap+2 +-0x1.408616p-1 +-0x1.5cb43ap+1 +-0x1.2b1624p+1 +-0x1.dbc6e2p+1 +-0x1.764c82p+2 +-0x1.5bffb6p+0 +-0x1.5532fcp+3 +-0x1.b8b9bap+2 +-0x1.ae6c6ep+3 +-0x1.79e84p+2 +-0x1.de66bep+2 +-0x1.b7dbb6p+3 +-0x1.abd916p-1 +-0x1.79e84p+2 +-0x1.abd916p-1 +-0x1.de66bep+2 +-0x1.b5bfd4p-1 +-0x1.f0f7bp+3 +-0x1.b5bfd4p-1 +-0x1.7a043ep+2 +-0x1.de82bcp+2 +-0x1.7a043ep+2 +-0x1.de82bcp+2 +-0x1.aa276p-1 +-0x1.bc56dap+3 +-0x1.aa27dcp-1 +-0x1.7a043ep+2 +-0x1.b89526p-1 +-0x1.de82bcp+2 +-0x1.b89518p-1 +-0x1.f64c3ap+3 +-0x1.aa277ep-1 +-0x1.7a043ep+2 +-0x1.de82bcp+2 +-0x1.b894fep-1 +-0x1.f64c3ap+3 +-0x1.bc56dap+3 +-0x1.72cb7ep+2 +-0x1.4b6adp-4 +-0x1.72cb7ep+2 +-0x1.f86f4cp-3 +-0x1.bcb50cp+2 +-0x1.f86f4cp-3 +-0x1.bcb50cp+2 +-0x1.b183b2p+1 +-0x1.72cb7ep+2 +-0x1.b183b2p+1 +-0x1.f86f4cp-3 +-0x1.c63b5ap-12 +-0x1.e76e24p-2 +-0x1.f86f4cp-3 +0x0p+0 +-0x1.e76e24p-2 +-0x1.c63b5ap-12 +-0x1.2bb1a4p-6 +-0x1.2bb1a4p-6 +-0x1.b6a86ep-7 +-0x1.b6a86ep-7 +0x1.7a1ffcp-4 +0x1.7a1ffcp-4 +0x1.a8e2c2p-4 +0x1.a8e2c2p-4 +0x1.95adbap-4 +0x1.95adbap-4 +0x1.68b658p-3 +0x1.68b658p-3 +0x1.0b49f8p-2 +0x1.0b49f8p-2 +0x0p+0 +-0x1.4b6adp-4 +-0x1.e9f8aap+1 +-0x1.6aac48p+1 +-0x1.e9f8aap+1 +-0x1.870c14p+2 +0x1.ea7ab8p-4 +-0x1.870c14p+2 +-0x1.db6eecp-4 +-0x1.cf10bap+2 +-0x1.dedf06p-4 +-0x1.aa8a4p+1 +-0x1.cf10d2p+2 +-0x1.aaa1aap+1 +-0x1.87186ep+2 +-0x1.07886cp-4 +-0x1.da5ed4p-4 +-0x1.c2b31ep-4 +-0x1.1029e2p-1 +-0x1.07e1d4p-1 +0x0p+0 +0x1.628a5p-5 +-0x1.0478f8p-4 +-0x1.0faf02p-4 +0x1.31e878p-5 +0x1.8977cap-5 +-0x1.ea30ap-5 +0x1.1ae8c8p-3 +0x1.43be7cp-5 +0x1.134bp-3 +0x1.12a21ep-3 +0x1.5cffe2p-3 +0x1.1258eap-3 +0x1.dff56cp-3 +0x1.544834p-3 +0x0p+0 +0x1.d8531ep-3 +-0x1.e1837cp+1 +0x1.ea7ab8p-4 +-0x1.e17eb8p+1 +-0x1.6e8d9ap+1 +-0x1.87186ep+2 +0x1.ea7ab8p-4 +-0x1.87186ep+2 +-0x1.270d4cp-3 +-0x1.cf10d2p+2 +-0x1.291eacp-3 +-0x1.aaa51p+1 +-0x1.cf110ap+2 +-0x1.aaa7c6p+1 +-0x1.8725c6p+2 +-0x1.db8fd2p-5 +-0x1.1d819ap-3 +-0x1.01524cp-3 +-0x1.0c3c0cp-1 +-0x1.0469b2p-1 +0x0p+0 +0x1.04a2bep-5 +-0x1.b5d83p-5 +-0x1.c36154p-5 +0x1.be7854p-6 +0x1.8a2846p-5 +-0x1.9cc7bep-5 +0x1.11c64ep-3 +0x1.3ce82ap-5 +0x1.13993ep-3 +0x1.0af644p-3 +0x1.5f510ap-3 +0x1.1482d6p-3 +0x1.dc6358p-3 +0x1.573dc6p-3 +0x0p+0 +0x1.d4a162p-3 +-0x1.e1842ap+1 +0x1.ea7ab8p-4 +-0x1.e1823ap+1 +-0x1.6e8d9ap+1 +-0x1.8725c6p+2 +0x1.ea7ab8p-4 +-0x1.8725c6p+2 +-0x1.3cb6p-3 +-0x1.cf110ap+2 +-0x1.3ed5d6p-3 +-0x1.aa9b16p+1 +-0x1.cf113p+2 +-0x1.aaa4f8p+1 +-0x1.87341p+2 +-0x1.8c2e78p-5 +-0x1.2f2f1ap-3 +-0x1.13bdc4p-3 +-0x1.0885p-1 +-0x1.02247cp-1 +0x0p+0 +0x1.6df588p-6 +-0x1.79d8aap-5 +-0x1.87f3d2p-5 +0x1.39fea8p-6 +0x1.83bfb2p-5 +-0x1.66c198p-5 +0x1.0cfee4p-3 +0x1.3ba262p-5 +0x1.164884p-3 +0x1.057716p-3 +0x1.612c92p-3 +0x1.16bb8cp-3 +0x1.d8beccp-3 +0x1.599656p-3 +0x0p+0 +0x1.d154d2p-3 +-0x1.e182e8p+1 +0x1.ea7ab8p-4 +-0x1.e182a8p+1 +-0x1.6e8d9ap+1 +-0x1.aa949cp+1 +-0x1.87341p+2 +-0x1.4d95a2p-3 +-0x1.057bd8p-1 +0x0p+0 +-0x1.53fd28p-5 +0x1.f7b9e6p-7 +-0x1.54b5fap-5 +0x1.7c582p-5 +0x1.081214p-3 +0x1.18db18p-3 +0x1.62e09cp-3 +0x1.d542ecp-3 +0x1.ea7ab8p-4 +-0x1.e182bep+1 +-0x1.6e8d9ap+1 +-0x1.cf113p+2 +-0x1.d222c2p+2 +-0x1.5c0feep-1 +-0x1.5e2708p+3 +-0x1.5c0feep-1 +-0x1.431a06p-1 +-0x1.dfd53cp+2 +-0x1.432bf2p-1 +-0x1.61eec4p+3 +-0x1.43287ep-1 +-0x1.61eec4p+3 +-0x1.dfd53cp+2 +0x1.195806p+1 +-0x1.4af53cp+2 +-0x1.19e11ap+3 +-0x1.4af53cp+2 +-0x1.4e651cp+2 +0x1.187b52p+1 +-0x1.4e62e8p+2 +-0x1.1a498ep+3 +-0x1.4e6332p+2 +-0x1.1a498ep+3 +0x1.187b52p+1 +-0x1.7ec37cp-5 +-0x1.0e51dp-5 +-0x1.189986p-6 +-0x1.8f38a6p-7 +0x1.fd1764p-8 +0x1.7df1b6p-6 +0x1.9e703ep-6 +0x1.78a2e8p-3 +0x1.013306p-1 +0x1.bdf248p+1 +-0x1.00bc34p+1 +-0x1.a2c80cp+1 +0x1.cccc08p+3 +-0x1.9721eap+2 +-0x1.9871f4p-1 +-0x1.49f2aep-1 +-0x1.06eafap+3 +-0x1.b46512p+3 +-0x1.3fbcbep-1 +-0x1.a91a12p+3 +-0x1.4ccbaap+1 +-0x1.de6f9p+1 +-0x1.70615cp+2 +-0x1.3126aep+1 +-0x1.abd916p-1 +-0x1.b7dbb6p+3 +-0x1.79e84p+2 +-0x1.b5bfd4p-1 +-0x1.de66bep+2 +-0x1.f0f7bp+3 +-0x1.b183b2p+1 +-0x1.bcb50cp+2 +-0x1.72cb7ep+2 +-0x1.e9f8aap+1 +-0x1.6aac48p+1 +-0x1.4b6adp-4 +-0x1.5c0feep-1 +-0x1.d222c2p+2 +-0x1.5e2708p+3 +-0x1.53037cp+3 +-0x1.b62188p+2 +-0x1.4dff1ap+0 +-0x1.4af53cp+2 +0x1.195806p+1 +-0x1.19e11ap+3 +0x1.0b49f8p-2 +0x1.68b658p-3 +0x1.95adbap-4 +0x1.a8e2c2p-4 +0x1.7a1ffcp-4 +-0x1.b6a86ep-7 +-0x1.2bb1a4p-6 +-0x1.c63b5ap-12 +-0x1.f86f4cp-3 +-0x1.e76e24p-2 +0x0p+0 +0x1.d773c2p+1 +0x0p+0 +0x1.c78b32p+1 +0x0p+0 +0x1.5b67bcp+2 +0x0p+0 +0x1.5b0d16p+2 +0x0p+0 +0x1.b99324p+1 +0x0p+0 +0x1.b5b1d2p+1 +0x0p+0 +0x1.6a281ep+2 +0x0p+0 +0x1.6a0ef4p+2 +0x0p+0 +0x1.9fc57p+0 +0x0p+0 +0x1.81879p+0 +0x0p+0 +0x1.45d8aep+2 +0x0p+0 +0x1.45bcbp+2 +0x0p+0 +0x1.642afep+2 +0x0p+0 +0x1.598646p+2 +0x0p+0 +0x1.3a46c2p+1 +0x0p+0 +0x1.42bcaep+1 +0x0p+0 +0x1.5f1178p+2 +0x0p+0 +0x1.63429ap+2 +0x0p+0 +0x1.8cf20ap+2 +0x0p+0 +0x1.99c9ap+2 +0x0p+0 +0x1.92189ep+2 +0x0p+0 +0x1.8f77bcp+2 +0x0p+0 +0x1.669db8p+2 +0x0p+0 +0x1.69baa6p+2 +0x0p+0 +0x1.825c3cp+2 +0x0p+0 +0x1.87b308p+2 +0x0p+0 +0x1.f8e1dp+0 +0x0p+0 +0x1.e765dp+0 +0x0p+0 +0x1.521caap+2 +0x0p+0 +0x1.446a3p+2 +0x0p+0 +0x1.6e1de4p+2 +0x0p+0 +0x1.6b85b2p+2 +0x0p+0 +0x1.83776p-2 +0x0p+0 +0x1.81b78p-2 +0x0p+0 +0x1.72bbbap+1 +0x0p+0 +0x1.79aadp+1 +0x0p+0 +0x1.5ca494p+2 +0x0p+0 +0x1.5cdac6p+2 +0x0p+0 +0x1.f5438p-2 +0x0p+0 +0x1.5d74cp-3 +0x0p+0 +0x1.678a6p+2 +0x0p+0 +0x1.552e3cp+2 +0x0p+0 +0x1.4d94fep+2 +0x0p+0 +0x1.439c32p+2 +0x0p+0 +0x1.e0fa7p+1 +0x0p+0 +0x1.df58ap+1 +0x0p+0 +0x1.45cfdcp+1 +0x0p+0 +0x1.48788ap+1 +0x0p+0 +0x1.46a7b6p+2 +0x0p+0 +0x1.3db16ep+2 +0x0p+0 +0x1.8d1d82p+2 +0x0p+0 +0x1.80b9dp+2 +0x0p+0 +0x1.86eba8p+2 +0x0p+0 +0x1.8113e6p+2 +0x0p+0 +0x1.0df2dp-1 +0x0p+0 +0x1.bd334p-2 +0x0p+0 +0x1.ec8c7p-2 +0x0p+0 +0x1.da60bap-2 +0x0p+0 +0x1.f318bep+1 +0x0p+0 +0x1.f92948p+1 +0x0p+0 +0x1.d773c2p+1 +0x0p+0 +0x1.c78b32p+1 +0x0p+0 +0x1.68e16p+2 +0x0p+0 +0x1.6484eep+2 +0x0p+0 +0x1.166978p+2 +0x0p+0 +0x1.0f43d8p+2 +0x0p+0 +0x1.a8df84p+1 +0x0p+0 +0x1.938d5cp+1 +0x0p+0 +0x1.6a281ep+2 +0x0p+0 +0x1.6a0ef4p+2 +0x0p+0 +0x1.9fc57p+0 +0x0p+0 +0x1.81879p+0 +0x0p+0 +0x1.5b67bcp+2 +0x0p+0 +0x1.5b0d16p+2 +0x0p+0 +0x1.45d8aep+2 +0x0p+0 +0x1.45bcbp+2 +0x0p+0 +0x1.68b658p-3 +0x0p+0 +0x1.62e09cp-3 +0x0p+0 +0x1.825c3cp+2 +0x0p+0 +0x1.87b308p+2 +0x0p+0 +0x1.8507a2p+2 +0x0p+0 +0x1.873eaap+2 +0x0p+0 +-0x1.7479aap+2 +-0x1.7479aap+2 +0x0p+0 +-0x1.73e404p+2 +0x0p+0 +-0x1.73bed6p+2 +0x0p+0 +-0x1.73b59ap+2 +0x0p+0 +0x0p+0 +-0x1.75f938p+2 +-0x1.73b59ap+2 +0x0p+0 +0x1.e6a1cp-2 +0x0p+0 +0x1.c267ep-2 +0x0p+0 +-0x1.5c217ep-3 +0x0p+0 +-0x1.5c217ep-3 +0x0p+0 +-0x1.64c4fep-3 +0x0p+0 +-0x1.66ec2cp-3 +0x0p+0 +-0x1.6775dcp-3 +0x0p+0 +0x0p+0 +-0x1.613b5cp-3 +-0x1.6775dcp-3 +0x0p+0 +0x1.86e408p+2 +0x0p+0 +0x1.8715dcp+2 +0x0p+0 +0x1.86e408p+2 +0x0p+0 +0x1.8715dcp+2 +0x0p+0 +-0x1.a32b88p+2 +-0x1.a32b88p+2 +0x0p+0 +-0x1.a32b88p+2 +0x0p+0 +-0x1.a32b88p+2 +0x0p+0 +0x0p+0 +-0x1.a396a8p+2 +-0x1.a32b88p+2 +0x0p+0 +0x1.8113e4p+2 +0x0p+0 +0x1.80a8c4p+2 +-0x1.d2a26cp-5 +-0x1.2ea854p-5 +-0x1.42929p-6 +-0x1.42929p-6 +-0x1.d31fa2p-7 +-0x1.4efed8p-5 +-0x1.6e2f7ep-6 +-0x1.6e2f7ep-6 +-0x1.09e286p-6 +-0x1.6e2f7ep-6 +-0x1.09e286p-6 +-0x1.4efed8p-5 +-0x1.6cf3d8p-6 +-0x1.0b1b94p-6 +0x1.8d663cp-8 +0x1.748bf2p-6 +0x1.79018ep-6 +0x1.a3f904p-3 +0x1.20e12ap-1 +0x1.d6b1ecp+1 +0x1.081214p-3 +-0x1.cf113p+2 +-0x1.613b5cp-3 +-0x1.87341p+2 +-0x1.613b5cp-3 +-0x1.613b5cp-3 +0x0p+0 +-0x1.87341p+2 +0x1.ea7ab8p-4 +0x1.081214p-3 +0x1.18db18p-3 +0x1.7c582p-5 +0x1.081214p-3 +-0x1.54b5fap-5 +0x1.7c582p-5 +0x1.f7b9e6p-7 +-0x1.54b5fap-5 +-0x1.53fd28p-5 +0x1.f7b9e6p-7 +-0x1.613b5cp-3 +-0x1.53fd28p-5 +-0x1.057bd8p-1 +-0x1.613b5cp-3 +0x0p+0 +-0x1.057bd8p-1 +-0x1.87341p+2 +-0x1.aa949cp+1 +-0x1.cf113p+2 +-0x1.aa949cp+1 +0x1.ea7ab8p-4 +-0x1.e182bep+1 +-0x1.6e8d9ap+1 +-0x1.e182bep+1 +0x1.18db18p-3 +0x1.62e09cp-3 +0x1.62e09cp-3 +0x1.d542ecp-3 +0x1.d542ecp-3 +0x0p+0 +0x1.d75558p+1 +0x1.0b09d6p-3 +-0x1.e17f38p+2 +-0x1.cdec3ap-4 +-0x1.9b74a6p+2 +-0x1.81a1b8p-4 +-0x1.831924p-4 +0x0p+0 +-0x1.9b7d64p+2 +0x1.48181p-2 +0x1.97e5p-3 +0x1.0a6b6ep-3 +0x1.0dc06ap-3 +-0x1.08cd08p-7 +-0x1.4eb64ap-10 +-0x1.3f99f2p-5 +-0x1.434d52p-5 +0x1.b8e3acp-6 +0x1.6aa8cp-6 +-0x1.5fb498p-4 +-0x1.384362p-4 +-0x1.92fe94p-4 +-0x1.737e28p-4 +-0x1.071356p-1 +-0x1.f37d4cp-2 +0x0p+0 +-0x1.a4bce2p+1 +-0x1.9b7d64p+2 +-0x1.a4a7dp+1 +-0x1.e189ep+2 +-0x1.d90cfap+1 +0x1.48181p-2 +-0x1.d91192p+1 +-0x1.726eecp+1 +0x1.5a70e6p-3 +0x1.926e2cp-3 +0x1.87314p-3 +0x1.5c090ep-3 +0x0p+0 +0x1.84a74ep-3 +0x1.d73feep+1 +0x1.026452p-3 +-0x1.e189ep+2 +-0x1.d6bb88p-4 +-0x1.9b7d64p+2 +-0x1.89019cp-4 +-0x1.89cdp-4 +0x0p+0 +-0x1.9b86bap+2 +0x1.48181p-2 +0x1.8e8b8ap-3 +0x1.01f99ap-3 +0x1.0cc6a8p-3 +-0x1.6215acp-8 +0x1.7f75c4p-11 +-0x1.30f948p-5 +-0x1.339278p-5 +0x1.36ed1cp-6 +0x1.14a582p-6 +-0x1.28f6c4p-4 +-0x1.126616p-4 +-0x1.91d9fep-4 +-0x1.80e578p-4 +-0x1.00c344p-1 +-0x1.f0285ap-2 +0x0p+0 +-0x1.a4e482p+1 +-0x1.9b86bap+2 +-0x1.a4c9c8p+1 +-0x1.e1946ap+2 +-0x1.d911eap+1 +0x1.48181p-2 +-0x1.d911cap+1 +-0x1.726eecp+1 +0x1.5e6bc8p-3 +0x1.8c4d3ap-3 +0x1.8604a2p-3 +0x1.60b038p-3 +0x0p+0 +0x1.830c1ap-3 +0x1.d731ccp+1 +0x1.fe034ep-4 +-0x1.e1946ap+2 +-0x1.00244cp-3 +-0x1.9b86bap+2 +-0x1.ac2966p-4 +-0x1.acc35p-4 +0x0p+0 +-0x1.9b9074p+2 +0x1.48181p-2 +0x1.89d33ep-3 +0x1.fc719ap-4 +0x1.09d8e4p-3 +-0x1.ba0a6cp-9 +0x1.71ad3ap-9 +-0x1.125cacp-5 +-0x1.19246cp-5 +0x1.3c9aacp-7 +0x1.2e0d4cp-7 +-0x1.11fb04p-4 +-0x1.fc62a6p-5 +-0x1.ade518p-4 +-0x1.95c312p-4 +-0x1.f94e48p-2 +-0x1.ed0c46p-2 +0x0p+0 +-0x1.a4dfe6p+1 +-0x1.9b9074p+2 +-0x1.a4d2bcp+1 +-0x1.e19f72p+2 +-0x1.d911d4p+1 +0x1.48181p-2 +-0x1.d911d2p+1 +-0x1.726eecp+1 +0x1.61d0eep-3 +0x1.87b404p-3 +0x1.849b14p-3 +0x1.6404e8p-3 +0x0p+0 +0x1.81e3dep-3 +0x1.d71748p+1 +0x1.f7852p-4 +-0x1.cc9ca6p-10 +-0x1.e154ap-6 +0x1.26bf9ep-8 +-0x1.f6877ap-5 +-0x1.0f754cp-3 +-0x1.f37f8cp-2 +0x0p+0 +-0x1.9b9074p+2 +-0x1.a4e4fp+1 +0x1.48181p-2 +-0x1.d911d2p+1 +-0x1.726eecp+1 +-0x1.e19f72p+2 +0x1.85f63cp-3 +0x1.64c9a6p-3 +0x1.835016p-3 +-0x1.5d14dp+1 +-0x1.ac38ap+1 +0x1.bf7ad8p+3 +-0x1.a396a8p+2 +0x0p+0 +-0x1.b25266p+2 +0x0p+0 +-0x1.b25266p+2 +0x0p+0 +-0x1.555fccp-1 +-0x1.0a7dcap+3 +-0x1.6cd63cp-1 +-0x1.b96178p+3 +-0x1.6cd63cp-1 +-0x1.8fc3a4p-1 +-0x1.0e109ap+3 +-0x1.8fb0d2p-1 +-0x1.be5ddep+3 +-0x1.8faecep-1 +-0x1.be5ddep+3 +-0x1.0e109ap+3 +-0x1.5cb43ap+1 +-0x1.5bffb6p+0 +-0x1.5cb43ap+1 +-0x1.2b1624p+1 +-0x1.75f938p+2 +0x0p+0 +-0x1.ae6c6ep+3 +-0x1.408616p-1 +-0x1.5cb43ap+1 +-0x1.408616p-1 +-0x1.2b1624p+1 +-0x1.dbc6e2p+1 +-0x1.75f938p+2 +-0x1.dbc6e2p+1 +-0x1.5bffb6p+0 +-0x1.5532fcp+3 +-0x1.b8b9bap+2 +-0x1.5532fcp+3 +-0x1.6a72f6p+1 +-0x1.6dec22p+0 +-0x1.6aaca4p+1 +-0x1.24fdc6p+1 +-0x1.7e5ef8p+2 +0x0p+0 +-0x1.4367f2p-1 +-0x1.b3becap+3 +-0x1.43b076p-1 +-0x1.6aaca4p+1 +-0x1.e00374p+1 +-0x1.24fdc6p+1 +-0x1.dfffbap+1 +-0x1.7e5ef8p+2 +-0x1.5783e6p+3 +-0x1.6d7b9cp+0 +-0x1.577bcp+3 +-0x1.bb51ecp+2 +-0x1.6aaca4p+1 +-0x1.6d7b9cp+0 +-0x1.6adc3cp+1 +-0x1.24fdc6p+1 +-0x1.7e5ef8p+2 +0x0p+0 +-0x1.4357eap-1 +-0x1.b3becap+3 +-0x1.4377bep-1 +-0x1.6adc3cp+1 +-0x1.e32042p+1 +-0x1.24fdc6p+1 +-0x1.e1fd46p+1 +-0x1.7e5ef8p+2 +-0x1.577e08p+3 +-0x1.6d1e0cp+0 +-0x1.577938p+3 +-0x1.bb51ecp+2 +-0x1.6adc3cp+1 +-0x1.6d1e0cp+0 +-0x1.6b0346p+1 +-0x1.24fdc6p+1 +-0x1.7e5ef8p+2 +0x0p+0 +-0x1.4338ap-1 +-0x1.b3becap+3 +-0x1.434f5p-1 +-0x1.6b0346p+1 +-0x1.e26692p+1 +-0x1.24fdc6p+1 +-0x1.e24094p+1 +-0x1.7e5ef8p+2 +-0x1.577af2p+3 +-0x1.6cd0cep+0 +-0x1.57770cp+3 +-0x1.bb51ecp+2 +-0x1.431cc8p-1 +-0x1.6b0346p+1 +-0x1.24fdc6p+1 +-0x1.e24e42p+1 +-0x1.7e5ef8p+2 +0x0p+0 +-0x1.6cd0cep+0 +-0x1.577872p+3 +-0x1.bb51ecp+2 +-0x1.b3becap+3 +-0x1.7a043ep+2 +-0x1.de82bcp+2 +-0x1.bc56dap+3 +-0x1.aa277ep-1 +-0x1.7a043ep+2 +-0x1.aa277ep-1 +-0x1.de82bcp+2 +-0x1.b894fep-1 +-0x1.f64c3ap+3 +-0x1.b894fep-1 +-0x1.7a203cp+2 +-0x1.de9ebap+2 +-0x1.7a203cp+2 +-0x1.de9ebap+2 +-0x1.a875c8p-1 +-0x1.c0d1fep+3 +-0x1.a875eep-1 +-0x1.7a203cp+2 +-0x1.bb6a4cp-1 +-0x1.de9ebap+2 +-0x1.bb6a78p-1 +-0x1.fba0c4p+3 +-0x1.a875dcp-1 +-0x1.7a203cp+2 +-0x1.de9ebap+2 +-0x1.bb6a48p-1 +-0x1.fba0c4p+3 +-0x1.c0d1fep+3 +-0x1.dfd53cp+2 +-0x1.43287ep-1 +-0x1.61eec4p+3 +-0x1.43287ep-1 +-0x1.2a39ap-1 +-0x1.ed87b6p+2 +-0x1.2a4bcp-1 +-0x1.65b68p+3 +-0x1.2a4858p-1 +-0x1.65b68p+3 +-0x1.ed87b6p+2 +0x1.187b52p+1 +-0x1.4e6332p+2 +-0x1.1a498ep+3 +-0x1.4e6332p+2 +-0x1.51d1e4p+2 +0x1.179e9ep+1 +-0x1.51cf4p+2 +-0x1.1ab202p+3 +-0x1.51cfaap+2 +-0x1.1ab202p+3 +0x1.179e9ep+1 +-0x1.a8b2f4p-5 +-0x1.2ea854p-5 +-0x1.42929p-6 +-0x1.d31fa2p-7 +0x1.c53edp-8 +0x1.793ed4p-6 +0x1.8bb8e6p-6 +0x1.8e4df6p-3 +0x1.110a18p-1 +0x1.d6b1ecp+1 +-0x1.2ee882p+1 +-0x1.a78056p+1 +0x1.c6237p+3 +-0x1.a396a8p+2 +-0x1.76e8ep-1 +-0x1.6cd63cp-1 +-0x1.0a7dcap+3 +-0x1.b96178p+3 +-0x1.408616p-1 +-0x1.ae6c6ep+3 +-0x1.5cb43ap+1 +-0x1.dbc6e2p+1 +-0x1.75f938p+2 +-0x1.2b1624p+1 +-0x1.aa277ep-1 +-0x1.bc56dap+3 +-0x1.7a043ep+2 +-0x1.b894fep-1 +-0x1.de82bcp+2 +-0x1.f64c3ap+3 +-0x1.aa949cp+1 +-0x1.cf113p+2 +-0x1.87341p+2 +-0x1.e182bep+1 +-0x1.6e8d9ap+1 +0x1.ea7ab8p-4 +-0x1.43287ep-1 +-0x1.dfd53cp+2 +-0x1.61eec4p+3 +-0x1.5532fcp+3 +-0x1.b8b9bap+2 +-0x1.5bffb6p+0 +-0x1.4e6332p+2 +0x1.187b52p+1 +-0x1.1a498ep+3 +0x1.d542ecp-3 +0x1.62e09cp-3 +0x1.18db18p-3 +0x1.081214p-3 +0x1.7c582p-5 +-0x1.54b5fap-5 +0x1.f7b9e6p-7 +-0x1.53fd28p-5 +-0x1.613b5cp-3 +-0x1.057bd8p-1 +0x0p+0 +0x1.c78b32p+1 +0x0p+0 +0x1.b93c26p+1 +0x0p+0 +0x1.5b0d16p+2 +0x0p+0 +0x1.5ab26cp+2 +0x0p+0 +0x1.b5b1d2p+1 +0x0p+0 +0x1.b1d08p+1 +0x0p+0 +0x1.6a0ef4p+2 +0x0p+0 +0x1.69bc1cp+2 +0x0p+0 +0x1.81879p+0 +0x0p+0 +0x1.6349bp+0 +0x0p+0 +0x1.45bcbp+2 +0x0p+0 +0x1.45a0b2p+2 +0x0p+0 +0x1.598646p+2 +0x0p+0 +0x1.4ee18ep+2 +0x0p+0 +0x1.42bcaep+1 +0x0p+0 +0x1.4b2d9ap+1 +0x0p+0 +0x1.63429ap+2 +0x0p+0 +0x1.6773bcp+2 +0x0p+0 +0x1.ea7ab8p-4 +0x0p+0 +0x1.48181p-2 +0x0p+0 +0x1.8f77bcp+2 +0x0p+0 +0x1.8e32a8p+2 +0x0p+0 +0x1.69baa6p+2 +0x0p+0 +0x1.6cd6acp+2 +0x0p+0 +0x1.8715dcp+2 +0x0p+0 +0x1.89a40cp+2 +0x0p+0 +0x1.e765dp+0 +0x0p+0 +0x1.d53a2p+0 +0x0p+0 +0x1.446a3p+2 +0x0p+0 +0x1.36b7b6p+2 +0x0p+0 +0x1.6b85b2p+2 +0x0p+0 +0x1.68ed8p+2 +0x0p+0 +0x1.81b78p-2 +0x0p+0 +0x1.7ff7ap-2 +0x0p+0 +0x1.79aadp+1 +0x0p+0 +0x1.7f5a7cp+1 +0x0p+0 +0x1.5cdac6p+2 +0x0p+0 +0x1.5d10fap+2 +0x0p+0 +0x1.5d74cp-3 +0x0p+0 +-0x1.2e17cp-3 +0x0p+0 +0x1.552e3cp+2 +0x0p+0 +0x1.429ffap+2 +0x0p+0 +0x1.439c32p+2 +0x0p+0 +0x1.39a366p+2 +0x0p+0 +0x1.df58ap+1 +0x0p+0 +0x1.ddb6dp+1 +0x0p+0 +0x1.48788ap+1 +0x0p+0 +0x1.41f12ap+1 +0x0p+0 +0x1.3db16ep+2 +0x0p+0 +0x1.34bb26p+2 +0x0p+0 +0x1.80a8c4p+2 +0x0p+0 +0x1.71ed06p+2 +0x0p+0 +0x1.c267ep-2 +0x0p+0 +0x1.3c0bep-2 +0x0p+0 +0x1.f92948p+1 +0x0p+0 +0x1.ff41a6p+1 +0x0p+0 +0x1.c78b32p+1 +0x0p+0 +0x1.b93c26p+1 +0x0p+0 +0x1.6484eep+2 +0x0p+0 +0x1.6029dcp+2 +0x0p+0 +0x1.0f43d8p+2 +0x0p+0 +0x1.081e38p+2 +0x0p+0 +0x1.938d5cp+1 +0x0p+0 +0x1.7e3b34p+1 +0x0p+0 +0x1.6a0ef4p+2 +0x0p+0 +0x1.69bc1cp+2 +0x0p+0 +0x1.81879p+0 +0x0p+0 +0x1.6349bp+0 +0x0p+0 +0x1.5b0d16p+2 +0x0p+0 +0x1.5ab26cp+2 +0x0p+0 +0x1.45bcbp+2 +0x0p+0 +0x1.45a0b2p+2 +0x0p+0 +0x1.62e09cp-3 +0x0p+0 +0x1.64c9a6p-3 +0x0p+0 +0x1.8715dcp+2 +0x0p+0 +0x1.89a40cp+2 +-0x1.fc91e4p-5 +-0x1.4efed8p-5 +-0x1.6cf3d8p-6 +-0x1.6cf3d8p-6 +-0x1.0b1b94p-6 +-0x1.6f555cp-5 +-0x1.9890c6p-6 +-0x1.9890c6p-6 +-0x1.2b6e48p-6 +-0x1.6f555cp-5 +-0x1.97a9d8p-6 +-0x1.2c532p-6 +0x1.558da8p-8 +0x1.6fd91p-6 +0x1.664a36p-6 +0x1.b9a412p-3 +0x1.30b83cp-1 +0x1.d71748p+1 +0x1.f7852p-4 +-0x1.e19f72p+2 +-0x1.0f754cp-3 +-0x1.9b9074p+2 +-0x1.0f754cp-3 +-0x1.9b9074p+2 +0x1.48181p-2 +0x1.f7852p-4 +0x1.85f63cp-3 +-0x1.cc9ca6p-10 +0x1.f7852p-4 +-0x1.e154ap-6 +-0x1.cc9ca6p-10 +0x1.26bf9ep-8 +-0x1.e154ap-6 +-0x1.f6877ap-5 +0x1.26bf9ep-8 +-0x1.0f754cp-3 +-0x1.f6877ap-5 +-0x1.f37f8cp-2 +-0x1.0f754cp-3 +0x0p+0 +-0x1.f37f8cp-2 +-0x1.9b9074p+2 +-0x1.a4e4fp+1 +-0x1.e19f72p+2 +-0x1.a4e4fp+1 +0x1.48181p-2 +-0x1.d911d2p+1 +-0x1.726eecp+1 +-0x1.d911d2p+1 +0x1.85f63cp-3 +0x1.64c9a6p-3 +0x1.64c9a6p-3 +0x1.835016p-3 +0x1.835016p-3 +0x0p+0 +0x1.d24b2ap+1 +0x1.b54b5cp-4 +-0x1.f3b5eap+2 +-0x1.c3888ep-3 +-0x1.a6aa6ep+2 +-0x1.9bdf9ap-3 +-0x1.a6aa6ep+2 +-0x1.9bdf9ap-3 +-0x1.a6a446p+2 +0x1.29b63p-2 +0x1.df8d18p-3 +0x1.b3e7ep-4 +0x1.d323bp-4 +-0x1.134c2ap-5 +-0x1.c2b23cp-6 +0x1.51f3ep-9 +-0x1.1775bp-9 +-0x1.01d80cp-4 +-0x1.cd4d9p-5 +0x1.7cd3ccp-4 +0x1.439016p-4 +-0x1.a6e096p-3 +-0x1.5b3282p-3 +-0x1.dae6ccp-2 +-0x1.df7fbap-2 +0x0p+0 +-0x1.a8191p+1 +-0x1.a5ab5p+2 +-0x1.aa1aacp+1 +-0x1.f3c57p+2 +-0x1.ca2c4p+1 +0x1.03f074p-2 +-0x1.c87412p+1 +-0x1.76503ep+1 +0x1.79879cp-3 +0x1.d6c5bap-3 +0x1.2b2b34p-3 +0x1.7fee36p-3 +0x0p+0 +0x1.2ea2c4p-3 +0x1.d236ecp+1 +0x1.b77d16p-4 +-0x1.f3c57p+2 +-0x1.bf849ap-3 +-0x1.a5ab5p+2 +-0x1.934bf4p-3 +-0x1.a5ab5p+2 +-0x1.934bf4p-3 +-0x1.a5a048p+2 +0x1.03f074p-2 +0x1.d3e15ap-3 +0x1.b48dcep-4 +0x1.d64102p-4 +-0x1.e2f464p-6 +-0x1.8f7caep-6 +-0x1.5c3a94p-10 +-0x1.0182ap-8 +-0x1.b6adbcp-5 +-0x1.a2be36p-5 +0x1.1990eap-4 +0x1.03df58p-4 +-0x1.a6e8eap-3 +-0x1.6412eap-3 +-0x1.dd09eep-2 +-0x1.dac9b4p-2 +0x0p+0 +-0x1.a97b96p+1 +-0x1.a49e76p+2 +-0x1.ab4aacp+1 +-0x1.f3d6bep+2 +-0x1.c91b26p+1 +0x1.cb3f08p-3 +-0x1.c77e78p+1 +-0x1.76503ep+1 +0x1.7aa9bcp-3 +0x1.cda6ccp-3 +0x1.2cdc5ep-3 +0x1.81a7fcp-3 +0x0p+0 +0x1.2fc42cp-3 +0x1.d20becp+1 +0x1.b5821cp-4 +-0x1.f3d6bep+2 +-0x1.b5781cp-3 +-0x1.a49e76p+2 +-0x1.87a1c8p-3 +-0x1.a4a386p+2 +-0x1.884e42p-3 +-0x1.a49584p+2 +0x1.cb3f08p-3 +0x1.cc8b3cp-3 +0x1.b155p-4 +0x1.d39ebap-4 +-0x1.96df9ep-6 +-0x1.4bb63p-6 +-0x1.af37dcp-8 +-0x1.fafc74p-8 +-0x1.4ca47ap-5 +-0x1.52379ep-5 +0x1.e3c49ep-5 +0x1.bcb0a8p-5 +-0x1.a1469p-3 +-0x1.631ea8p-3 +-0x1.dbfd3p-2 +-0x1.d980fcp-2 +0x0p+0 +-0x1.aab01cp+1 +-0x1.a39e64p+2 +-0x1.ac2a2ep+1 +-0x1.f3e8eep+2 +-0x1.c80ec4p+1 +0x1.9a0068p-3 +-0x1.c6b8cap+1 +-0x1.76503ep+1 +0x1.7bf1d4p-3 +0x1.c6e5bep-3 +0x1.2e3f78p-3 +0x1.82852ep-3 +0x0p+0 +0x1.311904p-3 +0x1.d1ce86p+1 +0x1.b1e772p-4 +-0x1.48e0fap-6 +-0x1.8ea728p-7 +-0x1.129b5cp-5 +0x1.a09c4ap-5 +-0x1.af8e5ap-3 +-0x1.dad33cp-2 +0x0p+0 +-0x1.a39e64p+2 +-0x1.abaec2p+1 +0x1.9a0068p-3 +-0x1.c72fe8p+1 +-0x1.76503ep+1 +-0x1.f3e8eep+2 +0x1.c62b8p-3 +0x1.7cfd4ep-3 +0x1.2f9c26p-3 +-0x1.8b411ep+1 +-0x1.b0f0eap+1 +0x1.b8d24p+3 +-0x1.c10e24p+2 +-0x1.33d6b8p-1 +-0x1.0e109ap+3 +-0x1.8faecep-1 +-0x1.be5ddep+3 +-0x1.8faecep-1 +-0x1.b289a2p-1 +-0x1.11a36ap+3 +-0x1.b2696ep-1 +-0x1.c35a44p+3 +-0x1.b26c78p-1 +-0x1.11a36ap+3 +-0x1.b26b5cp-1 +-0x1.c35a44p+3 +-0x1.b26ba8p-1 +-0x1.c35a44p+3 +-0x1.11a36ap+3 +-0x1.6b0346p+1 +-0x1.6cd0cep+0 +-0x1.b3becap+3 +-0x1.431cc8p-1 +-0x1.6b0346p+1 +-0x1.431cc8p-1 +-0x1.6cd0cep+0 +-0x1.577872p+3 +-0x1.bb51ecp+2 +-0x1.577872p+3 +-0x1.78c202p+1 +-0x1.7ebd3ap+0 +-0x1.45fddap-1 +-0x1.b91126p+3 +-0x1.460f7ap-1 +-0x1.78c202p+1 +-0x1.59c78ep+3 +-0x1.7ebd3ap+0 +-0x1.59c5dcp+3 +-0x1.bdea1ep+2 +-0x1.46093p-1 +-0x1.78c202p+1 +-0x1.7ebd3ap+0 +-0x1.59c5d4p+3 +-0x1.bdea1ep+2 +-0x1.b91126p+3 +-0x1.7e5ef8p+2 +0x0p+0 +-0x1.7e5ef8p+2 +-0x1.e24e42p+1 +-0x1.24fdc6p+1 +-0x1.e24e42p+1 +-0x1.86c4b8p+2 +0x0p+0 +-0x1.e6889cp+1 +-0x1.86c4b8p+2 +-0x1.e6889ap+1 +-0x1.1ee568p+1 +-0x1.e6818p+1 +-0x1.1ee568p+1 +-0x1.86c4b8p+2 +0x0p+0 +-0x1.7a203cp+2 +-0x1.de9ebap+2 +-0x1.c0d1fep+3 +-0x1.a875dcp-1 +-0x1.7a203cp+2 +-0x1.a875dcp-1 +-0x1.de9ebap+2 +-0x1.bb6a48p-1 +-0x1.fba0c4p+3 +-0x1.bb6a48p-1 +-0x1.7a3c3ap+2 +-0x1.debab8p+2 +-0x1.7a3c3ap+2 +-0x1.debab8p+2 +-0x1.a6c426p-1 +-0x1.c54d22p+3 +-0x1.a6c418p-1 +-0x1.7a3c3ap+2 +-0x1.be3f94p-1 +-0x1.debab8p+2 +-0x1.be3fa2p-1 +-0x1.007aa6p+4 +-0x1.a6c41p-1 +-0x1.7a3c3ap+2 +-0x1.debab8p+2 +-0x1.be3fdcp-1 +-0x1.007aa6p+4 +-0x1.c54d22p+3 +-0x1.ed87b6p+2 +-0x1.2a4858p-1 +-0x1.65b68p+3 +-0x1.2a4858p-1 +-0x1.11607ep-1 +-0x1.fb3a3p+2 +-0x1.1172c4p-1 +-0x1.697e3cp+3 +-0x1.116f58p-1 +-0x1.697e3cp+3 +-0x1.fb3a3p+2 +0x1.179e9ep+1 +-0x1.51cfaap+2 +-0x1.1ab202p+3 +-0x1.51cfaap+2 +-0x1.553d32p+2 +0x1.16c1eap+1 +-0x1.553a6p+2 +-0x1.1b1a76p+3 +-0x1.553adep+2 +-0x1.1b1a76p+3 +0x1.16c1eap+1 +-0x1.d2a26cp-5 +-0x1.4efed8p-5 +-0x1.6cf3d8p-6 +-0x1.0b1b94p-6 +0x1.8d663cp-8 +0x1.748bf2p-6 +0x1.79018ep-6 +0x1.a3f904p-3 +0x1.20e12ap-1 +0x1.d71748p+1 +-0x1.5d14dp+1 +-0x1.ac38ap+1 +0x1.bf7ad8p+3 +-0x1.b25266p+2 +-0x1.555fccp-1 +-0x1.8faecep-1 +-0x1.0e109ap+3 +-0x1.be5ddep+3 +-0x1.431cc8p-1 +-0x1.b3becap+3 +-0x1.6b0346p+1 +-0x1.e24e42p+1 +-0x1.7e5ef8p+2 +-0x1.24fdc6p+1 +-0x1.a875dcp-1 +-0x1.c0d1fep+3 +-0x1.7a203cp+2 +-0x1.bb6a48p-1 +-0x1.de9ebap+2 +-0x1.fba0c4p+3 +-0x1.a4e4fp+1 +-0x1.e19f72p+2 +-0x1.9b9074p+2 +-0x1.d911d2p+1 +-0x1.726eecp+1 +0x1.48181p-2 +-0x1.2a4858p-1 +-0x1.ed87b6p+2 +-0x1.65b68p+3 +-0x1.577872p+3 +-0x1.bb51ecp+2 +-0x1.6cd0cep+0 +-0x1.51cfaap+2 +0x1.179e9ep+1 +-0x1.1ab202p+3 +0x1.835016p-3 +0x1.64c9a6p-3 +0x1.85f63cp-3 +0x1.f7852p-4 +-0x1.cc9ca6p-10 +-0x1.e154ap-6 +0x1.26bf9ep-8 +-0x1.f6877ap-5 +-0x1.0f754cp-3 +-0x1.f37f8cp-2 +0x0p+0 +0x1.88aef8p+2 +0x0p+0 +0x1.80a108p+2 +0x0p+0 +0x1.36eb82p+2 +0x0p+0 +0x1.327068p+2 +0x0p+0 +0x1.b93c26p+1 +0x0p+0 +0x1.ab7d6ap+1 +0x0p+0 +0x1.5ab26cp+2 +0x0p+0 +0x1.5a57bap+2 +0x0p+0 +0x1.b1d08p+1 +0x0p+0 +0x1.adef2ep+1 +0x0p+0 +0x1.69bc1cp+2 +0x0p+0 +0x1.695e9p+2 +0x0p+0 +0x1.6349bp+0 +0x0p+0 +0x1.450bdp+0 +0x0p+0 +0x1.45a0b2p+2 +0x0p+0 +0x1.4584b4p+2 +0x0p+0 +0x1.4ee18ep+2 +0x0p+0 +0x1.443cd6p+2 +0x0p+0 +0x1.4b2d9ap+1 +0x0p+0 +0x1.5d0f84p+1 +0x0p+0 +0x1.6773bcp+2 +0x0p+0 +0x1.6ba4ep+2 +0x0p+0 +0x1.48181p-2 +0x0p+0 +0x1.9a0068p-3 +0x0p+0 +0x1.8e32a8p+2 +0x0p+0 +0x1.9560eep+2 +0x0p+0 +0x1.6cd6acp+2 +0x0p+0 +0x1.6ff1ccp+2 +0x0p+0 +0x1.d53a2p+0 +0x0p+0 +0x1.c2cf1p+0 +0x0p+0 +0x1.36b7b6p+2 +0x0p+0 +0x1.29053cp+2 +0x0p+0 +0x1.68ed8p+2 +0x0p+0 +0x1.66554ep+2 +0x0p+0 +0x1.7ff7ap-2 +0x0p+0 +0x1.7e37cp-2 +0x0p+0 +0x1.7f5a7cp+1 +0x0p+0 +0x1.7890aap+1 +0x0p+0 +0x1.5d10fap+2 +0x0p+0 +0x1.5d4734p+2 +0x0p+0 +0x1.88aef8p+2 +0x0p+0 +0x1.80a108p+2 +0x0p+0 +0x1.429ffap+2 +0x0p+0 +0x1.30567ep+2 +0x0p+0 +0x1.39a366p+2 +0x0p+0 +0x1.2faa9ap+2 +0x0p+0 +0x1.ddb6dp+1 +0x0p+0 +0x1.dc15p+1 +0x0p+0 +0x1.41f12ap+1 +0x0p+0 +0x1.3dbdecp+1 +0x0p+0 +0x1.34bb26p+2 +0x0p+0 +0x1.2bc4dep+2 +0x0p+0 +0x1.71ed06p+2 +0x0p+0 +0x1.633148p+2 +0x0p+0 +0x1.3c0bep-2 +0x0p+0 +0x1.6b5fcp-3 +0x0p+0 +0x1.ff41a6p+1 +0x0p+0 +0x1.02ad02p+2 +0x0p+0 +0x1.b93c26p+1 +0x0p+0 +0x1.ab7d6ap+1 +0x0p+0 +0x1.6029dcp+2 +0x0p+0 +0x1.5bd24p+2 +0x0p+0 +0x1.081e38p+2 +0x0p+0 +0x1.00f898p+2 +0x0p+0 +0x1.7e3b34p+1 +0x0p+0 +0x1.68e914p+1 +0x0p+0 +0x1.69bc1cp+2 +0x0p+0 +0x1.695e9p+2 +0x0p+0 +0x1.6349bp+0 +0x0p+0 +0x1.450bdp+0 +0x0p+0 +0x1.5ab26cp+2 +0x0p+0 +0x1.5a57bap+2 +0x0p+0 +0x1.45a0b2p+2 +0x0p+0 +0x1.4584b4p+2 +0x0p+0 +0x1.64c9a6p-3 +0x0p+0 +0x1.7cfd4ep-3 +0x0p+0 +0x1.89a40cp+2 +0x0p+0 +0x1.84a344p+2 +-0x1.1340aep-4 +-0x1.8fabep-5 +-0x1.97a9d8p-6 +-0x1.2c532p-6 +-0x1.c346c6p-6 +-0x1.4ca5d4p-6 +-0x1.c2a3a2p-6 +-0x1.4d476p-6 +0x1.1db514p-8 +0x1.6b262ep-6 +0x1.5392dep-6 +0x1.cf4f2p-3 +0x1.408f4ep-1 +0x1.d1ce86p+1 +0x1.b1e772p-4 +-0x1.f3e8eep+2 +-0x1.af8e5ap-3 +-0x1.a39e64p+2 +-0x1.af8e5ap-3 +-0x1.a39e64p+2 +0x1.9a0068p-3 +0x1.b1e772p-4 +0x1.c62b8p-3 +-0x1.48e0fap-6 +0x1.b1e772p-4 +-0x1.8ea728p-7 +-0x1.48e0fap-6 +-0x1.129b5cp-5 +-0x1.8ea728p-7 +0x1.a09c4ap-5 +-0x1.129b5cp-5 +-0x1.af8e5ap-3 +0x1.a09c4ap-5 +-0x1.dad33cp-2 +-0x1.af8e5ap-3 +0x0p+0 +-0x1.dad33cp-2 +-0x1.a39e64p+2 +-0x1.abaec2p+1 +-0x1.f3e8eep+2 +-0x1.abaec2p+1 +0x1.9a0068p-3 +-0x1.c72fe8p+1 +-0x1.76503ep+1 +-0x1.c72fe8p+1 +0x1.c62b8p-3 +0x1.7cfd4ep-3 +0x1.7cfd4ep-3 +0x1.2f9c26p-3 +0x1.2f9c26p-3 +0x0p+0 +0x1.c3524p+1 +0x1.42a4a8p-4 +-0x1.033c34p+3 +-0x1.3fb05ap-2 +-0x1.afe81p+2 +-0x1.2acebp-2 +-0x1.afe81p+2 +-0x1.2acebp-2 +-0x1.afdbc2p+2 +0x1.5d3caap-3 +0x1.e4e86p-3 +0x1.3fa896p-4 +0x1.69a194p-4 +-0x1.4fc67cp-7 +-0x1.073b16p-7 +-0x1.63043ap-7 +-0x1.4867aep-7 +-0x1.9e6694p-5 +-0x1.9a471ep-5 +0x1.4cb35cp-3 +0x1.2b9b9p-3 +-0x1.3782c6p-2 +-0x1.03afe2p-2 +-0x1.bcb086p-2 +-0x1.c32004p-2 +0x0p+0 +-0x1.af18dcp+1 +-0x1.af6c22p+2 +-0x1.b04772p+1 +-0x1.0346f6p+3 +-0x1.b85698p+1 +0x1.3b2644p-3 +-0x1.b7194ap+1 +-0x1.7a319p+1 +0x1.9ad23ep-3 +0x1.db08bep-3 +0x1.ce793p-4 +0x1.a15946p-3 +0x0p+0 +0x1.de44fap-4 +0x1.c32392p+1 +0x1.48ffap-4 +-0x1.0346f6p+3 +-0x1.270f8cp-2 +-0x1.af6c22p+2 +-0x1.138dcap-2 +-0x1.af6c22p+2 +-0x1.138dcap-2 +-0x1.af5aep+2 +0x1.3b2644p-3 +0x1.dbac84p-3 +0x1.43f93cp-4 +0x1.6c78f4p-4 +-0x1.ee989ap-8 +-0x1.458c8ap-8 +-0x1.e1e836p-7 +-0x1.bd3b14p-7 +-0x1.2dd30cp-5 +-0x1.41370ap-5 +0x1.1475c8p-3 +0x1.051cc2p-3 +-0x1.260aep-2 +-0x1.f4282ep-3 +-0x1.bfaceep-2 +-0x1.c46174p-2 +0x0p+0 +-0x1.afe694p+1 +-0x1.aef09ep+2 +-0x1.b0de6cp+1 +-0x1.035166p+3 +-0x1.b795a2p+1 +0x1.1f0bdcp-3 +-0x1.b68e1ep+1 +-0x1.7a319p+1 +0x1.986a28p-3 +0x1.d1ba5ap-3 +0x1.d618dp-4 +0x1.a00592p-3 +0x0p+0 +0x1.e4ff3ep-4 +0x1.c2d4b8p+1 +0x1.4d42ccp-4 +-0x1.035166p+3 +-0x1.1b46bap-2 +-0x1.aef09ep+2 +-0x1.081d86p-2 +-0x1.aef09ep+2 +-0x1.081d86p-2 +-0x1.aedc9ep+2 +0x1.1f0bdcp-3 +0x1.d3fdc4p-3 +0x1.46b10ap-4 +0x1.6e864ep-4 +-0x1.46bcaap-8 +-0x1.1cf8dap-9 +-0x1.35d5bep-6 +-0x1.1b20e6p-6 +-0x1.8c4b5cp-6 +-0x1.cd9d82p-6 +0x1.d90d92p-4 +0x1.c5dd84p-4 +-0x1.1de29ep-2 +-0x1.e77c36p-3 +-0x1.c1dea8p-2 +-0x1.c5188cp-2 +0x0p+0 +-0x1.b0908cp+1 +-0x1.ae7b14p+2 +-0x1.b15754p+1 +-0x1.035bdcp+3 +-0x1.b6ebcap+1 +0x1.07e3e2p-3 +-0x1.b61584p+1 +-0x1.7a319p+1 +0x1.96c298p-3 +0x1.c9f1d6p-3 +0x1.dd3eaep-4 +0x1.9e3f62p-3 +0x0p+0 +0x1.ebd416p-4 +0x1.c26d2ep+1 +0x1.50a70cp-4 +-0x1.481f5p-9 +-0x1.6a56c6p-6 +-0x1.e5f966p-7 +0x1.a22fc6p-4 +-0x1.12d5eep-2 +-0x1.c361bap-2 +0x0p+0 +-0x1.ae7b14p+2 +-0x1.b11b52p+1 +0x1.07e3e2p-3 +-0x1.b6618p+1 +-0x1.7a319p+1 +-0x1.035bdcp+3 +0x1.cc8e9p-3 +0x1.9522e4p-3 +0x1.e43ccap-4 +-0x1.b96d6cp+1 +-0x1.b0f0eap+1 +0x1.b8d24p+3 +-0x1.c93deap+1 +0x1.ad447ap+3 +-0x1.c93deap+1 +0x1.ad447ap+3 +-0x1.cfc9e2p+2 +-0x1.124da4p-1 +-0x1.11a36ap+3 +-0x1.b26ba8p-1 +-0x1.c35a44p+3 +-0x1.b26ba8p-1 +-0x1.d5333ap-1 +-0x1.15363ap+3 +-0x1.d51988p-1 +-0x1.c856aap+3 +-0x1.d51a34p-1 +-0x1.c856aap+3 +-0x1.15363ap+3 +-0x1.46093p-1 +-0x1.7ebd3ap+0 +-0x1.b91126p+3 +-0x1.7ebd3ap+0 +-0x1.b91126p+3 +-0x1.46093p-1 +-0x1.78c202p+1 +-0x1.46093p-1 +-0x1.7ebd3ap+0 +-0x1.59c5d4p+3 +-0x1.bdea1ep+2 +-0x1.59c5d4p+3 +-0x1.5a630ap-1 +-0x1.8b8a34p+0 +-0x1.bb29p+3 +-0x1.8b8a34p+0 +-0x1.5a630ap-1 +-0x1.bb29p+3 +-0x1.5e4198p-1 +-0x1.8680bep+1 +-0x1.5ba0ep+3 +-0x1.8b8a34p+0 +-0x1.5bad3ap+3 +-0x1.c0825p+2 +-0x1.585af8p-1 +-0x1.8b8a34p+0 +-0x1.bb29p+3 +-0x1.8b8a34p+0 +-0x1.585af8p-1 +-0x1.bb29p+3 +-0x1.5a7dccp-1 +-0x1.8680bep+1 +-0x1.5ba87cp+3 +-0x1.8b8a34p+0 +-0x1.5baa2cp+3 +-0x1.c0825p+2 +-0x1.59b882p-1 +-0x1.8b8a34p+0 +-0x1.bb29p+3 +-0x1.8b8a34p+0 +-0x1.59b882p-1 +-0x1.bb29p+3 +-0x1.59ff98p-1 +-0x1.8680bep+1 +-0x1.5ba992p+3 +-0x1.8b8a34p+0 +-0x1.5ba9cap+3 +-0x1.c0825p+2 +-0x1.59e5fap-1 +-0x1.8680bep+1 +-0x1.bb29p+3 +-0x1.8b8a34p+0 +-0x1.5ba9b6p+3 +-0x1.c0825p+2 +-0x1.86c4b8p+2 +-0x1.e6818p+1 +-0x1.1ee568p+1 +-0x1.e6818p+1 +-0x1.eabb86p+1 +-0x1.8f2a78p+2 +-0x1.eabc0ep+1 +-0x1.18cd0ap+1 +-0x1.eabb9ep+1 +-0x1.18cd0ap+1 +-0x1.8f2a78p+2 +-0x1.c54d22p+3 +-0x1.a6c41p-1 +-0x1.7a3c3ap+2 +-0x1.a6c41p-1 +-0x1.a5125cp-1 +-0x1.c9c846p+3 +-0x1.a51276p-1 +-0x1.7a5838p+2 +-0x1.a5126ap-1 +-0x1.7a5838p+2 +-0x1.c9c846p+3 +-0x1.debab8p+2 +-0x1.be3fdcp-1 +-0x1.007aa6p+4 +-0x1.be3fdcp-1 +-0x1.c11526p-1 +-0x1.ded6b6p+2 +-0x1.c114ecp-1 +-0x1.0324eap+4 +-0x1.c115p-1 +-0x1.0324eap+4 +-0x1.ded6b6p+2 +-0x1.697e3cp+3 +-0x1.1b1a76p+3 +-0x1.fb3a3p+2 +-0x1.116f58p-1 +-0x1.697e3cp+3 +-0x1.116f58p-1 +-0x1.1b1a76p+3 +-0x1.553adep+2 +0x1.16c1eap+1 +-0x1.553adep+2 +-0x1.6c139cp+3 +-0x1.1aee0cp+3 +-0x1.d113ccp-2 +-0x1.047656p+3 +-0x1.d194fep-2 +-0x1.6c0316p+3 +-0x1.594fcp+2 +-0x1.1add4cp+3 +-0x1.596046p+2 +0x1.15e536p+1 +-0x1.6c0316p+3 +-0x1.1add4cp+3 +-0x1.cebfb2p-2 +-0x1.047656p+3 +-0x1.cfc57ep-2 +-0x1.6bf558p+3 +-0x1.5956a2p+2 +-0x1.1acf42p+3 +-0x1.59637p+2 +0x1.15e536p+1 +-0x1.6bf558p+3 +-0x1.1acf42p+3 +-0x1.cd74bp-2 +-0x1.047656p+3 +-0x1.ce49f2p-2 +-0x1.6bea3cp+3 +-0x1.595edcp+2 +-0x1.1ac3c6p+3 +-0x1.596828p+2 +0x1.15e536p+1 +-0x1.cc65dep-2 +-0x1.6bea3cp+3 +-0x1.1ac3c6p+3 +-0x1.5964d8p+2 +0x1.15e536p+1 +-0x1.047656p+3 +-0x1.fc91e4p-5 +-0x1.6f555cp-5 +-0x1.97a9d8p-6 +-0x1.2c532p-6 +0x1.558da8p-8 +0x1.6fd91p-6 +0x1.664a36p-6 +0x1.b9a412p-3 +0x1.30b83cp-1 +0x1.d1ce86p+1 +-0x1.8b411ep+1 +-0x1.b0f0eap+1 +0x1.b8d24p+3 +-0x1.c10e24p+2 +-0x1.33d6b8p-1 +-0x1.b26ba8p-1 +-0x1.11a36ap+3 +-0x1.c35a44p+3 +-0x1.46093p-1 +-0x1.b91126p+3 +-0x1.78c202p+1 +-0x1.e6818p+1 +-0x1.86c4b8p+2 +-0x1.1ee568p+1 +-0x1.a6c41p-1 +-0x1.c54d22p+3 +-0x1.7a3c3ap+2 +-0x1.be3fdcp-1 +-0x1.debab8p+2 +-0x1.007aa6p+4 +-0x1.abaec2p+1 +-0x1.f3e8eep+2 +-0x1.a39e64p+2 +-0x1.c72fe8p+1 +-0x1.76503ep+1 +0x1.9a0068p-3 +-0x1.116f58p-1 +-0x1.fb3a3p+2 +-0x1.697e3cp+3 +-0x1.59c5d4p+3 +-0x1.bdea1ep+2 +-0x1.7ebd3ap+0 +-0x1.553adep+2 +0x1.16c1eap+1 +-0x1.1b1a76p+3 +0x1.2f9c26p-3 +0x1.7cfd4ep-3 +0x1.c62b8p-3 +0x1.b1e772p-4 +-0x1.48e0fap-6 +-0x1.8ea728p-7 +-0x1.129b5cp-5 +0x1.a09c4ap-5 +-0x1.af8e5ap-3 +-0x1.dad33cp-2 +0x0p+0 +0x1.84a344p+2 +0x0p+0 +0x1.80f258p+2 +0x0p+0 +0x1.80a108p+2 +0x0p+0 +0x1.75c458p+2 +0x0p+0 +0x1.327068p+2 +0x0p+0 +0x1.2f3d28p+2 +0x0p+0 +0x1.ab7d6ap+1 +0x0p+0 +0x1.9dbeaep+1 +0x0p+0 +0x1.a49e0cp+1 +0x0p+0 +0x1.a5b448p+1 +0x0p+0 +0x1.5a57bap+2 +0x0p+0 +0x1.59fd16p+2 +0x0p+0 +0x1.adef2ep+1 +0x0p+0 +0x1.aa0ddcp+1 +0x0p+0 +0x1.695e9p+2 +0x0p+0 +0x1.66e2f6p+2 +0x0p+0 +0x1.450bdp+0 +0x0p+0 +0x1.31abdp+0 +0x0p+0 +0x1.4584b4p+2 +0x0p+0 +0x1.4568b6p+2 +0x0p+0 +0x1.443cd6p+2 +0x0p+0 +0x1.400d22p+2 +0x0p+0 +0x1.5d0f84p+1 +0x0p+0 +0x1.6dddecp+1 +0x0p+0 +0x1.6ba4ep+2 +0x0p+0 +0x1.6fd602p+2 +0x0p+0 +0x1.9a0068p-3 +0x0p+0 +0x1.07e3e2p-3 +0x0p+0 +0x1.a09c4ap-5 +0x0p+0 +0x1.a22fc6p-4 +0x0p+0 +0x1.6ff1ccp+2 +0x0p+0 +0x1.755958p+2 +0x0p+0 +0x1.29053cp+2 +0x0p+0 +0x1.1b52cp+2 +0x0p+0 +0x1.66554ep+2 +0x0p+0 +0x1.63bd1cp+2 +0x0p+0 +0x1.7e37cp-2 +0x0p+0 +0x1.7c77ep-2 +0x0p+0 +0x1.7890aap+1 +0x0p+0 +0x1.73241ap+1 +0x0p+0 +0x1.5d4734p+2 +0x0p+0 +0x1.5d7d68p+2 +0x0p+0 +0x1.30567ep+2 +0x0p+0 +0x1.1d87b4p+2 +0x0p+0 +0x1.2faa9ap+2 +0x0p+0 +0x1.25b1cep+2 +0x0p+0 +0x1.dc15p+1 +0x0p+0 +0x1.dd6fcp+1 +0x0p+0 +0x1.3dbdecp+1 +0x0p+0 +0x1.3983cep+1 +0x0p+0 +0x1.2bc4dep+2 +0x0p+0 +0x1.22ce96p+2 +0x0p+0 +0x1.633148p+2 +0x0p+0 +0x1.54758ap+2 +0x0p+0 +0x1.6b5fcp-3 +0x0p+0 +0x1.7a9fp-5 +0x0p+0 +0x1.02ad02p+2 +0x0p+0 +0x1.05b93p+2 +0x0p+0 +0x1.ab7d6ap+1 +0x0p+0 +0x1.9dbeaep+1 +0x0p+0 +0x1.a49e0cp+1 +0x0p+0 +0x1.9e5bbep+1 +0x0p+0 +0x1.9dbeaep+1 +0x0p+0 +0x1.5bd24p+2 +0x0p+0 +0x1.577c7p+2 +0x0p+0 +0x1.00f898p+2 +0x0p+0 +0x1.f3a5fp+1 +0x0p+0 +0x1.68e914p+1 +0x0p+0 +0x1.5396f4p+1 +0x0p+0 +0x1.695e9p+2 +0x0p+0 +0x1.66e2f6p+2 +0x0p+0 +0x1.450bdp+0 +0x0p+0 +0x1.31abdp+0 +0x0p+0 +0x1.5a57bap+2 +0x0p+0 +0x1.59fd16p+2 +0x0p+0 +0x1.7cfd4ep-3 +0x0p+0 +0x1.9522e4p-3 +0x0p+0 +0x1.84a344p+2 +0x0p+0 +0x1.80f258p+2 +0x0p+0 +-0x1.7e8b26p+1 +0x0p+0 +-0x1.7e8b26p+1 +0x0p+0 +-0x1.7e44dcp+1 +0x0p+0 +-0x1.7e32c2p+1 +0x0p+0 +-0x1.7e2e32p+1 +0x0p+0 +0x0p+0 +-0x1.8d970ap+1 +-0x1.7e2e32p+1 +0x0p+0 +0x1.a6113ap+1 +0x0p+0 +0x1.96a862p+1 +0x0p+0 +0x1.a6113ap+1 +0x0p+0 +0x1.96a862p+1 +-0x1.28386ap-4 +-0x1.b00264p-5 +-0x1.c2a3a2p-6 +-0x1.4d476p-6 +-0x1.ee409p-6 +-0x1.6d9a14p-6 +-0x1.edd78cp-6 +-0x1.6e01fcp-6 +0x1.cbb9p-9 +0x1.66734cp-6 +0x1.40db86p-6 +0x1.e4fa2ep-3 +0x1.50666p-1 +0x1.c26d2ep+1 +0x1.cc8e9p-3 +0x1.c26d2ep+1 +0x1.50a70cp-4 +-0x1.035bdcp+3 +-0x1.12d5eep-2 +-0x1.ae7b14p+2 +-0x1.12d5eep-2 +-0x1.ae7b14p+2 +0x1.07e3e2p-3 +-0x1.035bdcp+3 +-0x1.7a319p+1 +0x1.50a70cp-4 +0x1.cc8e9p-3 +-0x1.481f5p-9 +0x1.50a70cp-4 +-0x1.6a56c6p-6 +-0x1.481f5p-9 +-0x1.e5f966p-7 +-0x1.6a56c6p-6 +0x1.a22fc6p-4 +-0x1.e5f966p-7 +-0x1.12d5eep-2 +0x1.a22fc6p-4 +-0x1.c361bap-2 +-0x1.12d5eep-2 +0x0p+0 +-0x1.c361bap-2 +-0x1.ae7b14p+2 +-0x1.b11b52p+1 +-0x1.035bdcp+3 +-0x1.b11b52p+1 +0x1.07e3e2p-3 +-0x1.b6618p+1 +-0x1.7a319p+1 +-0x1.b6618p+1 +0x1.cc8e9p-3 +0x1.9522e4p-3 +0x1.9522e4p-3 +0x1.e43ccap-4 +0x1.e43ccap-4 +0x0p+0 +0x1.9e07cep+1 +0x1.a4faf8p-3 +0x1.9e07cep+1 +0x1.f8cf14p-5 +-0x1.04993ap+3 +-0x1.2ef408p-2 +-0x1.04a32cp+3 +-0x1.1cf076p-2 +-0x1.ba786cp+2 +-0x1.147aep-2 +-0x1.ba786cp+2 +-0x1.147aep-2 +-0x1.ba6852p+2 +0x1.964048p-4 +-0x1.048a8ap+3 +-0x1.8624e8p+1 +0x1.a4faf8p-3 +0x1.f8cf14p-5 +0x1.232c22p-4 +0x1.8e29c8p-6 +0x1.8bfd1cp-6 +-0x1.c7c2dap-6 +-0x1.8749dp-6 +0x1.a1734cp-8 +0x1.3a385ap-10 +0x1.844bdp-3 +0x1.759f7cp-3 +-0x1.2a6ff8p-2 +-0x1.0e6968p-2 +-0x1.cbf7a2p-2 +-0x1.d3b06ep-2 +0x0p+0 +-0x1.af4558p+1 +-0x1.ba594ap+2 +-0x1.afcff4p+1 +-0x1.048734p+3 +-0x1.ae764cp+1 +0x1.82f1eap-4 +-0x1.adde1p+1 +-0x1.863ab8p+1 +0x1.a29c34p-3 +0x1.996aacp-3 +0x1.9d5068p-4 +0x1.a75da6p-3 +0x0p+0 +0x1.b34fe2p-4 +0x1.9e07cep+1 +0x1.9f1b08p-3 +0x1.9e07cep+1 +0x1.0dca2ep-4 +-0x1.048734p+3 +-0x1.4a0db6p-2 +-0x1.04935ep+3 +-0x1.354ff4p-2 +-0x1.ba594ap+2 +-0x1.30d63cp-2 +-0x1.ba594ap+2 +-0x1.30d63cp-2 +-0x1.ba4d44p+2 +0x1.82f1eap-4 +-0x1.047ad6p+3 +-0x1.863ab8p+1 +0x1.9f1b08p-3 +0x1.0dca2ep-4 +0x1.2d4be6p-4 +0x1.713fb2p-6 +0x1.832ef8p-6 +-0x1.abe8a4p-6 +-0x1.7d688ap-6 +0x1.18b54ep-7 +0x1.24191ep-8 +0x1.6fce3cp-3 +0x1.65715ep-3 +-0x1.41a6c2p-2 +-0x1.054b36p-2 +-0x1.cf506p-2 +-0x1.db9e68p-2 +0x0p+0 +-0x1.afa654p+1 +-0x1.ba3edap+2 +-0x1.b000d2p+1 +-0x1.047832p+3 +-0x1.ae4398p+1 +0x1.72067ep-4 +-0x1.adc91ep+1 +-0x1.864bb4p+1 +0x1.9ce68ap-3 +0x1.91ba36p-3 +0x1.a7d522p-4 +0x1.a28fcp-3 +0x0p+0 +0x1.bc8b6ep-4 +0x1.9e07cep+1 +0x1.98857p-3 +0x1.9e07cep+1 +0x1.1bbf44p-4 +-0x1.047832p+3 +-0x1.3d5054p-2 +-0x1.04842cp+3 +-0x1.29b5c2p-2 +-0x1.ba3edap+2 +-0x1.2659dep-2 +-0x1.ba3edap+2 +-0x1.2659dep-2 +-0x1.ba31f8p+2 +0x1.72067ep-4 +-0x1.046b7ep+3 +-0x1.864bb4p+1 +0x1.98857p-3 +0x1.1bbf44p-4 +0x1.37f434p-4 +0x1.5f3e32p-6 +0x1.78c684p-6 +-0x1.924c58p-6 +-0x1.6dd47ap-6 +0x1.9c7564p-7 +0x1.12994ep-7 +0x1.3ded68p-3 +0x1.3a315cp-3 +-0x1.391f26p-2 +-0x1.f845bcp-3 +-0x1.d4d322p-2 +-0x1.e16b94p-2 +0x0p+0 +-0x1.b003fp+1 +-0x1.ba2474p+2 +-0x1.b040d8p+1 +-0x1.04693ep+3 +-0x1.adf9cp+1 +0x1.6350a4p-4 +-0x1.ad9e1ep+1 +-0x1.865ap+1 +0x1.984b9ap-3 +0x1.8b539cp-3 +0x1.b1bacap-4 +0x1.9dc49p-3 +0x0p+0 +0x1.c560b8p-4 +0x1.9e07cep+1 +0x1.278d56p-4 +0x1.530cb6p-6 +-0x1.8212ccp-6 +0x1.8bcdbep-6 +0x1.1dd0acp-3 +-0x1.3173f4p-2 +-0x1.da8e2ap-2 +0x0p+0 +-0x1.ba2474p+2 +-0x1.b04fdep+1 +0x1.6350a4p-4 +-0x1.adc30cp+1 +-0x1.865ap+1 +-0x1.04693ep+3 +0x1.921bcep-3 +0x1.93f0aap-3 +0x1.bb1e4ap-4 +-0x1.e799bap+1 +-0x1.e18aeap+1 +0x1.a1b6b4p+3 +-0x1.de85ap+2 +-0x1.e1891ep-2 +-0x1.c856aap+3 +-0x1.bb29p+3 +-0x1.bb29p+3 +-0x1.8b8a34p+0 +-0x1.bb29p+3 +0x0p+0 +-0x1.8d970ap+1 +0x0p+0 +-0x1.15363ap+3 +0x0p+0 +-0x1.15363ap+3 +-0x1.d51a34p-1 +-0x1.c856aap+3 +-0x1.d51a34p-1 +-0x1.bb29p+3 +-0x1.59e5fap-1 +-0x1.8d970ap+1 +-0x1.59e5fap-1 +-0x1.8b8a34p+0 +-0x1.5ba9b6p+3 +-0x1.c0825p+2 +-0x1.5ba9b6p+3 +-0x1.cd531p+3 +-0x1.c13e9cp+3 +-0x1.c13e9cp+3 +-0x1.6437c2p+0 +-0x1.c13e9cp+3 +0x0p+0 +-0x1.a83368p+1 +0x0p+0 +-0x1.188ecp+3 +0x0p+0 +-0x1.d9c8e6p-1 +-0x1.187e7ap+3 +-0x1.d836d8p-1 +-0x1.cd531p+3 +-0x1.4ef09ep-1 +-0x1.c13e9cp+3 +-0x1.4ed236p-1 +-0x1.a83368p+1 +-0x1.5cdffep+3 +-0x1.6437c2p+0 +-0x1.5cd6bap+3 +-0x1.c31a82p+2 +-0x1.cd531p+3 +-0x1.c13e9cp+3 +-0x1.c13e9cp+3 +-0x1.6437c2p+0 +-0x1.c13e9cp+3 +0x0p+0 +-0x1.a83368p+1 +0x0p+0 +-0x1.187e7ap+3 +0x0p+0 +-0x1.d8c36ep-1 +-0x1.186f5ap+3 +-0x1.d83b92p-1 +-0x1.cd531p+3 +-0x1.655b66p-1 +-0x1.c13e9cp+3 +-0x1.5d27fep-1 +-0x1.a83368p+1 +-0x1.5cd9f4p+3 +-0x1.6437c2p+0 +-0x1.5cd8cep+3 +-0x1.c31a82p+2 +-0x1.cd531p+3 +-0x1.c13e9cp+3 +-0x1.c13e9cp+3 +-0x1.6437c2p+0 +-0x1.c13e9cp+3 +0x0p+0 +-0x1.a83368p+1 +0x0p+0 +-0x1.186f5ap+3 +0x0p+0 +-0x1.d86b86p-1 +-0x1.186238p+3 +-0x1.d80fc4p-1 +-0x1.cd531p+3 +-0x1.601f64p-1 +-0x1.c13e9cp+3 +-0x1.5f0cep-1 +-0x1.a83368p+1 +-0x1.5cd938p+3 +-0x1.6437c2p+0 +-0x1.5cd914p+3 +-0x1.c31a82p+2 +-0x1.d8305p-1 +-0x1.cd531p+3 +-0x1.c13e9cp+3 +-0x1.5f6fcp-1 +-0x1.a83368p+1 +0x0p+0 +-0x1.6437c2p+0 +-0x1.5cd91ep+3 +-0x1.c31a82p+2 +-0x1.186238p+3 +-0x1.8f2a78p+2 +-0x1.eabb9ep+1 +-0x1.18cd0ap+1 +-0x1.eabb9ep+1 +-0x1.eef51ep+1 +-0x1.979038p+2 +-0x1.eef39cp+1 +-0x1.12b4acp+1 +-0x1.eef3d6p+1 +-0x1.12b4acp+1 +-0x1.979038p+2 +-0x1.c9c846p+3 +-0x1.a5126ap-1 +-0x1.7a5838p+2 +-0x1.a5126ap-1 +-0x1.a360b6p-1 +-0x1.ce436ap+3 +-0x1.a36112p-1 +-0x1.7a7436p+2 +-0x1.a360dcp-1 +-0x1.7a7436p+2 +-0x1.ce436ap+3 +-0x1.ded6b6p+2 +-0x1.c115p-1 +-0x1.0324eap+4 +-0x1.c115p-1 +-0x1.c3ea48p-1 +-0x1.def2b4p+2 +-0x1.c3ea48p-1 +-0x1.05cf2ep+4 +-0x1.c3ea54p-1 +-0x1.05cf2ep+4 +-0x1.def2b4p+2 +-0x1.6bea3cp+3 +-0x1.1ac3c6p+3 +-0x1.047656p+3 +-0x1.cc65dep-2 +-0x1.6bea3cp+3 +-0x1.cc65dep-2 +-0x1.1ac3c6p+3 +-0x1.5964d8p+2 +0x1.15e536p+1 +-0x1.5964d8p+2 +-0x1.6e7f9cp+3 +-0x1.1a975cp+3 +-0x1.7ab5a4p-2 +-0x1.0b4f94p+3 +-0x1.7b9376p-2 +-0x1.6e7984p+3 +-0x1.5d7c5p+2 +-0x1.1a8e74p+3 +-0x1.5d8074p+2 +0x1.150882p+1 +-0x1.6e7984p+3 +-0x1.1a8e74p+3 +-0x1.7a8882p-2 +-0x1.0b4f94p+3 +-0x1.7ae8bep-2 +-0x1.6e749ep+3 +-0x1.5d7e14p+2 +-0x1.1a8748p+3 +-0x1.5d820ap+2 +0x1.150882p+1 +-0x1.7a197cp-2 +-0x1.6e749ep+3 +-0x1.1a8748p+3 +-0x1.5d809cp+2 +0x1.150882p+1 +-0x1.0b4f94p+3 +-0x1.1340aep-4 +-0x1.8fabep-5 +-0x1.c2a3a2p-6 +-0x1.4d476p-6 +0x1.1db514p-8 +0x1.6b262ep-6 +0x1.5392dep-6 +0x1.cf4f2p-3 +0x1.408f4ep-1 +0x1.c26d2ep+1 +-0x1.b96d6cp+1 +-0x1.c93deap+1 +0x1.ad447ap+3 +-0x1.cfc9e2p+2 +-0x1.124da4p-1 +-0x1.d51a34p-1 +-0x1.15363ap+3 +-0x1.c856aap+3 +-0x1.59e5fap-1 +-0x1.bb29p+3 +-0x1.8d970ap+1 +-0x1.eabb9ep+1 +-0x1.8f2a78p+2 +-0x1.18cd0ap+1 +-0x1.a5126ap-1 +-0x1.c9c846p+3 +-0x1.7a5838p+2 +-0x1.c115p-1 +-0x1.ded6b6p+2 +-0x1.0324eap+4 +-0x1.b11b52p+1 +-0x1.035bdcp+3 +-0x1.ae7b14p+2 +-0x1.b6618p+1 +-0x1.7a319p+1 +0x1.07e3e2p-3 +-0x1.cc65dep-2 +-0x1.047656p+3 +-0x1.6bea3cp+3 +-0x1.5ba9b6p+3 +-0x1.c0825p+2 +-0x1.8b8a34p+0 +-0x1.5964d8p+2 +0x1.15e536p+1 +-0x1.1ac3c6p+3 +0x1.e43ccap-4 +0x1.9522e4p-3 +0x1.cc8e9p-3 +0x1.50a70cp-4 +-0x1.481f5p-9 +-0x1.6a56c6p-6 +-0x1.e5f966p-7 +0x1.a22fc6p-4 +-0x1.12d5eep-2 +-0x1.c361bap-2 +0x0p+0 +0x1.dd6fcp+1 +0x0p+0 +0x1.de61b8p+1 +0x0p+0 +0x1.80f258p+2 +0x0p+0 +0x1.7f0876p+2 +0x0p+0 +0x1.75c458p+2 +0x0p+0 +0x1.6a1af8p+2 +0x0p+0 +0x1.2f3d28p+2 +0x0p+0 +0x1.3911c6p+2 +0x0p+0 +0x1.96a862p+1 +0x0p+0 +0x1.7c0c04p+1 +0x0p+0 +0x1.59fd16p+2 +0x0p+0 +0x1.59a26cp+2 +0x0p+0 +0x1.aa0ddcp+1 +0x0p+0 +0x1.9de56cp+1 +0x0p+0 +0x1.66e2f6p+2 +0x0p+0 +0x1.6631bep+2 +0x0p+0 +0x1.31abdp+0 +0x0p+0 +0x1.1d58cp+0 +0x0p+0 +0x1.4568b6p+2 +0x0p+0 +0x1.454cb8p+2 +0x0p+0 +0x1.400d22p+2 +0x0p+0 +0x1.33e1eap+2 +0x0p+0 +0x1.6dddecp+1 +0x0p+0 +0x1.767c6p+1 +0x0p+0 +0x1.6fd602p+2 +0x0p+0 +0x1.740724p+2 +0x0p+0 +0x1.07e3e2p-3 +0x0p+0 +0x1.6350a4p-4 +0x0p+0 +0x1.a22fc6p-4 +0x0p+0 +0x1.1dd0acp-3 +0x0p+0 +0x1.755958p+2 +0x0p+0 +0x1.7a7e1ep+2 +0x0p+0 +0x1.1b52cp+2 +0x0p+0 +0x1.0da044p+2 +0x0p+0 +0x1.63bd1cp+2 +0x0p+0 +0x1.6124eap+2 +0x0p+0 +0x1.7c77ep-2 +0x0p+0 +0x1.7ab8p-2 +0x0p+0 +0x1.73241ap+1 +0x0p+0 +0x1.73ef8ep+1 +0x0p+0 +0x1.5d7d68p+2 +0x0p+0 +0x1.5db39ap+2 +0x0p+0 +0x1.1d87b4p+2 +0x0p+0 +0x1.1b6cfp+2 +0x0p+0 +0x1.25b1cep+2 +0x0p+0 +0x1.1bb902p+2 +0x0p+0 +0x1.dd6fcp+1 +0x0p+0 +0x1.de61b8p+1 +0x0p+0 +0x1.3983cep+1 +0x0p+0 +0x1.354b96p+1 +0x0p+0 +0x1.22ce96p+2 +0x0p+0 +0x1.19d84ep+2 +0x0p+0 +0x1.54758ap+2 +0x0p+0 +0x1.45b9ccp+2 +0x0p+0 +0x1.7a9fp-5 +0x0p+0 +-0x1.5c208p-4 +0x0p+0 +0x1.05b93p+2 +0x0p+0 +0x1.08c56p+2 +0x0p+0 +0x1.96a862p+1 +0x0p+0 +0x1.7c0c04p+1 +0x0p+0 +0x1.577c7p+2 +0x0p+0 +0x1.5719acp+2 +0x0p+0 +0x1.f3a5fp+1 +0x0p+0 +0x1.5396f4p+1 +0x0p+0 +0x1.3e44d4p+1 +0x0p+0 +0x1.59fd16p+2 +0x0p+0 +0x1.59a26cp+2 +0x0p+0 +0x1.9522e4p-3 +0x0p+0 +0x1.93f0aap-3 +0x0p+0 +0x1.80f258p+2 +0x0p+0 +0x1.7f0876p+2 +0x0p+0 +-0x1.15363ap+3 +-0x1.15363ap+3 +0x0p+0 +-0x1.14e20ep+3 +0x0p+0 +-0x1.14cd4p+3 +0x0p+0 +-0x1.14c81p+3 +0x0p+0 +0x0p+0 +-0x1.183c36p+3 +-0x1.14c81p+3 +0x0p+0 +0x1.f55e98p+1 +0x0p+0 +0x1.e78ep+1 +-0x1.3d3026p-4 +-0x1.d058e8p-5 +-0x1.edd78cp-6 +-0x1.6e01fcp-6 +-0x1.0cba3ep-5 +-0x1.8e54bp-6 +-0x1.0c9d4ap-5 +-0x1.8e8df2p-6 +0x1.5c07d8p-9 +0x1.61c06ap-6 +0x1.2e242ep-6 +0x1.faa53cp-3 +0x1.603d72p-1 +0x1.9e07cep+1 +0x1.921bcep-3 +-0x1.04693ep+3 +-0x1.3173f4p-2 +-0x1.ba2474p+2 +-0x1.3173f4p-2 +-0x1.ba2474p+2 +0x1.6350a4p-4 +-0x1.04693ep+3 +-0x1.865ap+1 +0x1.921bcep-3 +0x1.93f0aap-3 +0x1.278d56p-4 +0x1.921bcep-3 +0x1.530cb6p-6 +0x1.278d56p-4 +-0x1.8212ccp-6 +0x1.530cb6p-6 +0x1.8bcdbep-6 +-0x1.8212ccp-6 +0x1.1dd0acp-3 +0x1.8bcdbep-6 +-0x1.3173f4p-2 +0x1.1dd0acp-3 +-0x1.da8e2ap-2 +-0x1.3173f4p-2 +0x0p+0 +-0x1.da8e2ap-2 +-0x1.ba2474p+2 +-0x1.b04fdep+1 +-0x1.04693ep+3 +-0x1.b04fdep+1 +0x1.6350a4p-4 +-0x1.adc30cp+1 +-0x1.865ap+1 +-0x1.adc30cp+1 +0x1.93f0aap-3 +0x1.bb1e4ap-4 +0x1.bb1e4ap-4 +0x0p+0 +0x1.909b2ep+1 +0x1.4096ccp-3 +0x1.909b2ep+1 +0x1.4096ccp-3 +-0x1.0626e2p+3 +-0x1.5f0f8ap-2 +-0x1.0632d2p+3 +-0x1.4d817cp-2 +-0x1.c6223p+2 +-0x1.4d6ee6p-2 +-0x1.c61b2cp+2 +0x1.d3925p-5 +-0x1.0619f4p+3 +-0x1.93681ep+1 +0x1.8ec774p-3 +0x1.438108p-3 +0x1.4817c6p-3 +0x1.c7d706p-5 +0x1.f52ec8p-5 +0x1.70bdfcp-5 +0x1.6f09d6p-5 +-0x1.adb408p-7 +-0x1.4c9cbp-7 +0x1.27cd7ap-4 +0x1.00a81p-4 +0x1.510a2ep-3 +0x1.4eb0acp-3 +-0x1.5c6908p-2 +-0x1.10caap-2 +-0x1.edb1cep-2 +-0x1.f493e6p-2 +0x0p+0 +-0x1.af3b2ep+1 +-0x1.c61b2cp+2 +-0x1.af2c18p+1 +-0x1.0619f4p+3 +-0x1.a6ba44p+1 +0x1.d3925p-5 +-0x1.a6adf6p+1 +-0x1.93681ep+1 +0x1.c7a304p-4 +0x1.903c16p-3 +0x0p+0 +0x1.d38d02p-4 +0x1.92bad8p+1 +0x1.399f6p-3 +0x1.92bad8p+1 +0x1.399f6p-3 +-0x1.0619f4p+3 +-0x1.4b564ep-2 +-0x1.0625f6p+3 +-0x1.3abf5ap-2 +-0x1.c61b2cp+2 +-0x1.3c642p-2 +-0x1.c6135ap+2 +0x1.d3925p-5 +-0x1.060bc6p+3 +-0x1.93681ep+1 +0x1.8ad064p-3 +0x1.3bb74p-3 +0x1.44fd6cp-3 +0x1.e545fp-5 +0x1.febbdcp-5 +0x1.5a678ap-5 +0x1.612d32p-5 +-0x1.687bc2p-7 +-0x1.0f59d6p-7 +0x1.33cc4cp-4 +0x1.1003c8p-4 +0x1.43fee6p-3 +0x1.3f1088p-3 +-0x1.4e95d2p-2 +-0x1.078558p-2 +-0x1.f0be6ep-2 +-0x1.f9a16ep-2 +0x0p+0 +-0x1.af733ap+1 +-0x1.c6135ap+2 +-0x1.af4e58p+1 +-0x1.060bc6p+3 +-0x1.a6b3ep+1 +0x1.d3925p-5 +-0x1.a6b1c2p+1 +-0x1.93681ep+1 +0x1.cd6e5p-4 +0x1.8cb866p-3 +0x0p+0 +0x1.dbba7ep-4 +0x1.94962cp+1 +0x1.3704cap-3 +0x1.94962cp+1 +0x1.3704cap-3 +-0x1.060bc6p+3 +-0x1.3ff3b2p-2 +-0x1.0617aep+3 +-0x1.2ff6ep-2 +-0x1.c6135ap+2 +-0x1.326476p-2 +-0x1.c60b18p+2 +0x1.d3925p-5 +-0x1.05fcf4p+3 +-0x1.93681ep+1 +0x1.86b81ep-3 +0x1.38be98p-3 +0x1.41ed8cp-3 +0x1.f585cp-5 +0x1.0573fp-4 +0x1.4a884p-5 +0x1.5421a2p-5 +-0x1.db36cp-8 +-0x1.5a192ap-8 +0x1.3a5a86p-4 +0x1.1917b6p-4 +0x1.1edaccp-3 +0x1.218866p-3 +-0x1.46799ep-2 +-0x1.014f1ep-2 +-0x1.f4c06ep-2 +-0x1.fd3d56p-2 +0x0p+0 +-0x1.af8736p+1 +-0x1.c60b18p+2 +-0x1.af6696p+1 +-0x1.05fcd2p+3 +-0x1.a6b282p+1 +0x1.d3925p-5 +0x1.20ec56p-5 +0x0p+0 +0x1.abce8ap-9 +0x1.274f7cp-5 +0x1.abce8ap-9 +0x1.20ec56p-5 +-0x1.1016ap-2 +-0x1.5dbafap-2 +-0x1.1016ap-2 +0x1.903c7p-5 +0x1.89d94cp-5 +0x1.903c7p-5 +0x1.89d94cp-5 +0x1.25fd94p-8 +0x0p+0 +0x1.25e676p-8 +0x1.903c7p-5 +-0x1.40f45ap-2 +0x1.89d94cp-5 +-0x1.40e7d2p-2 +-0x1.92720cp-2 +0x1.25ff3ep-8 +0x1.903c7p-5 +0x1.89d94cp-5 +-0x1.40e68ap-2 +-0x1.92720cp-2 +0x0p+0 +0x1.1cdabep-1 +-0x1.59b51cp+1 +0x1.18ad8cp+2 +-0x1.59b51cp+1 +-0x1.628592p+1 +0x1.44ecbep-1 +-0x1.627e9cp+1 +0x1.2124a4p+2 +-0x1.627edp+1 +0x1.2124a4p+2 +0x1.44ecbep-1 +0x1.0d78c2p+0 +-0x1.f03baap-2 +-0x1.df5cfcp+1 +-0x1.f03baap-2 +-0x1.0eccacp-1 +0x1.1916a6p+0 +-0x1.0ebf6p-1 +-0x1.e7183ep+1 +-0x1.0ec1dp-1 +-0x1.e7183ep+1 +0x1.1916a6p+0 +0x1.e5ea78p-4 +0x0p+0 +0x1.067104p-4 +0x1.e5ea78p-4 +0x1.99f9c6p-7 +0x1.067104p-4 +-0x1.75697cp-6 +0x1.99f9c6p-7 +-0x1.25e4c6p-7 +-0x1.75697cp-6 +0x1.b87eap-7 +-0x1.25e4c6p-7 +0x1.772dfp-6 +0x1.b87eap-7 +-0x1.fdccd6p-7 +0x1.772dfp-6 +-0x1.13746p-4 +-0x1.fdccd6p-7 +-0x1.e11fap-4 +-0x1.13746p-4 +0x0p+0 +-0x1.e11fap-4 +0x0p+0 +0x1.f0b23ep-4 +0x1.f1375ep-4 +0x1.109c64p-4 +0x1.1216a8p-4 +0x1.fb2288p-7 +0x1.020d08p-6 +-0x1.290812p-6 +-0x1.271418p-6 +-0x1.b9131cp-8 +-0x1.c1e4fcp-8 +0x1.675572p-7 +0x1.64049cp-7 +0x1.3003fap-6 +0x1.3070ep-6 +-0x1.2c7384p-6 +-0x1.27a0c2p-6 +-0x1.1e2aeep-4 +-0x1.1cd006p-4 +-0x1.ec88cp-4 +-0x1.eb799p-4 +0x0p+0 +0x0p+0 +0x1.f01ac8p-4 +0x1.f0a912p-4 +0x1.10c3c4p-4 +0x1.123f82p-4 +0x1.fb00a2p-7 +0x1.020bd4p-6 +-0x1.271908p-6 +-0x1.24ff22p-6 +-0x1.ba9bf8p-8 +-0x1.c2d5cap-8 +0x1.67e36ep-7 +0x1.647934p-7 +0x1.2dfddp-6 +0x1.2e4b28p-6 +-0x1.2c6ceap-6 +-0x1.27b19ap-6 +-0x1.1e40eep-4 +-0x1.1cea98p-4 +-0x1.ec0148p-4 +-0x1.eaf6ep-4 +0x0p+0 +0x0p+0 +0x1.ef8f2cp-4 +0x1.f01bfap-4 +0x1.10ef64p-4 +0x1.126a22p-4 +0x1.fb567p-7 +0x1.022ebap-6 +-0x1.24e652p-6 +-0x1.22d5d6p-6 +-0x1.bbbdeep-8 +-0x1.c3cfbp-8 +0x1.68098cp-7 +0x1.64af6ep-7 +0x1.2bcd2ap-6 +0x1.2c1eb6p-6 +-0x1.2c884ap-6 +-0x1.27d0dep-6 +-0x1.1e5c9p-4 +-0x1.1d068ap-4 +-0x1.eb7c2ep-4 +-0x1.ea743ap-4 +0x0p+0 +0x1.ef0268p-4 +0x1.111754p-4 +0x1.fb9762p-7 +-0x1.22bae6p-6 +-0x1.bc98f8p-8 +0x1.68387p-7 +0x1.29a83ap-6 +-0x1.2ca286p-6 +-0x1.1e76fap-4 +-0x1.eaf7fap-4 +0x0p+0 +-0x1.61d84ep-10 +-0x1.9b131cp-10 +-0x1.0d66acp-9 +-0x1.7a913ep-9 +-0x1.03ac96p-8 +-0x1.40067p-8 +-0x1.6df1c8p-8 +-0x1.8b4aa6p-8 +-0x1.9900bcp-8 +-0x1.9d09cap-8 +0x0p+0 +0x0p+0 +0x1.12f21ep+0 +0x1.89cc08p-2 +-0x1.109facp+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.f46d46p-7 +0x0p+0 +-0x1.42bd3p-4 +-0x1.6e49bcp+0 +-0x1.39c29ap-3 +-0x1.5052cp+1 +-0x1.bb2892p-1 +-0x1.02724ap+2 +-0x1.48cbe2p+1 +-0x1.ee3962p-1 +-0x1.b457dep+1 +-0x1.58638p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.abce8ap-9 +0x0p+0 +0x1.274f7cp-5 +-0x1.1016ap-2 +0x1.20ec56p-5 +-0x1.5dbafap-2 +-0x1.59b51cp+1 +0x1.1cdabep-1 +0x1.18ad8cp+2 +-0x1.f03baap-2 +0x1.0d78c2p+0 +-0x1.df5cfcp+1 +0x1.e5ea78p-4 +0x1.067104p-4 +0x1.99f9c6p-7 +-0x1.75697cp-6 +-0x1.25e4c6p-7 +0x1.b87eap-7 +0x1.772dfp-6 +-0x1.fdccd6p-7 +-0x1.13746p-4 +-0x1.e11fap-4 +0x0p+0 +0x1.811e4cp+2 +0x0p+0 +0x1.7e114ep+2 +0x0p+0 +0x1.89cc08p-2 +0x0p+0 +0x1.5249c8p-3 +0x0p+0 +0x1.274f7cp-5 +0x0p+0 +0x1.903c7p-5 +0x0p+0 +0x1.20ec56p-5 +0x0p+0 +0x1.89d94cp-5 +0x0p+0 +0x1.7c4406p+2 +0x0p+0 +0x1.78f896p+2 +0x0p+0 +0x1.db738ap+1 +0x0p+0 +0x1.d93a52p+1 +0x0p+0 +0x1.12f21ep+0 +0x0p+0 +0x1.317eccp+0 +0x0p+0 +0x1.5abaa4p+2 +0x0p+0 +0x1.5901aap+2 +0x0p+0 +0x1.8d14c2p+2 +0x0p+0 +0x1.82650ap+2 +0x0p+0 +0x1.368d48p+2 +0x0p+0 +0x1.34d214p+2 +0x0p+0 +0x1.8851a2p+2 +0x0p+0 +0x1.7cfc96p+2 +0x0p+0 +0x1.d3ecacp+1 +0x0p+0 +0x1.bf915cp+1 +0x0p+0 +0x1.1f5ad8p+1 +0x0p+0 +0x1.024c54p+1 +0x0p+0 +0x1.731bfcp+2 +0x0p+0 +0x1.70477cp+2 +0x0p+0 +0x1.44e27p+1 +0x0p+0 +0x1.3d272ep+1 +0x0p+0 +0x1.0d78c2p+0 +0x0p+0 +0x1.1916a6p+0 +0x0p+0 +0x1.030014p+1 +0x0p+0 +0x1.ed6p+0 +0x0p+0 +0x1.cde1bp-1 +0x0p+0 +0x1.aa333p-1 +0x0p+0 +0x1.54588ap+2 +0x0p+0 +0x1.55f7e4p+2 +0x0p+0 +0x1.db738ap+1 +0x0p+0 +0x1.d93a52p+1 +0x0p+0 +0x1.6fe78ep+1 +0x0p+0 +0x1.64c8fcp+1 +0x0p+0 +0x1.067104p-4 +0x0p+0 +0x1.111754p-4 +0x0p+0 +0x1.8dd1e4p+2 +0x0p+0 +0x1.8da5dap+2 +-0x1.bba1e4p-10 +-0x1.f16e6p-10 +-0x1.f16e6p-10 +-0x1.35a5f4p-9 +-0x1.35a5f4p-9 +-0x1.9f30a6p-9 +-0x1.9f30a6p-9 +-0x1.13fff4p-8 +-0x1.13fff4p-8 +-0x1.4e69cep-8 +-0x1.4e69cep-8 +-0x1.7ae462p-8 +-0x1.7ae462p-8 +-0x1.97a1c6p-8 +-0x1.97a1c6p-8 +-0x1.a56682p-8 +-0x1.a56682p-8 +-0x1.a99988p-8 +-0x1.0980c6p-9 +-0x1.208e86p-9 +-0x1.49f656p-9 +-0x1.c00f16p-10 +-0x1.2058fcp-9 +-0x1.56842cp-9 +-0x1.9eee7p-9 +-0x1.af1ebp-10 +-0x1.54e58p-9 +-0x1.b6af08p-9 +-0x1.061a7ep-8 +-0x1.fd5b92p-10 +-0x1.b1fa4ep-9 +-0x1.29b8d6p-8 +-0x1.4c4bcep-8 +-0x1.6cd4ccp-9 +-0x1.24cceap-8 +-0x1.5d8c0ap-8 +-0x1.a8d242p-8 +-0x1.b4149ap-9 +-0x1.5cac3p-8 +-0x1.85764p-8 +-0x1.e52af4p-8 +-0x1.fb9cp-9 +-0x1.86fc38p-8 +-0x1.a031bcp-8 +-0x1.0206f4p-7 +-0x1.24198p-8 +-0x1.a3363p-8 +-0x1.ac7106p-8 +-0x1.01abp-7 +-0x1.4d0608p-8 +-0x1.afe7dep-8 +-0x1.ae2b3ep-8 +-0x1.e45334p-8 +-0x1.7a192p-8 +-0x1.09a3ecp-9 +-0x1.217874p-9 +-0x1.49ea08p-9 +-0x1.c2417cp-10 +-0x1.212b7p-9 +-0x1.58bc1p-9 +-0x1.9f50d8p-9 +-0x1.b46cf6p-10 +-0x1.56ec66p-9 +-0x1.bc9a0cp-9 +-0x1.06c08ap-8 +-0x1.054ffcp-9 +-0x1.b761b2p-9 +-0x1.273772p-8 +-0x1.4e557p-8 +-0x1.692aa4p-9 +-0x1.22eab8p-8 +-0x1.5d6314p-8 +-0x1.a5fb2ep-8 +-0x1.b5aadcp-9 +-0x1.5c435cp-8 +-0x1.8666ecp-8 +-0x1.e37532p-8 +-0x1.000892p-8 +-0x1.87b1ccp-8 +-0x1.a17634p-8 +-0x1.01a216p-7 +-0x1.26d914p-8 +-0x1.a4543cp-8 +-0x1.ae0ef6p-8 +-0x1.01907p-7 +-0x1.4ff376p-8 +-0x1.b165bap-8 +-0x1.b0d032p-8 +-0x1.e4ffc4p-8 +-0x1.7d8cecp-8 +-0x1.09de14p-9 +-0x1.2279ecp-9 +-0x1.49f9fcp-9 +-0x1.c49868p-10 +-0x1.2212e6p-9 +-0x1.5b3e8cp-9 +-0x1.9fc502p-9 +-0x1.ba56acp-10 +-0x1.593c52p-9 +-0x1.c0ca9cp-9 +-0x1.0783d6p-8 +-0x1.0a4798p-9 +-0x1.bb4fa6p-9 +-0x1.25911ap-8 +-0x1.4fad3ep-8 +-0x1.671f32p-9 +-0x1.21ac38p-8 +-0x1.5d2c08p-8 +-0x1.a3c31ep-8 +-0x1.b72e5ep-9 +-0x1.5be33p-8 +-0x1.873748p-8 +-0x1.e1c826p-8 +-0x1.0222eap-8 +-0x1.884934p-8 +-0x1.a2aab8p-8 +-0x1.013206p-7 +-0x1.298114p-8 +-0x1.a562fp-8 +-0x1.afb64cp-8 +-0x1.0171dcp-7 +-0x1.52e306p-8 +-0x1.b2e788p-8 +-0x1.b345b2p-8 +-0x1.e5b90ap-8 +-0x1.80c8aap-8 +-0x1.0a31bep-9 +-0x1.2391b8p-9 +-0x1.5dcb8cp-9 +-0x1.c3ed2p-9 +-0x1.2477f2p-8 +-0x1.5cfbd4p-8 +-0x1.87e946p-8 +-0x1.a3d576p-8 +-0x1.b15aa4p-8 +-0x1.b5932p-8 +0x0p+0 +0x0p+0 +0x1.500b7ap+0 +0x1.5249c8p-3 +-0x1.4b051ap+1 +-0x1.4b051ap+1 +0x0p+0 +-0x1.10f98cp+2 +-0x1.92720cp-2 +-0x1.4b051ap+1 +-0x1.c8f064p-1 +-0x1.10f98cp+2 +-0x1.c8f064p-1 +-0x1.92720cp-2 +-0x1.40e68ap-2 +0x1.89d94cp-5 +-0x1.40e68ap-2 +-0x1.bc12p-5 +-0x1.4d5404p+1 +-0x1.4d5404p+1 +0x0p+0 +-0x1.1bc0f2p+2 +-0x1.126622p-1 +-0x1.e650cap-1 +-0x1.4d5404p+1 +-0x1.e62e62p-1 +-0x1.1ad1fap+2 +-0x1.8eeb38p-2 +-0x1.12c2ecp-1 +-0x1.91ef4p-2 +0x1.f2c642p-5 +-0x1.bc12p-5 +-0x1.4d5404p+1 +-0x1.4d5404p+1 +0x0p+0 +-0x1.1ad1fap+2 +-0x1.12c2ecp-1 +-0x1.e88b5ap-1 +-0x1.4d5404p+1 +-0x1.e7b2fp-1 +-0x1.1a106ep+2 +-0x1.909ea8p-2 +-0x1.1336ecp-1 +-0x1.93a61p-2 +0x1.f2c642p-5 +-0x1.bc12p-5 +-0x1.4d5404p+1 +-0x1.4d5404p+1 +0x0p+0 +-0x1.1a106ep+2 +-0x1.1336ecp-1 +-0x1.e9eabep-1 +-0x1.4d5404p+1 +-0x1.e9201ap-1 +-0x1.19731cp+2 +-0x1.92918ap-2 +-0x1.13b158p-1 +-0x1.951646p-2 +0x1.f2c642p-5 +-0x1.bc12p-5 +-0x1.4d5404p+1 +-0x1.eafd06p-1 +-0x1.19731cp+2 +-0x1.13b158p-1 +-0x1.94311ep-2 +0x1.f2c642p-5 +0x0p+0 +-0x1.1cefcp+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.f75594p-3 +-0x1.523206p-2 +-0x1.523206p-2 +0x0p+0 +0x0p+0 +-0x1.2bdb26p-6 +-0x1.f75594p-3 +-0x1.2bdb26p-6 +-0x1.523206p-2 +-0x1.753684p+0 +-0x1.64ae1p+1 +-0x1.753684p+0 +-0x1.a5560cp-2 +-0x1.03d96p-1 +-0x1.03d96p-1 +0x0p+0 +-0x1.611ae4p-6 +0x0p+0 +-0x1.5f6a98p-6 +-0x1.a5560cp-2 +-0x1.8690ap+0 +-0x1.03d96p-1 +-0x1.86a184p+0 +-0x1.79096p+1 +-0x1.a5560cp-2 +-0x1.03d96p-1 +-0x1.03d96p-1 +0x0p+0 +-0x1.60072cp-6 +0x0p+0 +-0x1.5fcd22p-6 +-0x1.a5560cp-2 +-0x1.869732p+0 +-0x1.03d96p-1 +-0x1.869ae6p+0 +-0x1.79096p+1 +-0x1.5fdf5ep-6 +-0x1.a5560cp-2 +-0x1.03d96p-1 +-0x1.8699ap+0 +-0x1.79096p+1 +0x0p+0 +0x0p+0 +-0x1.bf767p+1 +-0x1.e13e88p-1 +-0x1.5cd95p+2 +-0x1.e13e88p-1 +-0x1.d4422ap-1 +-0x1.ca9502p+1 +-0x1.d444a2p-1 +-0x1.614f2p+2 +-0x1.d443dep-1 +-0x1.614f2p+2 +-0x1.ca9502p+1 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.25ff3ep-8 +0x1.903c7p-5 +0x1.25ff3ep-8 +0x1.7615d2p-8 +0x0p+0 +0x1.76142cp-8 +0x1.f92964p-5 +0x1.761796p-8 +0x1.f92964p-5 +0x0p+0 +0x1.44ecbep-1 +-0x1.627edp+1 +0x1.2124a4p+2 +-0x1.627edp+1 +-0x1.6b4a52p+1 +0x1.6cfebep-1 +-0x1.6b4112p+1 +0x1.299bbcp+2 +-0x1.6b4236p+1 +0x1.6cfebep-1 +-0x1.6b41c4p+1 +0x1.299bbcp+2 +-0x1.6b41e8p+1 +0x1.299bbcp+2 +0x1.6cfebep-1 +0x1.1916a6p+0 +-0x1.0ec1dp-1 +-0x1.e7183ep+1 +-0x1.0ec1dp-1 +-0x1.256b5ep-1 +0x1.24b48ap+0 +-0x1.255ddp-1 +-0x1.eed38p+1 +-0x1.25607cp-1 +-0x1.eed38p+1 +0x1.24b48ap+0 +0x1.ef0268p-4 +0x0p+0 +0x1.111754p-4 +0x1.ef0268p-4 +0x1.fb9762p-7 +0x1.111754p-4 +-0x1.22bae6p-6 +0x1.fb9762p-7 +-0x1.bc98f8p-8 +-0x1.22bae6p-6 +0x1.68387p-7 +-0x1.bc98f8p-8 +0x1.29a83ap-6 +0x1.68387p-7 +-0x1.2ca286p-6 +0x1.29a83ap-6 +-0x1.1e76fap-4 +-0x1.2ca286p-6 +-0x1.eaf7fap-4 +-0x1.1e76fap-4 +0x0p+0 +-0x1.eaf7fap-4 +0x0p+0 +0x1.f7c776p-4 +0x1.f852cp-4 +0x1.1c0954p-4 +0x1.1d8ce6p-4 +0x1.31efcep-6 +0x1.368684p-6 +-0x1.7710eep-7 +-0x1.73ac76p-7 +-0x1.3491b8p-8 +-0x1.3b0758p-8 +0x1.186fdap-7 +0x1.15c16ep-7 +0x1.90946p-7 +0x1.9211bp-7 +-0x1.5cfaa6p-6 +-0x1.586afep-6 +-0x1.291e48p-4 +-0x1.27b3e4p-4 +-0x1.f50dep-4 +-0x1.f3fc02p-4 +0x0p+0 +0x0p+0 +0x1.f73074p-4 +0x1.f7c182p-4 +0x1.1c2bc4p-4 +0x1.1db1b8p-4 +0x1.32259ep-6 +0x1.36c4d2p-6 +-0x1.743b06p-7 +-0x1.705bf8p-7 +-0x1.35939cp-8 +-0x1.3b7c66p-8 +0x1.18c4d4p-7 +0x1.160c3ap-7 +0x1.8d831p-7 +0x1.8e989cp-7 +-0x1.5d3da8p-6 +-0x1.58c4b6p-6 +-0x1.292e84p-4 +-0x1.27c90ep-4 +-0x1.f4852ap-4 +-0x1.f377b8p-4 +0x0p+0 +0x0p+0 +0x1.f6a31cp-4 +0x1.f73254p-4 +0x1.1c51bep-4 +0x1.1dd72ap-4 +0x1.32a5d4p-6 +0x1.373668p-6 +-0x1.70b1a2p-7 +-0x1.6cdf86p-7 +-0x1.361be6p-8 +-0x1.3beb28p-8 +0x1.189c92p-7 +0x1.15ff42p-7 +0x1.89f128p-7 +0x1.8b0b3ep-7 +-0x1.5da316p-6 +-0x1.592d36p-6 +-0x1.2944cp-4 +-0x1.27df7ep-4 +-0x1.f3fe7p-4 +-0x1.f2f36ep-4 +0x0p+0 +0x1.f614e6p-4 +0x1.1c7358p-4 +0x1.331688p-6 +-0x1.6d34dp-7 +-0x1.36575p-8 +0x1.188824p-7 +0x1.866f4ep-7 +-0x1.5e0606p-6 +-0x1.2959f8p-4 +-0x1.f3791ap-4 +0x0p+0 +-0x1.bba1e4p-10 +-0x1.f16e6p-10 +-0x1.35a5f4p-9 +-0x1.9f30a6p-9 +-0x1.13fff4p-8 +-0x1.4e69cep-8 +-0x1.7ae462p-8 +-0x1.97a1c6p-8 +-0x1.a56682p-8 +-0x1.a99988p-8 +0x0p+0 +0x0p+0 +0x1.317eccp+0 +0x1.5249c8p-3 +-0x1.16c7b6p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.2bdb26p-6 +0x0p+0 +-0x1.f75594p-3 +-0x1.753684p+0 +-0x1.523206p-2 +-0x1.64ae1p+1 +-0x1.c8f064p-1 +-0x1.10f98cp+2 +-0x1.4b051ap+1 +-0x1.e13e88p-1 +-0x1.bf767p+1 +-0x1.5cd95p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.25ff3ep-8 +0x0p+0 +0x1.903c7p-5 +-0x1.40e68ap-2 +0x1.89d94cp-5 +-0x1.92720cp-2 +-0x1.627edp+1 +0x1.44ecbep-1 +0x1.2124a4p+2 +-0x1.0ec1dp-1 +0x1.1916a6p+0 +-0x1.e7183ep+1 +0x1.ef0268p-4 +0x1.111754p-4 +0x1.fb9762p-7 +-0x1.22bae6p-6 +-0x1.bc98f8p-8 +0x1.68387p-7 +0x1.29a83ap-6 +-0x1.2ca286p-6 +-0x1.1e76fap-4 +-0x1.eaf7fap-4 +0x0p+0 +0x1.82650ap+2 +0x0p+0 +0x1.77ca56p+2 +0x0p+0 +0x1.44ecbep-1 +0x0p+0 +0x1.6cfebep-1 +0x0p+0 +0x1.7e114ep+2 +0x0p+0 +0x1.78dca4p+2 +0x0p+0 +0x1.5249c8p-3 +0x0p+0 +-0x1.bc12p-5 +0x0p+0 +0x1.903c7p-5 +0x0p+0 +0x1.f92964p-5 +0x0p+0 +0x1.89d94cp-5 +0x0p+0 +0x1.f2c642p-5 +0x0p+0 +0x1.78f896p+2 +0x0p+0 +0x1.6fa98cp+2 +0x0p+0 +0x1.d93a52p+1 +0x0p+0 +0x1.d6eb68p+1 +0x0p+0 +0x1.317eccp+0 +0x0p+0 +0x1.500b7ap+0 +0x0p+0 +0x1.5901aap+2 +0x0p+0 +0x1.54c016p+2 +0x0p+0 +0x1.82650ap+2 +0x0p+0 +0x1.77ca56p+2 +0x0p+0 +0x1.34d214p+2 +0x0p+0 +0x1.30794ep+2 +0x0p+0 +0x1.7cfc96p+2 +0x0p+0 +0x1.71a48ap+2 +0x0p+0 +0x1.bf915cp+1 +0x0p+0 +0x1.ab360cp+1 +0x0p+0 +0x1.024c54p+1 +0x0p+0 +0x1.e2b268p+0 +0x0p+0 +0x1.f3a588p+0 +0x0p+0 +0x1.ef7d9ep+0 +0x0p+0 +0x1.70477cp+2 +0x0p+0 +0x1.6d73a6p+2 +0x0p+0 +0x1.3d272ep+1 +0x0p+0 +0x1.356becp+1 +0x0p+0 +0x1.1916a6p+0 +0x0p+0 +0x1.24b48ap+0 +0x0p+0 +0x1.ed6p+0 +0x0p+0 +0x1.d4bfd8p+0 +0x0p+0 +0x1.aa333p-1 +0x0p+0 +0x1.8684bp-1 +0x0p+0 +0x1.55f7e4p+2 +0x0p+0 +0x1.57973ap+2 +0x0p+0 +0x1.d93a52p+1 +0x0p+0 +0x1.d6eb68p+1 +0x0p+0 +0x1.64c8fcp+1 +0x0p+0 +0x1.59aa6ap+1 +0x0p+0 +0x1.111754p-4 +0x0p+0 +0x1.1c7358p-4 +0x0p+0 +0x1.8da5dap+2 +0x0p+0 +0x1.8d7a4ep+2 +0x0p+0 +-0x1.16404ep+2 +-0x1.16404ep+2 +0x0p+0 +-0x1.15a6c6p+2 +0x0p+0 +-0x1.1580cp+2 +0x0p+0 +-0x1.157744p+2 +0x0p+0 +0x0p+0 +-0x1.15e9a2p+2 +-0x1.157744p+2 +0x0p+0 +0x1.f2a1c8p+0 +0x0p+0 +0x1.f0d85p+0 +-0x1.0a31bep-9 +-0x1.2391b8p-9 +-0x1.2391b8p-9 +-0x1.5dcb8cp-9 +-0x1.5dcb8cp-9 +-0x1.c3ed2p-9 +-0x1.c3ed2p-9 +-0x1.2477f2p-8 +-0x1.2477f2p-8 +-0x1.5cfbd4p-8 +-0x1.5cfbd4p-8 +-0x1.87e946p-8 +-0x1.87e946p-8 +-0x1.a3d576p-8 +-0x1.a3d576p-8 +-0x1.b15aa4p-8 +-0x1.b15aa4p-8 +-0x1.b5932p-8 +-0x1.35e192p-9 +-0x1.4b690ep-9 +-0x1.75508cp-9 +-0x1.0be926p-9 +-0x1.4b5a56p-9 +-0x1.7ea9c4p-9 +-0x1.c7b85p-9 +-0x1.01edf6p-9 +-0x1.7d5048p-9 +-0x1.db6b82p-9 +-0x1.187ca4p-8 +-0x1.27122ep-9 +-0x1.d70072p-9 +-0x1.3a30d4p-8 +-0x1.5c0e96p-8 +-0x1.934ba4p-9 +-0x1.357058p-8 +-0x1.6c1e1p-8 +-0x1.b5bc16p-8 +-0x1.d8b2b8p-9 +-0x1.6b5a1ap-8 +-0x1.927b24p-8 +-0x1.ef2864p-8 +-0x1.0f7f34p-8 +-0x1.93fea4p-8 +-0x1.ac656cp-8 +-0x1.05fa4ep-7 +-0x1.355dc6p-8 +-0x1.af3f56p-8 +-0x1.b86528p-8 +-0x1.056454p-7 +-0x1.5d857ap-8 +-0x1.bba2d4p-8 +-0x1.ba24d6p-8 +-0x1.ed537cp-8 +-0x1.88c5f6p-8 +-0x1.35de5ap-9 +-0x1.4c3574p-9 +-0x1.7523cap-9 +-0x1.0cdeeep-9 +-0x1.4c0b84p-9 +-0x1.80dadep-9 +-0x1.c7f912p-9 +-0x1.048ebap-9 +-0x1.7f498cp-9 +-0x1.e14c4ep-9 +-0x1.1915dep-8 +-0x1.2db654p-9 +-0x1.dc6216p-9 +-0x1.37be78p-8 +-0x1.5e181ep-8 +-0x1.8fb9cp-9 +-0x1.339798p-8 +-0x1.6c0184p-8 +-0x1.b2eb46p-8 +-0x1.da67e8p-9 +-0x1.6afbecp-8 +-0x1.9373b4p-8 +-0x1.ed894ap-8 +-0x1.11b5b2p-8 +-0x1.94b832p-8 +-0x1.ad9b0cp-8 +-0x1.05a124p-7 +-0x1.37fb58p-8 +-0x1.b053dp-8 +-0x1.b9e354p-8 +-0x1.05528ap-7 +-0x1.603866p-8 +-0x1.bd03f2p-8 +-0x1.bc9ef6p-8 +-0x1.edf7f2p-8 +-0x1.8bfa94p-8 +-0x1.35f5f4p-9 +-0x1.4d1c96p-9 +-0x1.7507f2p-9 +-0x1.0df956p-9 +-0x1.4cd77p-9 +-0x1.834b88p-9 +-0x1.c84cd4p-9 +-0x1.0776b2p-9 +-0x1.8185b4p-9 +-0x1.e581ep-9 +-0x1.19cba4p-8 +-0x1.32ba56p-9 +-0x1.e04c64p-9 +-0x1.362318p-8 +-0x1.5f6ccap-8 +-0x1.8dc6aep-9 +-0x1.326298p-8 +-0x1.6bd94p-8 +-0x1.b0bd88p-8 +-0x1.dc072p-9 +-0x1.6aaaaep-8 +-0x1.94439ep-8 +-0x1.ebf4cap-8 +-0x1.13c60ap-8 +-0x1.9553c8p-8 +-0x1.aec3fcp-8 +-0x1.053cf8p-7 +-0x1.3a8468p-8 +-0x1.b157f8p-8 +-0x1.bb6ad4p-8 +-0x1.053b48p-7 +-0x1.62ef4ep-8 +-0x1.be6cbp-8 +-0x1.beed76p-8 +-0x1.eea92cp-8 +-0x1.8efe9p-8 +-0x1.362854p-9 +-0x1.4e1aeap-9 +-0x1.85cdap-9 +-0x1.e8a358p-9 +-0x1.35132p-8 +-0x1.6bb3b2p-8 +-0x1.94f984p-8 +-0x1.afde6ep-8 +-0x1.bcf498p-8 +-0x1.c11606p-8 +0x0p+0 +0x0p+0 +0x1.6e9828p+0 +-0x1.bc12p-5 +0x1.6cfebep-1 +0x1.6cfebep-1 +-0x1.6b41e8p+1 +0x1.299bbcp+2 +-0x1.6b41e8p+1 +-0x1.15b4ccp-3 +0x1.931e9ep-1 +-0x1.748134p+1 +0x1.931e9ep-1 +-0x1.7479d4p+1 +0x1.3212d4p+2 +-0x1.15b4ccp-3 +0x1.931e9ep-1 +-0x1.7479eep+1 +0x1.931e9ep-1 +-0x1.7479e6p+1 +0x1.3212d4p+2 +-0x1.15b4ccp-3 +0x1.931e9ep-1 +-0x1.7479eep+1 +0x1.3212d4p+2 +-0x1.2317cap+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.5fdf5ep-6 +-0x1.a5560cp-2 +-0x1.5fdf5ep-6 +-0x1.936312p-6 +0x0p+0 +-0x1.9360e4p-6 +-0x1.2780a8p-1 +-0x1.936192p-6 +-0x1.2780a8p-1 +0x0p+0 +-0x1.03d96p-1 +-0x1.8699ap+0 +-0x1.79096p+1 +-0x1.8699ap+0 +-0x1.97df1cp+0 +-0x1.5e99bcp-1 +-0x1.97ded8p+0 +-0x1.8d64bp+1 +-0x1.97daa8p+0 +-0x1.8d64bp+1 +-0x1.5e99bcp-1 +-0x1.4d5404p+1 +0x0p+0 +-0x1.15e9a2p+2 +-0x1.13b158p-1 +-0x1.15e9a2p+2 +0x0p+0 +-0x1.15e9a2p+2 +-0x1.eafd06p-1 +-0x1.4d5404p+1 +-0x1.eafd06p-1 +-0x1.13b158p-1 +-0x1.94311ep-2 +0x1.f2c642p-5 +-0x1.94311ep-2 +-0x1.500cdap+1 +0x0p+0 +-0x1.16f5dap+2 +-0x1.5cde74p-1 +-0x1.169234p+2 +0x0p+0 +-0x1.ec6048p-1 +-0x1.168cc6p+2 +-0x1.dbd27p-1 +-0x1.500cdap+1 +-0x1.e20484p-2 +-0x1.5ed1cep-1 +-0x1.e4b652p-2 +0x1.2dd99cp-4 +-0x1.500cdap+1 +0x0p+0 +-0x1.168cc6p+2 +-0x1.5ed1cep-1 +-0x1.164238p+2 +0x0p+0 +-0x1.e0f92ap-1 +-0x1.162bep+2 +-0x1.e00218p-1 +-0x1.500cdap+1 +-0x1.e3a78ep-2 +-0x1.6053d6p-1 +-0x1.e5c25cp-2 +0x1.2dd99cp-4 +-0x1.500cdap+1 +0x0p+0 +-0x1.162bep+2 +-0x1.6053d6p-1 +-0x1.15eef6p+2 +0x0p+0 +-0x1.e059f8p-1 +-0x1.15d95ap+2 +-0x1.e0e50ap-1 +-0x1.500cdap+1 +-0x1.e501d8p-2 +-0x1.61997ap-1 +-0x1.e6b1dp-2 +0x1.2dd99cp-4 +-0x1.e0b342p-1 +-0x1.500cdap+1 +0x0p+0 +-0x1.15d95ap+2 +-0x1.61997ap-1 +-0x1.e617c8p-2 +0x1.2dd99cp-4 +-0x1.ca9502p+1 +-0x1.d443dep-1 +-0x1.614f2p+2 +-0x1.d443dep-1 +-0x1.c74882p-1 +-0x1.d5b394p+1 +-0x1.c74afep-1 +-0x1.65c4fp+2 +-0x1.c74acp-1 +-0x1.65c4fp+2 +-0x1.d5b394p+1 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.761796p-8 +0x1.f92964p-5 +0x1.761796p-8 +0x1.c62e06p-8 +0x0p+0 +0x1.c63d48p-8 +0x1.310b2cp-4 +0x1.c62a2cp-8 +0x1.310b2cp-4 +0x0p+0 +0x1.24b48ap+0 +-0x1.25607cp-1 +-0x1.eed38p+1 +-0x1.25607cp-1 +-0x1.3c04c4p-1 +0x1.30526ep+0 +-0x1.3bf708p-1 +-0x1.f68ec2p+1 +-0x1.3bf95ep-1 +-0x1.f68ec2p+1 +0x1.30526ep+0 +0x1.f614e6p-4 +0x0p+0 +0x1.1c7358p-4 +0x1.f614e6p-4 +0x1.331688p-6 +0x1.1c7358p-4 +-0x1.6d34dp-7 +0x1.331688p-6 +-0x1.36575p-8 +-0x1.6d34dp-7 +0x1.188824p-7 +-0x1.36575p-8 +0x1.866f4ep-7 +0x1.188824p-7 +-0x1.5e0606p-6 +0x1.866f4ep-7 +-0x1.2959f8p-4 +-0x1.5e0606p-6 +-0x1.f3791ap-4 +-0x1.2959f8p-4 +0x0p+0 +-0x1.f3791ap-4 +0x0p+0 +0x1.fce046p-4 +0x1.fd6eecp-4 +0x1.27d74ap-4 +0x1.296152p-4 +0x1.6e91a4p-6 +0x1.732c7ap-6 +-0x1.d259f8p-9 +-0x1.c710ccp-9 +-0x1.62843ap-9 +-0x1.694e46p-9 +0x1.8e5e44p-8 +0x1.8a73bcp-8 +0x1.328b5p-8 +0x1.373ddp-8 +-0x1.94adeep-6 +-0x1.9083eap-6 +-0x1.33b08cp-4 +-0x1.323732p-4 +-0x1.fc33fap-4 +-0x1.fb2092p-4 +0x0p+0 +0x0p+0 +0x1.fc4c7ep-4 +0x1.fcddb2p-4 +0x1.27f18ep-4 +0x1.297e6p-4 +0x1.6f21c2p-6 +0x1.73c47p-6 +-0x1.cc91b4p-9 +-0x1.beba0cp-9 +-0x1.624ce2p-9 +-0x1.681a86p-9 +0x1.8e04bep-8 +0x1.8a281ap-8 +0x1.2f07bap-8 +0x1.32a45p-8 +-0x1.95490ep-6 +-0x1.913948p-6 +-0x1.33bad2p-4 +-0x1.32467ap-4 +-0x1.fbaa1ep-4 +-0x1.fa9ae4p-4 +0x0p+0 +0x0p+0 +0x1.fbbfbap-4 +0x1.fc4ef2p-4 +0x1.280fc2p-4 +0x1.299c04p-4 +0x1.700cf4p-6 +0x1.749aep-6 +-0x1.c35a02p-9 +-0x1.b598a4p-9 +-0x1.61057cp-9 +-0x1.66c8ccp-9 +0x1.8c9906p-8 +0x1.89060ap-8 +0x1.2a225ep-8 +0x1.2dc578p-8 +-0x1.960998p-6 +-0x1.91fab8p-6 +-0x1.33cb4ep-4 +-0x1.3257c4p-4 +-0x1.fb228p-4 +-0x1.fa150ep-4 +0x0p+0 +0x1.fb31cep-4 +0x1.28288p-4 +0x1.70e3b6p-6 +-0x1.ba482ep-9 +-0x1.5f32a2p-9 +0x1.8b71d2p-8 +0x1.255592p-8 +-0x1.96c746p-6 +-0x1.33db24p-4 +-0x1.fa9c0ap-4 +0x0p+0 +-0x1.0a31bep-9 +-0x1.2391b8p-9 +-0x1.5dcb8cp-9 +-0x1.c3ed2p-9 +-0x1.2477f2p-8 +-0x1.5cfbd4p-8 +-0x1.87e946p-8 +-0x1.a3d576p-8 +-0x1.b15aa4p-8 +-0x1.b5932p-8 +0x0p+0 +0x0p+0 +0x1.500b7ap+0 +-0x1.bc12p-5 +-0x1.1cefcp+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.5fdf5ep-6 +0x0p+0 +-0x1.a5560cp-2 +-0x1.8699ap+0 +-0x1.03d96p-1 +-0x1.79096p+1 +-0x1.eafd06p-1 +-0x1.15e9a2p+2 +-0x1.4d5404p+1 +-0x1.d443dep-1 +-0x1.ca9502p+1 +-0x1.614f2p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.761796p-8 +0x0p+0 +0x1.f92964p-5 +-0x1.94311ep-2 +0x1.f2c642p-5 +-0x1.13b158p-1 +-0x1.6b41e8p+1 +0x1.6cfebep-1 +0x1.299bbcp+2 +-0x1.25607cp-1 +0x1.24b48ap+0 +-0x1.eed38p+1 +0x1.f614e6p-4 +0x1.1c7358p-4 +0x1.331688p-6 +-0x1.6d34dp-7 +-0x1.36575p-8 +0x1.188824p-7 +0x1.866f4ep-7 +-0x1.5e0606p-6 +-0x1.2959f8p-4 +-0x1.f3791ap-4 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.90bfd6p+2 +0x0p+0 +0x1.908c54p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.77ca56p+2 +0x0p+0 +0x1.6d2fap+2 +0x0p+0 +0x1.6cfebep-1 +0x0p+0 +0x1.931e9ep-1 +0x0p+0 +0x1.78dca4p+2 +0x0p+0 +0x1.73be3ap+2 +0x0p+0 +0x1.8ea792p+2 +0x0p+0 +0x1.89721p+2 +0x0p+0 +0x1.f2c642p-5 +0x0p+0 +0x1.2dd99cp-4 +0x0p+0 +0x1.6fa98cp+2 +0x0p+0 +0x1.65ec86p+2 +0x0p+0 +0x1.d6eb68p+1 +0x0p+0 +0x1.d43292p+1 +0x0p+0 +0x1.500b7ap+0 +0x0p+0 +0x1.6e9828p+0 +0x0p+0 +0x1.54c016p+2 +0x0p+0 +0x1.56094ep+2 +0x0p+0 +0x1.77ca56p+2 +0x0p+0 +0x1.6d2fap+2 +0x0p+0 +0x1.30794ep+2 +0x0p+0 +0x1.2c290cp+2 +0x0p+0 +0x1.71a48ap+2 +0x0p+0 +0x1.664c7ep+2 +0x0p+0 +0x1.ab360cp+1 +0x0p+0 +0x1.96dabcp+1 +0x0p+0 +0x1.f0d85p+0 +0x0p+0 +0x1.f1197p+0 +0x0p+0 +0x1.6d73a6p+2 +0x0p+0 +0x1.6aa08ap+2 +0x0p+0 +0x1.356becp+1 +0x0p+0 +0x1.2db0aap+1 +0x0p+0 +0x1.24b48ap+0 +0x0p+0 +0x1.30526ep+0 +0x0p+0 +0x1.d4bfd8p+0 +0x0p+0 +0x1.bc1fbp+0 +0x0p+0 +0x1.8684bp-1 +0x0p+0 +0x1.62d63p-1 +0x0p+0 +0x1.57973ap+2 +0x0p+0 +0x1.59365ep+2 +0x0p+0 +0x1.d6eb68p+1 +0x0p+0 +0x1.d43292p+1 +0x0p+0 +0x1.59aa6ap+1 +0x0p+0 +0x1.4e8bd8p+1 +0x0p+0 +0x1.1c7358p-4 +0x0p+0 +0x1.28288p-4 +0x0p+0 +0x1.8d7a4ep+2 +0x0p+0 +0x1.8d504ap+2 +-0x1.362854p-9 +-0x1.4e1aeap-9 +-0x1.4e1aeap-9 +-0x1.85cdap-9 +-0x1.85cdap-9 +-0x1.e8a358p-9 +-0x1.e8a358p-9 +-0x1.35132p-8 +-0x1.35132p-8 +-0x1.6bb3b2p-8 +-0x1.6bb3b2p-8 +-0x1.94f984p-8 +-0x1.94f984p-8 +-0x1.afde6ep-8 +-0x1.afde6ep-8 +-0x1.bcf498p-8 +-0x1.bcf498p-8 +-0x1.c11606p-8 +-0x1.61d828p-9 +-0x1.75f24p-9 +-0x1.a037d4p-9 +-0x1.378238p-9 +-0x1.76044ep-9 +-0x1.a6abd8p-9 +-0x1.f01d3ap-9 +-0x1.2c36cp-9 +-0x1.a58bb8p-9 +-0x1.0010dcp-8 +-0x1.2ab99ap-8 +-0x1.4f8b8ep-9 +-0x1.fbff8ep-9 +-0x1.4acc02p-8 +-0x1.6bcfcap-8 +-0x1.ba0474p-9 +-0x1.462722p-8 +-0x1.7ad5eep-8 +-0x1.c2b56p-8 +-0x1.fda324p-9 +-0x1.7a24d2p-8 +-0x1.9f8b62p-8 +-0x1.f967bep-8 +-0x1.211698p-8 +-0x1.a10d9cp-8 +-0x1.b86e64p-8 +-0x1.0a109ep-7 +-0x1.463e9ep-8 +-0x1.bb2956p-8 +-0x1.c3ff1cp-8 +-0x1.09366cp-7 +-0x1.6d5b24p-8 +-0x1.c70fdep-8 +-0x1.c5a7bcp-8 +-0x1.f63da4p-8 +-0x1.96c52p-8 +-0x1.61b4c6p-9 +-0x1.76a72p-9 +-0x1.9fe1d8p-9 +-0x1.386994p-9 +-0x1.769c66p-9 +-0x1.a8cb76p-9 +-0x1.f03c36p-9 +-0x1.2ececap-9 +-0x1.a778f4p-9 +-0x1.030b22p-8 +-0x1.2b4d7p-8 +-0x1.56424p-9 +-0x1.00b582p-8 +-0x1.4860d4p-8 +-0x1.6ddcb2p-8 +-0x1.b683cap-9 +-0x1.44529ap-8 +-0x1.7abc14p-8 +-0x1.bff09cp-8 +-0x1.ff4e06p-9 +-0x1.79cd6p-8 +-0x1.a083b8p-8 +-0x1.f7d718p-8 +-0x1.234534p-8 +-0x1.a1cb68p-8 +-0x1.b9977cp-8 +-0x1.09c2dep-7 +-0x1.48bd4ep-8 +-0x1.bc3254p-8 +-0x1.c564d2p-8 +-0x1.092c2ep-7 +-0x1.6fdb5ap-8 +-0x1.c85c82p-8 +-0x1.c7fdfap-8 +-0x1.f6ded2p-8 +-0x1.99c4e8p-8 +-0x1.61add6p-9 +-0x1.776fd6p-9 +-0x1.9fa5a4p-9 +-0x1.39676ap-9 +-0x1.774d78p-9 +-0x1.ab3a26p-9 +-0x1.f07136p-9 +-0x1.31b8bcp-9 +-0x1.a9ab78p-9 +-0x1.052d9cp-8 +-0x1.2bfcf6p-8 +-0x1.5b5886p-9 +-0x1.02b348p-8 +-0x1.46c5bcp-8 +-0x1.6f325p-8 +-0x1.b4a088p-9 +-0x1.432316p-8 +-0x1.7a9664p-8 +-0x1.bdcc5p-8 +-0x1.00753p-8 +-0x1.7978e2p-8 +-0x1.a1578cp-8 +-0x1.f64932p-8 +-0x1.254fa8p-8 +-0x1.a26d1cp-8 +-0x1.bab1ep-8 +-0x1.096a84p-7 +-0x1.4b268ap-8 +-0x1.bd2cfep-8 +-0x1.c6d5b8p-8 +-0x1.091dfep-7 +-0x1.72605ap-8 +-0x1.c9af98p-8 +-0x1.ca2b5p-8 +-0x1.f78ac8p-8 +-0x1.9c979p-8 +-0x1.61be28p-9 +-0x1.785b1p-9 +-0x1.adb0d6p-9 +-0x1.06c1aap-8 +-0x1.45c104p-8 +-0x1.7a6ba8p-8 +-0x1.a20f4p-8 +-0x1.bbc2c6p-8 +-0x1.c8480ep-8 +-0x1.cc350ap-8 +0x0p+0 +0x0p+0 +0x1.6e9828p+0 +-0x1.8d64bp+1 +-0x1.8d64bp+1 +-0x1.97daa8p+0 +-0x1.5e99bcp-1 +-0x1.97daa8p+0 +0x1.755958p+0 +-0x1.a0b6d8p+1 +-0x1.a83216p+0 +-0x1.a0b6d8p+1 +-0x1.a82ee8p+0 +-0x1.b95a18p-1 +0x1.755958p+0 +-0x1.a0b6d8p+1 +-0x1.a8281ep+0 +-0x1.b95a18p-1 +-0x1.15b4ccp-3 +-0x1.500cdap+1 +-0x1.500cdap+1 +0x0p+0 +-0x1.15d95ap+2 +-0x1.61997ap-1 +-0x1.15d95ap+2 +0x0p+0 +-0x1.500cdap+1 +-0x1.e0b342p-1 +-0x1.15d95ap+2 +-0x1.e0b342p-1 +-0x1.61997ap-1 +-0x1.e617c8p-2 +0x1.2dd99cp-4 +-0x1.e617c8p-2 +-0x1.61897cp-2 +-0x1.530374p+1 +-0x1.530524p+1 +0x0p+0 +-0x1.17269cp+2 +-0x1.aac696p-1 +-0x1.17269cp+2 +0x0p+0 +-0x1.e1bf14p-1 +-0x1.530524p+1 +-0x1.e1b3cep-1 +-0x1.17167p+2 +-0x1.19da52p-1 +-0x1.aac696p-1 +-0x1.19f546p-1 +0x1.625018p-4 +-0x1.61897cp-2 +-0x1.530524p+1 +-0x1.e195f2p-1 +-0x1.17167p+2 +-0x1.aac696p-1 +-0x1.19df74p-1 +0x1.625018p-4 +0x0p+0 +-0x1.293fd4p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.936192p-6 +-0x1.2780a8p-1 +-0x1.936192p-6 +-0x1.c6e488p-6 +0x0p+0 +-0x1.c6e778p-6 +-0x1.7c5648p-1 +-0x1.c6e8eap-6 +-0x1.7c5648p-1 +0x0p+0 +-0x1.d5b394p+1 +-0x1.c74acp-1 +-0x1.65c4fp+2 +-0x1.c74acp-1 +-0x1.ba506p-1 +-0x1.e0d226p+1 +-0x1.ba52a8p-1 +-0x1.6a3acp+2 +-0x1.ba526ap-1 +-0x1.6a3acp+2 +-0x1.e0d226p+1 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.c62a2cp-8 +0x1.310b2cp-4 +0x1.c62a2cp-8 +0x1.0b2052p-7 +0x0p+0 +0x1.0b23dp-7 +0x1.6581a6p-4 +0x1.0b2618p-7 +0x1.6581a6p-4 +0x0p+0 +0x1.931e9ep-1 +-0x1.7479eep+1 +0x1.3212d4p+2 +-0x1.7479eep+1 +-0x1.7db392p+1 +0x1.b93e7ep-1 +-0x1.7dacaap+1 +0x1.3a89ecp+2 +-0x1.7dac84p+1 +0x1.b93e7ep-1 +-0x1.7dacap+1 +0x1.3a89ecp+2 +-0x1.7dac8ep+1 +0x1.3a89ecp+2 +0x1.b93e7ep-1 +0x1.30526ep+0 +-0x1.3bf95ep-1 +-0x1.f68ec2p+1 +-0x1.3bf95ep-1 +-0x1.529866p-1 +0x1.3bf052p+0 +-0x1.528b1ap-1 +-0x1.fe4a04p+1 +-0x1.528d46p-1 +-0x1.fe4a04p+1 +0x1.3bf052p+0 +0x1.fb31cep-4 +0x0p+0 +0x1.28288p-4 +0x1.fb31cep-4 +0x1.70e3b6p-6 +0x1.28288p-4 +-0x1.ba482ep-9 +0x1.70e3b6p-6 +-0x1.5f32a2p-9 +-0x1.ba482ep-9 +0x1.8b71d2p-8 +-0x1.5f32a2p-9 +0x1.255592p-8 +0x1.8b71d2p-8 +-0x1.96c746p-6 +0x1.255592p-8 +-0x1.33db24p-4 +-0x1.96c746p-6 +-0x1.fa9c0ap-4 +-0x1.33db24p-4 +0x0p+0 +-0x1.fa9c0ap-4 +0x0p+0 +0x1.00105p-3 +0x1.00586ep-3 +0x1.33912p-4 +0x1.351facp-4 +0x1.b85a0cp-6 +0x1.bcdbe8p-6 +0x1.49de14p-8 +0x1.4e9f9ep-8 +-0x1.f8032p-12 +-0x1.f79be2p-12 +0x1.b38402p-9 +0x1.af8338p-9 +-0x1.dc882cp-9 +-0x1.cf455ep-9 +-0x1.d7fe08p-6 +-0x1.d4447ep-6 +-0x1.3d9e46p-4 +-0x1.3c1a2p-4 +-0x1.00fca8p-3 +-0x1.007172p-3 +0x0p+0 +0x0p+0 +0x1.ff9142p-4 +0x1.00109cp-3 +0x1.33a32ep-4 +0x1.35345cp-4 +0x1.b93eaep-6 +0x1.bdce66p-6 +0x1.49c40ap-8 +0x1.500476p-8 +-0x1.e26beap-12 +-0x1.d9dfep-12 +0x1.b09e02p-9 +0x1.acc83p-9 +-0x1.dddd48p-9 +-0x1.d32dc8p-9 +-0x1.d8e88cp-6 +-0x1.d5501cp-6 +-0x1.3da5c6p-4 +-0x1.3c26d8p-4 +-0x1.00b732p-3 +-0x1.002dd4p-3 +0x0p+0 +0x0p+0 +0x1.ff05bcp-4 +0x1.ff93c8p-4 +0x1.33babep-4 +0x1.354af6p-4 +0x1.ba8edap-6 +0x1.bf05ccp-6 +0x1.4baf4p-8 +0x1.51eb04p-8 +-0x1.c4117cp-12 +-0x1.bba282p-12 +0x1.ab5884p-9 +0x1.a838p-9 +-0x1.e2b24ap-9 +-0x1.d7fb46p-9 +-0x1.d9ff46p-6 +-0x1.d66594p-6 +-0x1.3db372p-4 +-0x1.3c3546p-4 +-0x1.0072ap-3 +-0x1.ffd44cp-4 +0x0p+0 +0x1.fe78aep-4 +0x1.33cbf6p-4 +0x1.bbc4acp-6 +0x1.4d9538p-8 +-0x1.a13036p-12 +0x1.a6d642p-9 +-0x1.e767d8p-9 +-0x1.db1044p-6 +-0x1.3dc09ap-4 +-0x1.002e6cp-3 +0x0p+0 +-0x1.362854p-9 +-0x1.4e1aeap-9 +-0x1.85cdap-9 +-0x1.e8a358p-9 +-0x1.35132p-8 +-0x1.6bb3b2p-8 +-0x1.94f984p-8 +-0x1.afde6ep-8 +-0x1.bcf498p-8 +-0x1.c11606p-8 +0x0p+0 +0x0p+0 +0x1.6e9828p+0 +-0x1.15b4ccp-3 +-0x1.2317cap+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.936192p-6 +0x0p+0 +-0x1.2780a8p-1 +-0x1.97daa8p+0 +-0x1.5e99bcp-1 +-0x1.8d64bp+1 +-0x1.e0b342p-1 +-0x1.15d95ap+2 +-0x1.500cdap+1 +-0x1.c74acp-1 +-0x1.d5b394p+1 +-0x1.65c4fp+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.c62a2cp-8 +0x0p+0 +0x1.310b2cp-4 +-0x1.e617c8p-2 +0x1.2dd99cp-4 +-0x1.61997ap-1 +-0x1.7479eep+1 +0x1.931e9ep-1 +0x1.3212d4p+2 +-0x1.3bf95ep-1 +0x1.30526ep+0 +-0x1.f68ec2p+1 +0x1.fb31cep-4 +0x1.28288p-4 +0x1.70e3b6p-6 +-0x1.ba482ep-9 +-0x1.5f32a2p-9 +0x1.8b71d2p-8 +0x1.255592p-8 +-0x1.96c746p-6 +-0x1.33db24p-4 +-0x1.fa9c0ap-4 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.908c54p+2 +0x0p+0 +0x1.9058cep+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.6d2fap+2 +0x0p+0 +0x1.6294ecp+2 +0x0p+0 +0x1.931e9ep-1 +0x0p+0 +0x1.b93e7ep-1 +0x0p+0 +0x1.73be3ap+2 +0x0p+0 +0x1.6ee3c8p+2 +0x0p+0 +0x1.89721p+2 +0x0p+0 +0x1.7c071ep+2 +0x0p+0 +0x1.2dd99cp-4 +0x0p+0 +0x1.625018p-4 +0x0p+0 +0x1.65ec86p+2 +0x0p+0 +0x1.5cc6e4p+2 +0x0p+0 +0x1.d43292p+1 +0x0p+0 +0x1.d13a48p+1 +0x0p+0 +0x1.6e9828p+0 +0x0p+0 +0x1.755958p+0 +0x0p+0 +0x1.56094ep+2 +0x0p+0 +0x1.55ecf8p+2 +0x0p+0 +0x1.6d2fap+2 +0x0p+0 +0x1.6294ecp+2 +0x0p+0 +0x1.2c290cp+2 +0x0p+0 +0x1.2815aep+2 +0x0p+0 +0x1.664c7ep+2 +0x0p+0 +0x1.5af474p+2 +0x0p+0 +0x1.96dabcp+1 +0x0p+0 +0x1.838894p+1 +0x0p+0 +0x1.f1197p+0 +0x0p+0 +0x1.ec2518p+0 +0x0p+0 +0x1.6aa08ap+2 +0x0p+0 +0x1.67ce0ep+2 +0x0p+0 +0x1.2db0aap+1 +0x0p+0 +0x1.25f568p+1 +0x0p+0 +0x1.30526ep+0 +0x0p+0 +0x1.3bf052p+0 +0x0p+0 +0x1.62d63p-1 +0x0p+0 +0x1.3f27bp-1 +0x0p+0 +0x1.59365ep+2 +0x0p+0 +0x1.5ad568p+2 +0x0p+0 +0x1.d43292p+1 +0x0p+0 +0x1.d13a48p+1 +0x0p+0 +0x1.4e8bd8p+1 +0x0p+0 +0x1.436d46p+1 +0x0p+0 +0x1.28288p-4 +0x0p+0 +0x1.33cbf6p-4 +0x0p+0 +0x1.8d504ap+2 +0x0p+0 +0x1.8d28b4p+2 +-0x1.61be28p-9 +-0x1.785b1p-9 +-0x1.785b1p-9 +-0x1.adb0d6p-9 +-0x1.adb0d6p-9 +-0x1.06c1aap-8 +-0x1.06c1aap-8 +-0x1.45c104p-8 +-0x1.45c104p-8 +-0x1.7a6ba8p-8 +-0x1.7a6ba8p-8 +-0x1.a20f4p-8 +-0x1.a20f4p-8 +-0x1.bbc2c6p-8 +-0x1.bbc2c6p-8 +-0x1.c8480ep-8 +-0x1.c8480ep-8 +-0x1.cc350ap-8 +-0x1.8d6dfcp-9 +-0x1.a03266p-9 +-0x1.cab622p-9 +-0x1.62da88p-9 +-0x1.a065d8p-9 +-0x1.ce8f0ep-9 +-0x1.0c1074p-8 +-0x1.56799ap-9 +-0x1.cda6b2p-9 +-0x1.1280dap-8 +-0x1.3cde0cp-8 +-0x1.783f4ep-9 +-0x1.108d5ep-8 +-0x1.5b79e6p-8 +-0x1.7b9e12p-8 +-0x1.e0e426p-9 +-0x1.56ee36p-8 +-0x1.898de4p-8 +-0x1.cfce0cp-8 +-0x1.113a74p-8 +-0x1.88f63cp-8 +-0x1.aca11ep-8 +-0x1.01e668p-7 +-0x1.32946cp-8 +-0x1.ae238ep-8 +-0x1.c452bcp-8 +-0x1.0e44dap-7 +-0x1.56c68ap-8 +-0x1.c6f54cp-8 +-0x1.cf5292p-8 +-0x1.0d2078p-7 +-0x1.7c9d4ap-8 +-0x1.d23d0ep-8 +-0x1.d0c6cp-8 +-0x1.ff1b0ep-8 +-0x1.a42e02p-8 +-0x1.8d29f4p-9 +-0x1.a0d228p-9 +-0x1.ca4212p-9 +-0x1.63aa38p-9 +-0x1.a0e3dcp-9 +-0x1.d0a962p-9 +-0x1.0c10dap-8 +-0x1.591084p-9 +-0x1.cf8762p-9 +-0x1.15803ep-8 +-0x1.3d6822p-8 +-0x1.7f074cp-9 +-0x1.134772p-8 +-0x1.590c9cp-8 +-0x1.7da78p-8 +-0x1.dd6eccp-9 +-0x1.551d0ap-8 +-0x1.897c58p-8 +-0x1.cd0d16p-8 +-0x1.1217acp-8 +-0x1.88a42ap-8 +-0x1.ad961p-8 +-0x1.01276ap-7 +-0x1.34b272p-8 +-0x1.aedf5cp-8 +-0x1.c571d8p-8 +-0x1.0dfff8p-7 +-0x1.5927c6p-8 +-0x1.c7f7fcp-8 +-0x1.d0a1fap-8 +-0x1.0d1c9p-7 +-0x1.7ef47cp-8 +-0x1.d3778cp-8 +-0x1.d2ff4cp-8 +-0x1.ffb7c8p-8 +-0x1.a70298p-8 +-0x1.8d075ep-9 +-0x1.a18826p-9 +-0x1.c9e91cp-9 +-0x1.649678p-9 +-0x1.a1809p-9 +-0x1.d30d4cp-9 +-0x1.0c20dap-8 +-0x1.5bf05ap-9 +-0x1.d1a8bep-9 +-0x1.17a17ap-8 +-0x1.3e0d2p-8 +-0x1.841f16p-9 +-0x1.154034p-8 +-0x1.5777a8p-8 +-0x1.7efe34p-8 +-0x1.db8b7cp-9 +-0x1.53ed7cp-8 +-0x1.895b06p-8 +-0x1.caeebcp-8 +-0x1.12e42ep-8 +-0x1.8855dp-8 +-0x1.ae64f8p-8 +-0x1.006836p-7 +-0x1.36aeb4p-8 +-0x1.af7b8ap-8 +-0x1.c68282p-8 +-0x1.0dafacp-7 +-0x1.5b71ep-8 +-0x1.c8e8d8p-8 +-0x1.d1fd92p-8 +-0x1.0d137ap-7 +-0x1.81507p-8 +-0x1.d4b77ap-8 +-0x1.d51294p-8 +-0x1.003036p-7 +-0x1.a9ab8ep-8 +-0x1.8cfdbep-9 +-0x1.a2657ap-9 +-0x1.d57a92p-9 +-0x1.19369ap-8 +-0x1.567122p-8 +-0x1.893754p-8 +-0x1.af17eep-8 +-0x1.c78828p-8 +-0x1.d35adep-8 +-0x1.d7049ep-8 +0x0p+0 +0x0p+0 +0x1.755958p+0 +0x1.6581a6p-4 +0x1.6581a6p-4 +0x1.0b2618p-7 +0x0p+0 +0x1.0b2618p-7 +0x1.c30ab6p+0 +0x1.f059eep-4 +0x1.eaec68p-10 +0x1.f059eep-4 +0x1.ead2f2p-10 +0x0p+0 +0x1.c30ab6p+0 +0x1.f059eep-4 +0x1.eb2c54p-10 +0x0p+0 +-0x1.61897cp-2 +0x1.b93e7ep-1 +-0x1.61897cp-2 +-0x1.530524p+1 +-0x1.530524p+1 +0x0p+0 +-0x1.17167p+2 +0x0p+0 +-0x1.530524p+1 +-0x1.e195f2p-1 +-0x1.17167p+2 +-0x1.e195f2p-1 +0x1.b93e7ep-1 +-0x1.7dac8ep+1 +0x1.3a89ecp+2 +-0x1.7dac8ep+1 +-0x1.2e5d4ep-1 +0x1.e212p-1 +-0x1.2e5d4ep-1 +-0x1.56725ap+1 +-0x1.56725ap+1 +0x0p+0 +-0x1.189334p+2 +0x0p+0 +-0x1.e268f8p-1 +-0x1.56725ap+1 +-0x1.e2df7p-1 +-0x1.1886f2p+2 +-0x1.873aa4p+1 +0x1.e13b1cp-1 +-0x1.873024p+1 +0x1.430104p+2 +-0x1.2e5d4ep-1 +0x1.e13b1cp-1 +-0x1.2e5d4ep-1 +-0x1.56725ap+1 +-0x1.56725ap+1 +0x0p+0 +-0x1.1886f2p+2 +0x0p+0 +-0x1.e28d8cp-1 +-0x1.56725ap+1 +-0x1.e2aad2p-1 +-0x1.187cf6p+2 +-0x1.87310ap+1 +0x1.e08b86p-1 +-0x1.873886p+1 +0x1.430104p+2 +-0x1.2e5d4ep-1 +0x1.e08b86p-1 +-0x1.2e5d4ep-1 +-0x1.56725ap+1 +-0x1.56725ap+1 +0x0p+0 +-0x1.187cf6p+2 +0x0p+0 +-0x1.e2805ap-1 +-0x1.56725ap+1 +-0x1.e28f66p-1 +-0x1.1874e2p+2 +-0x1.8735dcp+1 +0x1.dffafcp-1 +-0x1.873d4p+1 +0x1.430104p+2 +-0x1.2e5d4ep-1 +-0x1.56725ap+1 +-0x1.e27038p-1 +-0x1.1874e2p+2 +0x0p+0 +0x1.dffafcp-1 +-0x1.873a8ep+1 +0x1.430104p+2 +-0x1.2f67dep+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.c6e8eap-6 +-0x1.7c5648p-1 +-0x1.c6e8eap-6 +-0x1.fa6bdep-6 +0x0p+0 +-0x1.fa67ccp-6 +-0x1.d12be8p-1 +-0x1.fa66b6p-6 +-0x1.d12be8p-1 +0x0p+0 +-0x1.b95a18p-1 +-0x1.a8281ep+0 +-0x1.a0b6d8p+1 +-0x1.a8281ep+0 +-0x1.b877f6p+0 +-0x1.0a0d3ap+0 +-0x1.b87422p+0 +-0x1.b409p+1 +-0x1.b86954p+0 +-0x1.0a0d3ap+0 +-0x1.b86d4cp+0 +-0x1.b409p+1 +-0x1.b86bd6p+0 +-0x1.b409p+1 +-0x1.0a0d3ap+0 +-0x1.e0d226p+1 +-0x1.ba526ap-1 +-0x1.6a3acp+2 +-0x1.ba526ap-1 +-0x1.ad5908p-1 +-0x1.ebf0b8p+1 +-0x1.ad5b56p-1 +-0x1.6eb09p+2 +-0x1.ad5b72p-1 +-0x1.6eb09p+2 +-0x1.ebf0b8p+1 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.625018p-4 +-0x1.19df74p-1 +-0x1.aac696p-1 +-0x1.19df74p-1 +-0x1.409354p-1 +0x1.96c694p-4 +-0x1.408776p-1 +-0x1.f3f3b2p-1 +-0x1.4076aap-1 +0x1.96c694p-4 +-0x1.407cbp-1 +-0x1.f3f3b2p-1 +-0x1.407a92p-1 +-0x1.f3f3b2p-1 +0x1.96c694p-4 +0x1.3bf052p+0 +-0x1.528d46p-1 +-0x1.fe4a04p+1 +-0x1.528d46p-1 +-0x1.69271p-1 +0x1.478e36p+0 +-0x1.69198p-1 +-0x1.0302a4p+2 +-0x1.691c04p-1 +-0x1.0302a4p+2 +0x1.478e36p+0 +0x1.fe78aep-4 +0x0p+0 +0x1.33cbf6p-4 +0x1.fe78aep-4 +0x1.bbc4acp-6 +0x1.33cbf6p-4 +0x1.4d9538p-8 +0x1.bbc4acp-6 +-0x1.a13036p-12 +0x1.4d9538p-8 +0x1.a6d642p-9 +-0x1.a13036p-12 +-0x1.e767d8p-9 +0x1.a6d642p-9 +-0x1.db1044p-6 +-0x1.e767d8p-9 +-0x1.3dc09ap-4 +-0x1.db1044p-6 +-0x1.002e6cp-3 +-0x1.3dc09ap-4 +0x0p+0 +-0x1.002e6cp-3 +0x0p+0 +0x1.00d6eap-3 +0x1.011f86p-3 +0x1.3ee006p-4 +0x1.407188p-4 +0x1.09bdd4p-5 +0x1.0be2bcp-5 +0x1.c4def4p-7 +0x1.c7151p-7 +0x1.1fb0acp-9 +0x1.26bffp-9 +0x1.81324p-14 +0x1.aa7da8p-14 +-0x1.915aeap-7 +-0x1.8d1bd4p-7 +-0x1.155e12p-5 +-0x1.13b422p-5 +-0x1.46d0aap-4 +-0x1.45487ep-4 +-0x1.0329fcp-3 +-0x1.029c1ep-3 +0x0p+0 +0x0p+0 +0x1.009178p-3 +0x1.00d886p-3 +0x1.3eee7ep-4 +0x1.4081bep-4 +0x1.0a49bcp-5 +0x1.0c7ae4p-5 +0x1.c37e14p-7 +0x1.c681a8p-7 +0x1.241736p-9 +0x1.2c5bcp-9 +0x1.e9146p-15 +0x1.2156d2p-14 +-0x1.90700ep-7 +-0x1.8cdffcp-7 +-0x1.15e95p-5 +-0x1.14559ep-5 +-0x1.46db7ap-4 +-0x1.4558dep-4 +-0x1.02e336p-3 +-0x1.0256b6p-3 +0x0p+0 +0x0p+0 +0x1.004c0cp-3 +0x1.009264p-3 +0x1.3f047ap-4 +0x1.4095fp-4 +0x1.0b12aap-5 +0x1.0d37bp-5 +0x1.c342b2p-7 +0x1.c642acp-7 +0x1.29ab92p-9 +0x1.31e07ep-9 +0x1.845c04p-18 +0x1.76022ep-16 +-0x1.908cbap-7 +-0x1.8cf65cp-7 +-0x1.1690a2p-5 +-0x1.14fb7cp-5 +-0x1.46ec1p-4 +-0x1.456a94p-4 +-0x1.029d08p-3 +-0x1.02113ep-3 +0x0p+0 +0x1.0005aep-3 +0x1.3f13cp-4 +0x1.0bccbap-5 +0x1.c30722p-7 +0x1.2fc8a2p-9 +-0x1.486d6p-15 +-0x1.90a052p-7 +-0x1.173518p-5 +-0x1.46fc4p-4 +-0x1.025738p-3 +0x0p+0 +-0x1.61be28p-9 +-0x1.785b1p-9 +-0x1.adb0d6p-9 +-0x1.06c1aap-8 +-0x1.45c104p-8 +-0x1.7a6ba8p-8 +-0x1.a20f4p-8 +-0x1.bbc2c6p-8 +-0x1.c8480ep-8 +-0x1.cc350ap-8 +0x0p+0 +0x0p+0 +0x1.755958p+0 +-0x1.61897cp-2 +-0x1.293fd4p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.c6e8eap-6 +0x0p+0 +-0x1.7c5648p-1 +-0x1.a8281ep+0 +-0x1.b95a18p-1 +-0x1.a0b6d8p+1 +-0x1.e195f2p-1 +-0x1.17167p+2 +-0x1.530524p+1 +-0x1.ba526ap-1 +-0x1.e0d226p+1 +-0x1.6a3acp+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.0b2618p-7 +0x0p+0 +0x1.6581a6p-4 +-0x1.19df74p-1 +0x1.625018p-4 +-0x1.aac696p-1 +-0x1.7dac8ep+1 +0x1.b93e7ep-1 +0x1.3a89ecp+2 +-0x1.528d46p-1 +0x1.3bf052p+0 +-0x1.fe4a04p+1 +0x1.fe78aep-4 +0x1.33cbf6p-4 +0x1.bbc4acp-6 +0x1.4d9538p-8 +-0x1.a13036p-12 +0x1.a6d642p-9 +-0x1.e767d8p-9 +-0x1.db1044p-6 +-0x1.3dc09ap-4 +-0x1.002e6cp-3 +0x0p+0 +0x1.3a89ecp+2 +0x0p+0 +0x1.430104p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.9058cep+2 +0x0p+0 +0x1.90255p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.6294ecp+2 +0x0p+0 +0x1.57fa38p+2 +0x0p+0 +0x1.b93e7ep-1 +0x0p+0 +0x1.dffafcp-1 +0x0p+0 +0x1.6ee3c8p+2 +0x0p+0 +0x1.6a1064p+2 +0x0p+0 +0x1.7c071ep+2 +0x0p+0 +0x1.6c540cp+2 +0x0p+0 +0x1.625018p-4 +0x0p+0 +0x1.96c694p-4 +0x0p+0 +0x1.5cc6e4p+2 +0x0p+0 +0x1.53a14p+2 +0x0p+0 +0x1.d13a48p+1 +0x0p+0 +0x1.cdcd12p+1 +0x0p+0 +0x1.55ecf8p+2 +0x0p+0 +0x1.55d1bp+2 +0x0p+0 +0x1.6294ecp+2 +0x0p+0 +0x1.57fa38p+2 +0x0p+0 +0x1.2815aep+2 +0x0p+0 +0x1.2404cp+2 +0x0p+0 +0x1.5af474p+2 +0x0p+0 +0x1.4f9c68p+2 +0x0p+0 +0x1.838894p+1 +0x0p+0 +0x1.70366cp+1 +0x0p+0 +0x1.ec2518p+0 +0x0p+0 +0x1.e6ab5p+0 +0x0p+0 +0x1.67ce0ep+2 +0x0p+0 +0x1.64fc36p+2 +0x0p+0 +0x1.25f568p+1 +0x0p+0 +0x1.1e3a24p+1 +0x0p+0 +0x1.3bf052p+0 +0x0p+0 +0x1.478e36p+0 +0x0p+0 +0x1.3f27bp-1 +0x0p+0 +0x1.1b793p-1 +0x0p+0 +0x1.5ad568p+2 +0x0p+0 +0x1.5c7448p+2 +0x0p+0 +0x1.d13a48p+1 +0x0p+0 +0x1.cdcd12p+1 +0x0p+0 +0x1.436d46p+1 +0x0p+0 +0x1.384eb4p+1 +0x0p+0 +0x1.33cbf6p-4 +0x0p+0 +0x1.3f13cp-4 +0x0p+0 +0x1.8d28b4p+2 +0x0p+0 +0x1.8d03c4p+2 +-0x1.8cfdbep-9 +-0x1.a2657ap-9 +-0x1.a2657ap-9 +-0x1.d57a92p-9 +-0x1.d57a92p-9 +-0x1.19369ap-8 +-0x1.19369ap-8 +-0x1.567122p-8 +-0x1.567122p-8 +-0x1.893754p-8 +-0x1.893754p-8 +-0x1.af17eep-8 +-0x1.af17eep-8 +-0x1.c78828p-8 +-0x1.c78828p-8 +-0x1.d35adep-8 +-0x1.d35adep-8 +-0x1.d7049ep-8 +-0x1.b8ad92p-9 +-0x1.ca3cdp-9 +-0x1.f4dec8p-9 +-0x1.8dfc9p-9 +-0x1.ca8122p-9 +-0x1.f658cap-9 +-0x1.1ff058p-8 +-0x1.80a0aep-9 +-0x1.f59c14p-9 +-0x1.24f5cap-8 +-0x1.4eec3cp-8 +-0x1.a103fcp-9 +-0x1.231968p-8 +-0x1.6c2a04p-8 +-0x1.8b5d5ep-8 +-0x1.03f16ep-8 +-0x1.67be02p-8 +-0x1.98599p-8 +-0x1.dcf60cp-8 +-0x1.23affap-8 +-0x1.97d738p-8 +-0x1.b9a9ccp-8 +-0x1.072fb2p-7 +-0x1.43e748p-8 +-0x1.bb320ep-8 +-0x1.d0181ep-8 +-0x1.1293d6p-7 +-0x1.66f332p-8 +-0x1.d2a9a8p-8 +-0x1.da6562p-8 +-0x1.111cb2p-7 +-0x1.8b639ap-8 +-0x1.dd3402p-8 +-0x1.db9654p-8 +-0x1.03f57ap-7 +-0x1.b11f4ep-8 +-0x1.b8598p-9 +-0x1.cac336p-9 +-0x1.f449dp-9 +-0x1.8ec3ccp-9 +-0x1.caef82p-9 +-0x1.f86f08p-9 +-0x1.1fe6e2p-8 +-0x1.83379cp-9 +-0x1.f778f6p-9 +-0x1.27ed0cp-8 +-0x1.4f7212p-8 +-0x1.a7c09p-9 +-0x1.25ca54p-8 +-0x1.69c49p-8 +-0x1.8d61eap-8 +-0x1.023a38p-8 +-0x1.65f2p-8 +-0x1.98473p-8 +-0x1.da3e04p-8 +-0x1.248894p-8 +-0x1.97869cp-8 +-0x1.ba9ba2p-8 +-0x1.067532p-7 +-0x1.45fabap-8 +-0x1.bbe9ccp-8 +-0x1.d12c58p-8 +-0x1.1256bep-7 +-0x1.69361ep-8 +-0x1.d3a15ep-8 +-0x1.dba18cp-8 +-0x1.111cdep-7 +-0x1.8d94a6p-8 +-0x1.de5e0ep-8 +-0x1.ddb9eep-8 +-0x1.0442bap-7 +-0x1.b3d0e8p-8 +-0x1.b81d34p-9 +-0x1.cb6956p-9 +-0x1.f3d25ap-9 +-0x1.8fa4fep-9 +-0x1.cb7a24p-9 +-0x1.fad18p-9 +-0x1.1fe9fep-8 +-0x1.861dc6p-9 +-0x1.f9a04ap-9 +-0x1.2a07aap-8 +-0x1.5013f2p-8 +-0x1.acd77cp-9 +-0x1.27c2bap-8 +-0x1.683288p-8 +-0x1.8eb494p-8 +-0x1.014f1cp-8 +-0x1.64c4bcp-8 +-0x1.982884p-8 +-0x1.d825ecp-8 +-0x1.2553bap-8 +-0x1.973ad6p-8 +-0x1.bb673ap-8 +-0x1.05bcf8p-7 +-0x1.47e862p-8 +-0x1.bc85d4p-8 +-0x1.d22fep-8 +-0x1.120db8p-7 +-0x1.6b649ap-8 +-0x1.d489c8p-8 +-0x1.dced68p-8 +-0x1.11193ep-7 +-0x1.8fcdbcp-8 +-0x1.df9196p-8 +-0x1.dfb7f8p-8 +-0x1.049604p-7 +-0x1.b65a6ep-8 +-0x1.b7fc1ap-9 +-0x1.cc2d44p-9 +-0x1.fd3884p-9 +-0x1.2b9cf4p-8 +-0x1.672e5cp-8 +-0x1.980496p-8 +-0x1.bc15fcp-8 +-0x1.d32a64p-8 +-0x1.de3d42p-8 +-0x1.e1962cp-8 +0x0p+0 +0x0p+0 +0x1.085e0ap+1 +-0x1.2e5d4ep-1 +-0x1.1874e2p+2 +-0x1.2e5d4ep-1 +0x1.dffafcp-1 +-0x1.1874e2p+2 +0x0p+0 +-0x1.56725ap+1 +0x0p+0 +0x1.dffafcp-1 +-0x1.873a8ep+1 +0x1.430104p+2 +-0x1.873a8ep+1 +-0x1.1874e2p+2 +-0x1.e27038p-1 +-0x1.56725ap+1 +-0x1.e27038p-1 +-0x1.f1db72p-2 +-0x1.1e0174p+2 +-0x1.f1db72p-2 +0x1.edc00cp-1 +-0x1.1e18dep+2 +0x0p+0 +-0x1.5bb316p+1 +0x0p+0 +-0x1.959252p+1 +0x1.eda99p-1 +-0x1.9628bap+1 +0x1.4b781cp+2 +-0x1.ded282p-1 +-0x1.1e17ep+2 +-0x1.de180ap-1 +-0x1.5bb316p+1 +-0x1.f1db72p-2 +-0x1.1e17ep+2 +-0x1.f1db72p-2 +0x1.eda99p-1 +-0x1.1e2ca6p+2 +0x0p+0 +-0x1.5bb316p+1 +0x0p+0 +-0x1.95e7b2p+1 +0x1.ed7b2p-1 +-0x1.960356p+1 +0x1.4b781cp+2 +-0x1.decac4p-1 +-0x1.1e273cp+2 +-0x1.deaaeap-1 +-0x1.5bb316p+1 +-0x1.f1db72p-2 +-0x1.1e273cp+2 +-0x1.f1db72p-2 +0x1.ed7b2p-1 +-0x1.1e39b6p+2 +0x0p+0 +-0x1.5bb316p+1 +0x0p+0 +-0x1.95f94ap+1 +0x1.ed3e34p-1 +-0x1.96021ap+1 +0x1.4b781cp+2 +-0x1.deb688p-1 +-0x1.1e31f8p+2 +-0x1.dec4b2p-1 +-0x1.5bb316p+1 +-0x1.f1db72p-2 +0x1.ed3e34p-1 +-0x1.95fef6p+1 +0x1.4b781cp+2 +-0x1.1e31f8p+2 +-0x1.debfbp-1 +-0x1.5bb316p+1 +0x0p+0 +-0x1.358fe8p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.fa66b6p-6 +-0x1.d12be8p-1 +-0x1.fa66b6p-6 +-0x1.16f4cep-5 +0x0p+0 +-0x1.16f27ep-5 +-0x1.1300c4p+0 +-0x1.16f52p-5 +-0x1.1300c4p+0 +0x0p+0 +-0x1.0a0d3ap+0 +-0x1.b86bd6p+0 +-0x1.b409p+1 +-0x1.b86bd6p+0 +-0x1.c8b3c2p+0 +-0x1.376d68p+0 +-0x1.c8a81cp+0 +-0x1.c75b28p+1 +-0x1.c8a8d2p+0 +-0x1.c75b28p+1 +-0x1.376d68p+0 +-0x1.ebf0b8p+1 +-0x1.ad5b72p-1 +-0x1.6eb09p+2 +-0x1.ad5b72p-1 +-0x1.a0630ep-1 +-0x1.f70f4ap+1 +-0x1.a06576p-1 +-0x1.73266p+2 +-0x1.a06502p-1 +-0x1.73266p+2 +-0x1.f70f4ap+1 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.eb2c54p-10 +0x1.f059eep-4 +0x1.eb2c54p-10 +-0x1.20cb58p-8 +0x0p+0 +-0x1.20b25ap-8 +0x1.3d991cp-3 +-0x1.20e26cp-8 +0x1.3d991cp-3 +0x0p+0 +0x1.96c694p-4 +-0x1.407a92p-1 +-0x1.f3f3b2p-1 +-0x1.407a92p-1 +-0x1.67143ap-1 +0x1.cb3d1p-4 +-0x1.66f532p-1 +-0x1.1e9068p+0 +-0x1.66f4acp-1 +0x1.cb3d1p-4 +-0x1.66f4e6p-1 +-0x1.1e9068p+0 +-0x1.66f4d2p-1 +-0x1.1e9068p+0 +0x1.cb3d1p-4 +0x1.478e36p+0 +-0x1.691c04p-1 +-0x1.0302a4p+2 +-0x1.691c04p-1 +-0x1.7fb092p-1 +0x1.532c1ap+0 +-0x1.7fa2f8p-1 +-0x1.06e046p+2 +-0x1.7fa52cp-1 +-0x1.06e046p+2 +0x1.532c1ap+0 +0x1.0005aep-3 +0x0p+0 +0x1.3f13cp-4 +0x1.0005aep-3 +0x1.0bccbap-5 +0x1.3f13cp-4 +0x1.c30722p-7 +0x1.0bccbap-5 +0x1.2fc8a2p-9 +0x1.c30722p-7 +-0x1.486d6p-15 +0x1.2fc8a2p-9 +-0x1.90a052p-7 +-0x1.486d6p-15 +-0x1.173518p-5 +-0x1.90a052p-7 +-0x1.46fc4p-4 +-0x1.173518p-5 +-0x1.025738p-3 +-0x1.46fc4p-4 +0x0p+0 +-0x1.025738p-3 +0x0p+0 +0x1.00d1b6p-3 +0x1.011bp-3 +0x1.49b878p-4 +0x1.4b49dap-4 +0x1.411984p-5 +0x1.4311b8p-5 +0x1.6ebfa4p-6 +0x1.6ff986p-6 +0x1.657604p-8 +0x1.6c578ap-8 +-0x1.e7671ep-9 +-0x1.dee876p-9 +-0x1.5445fcp-6 +-0x1.51bb02p-6 +-0x1.47814ep-5 +-0x1.45f98p-5 +-0x1.4f7d22p-4 +-0x1.4dfbc6p-4 +-0x1.04946ep-3 +-0x1.0401f2p-3 +0x0p+0 +0x0p+0 +0x1.008df6p-3 +0x1.00d49cp-3 +0x1.49ca2ep-4 +0x1.4b5ba6p-4 +0x1.41a1f8p-5 +0x1.43b032p-5 +0x1.6d9754p-6 +0x1.6f37d6p-6 +0x1.67a3c6p-8 +0x1.6f529p-8 +-0x1.eba4aep-9 +-0x1.e34706p-9 +-0x1.5359d4p-6 +-0x1.5127c4p-6 +-0x1.4807e2p-5 +-0x1.469dccp-5 +-0x1.4f938p-4 +-0x1.4e176ap-4 +-0x1.044b5ap-3 +-0x1.03ba14p-3 +0x0p+0 +0x0p+0 +0x1.00484cp-3 +0x1.008e98p-3 +0x1.49e6bep-4 +0x1.4b74eap-4 +0x1.427024p-5 +0x1.447352p-5 +0x1.6d115ap-6 +0x1.6eab94p-6 +0x1.6a7c02p-8 +0x1.722f7ap-8 +-0x1.f29604p-9 +-0x1.e98338p-9 +-0x1.530448p-6 +-0x1.50cbc4p-6 +-0x1.48b1dcp-5 +-0x1.474654p-5 +-0x1.4faeccp-4 +-0x1.4e33fep-4 +-0x1.0402c4p-3 +-0x1.037242p-3 +0x0p+0 +0x1.00015ep-3 +0x1.49fbacp-4 +0x1.432d3cp-5 +0x1.6c8c16p-6 +0x1.6d9dfcp-8 +-0x1.f86b52p-9 +-0x1.52a908p-6 +-0x1.4959b2p-5 +-0x1.4fc9cep-4 +-0x1.03ba9ep-3 +0x0p+0 +-0x1.8cfdbep-9 +-0x1.a2657ap-9 +-0x1.d57a92p-9 +-0x1.19369ap-8 +-0x1.567122p-8 +-0x1.893754p-8 +-0x1.af17eep-8 +-0x1.c78828p-8 +-0x1.d35adep-8 +-0x1.d7049ep-8 +0x0p+0 +0x0p+0 +0x1.c30ab6p+0 +-0x1.2e5d4ep-1 +-0x1.2f67dep+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.fa66b6p-6 +0x0p+0 +-0x1.d12be8p-1 +-0x1.b86bd6p+0 +-0x1.0a0d3ap+0 +-0x1.b409p+1 +-0x1.e27038p-1 +-0x1.1874e2p+2 +-0x1.56725ap+1 +-0x1.ad5b72p-1 +-0x1.ebf0b8p+1 +-0x1.6eb09p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x1.eb2c54p-10 +0x0p+0 +0x1.f059eep-4 +-0x1.407a92p-1 +0x1.96c694p-4 +-0x1.f3f3b2p-1 +-0x1.873a8ep+1 +0x1.dffafcp-1 +0x1.430104p+2 +-0x1.691c04p-1 +0x1.478e36p+0 +-0x1.0302a4p+2 +0x1.0005aep-3 +0x1.3f13cp-4 +0x1.0bccbap-5 +0x1.c30722p-7 +0x1.2fc8a2p-9 +-0x1.486d6p-15 +-0x1.90a052p-7 +-0x1.173518p-5 +-0x1.46fc4p-4 +-0x1.025738p-3 +0x0p+0 +0x1.430104p+2 +0x0p+0 +0x1.4b781cp+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.90255p+2 +0x0p+0 +0x1.8ff1ccp+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.57fa38p+2 +0x0p+0 +0x1.4d5f84p+2 +0x0p+0 +0x1.52acdep+2 +0x0p+0 +0x1.4ff5c6p+2 +0x0p+0 +0x1.dffafcp-1 +0x0p+0 +0x1.ed3e34p-1 +0x0p+0 +0x1.6a1064p+2 +0x0p+0 +0x1.65411cp+2 +0x0p+0 +0x1.6c540cp+2 +0x0p+0 +0x1.7301fep+2 +0x0p+0 +0x1.96c694p-4 +0x0p+0 +0x1.cb3d1p-4 +0x0p+0 +0x1.53a14p+2 +0x0p+0 +0x1.4a7b9cp+2 +0x0p+0 +0x1.cdcd12p+1 +0x0p+0 +0x1.c88c56p+1 +0x0p+0 +0x1.55d1bp+2 +0x0p+0 +0x1.5647cp+2 +0x0p+0 +0x1.57fa38p+2 +0x0p+0 +0x1.4d5f84p+2 +0x0p+0 +0x1.2404cp+2 +0x0p+0 +0x1.1ff582p+2 +0x0p+0 +0x1.4f9c68p+2 +0x0p+0 +0x1.44445cp+2 +0x0p+0 +0x1.70366cp+1 +0x0p+0 +0x1.5ce444p+1 +0x0p+0 +0x1.e6ab5p+0 +0x0p+0 +0x1.cfb6f8p+0 +0x0p+0 +0x1.64fc36p+2 +0x0p+0 +0x1.622b1p+2 +0x0p+0 +0x1.1e3a24p+1 +0x0p+0 +0x1.167eep+1 +0x0p+0 +0x1.478e36p+0 +0x0p+0 +0x1.532c1ap+0 +0x0p+0 +0x1.1b793p-1 +0x0p+0 +0x1.ef956p-2 +0x0p+0 +0x1.5c7448p+2 +0x0p+0 +0x1.5e1316p+2 +0x0p+0 +0x1.cdcd12p+1 +0x0p+0 +0x1.c88c56p+1 +0x0p+0 +0x1.384eb4p+1 +0x0p+0 +0x1.2d3022p+1 +0x0p+0 +0x1.3f13cp-4 +0x0p+0 +0x1.49fbacp-4 +0x0p+0 +0x1.8d03c4p+2 +0x0p+0 +0x1.8ce08ep+2 +0x0p+0 +-0x1.08a7bep+0 +0x0p+0 +-0x1.08a7bep+0 +0x0p+0 +-0x1.063192p+0 +0x0p+0 +-0x1.0595ap+0 +0x0p+0 +-0x1.056edep+0 +0x0p+0 +0x0p+0 +-0x1.0e14d2p+0 +-0x1.056edep+0 +0x0p+0 +0x1.50c3fep+2 +0x0p+0 +0x1.4e9a82p+2 +0x0p+0 +0x1.50c3fep+2 +0x0p+0 +0x1.4e9a82p+2 +-0x1.b7fc1ap-9 +-0x1.cc2d44p-9 +-0x1.cc2d44p-9 +-0x1.fd3884p-9 +-0x1.fd3884p-9 +-0x1.2b9cf4p-8 +-0x1.2b9cf4p-8 +-0x1.672e5cp-8 +-0x1.672e5cp-8 +-0x1.980496p-8 +-0x1.980496p-8 +-0x1.bc15fcp-8 +-0x1.bc15fcp-8 +-0x1.d32a64p-8 +-0x1.d32a64p-8 +-0x1.de3d42p-8 +-0x1.de3d42p-8 +-0x1.e1962cp-8 +-0x1.e3abeep-9 +-0x1.f4049ap-9 +-0x1.0f51bcp-8 +-0x1.b8fec8p-9 +-0x1.f4676cp-9 +-0x1.0f0b5ep-8 +-0x1.33abccp-8 +-0x1.aacfeap-9 +-0x1.0ebd38p-8 +-0x1.375c24p-8 +-0x1.60e48ap-8 +-0x1.c9c078p-9 +-0x1.359fbep-8 +-0x1.7ce73ep-8 +-0x1.9b1988p-8 +-0x1.177b2p-8 +-0x1.7891b6p-8 +-0x1.a726d2p-8 +-0x1.ea3126p-8 +-0x1.361794p-8 +-0x1.a6c036p-8 +-0x1.c6a7dap-8 +-0x1.0c8a1ap-7 +-0x1.551548p-8 +-0x1.c83722p-8 +-0x1.dbba5ap-8 +-0x1.16f81cp-7 +-0x1.76c94p-8 +-0x1.de4024p-8 +-0x1.e547c6p-8 +-0x1.15267ep-7 +-0x1.99c12p-8 +-0x1.e800c4p-8 +-0x1.e627e2p-8 +-0x1.085acap-7 +-0x1.bdae22p-8 +-0x1.e33a4ap-9 +-0x1.f48aa4p-9 +-0x1.0efc4ap-8 +-0x1.b9bdfep-9 +-0x1.f4ca6cp-9 +-0x1.10062ap-8 +-0x1.339408p-8 +-0x1.ad579p-9 +-0x1.0fa0a4p-8 +-0x1.3a5d14p-8 +-0x1.615ffap-8 +-0x1.d08f3ap-9 +-0x1.385758p-8 +-0x1.7a79bep-8 +-0x1.9d206cp-8 +-0x1.15c02ap-8 +-0x1.76be5p-8 +-0x1.a7194cp-8 +-0x1.e77b98p-8 +-0x1.36eb22p-8 +-0x1.a66ebap-8 +-0x1.c79446p-8 +-0x1.0bd3d4p-7 +-0x1.571a12p-8 +-0x1.c8eeacp-8 +-0x1.dcc494p-8 +-0x1.16c258p-7 +-0x1.78f37cp-8 +-0x1.df312ep-8 +-0x1.e674a4p-8 +-0x1.152d06p-7 +-0x1.9bcfb6p-8 +-0x1.e919f6p-8 +-0x1.e839fap-8 +-0x1.08a6d2p-7 +-0x1.c03ffap-8 +-0x1.e2eb72p-9 +-0x1.f51af8p-9 +-0x1.0eb6a2p-8 +-0x1.ba8ab8p-9 +-0x1.f53df8p-9 +-0x1.112f78p-8 +-0x1.338938p-8 +-0x1.b032bp-9 +-0x1.10a962p-8 +-0x1.3c7da4p-8 +-0x1.61f754p-8 +-0x1.d5b14cp-9 +-0x1.3a4f4p-8 +-0x1.78e60ep-8 +-0x1.9e765p-8 +-0x1.14cfap-8 +-0x1.7591b6p-8 +-0x1.a6f4e4p-8 +-0x1.e565bap-8 +-0x1.37aef8p-8 +-0x1.a61ff4p-8 +-0x1.c85ce6p-8 +-0x1.0b20c2p-7 +-0x1.58f78cp-8 +-0x1.c98918p-8 +-0x1.ddc39p-8 +-0x1.168098p-7 +-0x1.7b0d7p-8 +-0x1.e014ep-8 +-0x1.e7afcap-8 +-0x1.152e44p-7 +-0x1.9de9dp-8 +-0x1.ea3fe8p-8 +-0x1.ea26c2p-8 +-0x1.08f99p-7 +-0x1.c2abe4p-8 +-0x1.e2b92p-9 +-0x1.f5cdf2p-9 +-0x1.125e9p-8 +-0x1.3e1014p-8 +-0x1.77dfdap-8 +-0x1.a6ccfap-8 +-0x1.c90abap-8 +-0x1.deb6cp-8 +-0x1.e8ef6ep-8 +-0x1.ebf6aep-8 +0x0p+0 +0x0p+0 +0x1.2f36b8p+1 +-0x1.f1db72p-2 +-0x1.1e31f8p+2 +-0x1.f1db72p-2 +0x1.ed3e34p-1 +-0x1.5bb316p+1 +0x1.ed3e34p-1 +-0x1.5bb316p+1 +0x0p+0 +-0x1.1e31f8p+2 +0x0p+0 +0x1.ed3e34p-1 +-0x1.95fef6p+1 +0x1.4b781cp+2 +-0x1.95fef6p+1 +-0x1.5bb316p+1 +-0x1.debfbp-1 +-0x1.1e31f8p+2 +-0x1.debfbp-1 +-0x1.cdcf56p-2 +-0x1.25b1f4p+2 +-0x1.cdcf56p-2 +0x1.ed5e6cp-1 +-0x1.60d8d6p+1 +0x1.ed2654p-1 +-0x1.60aeaap+1 +0x0p+0 +-0x1.25b6d6p+2 +0x0p+0 +-0x1.a77efap+1 +0x1.ebc7a4p-1 +-0x1.a75914p+1 +0x1.53ef34p+2 +-0x1.d946c6p-1 +-0x1.60aeaap+1 +-0x1.d80d7cp-1 +-0x1.25b6d6p+2 +-0x1.cdcf56p-2 +-0x1.25b6d6p+2 +-0x1.cdcf56p-2 +0x1.ebc7a4p-1 +-0x1.60aeaap+1 +0x1.eb93a6p-1 +-0x1.608cfcp+1 +0x0p+0 +-0x1.25baaep+2 +0x0p+0 +-0x1.a75572p+1 +0x1.ea7e9cp-1 +-0x1.a775f4p+1 +0x1.53ef34p+2 +-0x1.d80e38p-1 +-0x1.608cfcp+1 +-0x1.d79494p-1 +-0x1.25baaep+2 +-0x1.cdcf56p-2 +-0x1.25baaep+2 +-0x1.cdcf56p-2 +0x1.ea7e9cp-1 +-0x1.608cfcp+1 +0x1.ea4becp-1 +-0x1.6072dcp+1 +0x0p+0 +-0x1.25bddcp+2 +0x0p+0 +-0x1.a76a1ep+1 +0x1.e9767p-1 +-0x1.a786b2p+1 +0x1.53ef34p+2 +-0x1.d7cf3p-1 +-0x1.6072dcp+1 +-0x1.d75dacp-1 +-0x1.25bddcp+2 +-0x1.cdcf56p-2 +0x1.e9767p-1 +-0x1.a77c6ap+1 +0x1.53ef34p+2 +-0x1.6072dcp+1 +-0x1.d792ecp-1 +0x0p+0 +-0x1.25bddcp+2 +-0x1.3bb7f2p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.0e14d2p+0 +0x0p+0 +0x0p+0 +-0x1.16f52p-5 +-0x1.0e14d2p+0 +-0x1.16f52p-5 +-0x1.27c1f8p+0 +0x0p+0 +-0x1.ceabe2p-3 +0x0p+0 +-0x1.cbb2cp-3 +-0x1.27c1f8p+0 +-0x1.27c1f8p+0 +0x0p+0 +-0x1.22165ap-2 +0x0p+0 +-0x1.0be79ep-2 +-0x1.27c1f8p+0 +-0x1.27c1f8p+0 +0x0p+0 +-0x1.13fd9ap-2 +0x0p+0 +-0x1.110bacp-2 +-0x1.27c1f8p+0 +-0x1.121d7ap-2 +-0x1.27c1f8p+0 +0x0p+0 +0x0p+0 +-0x1.c75b28p+1 +0x1.cb3d1p-4 +-0x1.376d68p+0 +-0x1.c8a8d2p+0 +-0x1.c75b28p+1 +-0x1.c8a8d2p+0 +0x1.cb3d1p-4 +-0x1.66f4d2p-1 +-0x1.1e9068p+0 +-0x1.66f4d2p-1 +-0x1.bee984p+1 +0x1.0bc36cp-2 +-0x1.da0cacp+0 +-0x1.64cd96p+0 +-0x1.d9f5dep+0 +-0x1.be3d04p+1 +-0x1.70eae6p-1 +0x1.1030b6p-2 +-0x1.6ec594p-1 +-0x1.4326f6p+0 +-0x1.be3d04p+1 +0x1.1030b6p-2 +-0x1.db0306p+0 +-0x1.64cd96p+0 +-0x1.daa3d8p+0 +-0x1.bda918p+1 +-0x1.6f871p-1 +0x1.13be58p-2 +-0x1.6dcc28p-1 +-0x1.4326f6p+0 +-0x1.bda918p+1 +0x1.13be58p-2 +-0x1.db75e2p+0 +-0x1.64cd96p+0 +-0x1.db2bep+0 +-0x1.bd27a8p+1 +-0x1.6e67eap-1 +0x1.16ac9ep-2 +-0x1.6cebfcp-1 +-0x1.4326f6p+0 +-0x1.dbe0d2p+0 +-0x1.bd27a8p+1 +0x1.16ac9ep-2 +-0x1.6d7168p-1 +-0x1.4326f6p+0 +-0x1.64cd96p+0 +-0x1.f70f4ap+1 +-0x1.a06502p-1 +-0x1.73266p+2 +-0x1.a06502p-1 +-0x1.936d9cp-1 +-0x1.0116eep+2 +-0x1.93703cp-1 +-0x1.779c3p+2 +-0x1.936fdap-1 +-0x1.779c3p+2 +-0x1.0116eep+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +-0x1.20e26cp-8 +0x1.3d991cp-3 +-0x1.20e26cp-8 +0x1.39f496p-12 +0x1.39eeb2p-12 +0x1.39f496p-12 +0x1.39eeb2p-12 +0x1.cf4adp-15 +0x0p+0 +0x1.c7eec6p-15 +0x1.39f496p-12 +-0x1.61524p-7 +0x1.39eeb2p-12 +-0x1.62b688p-7 +0x1.83054p-3 +0x1.39f496p-12 +0x1.39eeb2p-12 +0x1.5b129ap-18 +0x1.3748c2p-11 +0x1.e05ebp-15 +0x0p+0 +0x1.cdd81ap-15 +0x1.46bfbep-12 +-0x1.622966p-7 +0x1.2d28a2p-12 +-0x1.627246p-7 +0x1.83054p-3 +0x1.e18b3p-15 +0x1.46bfbep-12 +0x1.2d28a2p-12 +-0x1.625f78p-7 +0x1.83054p-3 +0x0p+0 +0x1.532c1ap+0 +-0x1.7fa52cp-1 +-0x1.06e046p+2 +-0x1.7fa52cp-1 +-0x1.963484p-1 +0x1.5ec9fep+0 +-0x1.9626b6p-1 +-0x1.0abde8p+2 +-0x1.962944p-1 +-0x1.0abde8p+2 +0x1.5ec9fep+0 +0x1.00015ep-3 +0x0p+0 +0x1.49fbacp-4 +0x1.00015ep-3 +0x1.432d3cp-5 +0x1.49fbacp-4 +0x1.6c8c16p-6 +0x1.432d3cp-5 +0x1.6d9dfcp-8 +0x1.6c8c16p-6 +-0x1.f86b52p-9 +0x1.6d9dfcp-8 +-0x1.52a908p-6 +-0x1.f86b52p-9 +-0x1.4959b2p-5 +-0x1.52a908p-6 +-0x1.4fc9cep-4 +-0x1.4959b2p-5 +-0x1.03ba9ep-3 +-0x1.4fc9cep-4 +0x0p+0 +-0x1.03ba9ep-3 +0x0p+0 +0x1.00071cp-3 +0x1.0051e8p-3 +0x1.54710ep-4 +0x1.55fd42p-4 +0x1.81ea6p-5 +0x1.83a7fp-5 +0x1.f33238p-6 +0x1.f4c5aap-6 +0x1.2f8154p-7 +0x1.348a42p-7 +-0x1.07f5eep-7 +-0x1.037ec4p-7 +-0x1.da23b8p-6 +-0x1.d73fa8p-6 +-0x1.82351cp-5 +-0x1.80ba48p-5 +-0x1.5834dp-4 +-0x1.56c53ap-4 +-0x1.0526a8p-3 +-0x1.048e86p-3 +0x0p+0 +0x0p+0 +0x1.ff89e6p-4 +0x1.000b88p-3 +0x1.548df4p-4 +0x1.5618bep-4 +0x1.824accp-5 +0x1.842a1ep-5 +0x1.f1d5f4p-6 +0x1.f3cbd8p-6 +0x1.301144p-7 +0x1.359f1ep-7 +-0x1.087b06p-7 +-0x1.04244cp-7 +-0x1.d9002cp-6 +-0x1.d66dccp-6 +-0x1.829672p-5 +-0x1.814342p-5 +-0x1.585da8p-4 +-0x1.56f3b2p-4 +-0x1.04dacap-3 +-0x1.044388p-3 +0x0p+0 +0x0p+0 +0x1.fefd38p-4 +0x1.ff8a44p-4 +0x1.54b9dep-4 +0x1.563fbep-4 +0x1.82fa94p-5 +0x1.84d014p-5 +0x1.f127bcp-6 +0x1.f312ecp-6 +0x1.310086p-7 +0x1.3695e4p-7 +-0x1.09b61ap-7 +-0x1.0538d4p-7 +-0x1.d88068p-6 +-0x1.d5e0cp-6 +-0x1.8326bap-5 +-0x1.81d248p-5 +-0x1.588ac4p-4 +-0x1.57220cp-4 +-0x1.048f4cp-3 +-0x1.03f902p-3 +0x0p+0 +0x1.fe6d58p-4 +0x1.54dce2p-4 +0x1.83982cp-5 +0x1.f078ep-6 +0x1.32173ep-7 +-0x1.0aa2a4p-7 +-0x1.d7f4cep-6 +-0x1.83b616p-5 +-0x1.58b792p-4 +-0x1.044448p-3 +0x0p+0 +-0x1.b7fc1ap-9 +-0x1.cc2d44p-9 +-0x1.fd3884p-9 +-0x1.2b9cf4p-8 +-0x1.672e5cp-8 +-0x1.980496p-8 +-0x1.bc15fcp-8 +-0x1.d32a64p-8 +-0x1.de3d42p-8 +-0x1.e1962cp-8 +0x0p+0 +0x0p+0 +0x1.085e0ap+1 +-0x1.f1db72p-2 +-0x1.358fe8p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.16f52p-5 +0x0p+0 +-0x1.0e14d2p+0 +-0x1.c8a8d2p+0 +-0x1.376d68p+0 +-0x1.c75b28p+1 +-0x1.debfbp-1 +-0x1.1e31f8p+2 +-0x1.5bb316p+1 +-0x1.a06502p-1 +-0x1.f70f4ap+1 +-0x1.73266p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.20e26cp-8 +0x0p+0 +0x1.3d991cp-3 +-0x1.66f4d2p-1 +0x1.cb3d1p-4 +-0x1.1e9068p+0 +-0x1.95fef6p+1 +0x1.ed3e34p-1 +0x1.4b781cp+2 +-0x1.7fa52cp-1 +0x1.532c1ap+0 +-0x1.06e046p+2 +0x1.00015ep-3 +0x1.49fbacp-4 +0x1.432d3cp-5 +0x1.6c8c16p-6 +0x1.6d9dfcp-8 +-0x1.f86b52p-9 +-0x1.52a908p-6 +-0x1.4959b2p-5 +-0x1.4fc9cep-4 +-0x1.03ba9ep-3 +0x0p+0 +0x1.8e4076p+1 +0x0p+0 +0x1.7cc302p+1 +0x0p+0 +0x1.4b781cp+2 +0x0p+0 +0x1.53ef34p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.8ff1ccp+2 +0x0p+0 +0x1.80fddep+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.4e9a82p+2 +0x0p+0 +0x1.482f38p+2 +0x0p+0 +0x1.ed3e34p-1 +0x0p+0 +0x1.e9767p-1 +0x0p+0 +0x1.65411cp+2 +0x0p+0 +0x1.647188p+2 +0x0p+0 +0x1.7301fep+2 +0x0p+0 +0x1.7542cp+2 +0x0p+0 +0x1.cb3d1p-4 +0x0p+0 +0x1.16ac9ep-2 +0x0p+0 +0x1.4a7b9cp+2 +0x0p+0 +0x1.4155f8p+2 +0x0p+0 +0x1.c88c56p+1 +0x0p+0 +0x1.c3cc9p+1 +0x0p+0 +0x1.5647cp+2 +0x0p+0 +0x1.572d58p+2 +0x0p+0 +0x1.4e9a82p+2 +0x0p+0 +0x1.482f38p+2 +0x0p+0 +0x1.1ff582p+2 +0x0p+0 +0x1.1b2782p+2 +0x0p+0 +0x1.44445cp+2 +0x0p+0 +0x1.38ec5p+2 +0x0p+0 +0x1.5ce444p+1 +0x0p+0 +0x1.6717c4p+1 +0x0p+0 +0x1.cfb6f8p+0 +0x0p+0 +0x1.b18768p+0 +0x0p+0 +0x1.622b1p+2 +0x0p+0 +0x1.5f5a8ep+2 +0x0p+0 +0x1.167eep+1 +0x0p+0 +0x1.0ec39cp+1 +0x0p+0 +0x1.532c1ap+0 +0x0p+0 +0x1.5ec9fep+0 +0x0p+0 +0x1.ef956p-2 +0x0p+0 +0x1.a8386p-2 +0x0p+0 +0x1.5e1316p+2 +0x0p+0 +0x1.5fb1bap+2 +0x0p+0 +0x1.c88c56p+1 +0x0p+0 +0x1.c3cc9p+1 +0x0p+0 +0x1.2d3022p+1 +0x0p+0 +0x1.22119p+1 +0x0p+0 +0x1.49fbacp-4 +0x0p+0 +0x1.54dce2p-4 +0x0p+0 +0x1.8ce08ep+2 +0x0p+0 +0x1.8cbcd8p+2 +-0x1.e2b92p-9 +-0x1.f5cdf2p-9 +-0x1.f5cdf2p-9 +-0x1.125e9p-8 +-0x1.125e9p-8 +-0x1.3e1014p-8 +-0x1.3e1014p-8 +-0x1.77dfdap-8 +-0x1.77dfdap-8 +-0x1.a6ccfap-8 +-0x1.a6ccfap-8 +-0x1.c90abap-8 +-0x1.c90abap-8 +-0x1.deb6cp-8 +-0x1.deb6cp-8 +-0x1.e8ef6ep-8 +-0x1.e8ef6ep-8 +-0x1.ebf6aep-8 +-0x1.07347ap-8 +-0x1.0ed2a4p-8 +-0x1.2417f8p-8 +-0x1.e3d0c6p-9 +-0x1.0f0a68p-8 +-0x1.22cdacp-8 +-0x1.473d9cp-8 +-0x1.d4e05ep-9 +-0x1.22982cp-8 +-0x1.49cf44p-8 +-0x1.72c3bp-8 +-0x1.f2a06ep-9 +-0x1.4823ap-8 +-0x1.8d98bcp-8 +-0x1.aad646p-8 +-0x1.2af5f2p-8 +-0x1.8962f2p-8 +-0x1.b5ef36p-8 +-0x1.f772d2p-8 +-0x1.4870fp-8 +-0x1.b5a17cp-8 +-0x1.d39c98p-8 +-0x1.11f678p-7 +-0x1.660e6ep-8 +-0x1.d5351cp-8 +-0x1.e746b6p-8 +-0x1.1b6f58p-7 +-0x1.865cd2p-8 +-0x1.e9c4d6p-8 +-0x1.eff9f2p-8 +-0x1.193f92p-7 +-0x1.a7bea8p-8 +-0x1.f2a0f4p-8 +-0x1.f08864p-8 +-0x1.0cbe1ap-7 +-0x1.c9e3dp-8 +-0x1.06f5c8p-8 +-0x1.0f0446p-8 +-0x1.23bd88p-8 +-0x1.e46b7cp-9 +-0x1.0f2ac2p-8 +-0x1.23cff2p-8 +-0x1.471cdp-8 +-0x1.d766bp-9 +-0x1.237ed4p-8 +-0x1.4cc156p-8 +-0x1.7339ep-8 +-0x1.f962aep-9 +-0x1.4ad566p-8 +-0x1.8b2ee2p-8 +-0x1.acd786p-8 +-0x1.293e5ep-8 +-0x1.8792b4p-8 +-0x1.b5e244p-8 +-0x1.f4c444p-8 +-0x1.494134p-8 +-0x1.b54ed8p-8 +-0x1.d48326p-8 +-0x1.114444p-7 +-0x1.680426p-8 +-0x1.d5e64ap-8 +-0x1.e848f4p-8 +-0x1.1b3edep-7 +-0x1.886e58p-8 +-0x1.eaaf2ap-8 +-0x1.f11a32p-8 +-0x1.194b1p-7 +-0x1.a9b02cp-8 +-0x1.f3b044p-8 +-0x1.f28b0ap-8 +-0x1.0d0a0cp-7 +-0x1.cc5cap-8 +-0x1.06c84ap-8 +-0x1.0f3f88p-8 +-0x1.236b48p-8 +-0x1.e52b7ap-9 +-0x1.0f5ab4p-8 +-0x1.24f3a8p-8 +-0x1.470bbp-8 +-0x1.da2f9cp-9 +-0x1.247f06p-8 +-0x1.4edc72p-8 +-0x1.73c864p-8 +-0x1.fe7a86p-9 +-0x1.4cc6a2p-8 +-0x1.89a016p-8 +-0x1.ae2adcp-8 +-0x1.284e8cp-8 +-0x1.8666c4p-8 +-0x1.b5bd8p-8 +-0x1.f2b4c8p-8 +-0x1.49feeep-8 +-0x1.b5020ep-8 +-0x1.d544b8p-8 +-0x1.1095d6p-7 +-0x1.69d356p-8 +-0x1.d67922p-8 +-0x1.e93fp-8 +-0x1.1b0146p-7 +-0x1.8a6fa4p-8 +-0x1.eb8b3ap-8 +-0x1.f24a28p-8 +-0x1.1950dap-7 +-0x1.abae8cp-8 +-0x1.f4cca2p-8 +-0x1.f469fep-8 +-0x1.0d5c6cp-7 +-0x1.ceb1fcp-8 +-0x1.06a6p-8 +-0x1.0f922cp-8 +-0x1.261b8cp-8 +-0x1.506c5cp-8 +-0x1.88984p-8 +-0x1.b59854p-8 +-0x1.d5ea3p-8 +-0x1.ea2972p-8 +-0x1.f3801ap-8 +-0x1.f62c7ap-8 +0x0p+0 +0x0p+0 +0x1.560f66p+1 +-0x1.cdcf56p-2 +-0x1.25bddcp+2 +-0x1.cdcf56p-2 +0x1.e9767p-1 +-0x1.6072dcp+1 +0x1.e9767p-1 +-0x1.3bb7f2p+2 +0x1.e9767p-1 +-0x1.6072dcp+1 +0x0p+0 +-0x1.25bddcp+2 +0x0p+0 +0x1.e9767p-1 +-0x1.a77c6ap+1 +0x1.53ef34p+2 +-0x1.a77c6ap+1 +-0x1.6072dcp+1 +-0x1.d792ecp-1 +-0x1.25bddcp+2 +-0x1.d792ecp-1 +-0x1.ad3daep-2 +-0x1.2db716p+2 +-0x1.ad3daep-2 +0x1.e15a14p-1 +-0x1.659434p+1 +0x1.e12fdcp-1 +-0x1.3e1dc2p+2 +0x1.e0e688p-1 +-0x1.658bd4p+1 +0x0p+0 +-0x1.2db716p+2 +0x0p+0 +-0x1.b809a4p+1 +0x1.e0bfbep-1 +-0x1.b7c054p+1 +0x1.5c664cp+2 +-0x1.d15e44p-1 +-0x1.658bd4p+1 +-0x1.d14096p-1 +-0x1.2db716p+2 +-0x1.ad3daep-2 +-0x1.2db716p+2 +-0x1.ad3daep-2 +0x1.e0bfbep-1 +-0x1.658bd4p+1 +0x1.e09a38p-1 +-0x1.3e1dc2p+2 +0x1.e05c4ep-1 +-0x1.6584cap+1 +0x0p+0 +-0x1.2db716p+2 +0x0p+0 +-0x1.b7cc4ap+1 +0x1.e03ec8p-1 +-0x1.b7cbfcp+1 +0x1.5c664cp+2 +-0x1.d106a8p-1 +-0x1.6584cap+1 +-0x1.d0ff46p-1 +-0x1.2db716p+2 +-0x1.ad3daep-2 +-0x1.2db716p+2 +-0x1.ad3daep-2 +0x1.e03ec8p-1 +-0x1.6584cap+1 +0x1.e019c2p-1 +-0x1.3e1dc2p+2 +0x1.dfe8ap-1 +-0x1.657f3cp+1 +0x0p+0 +-0x1.2db716p+2 +0x0p+0 +-0x1.b7cc14p+1 +0x1.dfd3bap-1 +-0x1.b7cfb2p+1 +0x1.5c664cp+2 +-0x1.d101bep-1 +-0x1.657f3cp+1 +-0x1.d0eaeep-1 +-0x1.2db716p+2 +-0x1.ad3daep-2 +0x1.dfd3bap-1 +-0x1.b7ce5ep+1 +0x1.5c664cp+2 +-0x1.3e1dc2p+2 +-0x1.657f3cp+1 +-0x1.d0f2e6p-1 +0x0p+0 +-0x1.2db716p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.27c1f8p+0 +0x0p+0 +0x0p+0 +-0x1.121d7ap-2 +-0x1.27c1f8p+0 +-0x1.121d7ap-2 +-0x1.416f1cp+0 +0x0p+0 +-0x1.d20356p-2 +0x0p+0 +-0x1.cf521ap-2 +-0x1.416f1cp+0 +-0x1.416f1cp+0 +0x0p+0 +-0x1.ceedd4p-2 +0x0p+0 +-0x1.cf135ep-2 +-0x1.416f1cp+0 +-0x1.416f1cp+0 +0x0p+0 +-0x1.cf059p-2 +0x0p+0 +-0x1.cf0a44p-2 +-0x1.416f1cp+0 +-0x1.cf088ep-2 +-0x1.416f1cp+0 +0x0p+0 +0x0p+0 +-0x1.bd27a8p+1 +0x1.16ac9ep-2 +-0x1.64cd96p+0 +0x0p+0 +-0x1.64cd96p+0 +-0x1.dbe0d2p+0 +-0x1.bd27a8p+1 +-0x1.dbe0d2p+0 +0x1.16ac9ep-2 +-0x1.6d7168p-1 +-0x1.4326f6p+0 +-0x1.6d7168p-1 +-0x1.b0d3bp+1 +0x1.c5084cp-2 +-0x1.9d434ap+0 +0x0p+0 +-0x1.e893b8p+0 +-0x1.9d434ap+0 +-0x1.e8351cp+0 +-0x1.b09c94p+1 +-0x1.70e3f8p-1 +0x1.c71078p-2 +-0x1.6f7768p-1 +-0x1.67bd84p+0 +-0x1.b09c94p+1 +0x1.c71078p-2 +-0x1.9d434ap+0 +0x0p+0 +-0x1.e9253ap+0 +-0x1.9d434ap+0 +-0x1.e8d2bap+0 +-0x1.b066c2p+1 +-0x1.6ff73cp-1 +0x1.c911f8p-2 +-0x1.6f24dcp-1 +-0x1.67bd84p+0 +-0x1.b066c2p+1 +0x1.c911f8p-2 +-0x1.9d434ap+0 +0x0p+0 +-0x1.e9825p+0 +-0x1.9d434ap+0 +-0x1.e94516p+0 +-0x1.b03486p+1 +-0x1.6f6edp-1 +0x1.caf05cp-2 +-0x1.6eba44p-1 +-0x1.67bd84p+0 +-0x1.e9e4c4p+0 +-0x1.b03486p+1 +0x1.caf05cp-2 +-0x1.6efa04p-1 +-0x1.67bd84p+0 +-0x1.9d434ap+0 +0x0p+0 +-0x1.0116eep+2 +-0x1.936fdap-1 +-0x1.779c3p+2 +-0x1.936fdap-1 +-0x1.867972p-1 +-0x1.06a636p+2 +-0x1.867c0ep-1 +-0x1.7c12p+2 +-0x1.867bacp-1 +-0x1.7c12p+2 +-0x1.06a636p+2 +0x1.46bfbep-12 +0x1.2d28a2p-12 +0x0p+0 +0x1.e18b3p-15 +0x1.46bfbep-12 +0x1.e18b3p-15 +0x1.2d28a2p-12 +-0x1.625f78p-7 +0x1.83054p-3 +-0x1.625f78p-7 +0x1.6e1ad8p-11 +0x1.614f34p-11 +0x1.d008dep-13 +0x1.2dc01ap-10 +0x1.0ca63ep-13 +0x0p+0 +0x1.0b30ep-13 +0x1.76ae6ep-11 +-0x1.1b9706p-6 +0x1.58ad36p-11 +-0x1.1b4e8p-6 +0x1.c87164p-3 +0x1.0a7f3ep-13 +0x1.76ae6ep-11 +0x1.58ad36p-11 +-0x1.1b6762p-6 +0x1.c87164p-3 +0x0p+0 +0x1.5ec9fep+0 +-0x1.962944p-1 +-0x1.0abde8p+2 +-0x1.962944p-1 +-0x1.acb368p-1 +0x1.6a67e2p+0 +-0x1.aca5d8p-1 +-0x1.0e9b8ap+2 +-0x1.aca8a8p-1 +-0x1.0e9b8ap+2 +0x1.6a67e2p+0 +0x1.fe6d58p-4 +0x0p+0 +0x1.54dce2p-4 +0x1.fe6d58p-4 +0x1.83982cp-5 +0x1.54dce2p-4 +0x1.f078ep-6 +0x1.83982cp-5 +0x1.32173ep-7 +0x1.f078ep-6 +-0x1.0aa2a4p-7 +0x1.32173ep-7 +-0x1.d7f4cep-6 +-0x1.0aa2a4p-7 +-0x1.83b616p-5 +-0x1.d7f4cep-6 +-0x1.58b792p-4 +-0x1.83b616p-5 +-0x1.044448p-3 +-0x1.58b792p-4 +0x0p+0 +-0x1.044448p-3 +0x0p+0 +0x1.fcf48cp-4 +0x1.fd8e1ep-4 +0x1.5fc0a8p-4 +0x1.613f7p-4 +0x1.ca38ecp-5 +0x1.cbb3f2p-5 +0x1.37577ap-5 +0x1.386bep-5 +0x1.b6ec2cp-7 +0x1.bd8806p-7 +-0x1.9f9fc4p-7 +-0x1.98575cp-7 +-0x1.2c6328p-5 +-0x1.2ac73p-5 +-0x1.c3e92ap-5 +-0x1.c2653ep-5 +-0x1.61d5f8p-4 +-0x1.6082dp-4 +-0x1.04c8fap-3 +-0x1.042b8ep-3 +0x0p+0 +0x0p+0 +0x1.fc73bp-4 +0x1.fd0132p-4 +0x1.5feeb2p-4 +0x1.616b36p-4 +0x1.ca4f46p-5 +0x1.cbf8b4p-5 +0x1.36b0d4p-5 +0x1.37f2e6p-5 +0x1.b674f4p-7 +0x1.bdb344p-7 +-0x1.9f2398p-7 +-0x1.9815ep-7 +-0x1.2bd216p-5 +-0x1.2a5a52p-5 +-0x1.c407b2p-5 +-0x1.c2b508p-5 +-0x1.62153p-4 +-0x1.60c9p-4 +-0x1.047a74p-3 +-0x1.03ddd8p-3 +0x0p+0 +0x0p+0 +0x1.fbe656p-4 +0x1.fc7428p-4 +0x1.6030ap-4 +0x1.61a614p-4 +0x1.cabf38p-5 +0x1.cc615ep-5 +0x1.36643cp-5 +0x1.379df4p-5 +0x1.b66998p-7 +0x1.bdba32p-7 +-0x1.9f6896p-7 +-0x1.983e04p-7 +-0x1.2b9728p-5 +-0x1.2a157cp-5 +-0x1.c4635ap-5 +-0x1.c30f8p-5 +-0x1.625942p-4 +-0x1.610dep-4 +-0x1.042c6p-3 +-0x1.0390cap-3 +0x0p+0 +0x1.fb54a4p-4 +0x1.606806p-4 +0x1.cb1d7ep-5 +0x1.36163cp-5 +0x1.b68f2p-7 +-0x1.9f5efep-7 +-0x1.2b5268p-5 +-0x1.c4befcp-5 +-0x1.629c1cp-4 +-0x1.03defep-3 +0x0p+0 +-0x1.e2b92p-9 +-0x1.f5cdf2p-9 +-0x1.125e9p-8 +-0x1.3e1014p-8 +-0x1.77dfdap-8 +-0x1.a6ccfap-8 +-0x1.c90abap-8 +-0x1.deb6cp-8 +-0x1.e8ef6ep-8 +-0x1.ebf6aep-8 +0x0p+0 +0x0p+0 +0x1.2f36b8p+1 +-0x1.cdcf56p-2 +-0x1.3bb7f2p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.121d7ap-2 +0x0p+0 +-0x1.27c1f8p+0 +-0x1.dbe0d2p+0 +-0x1.64cd96p+0 +-0x1.bd27a8p+1 +-0x1.d792ecp-1 +-0x1.25bddcp+2 +-0x1.6072dcp+1 +-0x1.936fdap-1 +-0x1.0116eep+2 +-0x1.779c3p+2 +0x1.e18b3p-15 +0x0p+0 +0x1.46bfbep-12 +-0x1.625f78p-7 +0x1.2d28a2p-12 +0x1.83054p-3 +-0x1.6d7168p-1 +0x1.16ac9ep-2 +-0x1.4326f6p+0 +-0x1.a77c6ap+1 +0x1.e9767p-1 +0x1.53ef34p+2 +-0x1.962944p-1 +0x1.5ec9fep+0 +-0x1.0abde8p+2 +0x1.fe6d58p-4 +0x1.54dce2p-4 +0x1.83982cp-5 +0x1.f078ep-6 +0x1.32173ep-7 +-0x1.0aa2a4p-7 +-0x1.d7f4cep-6 +-0x1.83b616p-5 +-0x1.58b792p-4 +-0x1.044448p-3 +0x0p+0 +0x1.7cc302p+1 +0x0p+0 +0x1.6c710ep+1 +0x0p+0 +0x1.53ef34p+2 +0x0p+0 +0x1.5c664cp+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.80fddep+2 +0x0p+0 +0x1.752f2ep+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.482f38p+2 +0x0p+0 +0x1.41c3fp+2 +0x0p+0 +0x1.e9767p-1 +0x0p+0 +0x1.dfd3bap-1 +0x0p+0 +0x1.647188p+2 +0x0p+0 +0x1.644076p+2 +0x0p+0 +0x1.7542cp+2 +0x0p+0 +0x1.774bdcp+2 +0x0p+0 +0x1.16ac9ep-2 +0x0p+0 +0x1.caf05cp-2 +0x0p+0 +0x1.4155f8p+2 +0x0p+0 +0x1.383054p+2 +0x0p+0 +0x1.c3cc9p+1 +0x0p+0 +0x1.bec03p+1 +0x0p+0 +0x1.572d58p+2 +0x0p+0 +0x1.58015ap+2 +0x0p+0 +0x1.482f38p+2 +0x0p+0 +0x1.41c3fp+2 +0x0p+0 +0x1.1b2782p+2 +0x0p+0 +0x1.17a684p+2 +0x0p+0 +0x1.38ec5p+2 +0x0p+0 +0x1.2acee4p+2 +0x0p+0 +0x1.6717c4p+1 +0x0p+0 +0x1.740ae6p+1 +0x0p+0 +0x1.b18768p+0 +0x0p+0 +0x1.91a28p+0 +0x0p+0 +0x1.5f5a8ep+2 +0x0p+0 +0x1.5c8aap+2 +0x0p+0 +0x1.0ec39cp+1 +0x0p+0 +0x1.070858p+1 +0x0p+0 +0x1.5ec9fep+0 +0x0p+0 +0x1.6a67e2p+0 +0x0p+0 +0x1.a8386p-2 +0x0p+0 +0x1.60db6p-2 +0x0p+0 +0x1.5fb1bap+2 +0x0p+0 +0x1.61504p+2 +0x0p+0 +0x1.c3cc9p+1 +0x0p+0 +0x1.bec03p+1 +0x0p+0 +0x1.22119p+1 +0x0p+0 +0x1.16f3p+1 +0x0p+0 +0x1.54dce2p-4 +0x0p+0 +0x1.606806p-4 +0x0p+0 +0x1.8cbcd8p+2 +0x0p+0 +0x1.8c9546p+2 +-0x1.06a6p-8 +-0x1.0f922cp-8 +-0x1.0f922cp-8 +-0x1.261b8cp-8 +-0x1.261b8cp-8 +-0x1.506c5cp-8 +-0x1.506c5cp-8 +-0x1.88984p-8 +-0x1.88984p-8 +-0x1.b59854p-8 +-0x1.b59854p-8 +-0x1.d5ea3p-8 +-0x1.d5ea3p-8 +-0x1.ea2972p-8 +-0x1.ea2972p-8 +-0x1.f3801ap-8 +-0x1.f3801ap-8 +-0x1.f62c7ap-8 +-0x1.1c7deap-8 +-0x1.237dd8p-8 +-0x1.38bf34p-8 +-0x1.073634p-8 +-0x1.23c3bp-8 +-0x1.368aa8p-8 +-0x1.5ab95ap-8 +-0x1.fed774p-9 +-0x1.366738p-8 +-0x1.5c2b8cp-8 +-0x1.8491d4p-8 +-0x1.0dae96p-8 +-0x1.5a9ae6p-8 +-0x1.9e5122p-8 +-0x1.ba8a8ap-8 +-0x1.3e7362p-8 +-0x1.9a32cp-8 +-0x1.c4ba9p-8 +-0x1.02631ap-7 +-0x1.5ab9d6p-8 +-0x1.c48296p-8 +-0x1.e07c0ep-8 +-0x1.176e9ap-7 +-0x1.76daa6p-8 +-0x1.e224p-8 +-0x1.f2b968p-8 +-0x1.1ff66ap-7 +-0x1.95a87p-8 +-0x1.f53578p-8 +-0x1.fa8a9ep-8 +-0x1.1d664p-7 +-0x1.b56beap-8 +-0x1.fd2722p-8 +-0x1.fabe3p-8 +-0x1.1121a8p-7 +-0x1.d5d4a6p-8 +-0x1.1c31aep-8 +-0x1.23ac6ep-8 +-0x1.38552p-8 +-0x1.0782ap-8 +-0x1.23e514p-8 +-0x1.3783dap-8 +-0x1.5a9352p-8 +-0x1.00ac2p-8 +-0x1.3741b2p-8 +-0x1.5f212p-8 +-0x1.84fc16p-8 +-0x1.111302p-8 +-0x1.5d4824p-8 +-0x1.9be572p-8 +-0x1.bc90bap-8 +-0x1.3cb072p-8 +-0x1.985bacp-8 +-0x1.c4a56cp-8 +-0x1.010b08p-7 +-0x1.5b7ca6p-8 +-0x1.c42cf8p-8 +-0x1.e15ed2p-8 +-0x1.16c18cp-7 +-0x1.78bf68p-8 +-0x1.e2d0e4p-8 +-0x1.f3b334p-8 +-0x1.1fca4ep-7 +-0x1.97a4a4p-8 +-0x1.f6195cp-8 +-0x1.fba546p-8 +-0x1.1d769p-7 +-0x1.b747ecp-8 +-0x1.fe2fdp-8 +-0x1.fcb2b6p-8 +-0x1.116dbap-7 +-0x1.d83888p-8 +-0x1.1bf292p-8 +-0x1.23ebe6p-8 +-0x1.37fb18p-8 +-0x1.07dcfap-8 +-0x1.2411a2p-8 +-0x1.38a38cp-8 +-0x1.5a78d4p-8 +-0x1.021298p-8 +-0x1.3843cap-8 +-0x1.613ca4p-8 +-0x1.858aa6p-8 +-0x1.13a13cp-8 +-0x1.5f3f6ap-8 +-0x1.9a4ab8p-8 +-0x1.bde1bp-8 +-0x1.3bbd16p-8 +-0x1.972a7cp-8 +-0x1.c47e86p-8 +-0x1.00047p-7 +-0x1.5c30b4p-8 +-0x1.c3daf6p-8 +-0x1.e21a8cp-8 +-0x1.16161ep-7 +-0x1.7a7dap-8 +-0x1.e35d8p-8 +-0x1.f4a446p-8 +-0x1.1f90bp-7 +-0x1.9992ecp-8 +-0x1.f6f03p-8 +-0x1.fccba8p-8 +-0x1.1d8038p-7 +-0x1.b92fe6p-8 +-0x1.ff43bep-8 +-0x1.fe86b6p-8 +-0x1.11c064p-7 +-0x1.da7a08p-8 +-0x1.1bc642p-8 +-0x1.24354ep-8 +-0x1.39c7cap-8 +-0x1.62cbe4p-8 +-0x1.9940cap-8 +-0x1.c454d6p-8 +-0x1.e2ba7cp-8 +-0x1.f588cp-8 +-0x1.fdfb48p-8 +-0x1.001e2ep-7 +0x0p+0 +0x0p+0 +0x1.7ce814p+1 +-0x1.ad3daep-2 +0x1.dfd3bap-1 +-0x1.657f3cp+1 +0x1.dfd3bap-1 +-0x1.3e1dc2p+2 +0x1.dfd3bap-1 +-0x1.657f3cp+1 +0x0p+0 +0x1.dfd3bap-1 +-0x1.b7ce5ep+1 +0x1.5c664cp+2 +-0x1.b7ce5ep+1 +-0x1.657f3cp+1 +-0x1.d0f2e6p-1 +-0x1.2db716p+2 +-0x1.d0f2e6p-1 +-0x1.95ad7p-2 +0x1.d6894ep-1 +-0x1.6c9dap+1 +0x1.d667fcp-1 +-0x1.408392p+2 +0x1.d62c8ep-1 +-0x1.6c9814p+1 +0x0p+0 +-0x1.c812d2p+1 +0x1.d62c8ep-1 +-0x1.c80688p+1 +0x1.64dd64p+2 +-0x1.cc9c6ep-1 +-0x1.6c9814p+1 +-0x1.cd2382p-1 +-0x1.35b05p+2 +-0x1.95ad7p-2 +0x1.d62c8ep-1 +-0x1.6c9814p+1 +0x1.d6094p-1 +-0x1.408392p+2 +0x1.d5e686p-1 +-0x1.6c94d6p+1 +0x0p+0 +-0x1.c7fcdcp+1 +0x1.d5e686p-1 +-0x1.c80512p+1 +0x1.64dd64p+2 +-0x1.ccf316p-1 +-0x1.6c94d6p+1 +-0x1.ccf512p-1 +-0x1.35b05p+2 +-0x1.95ad7p-2 +0x1.d5e686p-1 +-0x1.6c94d6p+1 +0x1.d5c008p-1 +-0x1.408392p+2 +0x1.d5af0cp-1 +-0x1.6c9342p+1 +0x0p+0 +-0x1.c80212p+1 +0x1.d5af0cp-1 +-0x1.c805e2p+1 +0x1.64dd64p+2 +-0x1.ccf426p-1 +-0x1.6c9342p+1 +-0x1.ccecc6p-1 +-0x1.35b05p+2 +-0x1.95ad7p-2 +0x1.d5af0cp-1 +-0x1.c80472p+1 +0x1.64dd64p+2 +-0x1.408392p+2 +-0x1.6c9342p+1 +-0x1.ccef52p-1 +-0x1.35b05p+2 +0x0p+0 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.cf088ep-2 +-0x1.416f1cp+0 +-0x1.cf088ep-2 +-0x1.45e144p-1 +0x0p+0 +-0x1.44b98cp-1 +-0x1.5b1c4p+0 +-0x1.447da8p-1 +0x0p+0 +-0x1.44941ep-1 +-0x1.5b1c4p+0 +-0x1.448bbp-1 +0x0p+0 +-0x1.448ec8p-1 +-0x1.5b1c4p+0 +-0x1.448d96p-1 +-0x1.5b1c4p+0 +0x0p+0 +-0x1.b03486p+1 +0x1.c87164p-3 +-0x1.b03486p+1 +0x1.caf05cp-2 +0x1.c87164p-3 +0x1.caf05cp-2 +0x1.76ae6ep-11 +0x1.58ad36p-11 +-0x1.9d434ap+0 +-0x1.e9e4c4p+0 +-0x1.b03486p+1 +-0x1.e9e4c4p+0 +0x1.caf05cp-2 +-0x1.6efa04p-1 +-0x1.67bd84p+0 +-0x1.6efa04p-1 +0x1.c87164p-3 +-0x1.1b6762p-6 +0x1.58ad36p-11 +-0x1.1b6762p-6 +0x1.76ae6ep-11 +0x1.0a7f3ep-13 +0x0p+0 +0x1.0a7f3ep-13 +-0x1.90c62cp+1 +0x1.b9cdap-3 +-0x1.900cp+1 +0x1.0b3936p-1 +0x1.8b20eep-3 +0x1.0b3936p-1 +0x1.31929cp-8 +0x1.2dd236p-8 +0x1.1dd42ep-8 +0x1.4192a6p-8 +-0x1.f3395p+0 +-0x1.d5b8fep+0 +-0x1.f3214ap+0 +-0x1.900cp+1 +-0x1.7b7e3ep-1 +0x1.03638p-1 +-0x1.7e8e7ap-1 +-0x1.8c5412p+0 +-0x1.a32966p-4 +0x1.97ba82p-3 +-0x1.d2725ep-4 +0x1.2d77a8p-8 +0x1.d7623ap-11 +0x1.31ee12p-8 +0x1.e24fb2p-11 +0x0p+0 +-0x1.900cp+1 +0x1.97ba82p-3 +-0x1.8f6b74p+1 +0x1.03638p-1 +0x1.700324p-3 +0x1.03638p-1 +0x1.31ee12p-8 +0x1.2d77a8p-8 +0x1.05240ep-8 +0x1.5a5702p-8 +-0x1.f3efe8p+0 +-0x1.d5b8fep+0 +-0x1.f3a84ap+0 +-0x1.8f6b74p+1 +-0x1.7d7ab4p-1 +0x1.f9629cp-2 +-0x1.80429ep-1 +-0x1.8c5412p+0 +-0x1.c1d848p-4 +0x1.7cdd34p-3 +-0x1.ea2fa8p-4 +0x1.2c3d64p-8 +0x1.ddc128p-11 +0x1.33435cp-8 +0x1.dda89ap-11 +0x0p+0 +-0x1.8f6b74p+1 +0x1.7cdd34p-3 +-0x1.8ee0bap+1 +0x1.f9629cp-2 +0x1.5accb4p-3 +0x1.f9629cp-2 +0x1.33435cp-8 +0x1.2c3d64p-8 +0x1.eb7abap-9 +0x1.69f6dep-8 +-0x1.f46db6p+0 +-0x1.d5b8fep+0 +-0x1.f42952p+0 +-0x1.8ee0bap+1 +-0x1.7f4882p-1 +0x1.edd376p-2 +-0x1.81ad96p-1 +-0x1.8c5412p+0 +-0x1.dc4542p-4 +0x1.675f3p-3 +-0x1.fe0a92p-4 +0x1.2ab2dp-8 +0x1.dd5dbap-11 +0x1.3517b4p-8 +0x1.dba2e6p-11 +0x0p+0 +-0x1.f4d3acp+0 +-0x1.8ee0bap+1 +0x1.edd376p-2 +-0x1.80d5d4p-1 +-0x1.8c5412p+0 +0x1.675f3p-3 +-0x1.f27ea2p-4 +0x1.2ab2dp-8 +0x1.3517b4p-8 +0x1.dc79b6p-11 +0x0p+0 +-0x1.d5b8fep+0 +-0x1.06a636p+2 +-0x1.867bacp-1 +-0x1.7c12p+2 +-0x1.867bacp-1 +-0x1.79864p-1 +-0x1.0c357ep+2 +-0x1.798888p-1 +-0x1.8087dp+2 +-0x1.79882ap-1 +-0x1.8087dp+2 +-0x1.0c357ep+2 +0x1.6a67e2p+0 +-0x1.aca8a8p-1 +-0x1.0e9b8ap+2 +-0x1.aca8a8p-1 +-0x1.c32d9cp-1 +0x1.7605c6p+0 +-0x1.c32p-1 +-0x1.12792cp+2 +-0x1.c3225ep-1 +-0x1.12792cp+2 +0x1.7605c6p+0 +0x1.fb54a4p-4 +0x0p+0 +0x1.606806p-4 +0x1.fb54a4p-4 +0x1.cb1d7ep-5 +0x1.606806p-4 +0x1.36163cp-5 +0x1.cb1d7ep-5 +0x1.b68f2p-7 +0x1.36163cp-5 +-0x1.9f5efep-7 +0x1.b68f2p-7 +-0x1.2b5268p-5 +-0x1.9f5efep-7 +-0x1.c4befcp-5 +-0x1.2b5268p-5 +-0x1.629c1cp-4 +-0x1.c4befcp-5 +-0x1.03defep-3 +-0x1.629c1cp-4 +0x0p+0 +-0x1.03defep-3 +0x0p+0 +0x1.f8677ap-4 +0x1.f90546p-4 +0x1.6c983cp-4 +0x1.6dfd8ep-4 +0x1.0b56a8p-4 +0x1.0bf3e2p-4 +0x1.71644ep-5 +0x1.72da4cp-5 +0x1.1e51e8p-6 +0x1.227c9ap-6 +-0x1.1a3ea8p-6 +-0x1.150932p-6 +-0x1.687664p-5 +-0x1.66a862p-5 +-0x1.04f2bap-4 +-0x1.042342p-4 +-0x1.6d6472p-4 +-0x1.6c35d4p-4 +-0x1.036cbp-3 +-0x1.02cd2ap-3 +0x0p+0 +0x0p+0 +0x1.f7ecfp-4 +0x1.f879a4p-4 +0x1.6cd85ap-4 +0x1.6e3bfcp-4 +0x1.0b30bep-4 +0x1.0bea9cp-4 +0x1.70da74p-5 +0x1.727b8ap-5 +0x1.1d70c8p-6 +0x1.21f5b4p-6 +-0x1.19612cp-6 +-0x1.145006p-6 +-0x1.67f75ap-5 +-0x1.6649bep-5 +-0x1.04d72ap-4 +-0x1.04248ap-4 +-0x1.6db87cp-4 +-0x1.6c92ccp-4 +-0x1.031d28p-3 +-0x1.027e9p-3 +0x0p+0 +0x0p+0 +0x1.f761fp-4 +0x1.f7ee68p-4 +0x1.6d3152p-4 +0x1.6e8cb2p-4 +0x1.0b3cep-4 +0x1.0bf3f6p-4 +0x1.70aaf6p-5 +0x1.7241bp-5 +0x1.1cce1p-6 +0x1.215f98p-6 +-0x1.18e6f2p-6 +-0x1.13cd12p-6 +-0x1.67d17ep-5 +-0x1.6616fcp-5 +-0x1.04e19cp-4 +-0x1.042e6cp-4 +-0x1.6e12dep-4 +-0x1.6ced7p-4 +-0x1.02ce1ep-3 +-0x1.0230dcp-3 +0x0p+0 +0x1.f6d1aap-4 +0x1.6d7e4ep-4 +0x1.0b4102p-4 +0x1.707828p-5 +0x1.1c4764p-6 +-0x1.18484ap-6 +-0x1.679d64p-5 +-0x1.04ecb4p-4 +-0x1.6e6b6ap-4 +-0x1.027fa6p-3 +0x0p+0 +-0x1.06a6p-8 +-0x1.0f922cp-8 +-0x1.261b8cp-8 +-0x1.506c5cp-8 +-0x1.88984p-8 +-0x1.b59854p-8 +-0x1.d5ea3p-8 +-0x1.ea2972p-8 +-0x1.f3801ap-8 +-0x1.f62c7ap-8 +0x0p+0 +0x0p+0 +0x1.560f66p+1 +-0x1.ad3daep-2 +-0x1.3e1dc2p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.cf088ep-2 +0x0p+0 +-0x1.416f1cp+0 +-0x1.e9e4c4p+0 +-0x1.9d434ap+0 +-0x1.b03486p+1 +-0x1.d0f2e6p-1 +-0x1.2db716p+2 +-0x1.657f3cp+1 +-0x1.867bacp-1 +-0x1.06a636p+2 +-0x1.7c12p+2 +0x1.0a7f3ep-13 +0x0p+0 +0x1.76ae6ep-11 +-0x1.1b6762p-6 +0x1.58ad36p-11 +0x1.c87164p-3 +-0x1.6efa04p-1 +0x1.caf05cp-2 +-0x1.67bd84p+0 +-0x1.b7ce5ep+1 +0x1.dfd3bap-1 +0x1.5c664cp+2 +-0x1.aca8a8p-1 +0x1.6a67e2p+0 +-0x1.0e9b8ap+2 +0x1.fb54a4p-4 +0x1.606806p-4 +0x1.cb1d7ep-5 +0x1.36163cp-5 +0x1.b68f2p-7 +-0x1.9f5efep-7 +-0x1.2b5268p-5 +-0x1.c4befcp-5 +-0x1.629c1cp-4 +-0x1.03defep-3 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.2acee4p+2 +0x0p+0 +0x1.1cb176p+2 +0x0p+0 +0x1.6c710ep+1 +0x0p+0 +0x1.5c3afap+1 +0x0p+0 +0x1.5c664cp+2 +0x0p+0 +0x1.64dd64p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.752f2ep+2 +0x0p+0 +0x1.698e04p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.41c3fp+2 +0x0p+0 +0x1.3b58a6p+2 +0x0p+0 +0x1.dfd3bap-1 +0x0p+0 +0x1.d5af0cp-1 +0x0p+0 +0x1.644076p+2 +0x0p+0 +0x1.6204fcp+2 +0x0p+0 +0x1.774bdcp+2 +0x0p+0 +0x1.78c4ep+2 +0x0p+0 +0x1.caf05cp-2 +0x0p+0 +0x1.edd376p-2 +0x0p+0 +0x1.383054p+2 +0x0p+0 +0x1.2f0ab2p+2 +0x0p+0 +0x1.bec03p+1 +0x0p+0 +0x1.b7ac2ap+1 +0x0p+0 +0x1.58015ap+2 +0x0p+0 +0x1.5881ccp+2 +0x0p+0 +0x1.17a684p+2 +0x0p+0 +0x1.14eaccp+2 +0x0p+0 +0x1.2acee4p+2 +0x0p+0 +0x1.1cb176p+2 +0x0p+0 +0x1.740ae6p+1 +0x0p+0 +0x1.955eb2p+1 +0x0p+0 +0x1.91a28p+0 +0x0p+0 +0x1.71bd98p+0 +0x0p+0 +0x1.5c8aap+2 +0x0p+0 +0x1.59bb6ap+2 +0x0p+0 +0x1.070858p+1 +0x0p+0 +0x1.fe9a28p+0 +0x0p+0 +0x1.6a67e2p+0 +0x0p+0 +0x1.7605c6p+0 +0x0p+0 +0x1.60db6p-2 +0x0p+0 +0x1.197e6p-2 +0x0p+0 +0x1.3d2cep-2 +0x0p+0 +0x1.32d05ep-2 +0x0p+0 +0x1.61504p+2 +0x0p+0 +0x1.62eebp+2 +0x0p+0 +0x1.bec03p+1 +0x0p+0 +0x1.b7ac2ap+1 +0x0p+0 +0x1.16f3p+1 +0x0p+0 +0x1.0bd47p+1 +0x0p+0 +0x1.606806p-4 +0x0p+0 +0x1.6d7e4ep-4 +0x0p+0 +0x1.8c9546p+2 +0x0p+0 +0x1.8c6608p+2 +0x0p+0 +-0x1.7ef2bp+2 +-0x1.7ef2bp+2 +0x0p+0 +-0x1.7e5bd4p+2 +0x0p+0 +-0x1.7e367p+2 +0x0p+0 +0x0p+0 +-0x1.806512p+2 +-0x1.7e367p+2 +0x0p+0 +0x1.3e946p-2 +0x0p+0 +0x1.1baa4p-2 +-0x1.1bc642p-8 +-0x1.24354ep-8 +-0x1.24354ep-8 +-0x1.39c7cap-8 +-0x1.39c7cap-8 +-0x1.62cbe4p-8 +-0x1.62cbe4p-8 +-0x1.9940cap-8 +-0x1.9940cap-8 +-0x1.c454d6p-8 +-0x1.c454d6p-8 +-0x1.e2ba7cp-8 +-0x1.e2ba7cp-8 +-0x1.f588cp-8 +-0x1.f588cp-8 +-0x1.fdfb48p-8 +-0x1.fdfb48p-8 +-0x1.001e2ep-7 +-0x1.319e2cp-8 +-0x1.3820fap-8 +-0x1.4d4096p-8 +-0x1.1c789ep-8 +-0x1.387424p-8 +-0x1.4a36e6p-8 +-0x1.6e1ddcp-8 +-0x1.146502p-8 +-0x1.4a26b6p-8 +-0x1.6e8b14p-8 +-0x1.964aeap-8 +-0x1.2215c2p-8 +-0x1.6d0efep-8 +-0x1.aef9acp-8 +-0x1.ca3a9p-8 +-0x1.51e1eap-8 +-0x1.aaf85cp-8 +-0x1.d37712p-8 +-0x1.090fc6p-7 +-0x1.6ce37cp-8 +-0x1.d35b72p-8 +-0x1.ed4c5ap-8 +-0x1.1cf08cp-7 +-0x1.877bdap-8 +-0x1.ef058cp-8 +-0x1.fe18b6p-8 +-0x1.248c7p-7 +-0x1.a4b5dp-8 +-0x1.0049b6p-7 +-0x1.0282e6p-7 +-0x1.219a9cp-7 +-0x1.c2d61ap-8 +-0x1.03cbfcp-7 +-0x1.02670ap-7 +-0x1.158582p-7 +-0x1.e189eep-8 +-0x1.314528p-8 +-0x1.384abp-8 +-0x1.4ccb58p-8 +-0x1.1cbe8cp-8 +-0x1.3889a8p-8 +-0x1.4b2eccp-8 +-0x1.6dedccp-8 +-0x1.15a246p-8 +-0x1.4afe4p-8 +-0x1.7177fcp-8 +-0x1.96b784p-8 +-0x1.256c48p-8 +-0x1.6fb314p-8 +-0x1.ac8b16p-8 +-0x1.cc3766p-8 +-0x1.501c36p-8 +-0x1.a91eaap-8 +-0x1.d35ef8p-8 +-0x1.07ba24p-7 +-0x1.6d9bd8p-8 +-0x1.d301ccp-8 +-0x1.ee2db2p-8 +-0x1.1c4642p-7 +-0x1.8955b4p-8 +-0x1.efaff8p-8 +-0x1.ff0bdep-8 +-0x1.2466ap-7 +-0x1.a69c78p-8 +-0x1.00b8dp-7 +-0x1.030a4cp-7 +-0x1.21ae02p-7 +-0x1.c49a88p-8 +-0x1.044c08p-7 +-0x1.035dcep-7 +-0x1.15d16ep-7 +-0x1.e3dea4p-8 +-0x1.310044p-8 +-0x1.387ff2p-8 +-0x1.4c6714p-8 +-0x1.1d1326p-8 +-0x1.38b0dp-8 +-0x1.4c4c3p-8 +-0x1.6dcbdcp-8 +-0x1.17088p-8 +-0x1.4bfe36p-8 +-0x1.7389fap-8 +-0x1.974182p-8 +-0x1.27f38p-8 +-0x1.719e0ep-8 +-0x1.aaeee2p-8 +-0x1.cd7fccp-8 +-0x1.4f239ap-8 +-0x1.a7ea74p-8 +-0x1.d3355ap-8 +-0x1.06b5cap-7 +-0x1.6e45aap-8 +-0x1.d2abfcp-8 +-0x1.eee678p-8 +-0x1.1b9e9ep-7 +-0x1.8b05a6p-8 +-0x1.f03acep-8 +-0x1.fff46p-8 +-0x1.24331cp-7 +-0x1.a8745ep-8 +-0x1.012178p-7 +-0x1.039a82p-7 +-0x1.21bc74p-7 +-0x1.c66d9cp-8 +-0x1.04d278p-7 +-0x1.04431cp-7 +-0x1.1624a2p-7 +-0x1.e60eb4p-8 +-0x1.30c96p-8 +-0x1.38c3dp-8 +-0x1.4d713cp-8 +-0x1.750e6ep-8 +-0x1.a9e316p-8 +-0x1.d306f6p-8 +-0x1.ef821p-8 +-0x1.006a68p-7 +-0x1.042d18p-7 +-0x1.051b0ep-7 +0x0p+0 +0x0p+0 +-0x1.d5b8fep+0 +-0x1.5b1c4p+0 +-0x1.d5b8fep+0 +-0x1.d5b8fep+0 +0x0p+0 +-0x1.8ee0bap+1 +0x1.675f3p-3 +0x1.675f3p-3 +0x1.edd376p-2 +0x1.3517b4p-8 +0x1.2ab2dp-8 +-0x1.d5b8fep+0 +-0x1.f4d3acp+0 +-0x1.8ee0bap+1 +-0x1.f4d3acp+0 +0x1.675f3p-3 +-0x1.f27ea2p-4 +0x1.2ab2dp-8 +-0x1.f27ea2p-4 +0x1.3517b4p-8 +0x1.dc79b6p-11 +0x0p+0 +0x1.dc79b6p-11 +0x1.edd376p-2 +-0x1.80d5d4p-1 +-0x1.8c5412p+0 +-0x1.80d5d4p-1 +-0x1.5b1c4p+0 +-0x1.448d96p-1 +0x0p+0 +-0x1.448d96p-1 +-0x1.fb2802p-3 +-0x1.da97ep+0 +-0x1.45bec4p+0 +-0x1.da8bb6p+0 +-0x1.407a84p+0 +-0x1.d835f8p+0 +-0x1.d835f8p+0 +0x0p+0 +-0x1.6ec9ep+1 +0x1.75ca02p-3 +0x1.5d6d4ep-3 +0x1.1a980ap-1 +0x1.435ccap-7 +0x1.3e2a5cp-7 +0x1.1e34f6p-7 +0x1.637dep-7 +-0x1.007b92p+1 +-0x1.d835f8p+0 +-0x1.013d26p+1 +-0x1.6e756ep+1 +-0x1.aea466p-3 +0x1.699594p-3 +-0x1.b65ebp-3 +0x1.3d647ap-7 +0x1.fc3384p-10 +0x1.4464e6p-7 +0x1.e96c46p-10 +0x0p+0 +-0x1.8ec13ap-1 +0x1.15f7f2p-1 +-0x1.90ccb6p-1 +-0x1.b0eaap+0 +-0x1.8e2ae2p-1 +-0x1.407a84p+0 +-0x1.8c57ecp-1 +0x0p+0 +-0x1.fb2802p-3 +-0x1.d835f8p+0 +-0x1.407a84p+0 +-0x1.d835f8p+0 +-0x1.3c3cc8p+0 +-0x1.d65b5p+0 +-0x1.d65b5p+0 +0x0p+0 +-0x1.6e756ep+1 +0x1.699594p-3 +0x1.5433ccp-3 +0x1.15f7f2p-1 +0x1.4464e6p-7 +0x1.3d647ap-7 +0x1.2bfbe4p-7 +0x1.55e948p-7 +-0x1.012f44p+1 +-0x1.d65b5p+0 +-0x1.01dd4ep+1 +-0x1.6e2da6p+1 +-0x1.b30c26p-3 +0x1.5efa9p-3 +-0x1.bbf5dap-3 +0x1.3d521ep-7 +0x1.efd9bep-10 +0x1.44a59cp-7 +0x1.ed1c48p-10 +0x0p+0 +-0x1.90125ep-1 +0x1.121156p-1 +-0x1.91ea12p-1 +-0x1.b0eaap+0 +-0x1.8c50fap-1 +-0x1.3c3cc8p+0 +-0x1.8a8e6ap-1 +0x0p+0 +-0x1.fb2802p-3 +-0x1.d65b5p+0 +-0x1.3c3cc8p+0 +-0x1.d65b5p+0 +-0x1.38cea8p+0 +-0x1.d4e18cp+0 +-0x1.d4e18cp+0 +0x0p+0 +-0x1.6e2da6p+1 +0x1.5efa9p-3 +0x1.4bd10cp-3 +0x1.121156p-1 +0x1.44a59cp-7 +0x1.3d521ep-7 +0x1.3114dep-7 +0x1.50faaap-7 +-0x1.01da36p+1 +-0x1.d4e18cp+0 +-0x1.026bf6p+1 +-0x1.6dee76p+1 +-0x1.b8f608p-3 +0x1.555fa8p-3 +-0x1.c0bfeep-3 +0x1.3d79cap-7 +0x1.ee4a18p-10 +0x1.44a77ep-7 +0x1.ecd676p-10 +0x0p+0 +-0x1.9142eep-1 +0x1.0ec024p-1 +-0x1.92d3fep-1 +-0x1.b0eaap+0 +-0x1.8b2fd4p-1 +-0x1.38cea8p+0 +-0x1.8985e4p-1 +0x0p+0 +-0x1.fb2802p-3 +-0x1.d4e18cp+0 +-0x1.026d02p+1 +-0x1.6dee76p+1 +0x1.555fa8p-3 +-0x1.be20a4p-3 +0x1.3d79cap-7 +0x1.44a77ep-7 +0x1.ed91a4p-10 +0x0p+0 +0x1.0ec024p-1 +-0x1.9245aep-1 +-0x1.b0eaap+0 +0x0p+0 +-0x1.38cea8p+0 +-0x1.8a1c88p-1 +0x0p+0 +0x1.a3c0c2p+1 +-0x1.95ad7p-2 +0x1.64dd64p+2 +-0x1.95ad7p-2 +0x1.d5af0cp-1 +-0x1.6c9342p+1 +0x1.d5af0cp-1 +-0x1.6c9342p+1 +0x0p+0 +0x1.d5af0cp-1 +-0x1.c80472p+1 +0x1.64dd64p+2 +-0x1.c80472p+1 +-0x1.6c9342p+1 +-0x1.ccef52p-1 +-0x1.35b05p+2 +-0x1.ccef52p-1 +-0x1.a37df4p-1 +0x1.68e7d4p+2 +-0x1.a37df4p-1 +0x1.c1c45cp-1 +-0x1.7591d2p+1 +0x1.c1c45cp-1 +-0x1.7591d2p+1 +0x0p+0 +-0x1.d6027p+1 +0x1.c1c45cp-1 +-0x1.d587f8p+1 +0x1.68a92ap+2 +-0x1.cb7868p-1 +-0x1.7591d2p+1 +-0x1.cadfc4p-1 +-0x1.3da98ap+2 +-0x1.a37df4p-1 +0x1.68a92ap+2 +-0x1.a37df4p-1 +0x1.c1c45cp-1 +-0x1.7591d2p+1 +0x1.c1c45cp-1 +-0x1.7591d2p+1 +0x0p+0 +-0x1.d61d3ap+1 +0x1.c1c45cp-1 +-0x1.d5e73cp+1 +0x1.68779ep+2 +-0x1.cb169ap-1 +-0x1.7591d2p+1 +-0x1.cb02eap-1 +-0x1.3da98ap+2 +-0x1.a37df4p-1 +0x1.68779ep+2 +-0x1.a37df4p-1 +0x1.c1c45cp-1 +-0x1.7591d2p+1 +0x1.c1c1aep-1 +-0x1.7591d2p+1 +0x0p+0 +-0x1.d5e03ap+1 +0x1.c1c1aep-1 +-0x1.d5e2cep+1 +0x1.68501ep+2 +-0x1.cb09dep-1 +-0x1.7591d2p+1 +-0x1.cb078p-1 +-0x1.3da98ap+2 +-0x1.a37df4p-1 +0x1.c1c1aep-1 +-0x1.d5ccb2p+1 +-0x1.7591d2p+1 +-0x1.cb085ap-1 +-0x1.3da98ap+2 +0x0p+0 +0x1.68501ep+2 +-0x1.42e962p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.806512p+2 +0x0p+0 +-0x1.0c357ep+2 +-0x1.79882ap-1 +-0x1.806512p+2 +-0x1.79882ap-1 +-0x1.879d64p+2 +0x0p+0 +-0x1.840b04p-1 +-0x1.11c4c6p+2 +-0x1.83fadp-1 +-0x1.879d64p+2 +-0x1.879d64p+2 +0x0p+0 +-0x1.8fdbbep-1 +-0x1.11c4c6p+2 +-0x1.8b8a2p-1 +-0x1.879d64p+2 +-0x1.879d64p+2 +0x0p+0 +-0x1.8d1a82p-1 +-0x1.11c4c6p+2 +-0x1.8c8a02p-1 +-0x1.879d64p+2 +-0x1.8cbe42p-1 +-0x1.879d64p+2 +0x0p+0 +-0x1.11c4c6p+2 +0x1.7605c6p+0 +-0x1.c3225ep-1 +-0x1.12792cp+2 +-0x1.c3225ep-1 +-0x1.d9a226p-1 +0x1.81a3aap+0 +-0x1.d9949ep-1 +-0x1.1656cep+2 +-0x1.d9972ep-1 +-0x1.1656cep+2 +0x1.81a3aap+0 +0x1.f6d1aap-4 +0x0p+0 +0x1.6d7e4ep-4 +0x1.f6d1aap-4 +0x1.0b4102p-4 +0x1.6d7e4ep-4 +0x1.707828p-5 +0x1.0b4102p-4 +0x1.1c4764p-6 +0x1.707828p-5 +-0x1.18484ap-6 +0x1.1c4764p-6 +-0x1.679d64p-5 +-0x1.18484ap-6 +-0x1.04ecb4p-4 +-0x1.679d64p-5 +-0x1.6e6b6ap-4 +-0x1.04ecb4p-4 +-0x1.027fa6p-3 +-0x1.6e6b6ap-4 +0x0p+0 +-0x1.027fa6p-3 +0x0p+0 +0x1.f2a2a2p-4 +0x1.f3416ep-4 +0x1.7bdb46p-4 +0x1.7d18ccp-4 +0x1.3195a6p-4 +0x1.3218ccp-4 +0x1.a92be8p-5 +0x1.ab11d8p-5 +0x1.5942f4p-6 +0x1.5e76b6p-6 +-0x1.5c3eccp-6 +-0x1.556dd4p-6 +-0x1.a23488p-5 +-0x1.a01d9ap-5 +-0x1.286c64p-4 +-0x1.278af6p-4 +-0x1.7bc2e6p-4 +-0x1.7abb14p-4 +-0x1.011c12p-3 +-0x1.008184p-3 +0x0p+0 +0x0p+0 +0x1.f23418p-4 +0x1.f2bb7p-4 +0x1.7c2708p-4 +0x1.7d6586p-4 +0x1.313c36p-4 +0x1.31df7ep-4 +0x1.a8bf7cp-5 +0x1.aad0fcp-5 +0x1.57c9bp-6 +0x1.5d59ap-6 +-0x1.5ad0aap-6 +-0x1.54254cp-6 +-0x1.a1c6eep-5 +-0x1.9fcda8p-5 +-0x1.28243cp-4 +-0x1.276312p-4 +-0x1.7c2268p-4 +-0x1.7b274p-4 +-0x1.00cf2ep-3 +-0x1.003548p-3 +0x0p+0 +0x0p+0 +0x1.f1b204p-4 +0x1.f2370ep-4 +0x1.7c9092p-4 +0x1.7dc684p-4 +0x1.3119dcp-4 +0x1.31baeep-4 +0x1.a8ad16p-5 +0x1.aab2a4p-5 +0x1.569634p-6 +0x1.5c3172p-6 +-0x1.59c546p-6 +-0x1.5313eap-6 +-0x1.a1b4a4p-5 +-0x1.9fac2ep-5 +-0x1.280a98p-4 +-0x1.274808p-4 +-0x1.7c8ad6p-4 +-0x1.7b900ep-4 +-0x1.008286p-3 +-0x1.ffd436p-4 +0x0p+0 +0x1.f12912p-4 +0x1.7ced12p-4 +0x1.30f088p-4 +0x1.a8936ap-5 +0x1.5580e6p-6 +-0x1.589724p-6 +-0x1.a18e68p-5 +-0x1.27f21p-4 +-0x1.7cf146p-4 +-0x1.0036bcp-3 +0x0p+0 +-0x1.1bc642p-8 +-0x1.24354ep-8 +-0x1.39c7cap-8 +-0x1.62cbe4p-8 +-0x1.9940cap-8 +-0x1.c454d6p-8 +-0x1.e2ba7cp-8 +-0x1.f588cp-8 +-0x1.fdfb48p-8 +-0x1.001e2ep-7 +0x0p+0 +0x0p+0 +0x1.7ce814p+1 +-0x1.95ad7p-2 +-0x1.408392p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.448d96p-1 +0x0p+0 +-0x1.5b1c4p+0 +-0x1.f4d3acp+0 +-0x1.d5b8fep+0 +-0x1.8ee0bap+1 +-0x1.ccef52p-1 +-0x1.35b05p+2 +-0x1.6c9342p+1 +-0x1.79882ap-1 +-0x1.0c357ep+2 +-0x1.806512p+2 +0x1.dc79b6p-11 +0x0p+0 +0x1.3517b4p-8 +-0x1.f27ea2p-4 +0x1.2ab2dp-8 +0x1.675f3p-3 +-0x1.80d5d4p-1 +0x1.edd376p-2 +-0x1.8c5412p+0 +-0x1.c80472p+1 +0x1.d5af0cp-1 +0x1.64dd64p+2 +-0x1.c3225ep-1 +0x1.7605c6p+0 +-0x1.12792cp+2 +0x1.f6d1aap-4 +0x1.6d7e4ep-4 +0x1.0b4102p-4 +0x1.707828p-5 +0x1.1c4764p-6 +-0x1.18484ap-6 +-0x1.679d64p-5 +-0x1.04ecb4p-4 +-0x1.6e6b6ap-4 +-0x1.027fa6p-3 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +-0x1.fb2802p-3 +0x0p+0 +0x1.1cb176p+2 +0x0p+0 +0x1.1ce754p+2 +0x0p+0 +0x1.5c3afap+1 +0x0p+0 +0x1.4e72bap+1 +0x0p+0 +0x1.64dd64p+2 +0x0p+0 +0x1.68501ep+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.698e04p+2 +0x0p+0 +0x1.60dc24p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.3b58a6p+2 +0x0p+0 +0x1.43ec0cp+2 +0x0p+0 +0x1.d5af0cp-1 +0x0p+0 +0x1.c1c1aep-1 +0x0p+0 +0x1.6204fcp+2 +0x0p+0 +0x1.5fd7p+2 +0x0p+0 +0x1.78c4ep+2 +0x0p+0 +0x1.5daff8p+2 +0x0p+0 +0x1.edd376p-2 +0x0p+0 +0x1.0ec024p-1 +0x0p+0 +0x1.2f0ab2p+2 +0x0p+0 +0x1.25e50ep+2 +0x0p+0 +0x1.b7ac2ap+1 +0x0p+0 +0x1.aead9ap+1 +0x0p+0 +0x1.5881ccp+2 +0x0p+0 +0x1.58beaap+2 +0x0p+0 +0x1.14eaccp+2 +0x0p+0 +0x1.10e934p+2 +0x0p+0 +0x1.1cb176p+2 +0x0p+0 +0x1.1ce754p+2 +0x0p+0 +0x1.955eb2p+1 +0x0p+0 +0x1.b650f6p+1 +0x0p+0 +0x1.71bd98p+0 +0x0p+0 +0x1.51d8bp+0 +0x0p+0 +0x1.59bb6ap+2 +0x0p+0 +0x1.56ecdp+2 +0x0p+0 +0x1.fe9a28p+0 +0x0p+0 +0x1.ef23ap+0 +0x0p+0 +0x1.7605c6p+0 +0x0p+0 +0x1.81a3aap+0 +0x0p+0 +0x1.1baa4p-2 +0x0p+0 +0x1.504a4p-3 +0x0p+0 +0x1.62eebp+2 +0x0p+0 +0x1.6087eep+2 +0x0p+0 +0x1.0bd47p+1 +0x0p+0 +0x1.00b5ep+1 +0x0p+0 +0x1.6d7e4ep-4 +0x0p+0 +0x1.7ced12p-4 +0x0p+0 +0x1.8c6608p+2 +0x0p+0 +0x1.8c2bfp+2 +-0x1.30c96p-8 +-0x1.38c3dp-8 +-0x1.38c3dp-8 +-0x1.4d713cp-8 +-0x1.4d713cp-8 +-0x1.750e6ep-8 +-0x1.750e6ep-8 +-0x1.a9e316p-8 +-0x1.a9e316p-8 +-0x1.d306f6p-8 +-0x1.d306f6p-8 +-0x1.ef821p-8 +-0x1.ef821p-8 +-0x1.006a68p-7 +-0x1.006a68p-7 +-0x1.042d18p-7 +-0x1.042d18p-7 +-0x1.051b0ep-7 +-0x1.46a14ap-8 +-0x1.4caf7cp-8 +-0x1.61a762p-8 +-0x1.31a3dap-8 +-0x1.4d0afp-8 +-0x1.5de058p-8 +-0x1.816c5ep-8 +-0x1.2957d2p-8 +-0x1.5de02p-8 +-0x1.80cd9ep-8 +-0x1.a7fe32p-8 +-0x1.365fcap-8 +-0x1.7f69bap-8 +-0x1.bf9bf8p-8 +-0x1.d9d86ep-8 +-0x1.6542e2p-8 +-0x1.bbaf44p-8 +-0x1.e22932p-8 +-0x1.0fc12ap-7 +-0x1.7eea66p-8 +-0x1.e222fap-8 +-0x1.fa13eep-8 +-0x1.2279e6p-7 +-0x1.97f44p-8 +-0x1.fbdfb4p-8 +-0x1.04b264p-7 +-0x1.293464p-7 +-0x1.b38516p-8 +-0x1.05f1dp-7 +-0x1.07b25ap-7 +-0x1.25d99ep-7 +-0x1.d0015ep-8 +-0x1.08f7dp-7 +-0x1.0763eap-7 +-0x1.19e9a4p-7 +-0x1.ed0f9cp-8 +-0x1.46408ap-8 +-0x1.4cd292p-8 +-0x1.612818p-8 +-0x1.31e57ap-8 +-0x1.4d1a7cp-8 +-0x1.5ed054p-8 +-0x1.81302p-8 +-0x1.2a936cp-8 +-0x1.5eb246p-8 +-0x1.83bdd4p-8 +-0x1.a865a6p-8 +-0x1.39b96ap-8 +-0x1.8212bp-8 +-0x1.bd28d4p-8 +-0x1.dbd7ecp-8 +-0x1.637acap-8 +-0x1.b9d726p-8 +-0x1.e2066ap-8 +-0x1.0e6bfep-7 +-0x1.7f98bap-8 +-0x1.e1c3c8p-8 +-0x1.faf0f4p-8 +-0x1.21d188p-7 +-0x1.99c07ap-8 +-0x1.fc8aep-8 +-0x1.052a64p-7 +-0x1.291522p-7 +-0x1.b55c5ap-8 +-0x1.065ffcp-7 +-0x1.08355ep-7 +-0x1.25f0a8p-7 +-0x1.d1b4p-8 +-0x1.097458p-7 +-0x1.085784p-7 +-0x1.1a36b2p-7 +-0x1.ef54ccp-8 +-0x1.45f346p-8 +-0x1.4cff68p-8 +-0x1.60baf4p-8 +-0x1.32322cp-8 +-0x1.4d3848p-8 +-0x1.5fe6d8p-8 +-0x1.81047p-8 +-0x1.2bf33p-8 +-0x1.5fa856p-8 +-0x1.85ce7ep-8 +-0x1.a8eb72p-8 +-0x1.3c399ep-8 +-0x1.83faf6p-8 +-0x1.bb891ep-8 +-0x1.dd213cp-8 +-0x1.627b02p-8 +-0x1.b89c34p-8 +-0x1.e1d28p-8 +-0x1.0d64eap-7 +-0x1.8036f6p-8 +-0x1.e166fp-8 +-0x1.fba98ep-8 +-0x1.212c28p-7 +-0x1.9b64c8p-8 +-0x1.fd1478p-8 +-0x1.059cfep-7 +-0x1.28e6b4p-7 +-0x1.b725acp-8 +-0x1.06c6a6p-7 +-0x1.08c2eap-7 +-0x1.26033ap-7 +-0x1.d375a2p-8 +-0x1.09f8e2p-7 +-0x1.0938eap-7 +-0x1.1a8a3p-7 +-0x1.f178bcp-8 +-0x1.45b4f6p-8 +-0x1.4d3dp-8 +-0x1.610372p-8 +-0x1.87536ep-8 +-0x1.ba736p-8 +-0x1.e19e6cp-8 +-0x1.fc44f2p-8 +-0x1.060aap-7 +-0x1.095292p-7 +-0x1.0a0e14p-7 +0x0p+0 +-0x1.fb2802p-3 +-0x1.38cea8p+0 +-0x1.38cea8p+0 +-0x1.d4e18cp+0 +-0x1.6dee76p+1 +0x1.555fa8p-3 +0x1.555fa8p-3 +0x1.0ec024p-1 +0x1.44a77ep-7 +0x1.3d79cap-7 +-0x1.38cea8p+0 +-0x1.8a1c88p-1 +0x0p+0 +-0x1.8a1c88p-1 +-0x1.d4e18cp+0 +-0x1.026d02p+1 +-0x1.6dee76p+1 +-0x1.026d02p+1 +0x1.555fa8p-3 +-0x1.be20a4p-3 +0x1.3d79cap-7 +-0x1.be20a4p-3 +0x1.44a77ep-7 +0x1.ed91a4p-10 +0x0p+0 +0x1.ed91a4p-10 +0x1.0ec024p-1 +-0x1.9245aep-1 +-0x1.b0eaap+0 +-0x1.9245aep-1 +-0x1.d88adp-2 +-0x1.2cd75cp+0 +-0x1.2d69aap+0 +-0x1.d9c06ep+0 +-0x1.5a423cp+1 +0x1.c6acf8p-3 +-0x1.5c8844p+1 +0x1.cfc09cp-3 +0x1.cfc09cp-3 +0x1.326e74p-1 +0x1.ed7872p-7 +0x1.e64abcp-7 +0x1.ed7872p-7 +0x1.e64abcp-7 +-0x1.ce8becp-1 +-0x1.2ad606p+0 +-0x1.cd713ap-1 +0x0p+0 +-0x1.0a1054p+1 +-0x1.d91abp+0 +-0x1.0a8d12p+1 +-0x1.5c8844p+1 +-0x1.54127cp-2 +0x1.d0b2a2p-3 +-0x1.59f794p-2 +0x1.e64abcp-7 +0x1.776978p-9 +0x1.ed7872p-7 +0x1.773064p-9 +0x0p+0 +-0x1.a0059ap-1 +0x1.321efp-1 +-0x1.a0615p-1 +-0x1.d5812ep+0 +-0x1.d88adp-2 +-0x1.2ad606p+0 +-0x1.2b4c84p+0 +-0x1.d91abp+0 +-0x1.5c8844p+1 +0x1.d0b2a2p-3 +-0x1.5e735p+1 +0x1.d8bdc2p-3 +0x1.d8bdc2p-3 +0x1.321efp-1 +0x1.ed7872p-7 +0x1.e64abcp-7 +0x1.ed7872p-7 +0x1.e64abcp-7 +-0x1.cd959cp-1 +-0x1.292794p+0 +-0x1.ccd8ecp-1 +0x0p+0 +-0x1.0af1dep+1 +-0x1.d8961ep+0 +-0x1.0b30ep+1 +-0x1.5e735p+1 +-0x1.577b12p-2 +0x1.d91c96p-3 +-0x1.5d107p-2 +0x1.e64abcp-7 +0x1.775c78p-9 +0x1.ed7872p-7 +0x1.77753p-9 +0x0p+0 +-0x1.a0402ap-1 +0x1.31ffe6p-1 +-0x1.a0590ap-1 +-0x1.d5812ep+0 +-0x1.d88adp-2 +-0x1.292794p+0 +-0x1.2986dep+0 +-0x1.d8961ep+0 +-0x1.5e735p+1 +0x1.d91c96p-3 +-0x1.601784p+1 +0x1.e03c96p-3 +0x1.e03c96p-3 +0x1.31ffe6p-1 +0x1.ed7872p-7 +0x1.e64abcp-7 +0x1.ed7872p-7 +0x1.e64abcp-7 +-0x1.cd1c76p-1 +-0x1.27bbecp+0 +-0x1.cc754cp-1 +0x0p+0 +-0x1.0b90e6p+1 +-0x1.d82b7cp+0 +-0x1.0bc2fcp+1 +-0x1.601784p+1 +-0x1.5b064p-2 +0x1.e03c96p-3 +-0x1.5f95ccp-2 +0x1.e64abcp-7 +0x1.774eap-9 +0x1.ed7872p-7 +0x1.777b3ap-9 +0x0p+0 +-0x1.a0503ap-1 +0x1.31ffe6p-1 +-0x1.a0533cp-1 +-0x1.d5812ep+0 +-0x1.d88adp-2 +-0x1.27bbecp+0 +-0x1.ccb074p-1 +0x0p+0 +-0x1.d82b7cp+0 +-0x1.0c14a6p+1 +-0x1.601784p+1 +0x1.e03c96p-3 +-0x1.5ded2ap-2 +0x1.e64abcp-7 +0x1.ed7872p-7 +0x1.77590ap-9 +0x0p+0 +0x1.31ffe6p-1 +-0x1.a05202p-1 +-0x1.d5812ep+0 +0x1.ca997p+1 +-0x1.a37df4p-1 +-0x1.3da98ap+2 +-0x1.a37df4p-1 +0x1.68501ep+2 +-0x1.7591d2p+1 +0x1.c1c1aep-1 +-0x1.7591d2p+1 +0x0p+0 +0x1.68501ep+2 +-0x1.d5ccb2p+1 +0x1.c1c1aep-1 +-0x1.d5ccb2p+1 +-0x1.7591d2p+1 +-0x1.cb085ap-1 +-0x1.3da98ap+2 +-0x1.cb085ap-1 +-0x1.a2fc8ap-1 +-0x1.45cb0cp+2 +-0x1.a2fc8ap-1 +0x1.5ad0a8p+2 +-0x1.7cfabp+1 +0x1.b261fcp-1 +-0x1.7cfabp+1 +0x0p+0 +-0x1.dd8fap+1 +0x1.5ab0b2p+2 +-0x1.dd32b8p+1 +0x1.b261fcp-1 +-0x1.e5dfbp-1 +-0x1.7cfabp+1 +-0x1.e6051ep-1 +-0x1.45ce84p+2 +-0x1.a2fc8ap-1 +-0x1.45ce84p+2 +-0x1.a2fc8ap-1 +0x1.5ab0b2p+2 +-0x1.7cfabp+1 +0x1.b261fcp-1 +-0x1.7cfabp+1 +0x0p+0 +-0x1.dd39ap+1 +0x1.5a8fdap+2 +-0x1.dd213ap+1 +0x1.b261fcp-1 +-0x1.e7bf7ap-1 +-0x1.7cfabp+1 +-0x1.e720cap-1 +-0x1.45d118p+2 +-0x1.a2fc8ap-1 +-0x1.45d118p+2 +-0x1.a2fc8ap-1 +0x1.5a8fdap+2 +-0x1.7cfabp+1 +0x1.b261fcp-1 +-0x1.7cfabp+1 +0x0p+0 +-0x1.dd2a0cp+1 +0x1.5a6edcp+2 +-0x1.dd1114p+1 +0x1.b261fcp-1 +-0x1.e7c31p-1 +-0x1.7cfabp+1 +-0x1.e788f2p-1 +-0x1.45d2fp+2 +-0x1.a2fc8ap-1 +0x1.5a6edcp+2 +-0x1.dd1a0cp+1 +0x1.b261fcp-1 +-0x1.7cfabp+1 +-0x1.e7fedap-1 +0x0p+0 +-0x1.45d2fp+2 +-0x1.454f32p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.879d64p+2 +0x0p+0 +-0x1.11c4c6p+2 +-0x1.8cbe42p-1 +-0x1.879d64p+2 +-0x1.8cbe42p-1 +-0x1.8ed5b6p+2 +0x0p+0 +-0x1.973d32p-1 +-0x1.17540ep+2 +-0x1.972656p-1 +-0x1.8ed5b6p+2 +-0x1.972e1ap-1 +-0x1.8ed5b6p+2 +0x0p+0 +-0x1.17540ep+2 +0x1.81a3aap+0 +-0x1.d9972ep-1 +-0x1.1656cep+2 +-0x1.d9972ep-1 +-0x1.f011cep-1 +0x1.8d418ep+0 +-0x1.f00408p-1 +-0x1.1a347p+2 +-0x1.f006c4p-1 +-0x1.1a347p+2 +0x1.8d418ep+0 +0x1.f12912p-4 +0x0p+0 +0x1.7ced12p-4 +0x1.f12912p-4 +0x1.30f088p-4 +0x1.7ced12p-4 +0x1.a8936ap-5 +0x1.30f088p-4 +0x1.5580e6p-6 +0x1.a8936ap-5 +-0x1.589724p-6 +0x1.5580e6p-6 +-0x1.a18e68p-5 +-0x1.589724p-6 +-0x1.27f21p-4 +-0x1.a18e68p-5 +-0x1.7cf146p-4 +-0x1.27f21p-4 +-0x1.0036bcp-3 +-0x1.7cf146p-4 +0x0p+0 +-0x1.0036bcp-3 +0x0p+0 +0x1.ec2da4p-4 +0x1.ecc6a6p-4 +0x1.8e05c8p-4 +0x1.8f0b3p-4 +0x1.55df0ep-4 +0x1.565456p-4 +0x1.dfc362p-5 +0x1.e21cbep-5 +0x1.8680bp-6 +0x1.8d031ep-6 +-0x1.900baep-6 +-0x1.87b94p-6 +-0x1.da34dp-5 +-0x1.d7af68p-5 +-0x1.4acd98p-4 +-0x1.49da58p-4 +-0x1.8d5d5cp-4 +-0x1.8c7a52p-4 +-0x1.fc1bb8p-4 +-0x1.fb035ap-4 +0x0p+0 +0x0p+0 +0x1.ebd2cp-4 +0x1.ec4d48p-4 +0x1.8e4e7cp-4 +0x1.8f5a08p-4 +0x1.555b6ep-4 +0x1.55f1cp-4 +0x1.df5d8ep-5 +0x1.e1e5dcp-5 +0x1.84b2a6p-6 +0x1.8b854cp-6 +-0x1.8e5006p-6 +-0x1.861814p-6 +-0x1.d9c37ap-5 +-0x1.d75d12p-5 +-0x1.4a616p-4 +-0x1.498f6p-4 +-0x1.8db6e6p-4 +-0x1.8ce5cap-4 +-0x1.fb903ep-4 +-0x1.fa7978p-4 +0x0p+0 +0x0p+0 +0x1.eb62d8p-4 +0x1.ebd88cp-4 +0x1.8eb9f4p-4 +0x1.8fbd3ep-4 +0x1.551292p-4 +0x1.55a682p-4 +0x1.df4e54p-5 +0x1.e1cb88p-5 +0x1.832e76p-6 +0x1.8a0964p-6 +-0x1.8cf0b6p-6 +-0x1.84b2f4p-6 +-0x1.d9af2p-5 +-0x1.d738eap-5 +-0x1.4a2aecp-4 +-0x1.495664p-4 +-0x1.8e1eb8p-4 +-0x1.8d4dacp-4 +-0x1.fb056p-4 +-0x1.f9f19ap-4 +0x0p+0 +0x1.eaea28p-4 +0x1.8f176ep-4 +0x1.54c3fap-4 +0x1.df363cp-5 +0x1.81c9b8p-6 +-0x1.8b6f54p-6 +-0x1.d982aep-5 +-0x1.49f506p-4 +-0x1.8e8424p-4 +-0x1.fa7c4p-4 +0x0p+0 +-0x1.30c96p-8 +-0x1.38c3dp-8 +-0x1.4d713cp-8 +-0x1.750e6ep-8 +-0x1.a9e316p-8 +-0x1.d306f6p-8 +-0x1.ef821p-8 +-0x1.006a68p-7 +-0x1.042d18p-7 +-0x1.051b0ep-7 +0x0p+0 +-0x1.fb2802p-3 +0x1.a3c0c2p+1 +-0x1.a37df4p-1 +-0x1.42e962p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.8a1c88p-1 +0x0p+0 +-0x1.38cea8p+0 +-0x1.026d02p+1 +-0x1.d4e18cp+0 +-0x1.6dee76p+1 +-0x1.cb085ap-1 +-0x1.3da98ap+2 +-0x1.7591d2p+1 +-0x1.8cbe42p-1 +-0x1.11c4c6p+2 +-0x1.879d64p+2 +0x1.ed91a4p-10 +0x0p+0 +0x1.44a77ep-7 +-0x1.be20a4p-3 +0x1.3d79cap-7 +0x1.555fa8p-3 +-0x1.9245aep-1 +0x1.0ec024p-1 +-0x1.b0eaap+0 +-0x1.d5ccb2p+1 +0x1.c1c1aep-1 +0x1.68501ep+2 +-0x1.d9972ep-1 +0x1.81a3aap+0 +-0x1.1656cep+2 +0x1.f12912p-4 +0x1.7ced12p-4 +0x1.30f088p-4 +0x1.a8936ap-5 +0x1.5580e6p-6 +-0x1.589724p-6 +-0x1.a18e68p-5 +-0x1.27f21p-4 +-0x1.7cf146p-4 +-0x1.0036bcp-3 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.824676p+2 +0x0p+0 +0x1.749708p+2 +0x0p+0 +0x1.1ce754p+2 +0x0p+0 +0x1.1c14d8p+2 +0x0p+0 +0x1.4e72bap+1 +0x0p+0 +0x1.47256p+1 +0x0p+0 +0x1.68501ep+2 +0x0p+0 +0x1.5a6edcp+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.60dc24p+2 +0x0p+0 +0x1.5889a8p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.43ec0cp+2 +0x0p+0 +0x1.4830bcp+2 +0x0p+0 +0x1.c1c1aep-1 +0x0p+0 +0x1.b261fcp-1 +0x0p+0 +0x1.5fd7p+2 +0x0p+0 +0x1.5e1576p+2 +0x0p+0 +0x1.5daff8p+2 +0x0p+0 +0x1.5dc024p+2 +0x0p+0 +0x1.0ec024p-1 +0x0p+0 +0x1.31ffe6p-1 +0x0p+0 +0x1.25e50ep+2 +0x0p+0 +0x1.1cbf6ap+2 +0x0p+0 +0x1.aead9ap+1 +0x0p+0 +0x1.a744bcp+1 +0x0p+0 +0x1.58beaap+2 +0x0p+0 +0x1.551fdap+2 +0x0p+0 +0x1.10e934p+2 +0x0p+0 +0x1.0c1564p+2 +0x0p+0 +0x1.1ce754p+2 +0x0p+0 +0x1.1c14d8p+2 +0x0p+0 +0x1.b650f6p+1 +0x0p+0 +0x1.c427e8p+1 +0x0p+0 +0x1.51d8bp+0 +0x0p+0 +0x1.313318p+0 +0x0p+0 +0x1.56ecdp+2 +0x0p+0 +0x1.541edep+2 +0x0p+0 +0x1.ef23ap+0 +0x0p+0 +0x1.dfad18p+0 +0x0p+0 +0x1.81a3aap+0 +0x0p+0 +0x1.8d418ep+0 +0x0p+0 +0x1.504a4p-3 +0x0p+0 +0x1.a5p-5 +0x0p+0 +0x1.6087eep+2 +0x0p+0 +0x1.5f39f2p+2 +0x0p+0 +0x1.00b5ep+1 +0x0p+0 +0x1.eb2eap+0 +0x0p+0 +0x1.7ced12p-4 +0x0p+0 +0x1.8f176ep-4 +0x0p+0 +0x1.8c2bfp+2 +0x0p+0 +0x1.8be5a6p+2 +-0x1.45b4f6p-8 +-0x1.4d3dp-8 +-0x1.4d3dp-8 +-0x1.610372p-8 +-0x1.610372p-8 +-0x1.87536ep-8 +-0x1.87536ep-8 +-0x1.ba736p-8 +-0x1.ba736p-8 +-0x1.e19e6cp-8 +-0x1.e19e6cp-8 +-0x1.fc44f2p-8 +-0x1.fc44f2p-8 +-0x1.060aap-7 +-0x1.060aap-7 +-0x1.095292p-7 +-0x1.095292p-7 +-0x1.0a0e14p-7 +-0x1.5b8cep-8 +-0x1.6128acp-8 +-0x1.75f182p-8 +-0x1.46beeap-8 +-0x1.6188e4p-8 +-0x1.71728ep-8 +-0x1.94971p-8 +-0x1.3e3e6ep-8 +-0x1.71828ep-8 +-0x1.93129ep-8 +-0x1.b99c9cp-8 +-0x1.4aaa3p-8 +-0x1.91c2f6p-8 +-0x1.d02c42p-8 +-0x1.e97d36p-8 +-0x1.788956p-8 +-0x1.cc5c9ep-8 +-0x1.f0c0a8p-8 +-0x1.166ec6p-7 +-0x1.90d464p-8 +-0x1.f0d8dcp-8 +-0x1.036b68p-7 +-0x1.280b94p-7 +-0x1.a845bap-8 +-0x1.045924p-7 +-0x1.0a529cp-7 +-0x1.2de994p-7 +-0x1.c226f8p-8 +-0x1.0b9512p-7 +-0x1.0cd7d4p-7 +-0x1.2a258ap-7 +-0x1.dcf584p-8 +-0x1.0e1c26p-7 +-0x1.0c56fp-7 +-0x1.1e505ap-7 +-0x1.f86db4p-8 +-0x1.5b27eep-8 +-0x1.61417cp-8 +-0x1.756b7ap-8 +-0x1.46f8dp-8 +-0x1.61912ap-8 +-0x1.725ef4p-8 +-0x1.94572cp-8 +-0x1.3f72d2p-8 +-0x1.724fdap-8 +-0x1.95f9bap-8 +-0x1.b9fae4p-8 +-0x1.4dff2p-8 +-0x1.9465a8p-8 +-0x1.cdb3b8p-8 +-0x1.eb7bdap-8 +-0x1.76b65ep-8 +-0x1.ca7a48p-8 +-0x1.f09f9cp-8 +-0x1.15186p-7 +-0x1.917caep-8 +-0x1.f077d6p-8 +-0x1.03d5d2p-7 +-0x1.2767d4p-7 +-0x1.a9fec6p-8 +-0x1.04ab88p-7 +-0x1.0ac802p-7 +-0x1.2dcbcep-7 +-0x1.c3efcap-8 +-0x1.0c015p-7 +-0x1.0d5a36p-7 +-0x1.2a41dap-7 +-0x1.de989cp-8 +-0x1.0e9828p-7 +-0x1.0d4666p-7 +-0x1.1e9f8ap-7 +-0x1.faa55ep-8 +-0x1.5ad378p-8 +-0x1.616856p-8 +-0x1.74f4dcp-8 +-0x1.4741d2p-8 +-0x1.61a994p-8 +-0x1.736df8p-8 +-0x1.9425a8p-8 +-0x1.40cb8ep-8 +-0x1.733d66p-8 +-0x1.9808e2p-8 +-0x1.ba7632p-8 +-0x1.507fd8p-8 +-0x1.964c86p-8 +-0x1.cc0d62p-8 +-0x1.ecc358p-8 +-0x1.75b05ap-8 +-0x1.c93b64p-8 +-0x1.f0685cp-8 +-0x1.141408p-7 +-0x1.920e2ep-8 +-0x1.f016c2p-8 +-0x1.042e6cp-7 +-0x1.26c3fap-7 +-0x1.ab9478p-8 +-0x1.04ed58p-7 +-0x1.0b38cp-7 +-0x1.2da10ap-7 +-0x1.c5a838p-8 +-0x1.0c66d4p-7 +-0x1.0de532p-7 +-0x1.2a5778p-7 +-0x1.e04cd2p-8 +-0x1.0f1acp-7 +-0x1.0e25ccp-7 +-0x1.1ef55p-7 +-0x1.fcbceep-8 +-0x1.5a8d62p-8 +-0x1.61a19cp-8 +-0x1.74820ep-8 +-0x1.9989b6p-8 +-0x1.caf4b6p-8 +-0x1.f02edep-8 +-0x1.04789ep-7 +-0x1.0ba4bep-7 +-0x1.0e73e4p-7 +-0x1.0ef80cp-7 +0x0p+0 +-0x1.d88adp-2 +-0x1.27bbecp+0 +-0x1.27bbecp+0 +-0x1.d82b7cp+0 +-0x1.d82b7cp+0 +0x0p+0 +-0x1.601784p+1 +0x1.e03c96p-3 +0x1.e03c96p-3 +0x1.31ffe6p-1 +-0x1.27bbecp+0 +-0x1.ccb074p-1 +0x0p+0 +-0x1.ccb074p-1 +-0x1.d82b7cp+0 +-0x1.0c14a6p+1 +-0x1.601784p+1 +-0x1.0c14a6p+1 +0x1.e03c96p-3 +-0x1.5ded2ap-2 +0x1.e64abcp-7 +-0x1.5ded2ap-2 +0x1.31ffe6p-1 +-0x1.a05202p-1 +-0x1.d5812ep+0 +-0x1.a05202p-1 +-0x1.59c0dp-1 +-0x1.1bc4ap+0 +-0x1.1bc4ap+0 +-0x1.e3a242p+0 +-0x1.e3a164p+0 +0x0p+0 +-0x1.4c6b4ap+1 +0x1.28c4f4p-2 +0x1.2afb1ep-2 +0x1.55ae36p-1 +-0x1.084abap+0 +-0x1.1b69f2p+0 +-0x1.082fe8p+0 +0x0p+0 +-0x1.1413dep+1 +-0x1.e3a164p+0 +-0x1.13f1d8p+1 +-0x1.4d8eacp+1 +-0x1.d1e95ap-2 +0x1.2afb1ep-2 +-0x1.d45a82p-2 +0x1.478dd8p-6 +-0x1.ae103ap-1 +0x1.55ae36p-1 +-0x1.ae118cp-1 +-0x1.fa17bcp+0 +-0x1.59c0dp-1 +-0x1.1b69f2p+0 +-0x1.1b69f2p+0 +-0x1.e3a164p+0 +-0x1.e3a0eep+0 +0x0p+0 +-0x1.4d8eacp+1 +0x1.2afb1ep-2 +0x1.2ceabcp-2 +0x1.55ae36p-1 +-0x1.0819a2p+0 +-0x1.1b2534p+0 +-0x1.081f98p+0 +0x0p+0 +-0x1.145416p+1 +-0x1.e3a0eep+0 +-0x1.143d4ep+1 +-0x1.4e8a16p+1 +-0x1.d3233ap-2 +0x1.2ceabcp-2 +-0x1.d5cd68p-2 +0x1.478dd8p-6 +-0x1.ae104ep-1 +0x1.55ae36p-1 +-0x1.ae10fcp-1 +-0x1.fa17bcp+0 +-0x1.59c0dp-1 +-0x1.1b2534p+0 +-0x1.1b2534p+0 +-0x1.e3a0eep+0 +-0x1.e3a0bcp+0 +0x0p+0 +-0x1.4e8a16p+1 +0x1.2ceabcp-2 +0x1.2ea028p-2 +0x1.55ae36p-1 +-0x1.081d7cp+0 +-0x1.1afa34p+0 +-0x1.081ceap+0 +0x0p+0 +-0x1.148ffcp+1 +-0x1.e3a0bcp+0 +-0x1.147a3p+1 +-0x1.4f65dp+1 +-0x1.d4d3f8p-2 +0x1.2ea028p-2 +-0x1.d715a4p-2 +0x1.478dd8p-6 +-0x1.ae10a8p-1 +0x1.55ae36p-1 +-0x1.ae10aap-1 +-0x1.fa17bcp+0 +-0x1.59c0dp-1 +-0x1.1afa34p+0 +-0x1.081d12p+0 +0x0p+0 +-0x1.e3a0bcp+0 +-0x1.14c24cp+1 +-0x1.4f65dp+1 +0x1.2ea028p-2 +-0x1.d643dcp-2 +0x1.478dd8p-6 +0x1.55ae36p-1 +-0x1.ae10c6p-1 +-0x1.fa17bcp+0 +0x0p+0 +0x1.f1721ep+1 +-0x1.a2fc8ap-1 +-0x1.45d2fp+2 +-0x1.a2fc8ap-1 +0x1.5a6edcp+2 +-0x1.a2fc8ap-1 +0x1.b261fcp-1 +0x1.b261fcp-1 +-0x1.dd1a0cp+1 +0x1.5a6edcp+2 +-0x1.dd1a0cp+1 +-0x1.45d2fp+2 +-0x1.e7fedap-1 +-0x1.7cfabp+1 +-0x1.e7fedap-1 +-0x1.96b438p-1 +-0x1.5028b8p+2 +-0x1.96b438p-1 +0x1.4efb28p+2 +-0x1.96b438p-1 +0x1.875a3p-1 +-0x1.e6418ap+1 +0x1.8743e6p-1 +-0x1.e613p+1 +0x1.4eea3p+2 +-0x1.03c1fp+0 +-0x1.502544p+2 +-0x1.02c372p+0 +-0x1.84638ep+1 +-0x1.96b438p-1 +-0x1.502544p+2 +-0x1.96b438p-1 +0x1.4eea3p+2 +-0x1.96b438p-1 +0x1.8743e6p-1 +-0x1.e6618p+1 +0x1.872814p-1 +-0x1.e6478ep+1 +0x1.4eda38p+2 +-0x1.030332p+0 +-0x1.5021bcp+2 +-0x1.030718p+0 +-0x1.84638ep+1 +-0x1.96b438p-1 +-0x1.5021bcp+2 +-0x1.96b438p-1 +0x1.4eda38p+2 +-0x1.96b438p-1 +0x1.872814p-1 +-0x1.e64284p+1 +0x1.8707bp-1 +-0x1.e6471cp+1 +0x1.4ecb08p+2 +-0x1.0305b8p+0 +-0x1.501e1cp+2 +-0x1.03212cp+0 +-0x1.84638ep+1 +-0x1.96b438p-1 +0x1.8707bp-1 +-0x1.e637dp+1 +0x1.4ecb08p+2 +-0x1.501e1cp+2 +-0x1.031754p+0 +-0x1.84638ep+1 +-0x1.47b502p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.17540ep+2 +-0x1.972e1ap-1 +-0x1.8ed5b6p+2 +-0x1.972e1ap-1 +-0x1.a1ad5ap-1 +-0x1.1ce356p+2 +-0x1.a1a7aep-1 +-0x1.960e08p+2 +-0x1.a1a99ap-1 +-0x1.960e08p+2 +-0x1.1ce356p+2 +0x0p+0 +0x1.77590ap-9 +0x1.ed7872p-7 +0x1.77590ap-9 +0x1.f7ee2p-9 +0x0p+0 +0x1.f7fdc8p-9 +0x1.4b24b4p-6 +0x1.f82de8p-9 +0x1.4b24b4p-6 +0x0p+0 +0x1.8d418ep+0 +-0x1.f006c4p-1 +-0x1.1a347p+2 +-0x1.f006c4p-1 +-0x1.033e2p+0 +0x1.98df72p+0 +-0x1.03375p+0 +-0x1.1e1212p+2 +-0x1.0338a8p+0 +-0x1.1e1212p+2 +0x1.98df72p+0 +0x1.eaea28p-4 +0x0p+0 +0x1.8f176ep-4 +0x1.eaea28p-4 +0x1.54c3fap-4 +0x1.8f176ep-4 +0x1.df363cp-5 +0x1.54c3fap-4 +0x1.81c9b8p-6 +0x1.df363cp-5 +-0x1.8b6f54p-6 +0x1.81c9b8p-6 +-0x1.d982aep-5 +-0x1.8b6f54p-6 +-0x1.49f506p-4 +-0x1.d982aep-5 +-0x1.8e8424p-4 +-0x1.49f506p-4 +-0x1.fa7c4p-4 +-0x1.8e8424p-4 +0x0p+0 +-0x1.fa7c4p-4 +0x0p+0 +0x1.e5f4bep-4 +0x1.e67d38p-4 +0x1.a2da5cp-4 +0x1.a39a0cp-4 +0x1.76bfdp-4 +0x1.77364cp-4 +0x1.0a78bap-4 +0x1.0bdd0cp-4 +0x1.a3ace4p-6 +0x1.abcb58p-6 +-0x1.b329dep-6 +-0x1.a986ep-6 +-0x1.07f9f8p-4 +-0x1.066a38p-4 +-0x1.6af092p-4 +-0x1.69ee38p-4 +-0x1.a1e3d6p-4 +-0x1.a11fd4p-4 +-0x1.f55f4p-4 +-0x1.f47a6ep-4 +0x0p+0 +0x0p+0 +0x1.e5b5aap-4 +0x1.e61a0ap-4 +0x1.a30c76p-4 +0x1.a3d8f8p-4 +0x1.76238p-4 +0x1.76b996p-4 +0x1.0a3504p-4 +0x1.0bb44ap-4 +0x1.a1f538p-6 +0x1.aa4c1cp-6 +-0x1.b186p-6 +-0x1.a7ea68p-6 +-0x1.07af2p-4 +-0x1.06304ap-4 +-0x1.6a6f32p-4 +-0x1.698cc2p-4 +-0x1.a2236cp-4 +-0x1.a17706p-4 +-0x1.f4ed44p-4 +-0x1.f409fp-4 +0x0p+0 +0x0p+0 +0x1.e56244p-4 +0x1.e5bebcp-4 +0x1.a36614p-4 +0x1.a42bc2p-4 +0x1.75c456p-4 +0x1.7656ap-4 +0x1.0a1aa2p-4 +0x1.0b9618p-4 +0x1.a083a2p-6 +0x1.a8db88p-6 +-0x1.b02f7p-6 +-0x1.a68bbp-6 +-0x1.0792ap-4 +-0x1.060c88p-4 +-0x1.6a284ap-4 +-0x1.6941cap-4 +-0x1.a2775ap-4 +-0x1.a1cb7p-4 +-0x1.f47c3ap-4 +-0x1.f39b3p-4 +0x0p+0 +0x1.e50418p-4 +0x1.a3b146p-4 +0x1.756012p-4 +0x1.09fc38p-4 +0x1.9f2ddep-6 +-0x1.aeb56cp-6 +-0x1.076926p-4 +-0x1.69e116p-4 +-0x1.a2c93ep-4 +-0x1.f40c86p-4 +0x0p+0 +-0x1.45b4f6p-8 +-0x1.4d3dp-8 +-0x1.610372p-8 +-0x1.87536ep-8 +-0x1.ba736p-8 +-0x1.e19e6cp-8 +-0x1.fc44f2p-8 +-0x1.060aap-7 +-0x1.095292p-7 +-0x1.0a0e14p-7 +0x0p+0 +-0x1.d88adp-2 +0x1.ca997p+1 +-0x1.a2fc8ap-1 +-0x1.454f32p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.ccb074p-1 +0x0p+0 +-0x1.27bbecp+0 +-0x1.0c14a6p+1 +-0x1.d82b7cp+0 +-0x1.601784p+1 +-0x1.e7fedap-1 +-0x1.45d2fp+2 +-0x1.7cfabp+1 +-0x1.972e1ap-1 +-0x1.17540ep+2 +-0x1.8ed5b6p+2 +0x1.77590ap-9 +0x0p+0 +0x1.ed7872p-7 +-0x1.5ded2ap-2 +0x1.e64abcp-7 +0x1.e03c96p-3 +-0x1.a05202p-1 +0x1.31ffe6p-1 +-0x1.d5812ep+0 +-0x1.dd1a0cp+1 +0x1.b261fcp-1 +0x1.5a6edcp+2 +-0x1.f006c4p-1 +0x1.8d418ep+0 +-0x1.1a347p+2 +0x1.eaea28p-4 +0x1.8f176ep-4 +0x1.54c3fap-4 +0x1.df363cp-5 +0x1.81c9b8p-6 +-0x1.8b6f54p-6 +-0x1.d982aep-5 +-0x1.49f506p-4 +-0x1.8e8424p-4 +-0x1.fa7c4p-4 +0x0p+0 +0x1.ca997p+1 +0x0p+0 +0x1.f1721ep+1 +0x0p+0 +0x1.0c1564p+2 +0x0p+0 +0x1.07be9p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.749708p+2 +0x0p+0 +0x1.66e79cp+2 +0x0p+0 +0x1.1c14d8p+2 +0x0p+0 +0x1.193788p+2 +0x0p+0 +0x1.1aa63p+2 +0x0p+0 +0x1.198cc8p+2 +0x0p+0 +0x1.193788p+2 +0x0p+0 +0x1.47256p+1 +0x0p+0 +0x1.3e079cp+1 +0x0p+0 +0x1.5a6edcp+2 +0x0p+0 +0x1.4ecb08p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.5889a8p+2 +0x0p+0 +0x1.501872p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.4830bcp+2 +0x0p+0 +0x1.4b6128p+2 +0x0p+0 +0x1.b261fcp-1 +0x0p+0 +0x1.8707bp-1 +0x0p+0 +0x1.5e1576p+2 +0x0p+0 +0x1.5c5d9ep+2 +0x0p+0 +0x1.5dc024p+2 +0x0p+0 +0x1.5f493p+2 +0x0p+0 +0x1.31ffe6p-1 +0x0p+0 +0x1.55ae36p-1 +0x0p+0 +0x1.1cbf6ap+2 +0x0p+0 +0x1.1399c8p+2 +0x0p+0 +0x1.a744bcp+1 +0x0p+0 +0x1.9fdbdep+1 +0x0p+0 +0x1.551fdap+2 +0x0p+0 +0x1.5159ep+2 +0x0p+0 +0x1.0c1564p+2 +0x0p+0 +0x1.07be9p+2 +0x0p+0 +0x1.1c14d8p+2 +0x0p+0 +0x1.193788p+2 +0x0p+0 +0x1.313318p+0 +0x0p+0 +0x1.080668p+0 +0x0p+0 +0x1.1c9ccp+0 +0x0p+0 +0x1.11a3c6p+0 +0x0p+0 +0x1.541edep+2 +0x0p+0 +0x1.51518cp+2 +0x0p+0 +0x1.dfad18p+0 +0x0p+0 +0x1.d0369p+0 +0x0p+0 +0x1.8d418ep+0 +0x0p+0 +0x1.98df72p+0 +0x0p+0 +0x1.a5p-5 +0x0p+0 +-0x1.f729p-5 +0x0p+0 +0x1.5f39f2p+2 +0x0p+0 +0x1.5dea82p+2 +0x0p+0 +0x1.eb2eap+0 +0x0p+0 +0x1.d4f18p+0 +0x0p+0 +0x1.8f176ep-4 +0x0p+0 +0x1.a3b146p-4 +0x0p+0 +0x1.8be5a6p+2 +0x0p+0 +0x1.8b9492p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.cf2c4ap-9 +0x0p+0 +0x1.23022ep-8 +0x0p+0 +0x0p+0 +-0x1.954338p-4 +0x1.23022ep-8 +0x0p+0 +0x1.23022ep-8 +0x0p+0 +-0x1.954338p-4 +0x0p+0 +-0x1.4db6c4p+2 +-0x1.4db6c4p+2 +0x0p+0 +-0x1.4e3a7p+2 +0x0p+0 +-0x1.4e5b88p+2 +0x0p+0 +-0x1.4e63dp+2 +0x0p+0 +0x0p+0 +-0x1.50c174p+2 +-0x1.4e63dp+2 +0x0p+0 +0x1.0eef98p+0 +0x0p+0 +0x1.057908p+0 +-0x1.5a8d62p-8 +-0x1.61a19cp-8 +-0x1.61a19cp-8 +-0x1.74820ep-8 +-0x1.74820ep-8 +-0x1.9989b6p-8 +-0x1.9989b6p-8 +-0x1.caf4b6p-8 +-0x1.caf4b6p-8 +-0x1.f02edep-8 +-0x1.f02edep-8 +-0x1.04789ep-7 +-0x1.04789ep-7 +-0x1.0ba4bep-7 +-0x1.0ba4bep-7 +-0x1.0e73e4p-7 +-0x1.0e73e4p-7 +-0x1.0ef80cp-7 +-0x1.70654cp-8 +-0x1.758d48p-8 +-0x1.8a235ap-8 +-0x1.5bca86p-8 +-0x1.75f848p-8 +-0x1.84f12ap-8 +-0x1.a7b5dap-8 +-0x1.530eccp-8 +-0x1.851016p-8 +-0x1.a548e6p-8 +-0x1.cb255p-8 +-0x1.5ee6c2p-8 +-0x1.a41132p-8 +-0x1.e0ad98p-8 +-0x1.f915fap-8 +-0x1.8bc1bcp-8 +-0x1.dcf8e2p-8 +-0x1.ff511ap-8 +-0x1.1d20fap-7 +-0x1.a29ce8p-8 +-0x1.ff8274p-8 +-0x1.09c18cp-7 +-0x1.2da4d6p-7 +-0x1.b86536p-8 +-0x1.0ab97p-7 +-0x1.0fecbap-7 +-0x1.32a7bep-7 +-0x1.d09906p-8 +-0x1.1132d4p-7 +-0x1.11f926p-7 +-0x1.2e7c2p-7 +-0x1.e9c15p-8 +-0x1.133c1p-7 +-0x1.1140e8p-7 +-0x1.22be32p-7 +-0x1.01d16ap-7 +-0x1.6ff626p-8 +-0x1.75a332p-8 +-0x1.8992fp-8 +-0x1.5c01b6p-8 +-0x1.75fa2cp-8 +-0x1.85d52cp-8 +-0x1.a771p-8 +-0x1.543964p-8 +-0x1.85d43p-8 +-0x1.a82ca2p-8 +-0x1.cb7e12p-8 +-0x1.6234b2p-8 +-0x1.a6a988p-8 +-0x1.de32b6p-8 +-0x1.fb0c06p-8 +-0x1.89ea9cp-8 +-0x1.db1a5p-8 +-0x1.ff2868p-8 +-0x1.1bd014p-7 +-0x1.a33656p-8 +-0x1.ff1d24p-8 +-0x1.0a2a0ep-7 +-0x1.2d03a8p-7 +-0x1.ba111cp-8 +-0x1.0b0988p-7 +-0x1.1060cep-7 +-0x1.328dep-7 +-0x1.d252ecp-8 +-0x1.119ceap-7 +-0x1.127908p-7 +-0x1.2e9a7cp-7 +-0x1.eb571ap-8 +-0x1.13b62cp-7 +-0x1.122e22p-7 +-0x1.230dc4p-7 +-0x1.02e8c2p-7 +-0x1.6f9afcp-8 +-0x1.75c482p-8 +-0x1.89135ep-8 +-0x1.5c476ep-8 +-0x1.760ba4p-8 +-0x1.86e21cp-8 +-0x1.a73a58p-8 +-0x1.558e4p-8 +-0x1.86c006p-8 +-0x1.aa2b46p-8 +-0x1.cbf4dp-8 +-0x1.64a7d8p-8 +-0x1.a8859ap-8 +-0x1.dc8ceep-8 +-0x1.fc506cp-8 +-0x1.88dd66p-8 +-0x1.d9da6cp-8 +-0x1.feedeap-8 +-0x1.1acc14p-7 +-0x1.a3c2ep-8 +-0x1.feb766p-8 +-0x1.0a815ep-7 +-0x1.2c632cp-7 +-0x1.bb98e6p-8 +-0x1.0b4aa2p-7 +-0x1.10ceeap-7 +-0x1.32680ap-7 +-0x1.d3faeep-8 +-0x1.11ff9p-7 +-0x1.130142p-7 +-0x1.2eb358p-7 +-0x1.ecf9b2p-8 +-0x1.1435d2p-7 +-0x1.130c38p-7 +-0x1.2363e6p-7 +-0x1.03eff4p-7 +-0x1.6f4f9ap-8 +-0x1.75f68p-8 +-0x1.87eefp-8 +-0x1.aba2d4p-8 +-0x1.db74a4p-8 +-0x1.feaee2p-8 +-0x1.0acb3ep-7 +-0x1.11386p-7 +-0x1.138e24p-7 +-0x1.13dc1ap-7 +0x0p+0 +-0x1.59c0dp-1 +-0x1.4f65dp+1 +-0x1.59c0dp-1 +0x1.f1721ep+1 +-0x1.4f65dp+1 +0x1.2ea028p-2 +-0x1.e3a0bcp+0 +0x0p+0 +-0x1.1afa34p+0 +-0x1.e3a0bcp+0 +-0x1.954338p-4 +0x0p+0 +-0x1.4f65dp+1 +-0x1.14c24cp+1 +-0x1.e3a0bcp+0 +-0x1.14c24cp+1 +-0x1.1afa34p+0 +-0x1.081d12p+0 +-0x1.954338p-4 +-0x1.081d12p+0 +0x1.2ea028p-2 +-0x1.d643dcp-2 +0x1.478dd8p-6 +-0x1.d643dcp-2 +-0x1.974bbcp-1 +-0x1.3f646ap+1 +-0x1.974bbcp-1 +0x1.056c7ap+2 +-0x1.3f646ap+1 +0x1.4bdbd8p-2 +-0x1.ef40ep+0 +0x0p+0 +-0x1.0f02e8p+0 +-0x1.ef5a88p+0 +-0x1.55fdccp-2 +0x0p+0 +-0x1.1ba8eep+1 +-0x1.3fe83ap+1 +-0x1.1c4332p+1 +-0x1.ef5a88p+0 +-0x1.08a026p+0 +-0x1.0f02e8p+0 +-0x1.08a4e8p+0 +-0x1.55fdccp-2 +-0x1.24e818p-1 +0x1.4d0428p-2 +-0x1.222d66p-1 +0x1.9bf652p-6 +-0x1.974bbcp-1 +-0x1.3fe83ap+1 +-0x1.974bbcp-1 +0x1.056c7ap+2 +-0x1.3fe83ap+1 +0x1.4d0428p-2 +-0x1.ef5a88p+0 +0x0p+0 +-0x1.0f02e8p+0 +-0x1.ef6aa6p+0 +-0x1.55fdccp-2 +0x0p+0 +-0x1.1bd13p+1 +-0x1.405b56p+1 +-0x1.1c23ecp+1 +-0x1.ef6aa6p+0 +-0x1.df839cp-1 +-0x1.0f02e8p+0 +-0x1.efb6bap-1 +-0x1.55fdccp-2 +-0x1.2308dep-1 +0x1.4dfcfap-2 +-0x1.23373cp-1 +0x1.9bf652p-6 +-0x1.974bbcp-1 +-0x1.405b56p+1 +-0x1.974bbcp-1 +0x1.056c7ap+2 +-0x1.405b56p+1 +0x1.4dfcfap-2 +-0x1.ef6aa6p+0 +0x0p+0 +-0x1.0f02e8p+0 +-0x1.ef7798p+0 +-0x1.55fdccp-2 +0x0p+0 +-0x1.1c04a6p+1 +-0x1.40c506p+1 +-0x1.1c35f2p+1 +-0x1.ef7798p+0 +-0x1.ea5daep-1 +-0x1.0f02e8p+0 +-0x1.ec30fp-1 +-0x1.55fdccp-2 +-0x1.232656p-1 +0x1.4ede06p-2 +-0x1.239fccp-1 +0x1.9bf652p-6 +-0x1.974bbcp-1 +0x1.056c7ap+2 +-0x1.40c506p+1 +-0x1.1c2306p+1 +-0x1.ef7798p+0 +-0x1.0f02e8p+0 +-0x1.eb8f3ap-1 +-0x1.55fdccp-2 +0x0p+0 +0x1.4ede06p-2 +-0x1.2373dp-1 +0x1.9bf652p-6 +-0x1.96b438p-1 +-0x1.50c174p+2 +-0x1.96b438p-1 +0x1.4ecb08p+2 +-0x1.96b438p-1 +0x1.8707bp-1 +-0x1.50c174p+2 +0x0p+0 +0x1.8707bp-1 +-0x1.e637dp+1 +0x1.4ecb08p+2 +-0x1.e637dp+1 +-0x1.50c174p+2 +-0x1.031754p+0 +-0x1.84638ep+1 +-0x1.031754p+0 +-0x1.9185bcp-1 +-0x1.5a75d8p+2 +-0x1.9185bcp-1 +0x1.435754p+2 +-0x1.9185bcp-1 +0x1.5d6672p-1 +-0x1.5a6b56p+2 +0x0p+0 +-0x1.efa46ap+1 +0x1.5d6672p-1 +-0x1.ef7f0cp+1 +0x1.434c3ep+2 +-0x1.0d6fcep+0 +-0x1.5a6b56p+2 +-0x1.0a47ecp+0 +-0x1.8bcc6cp+1 +-0x1.9185bcp-1 +-0x1.5a6b56p+2 +-0x1.9185bcp-1 +0x1.434c3ep+2 +-0x1.9185bcp-1 +0x1.5d6672p-1 +-0x1.5a6124p+2 +0x0p+0 +-0x1.ef7956p+1 +0x1.5d6672p-1 +-0x1.ef7b62p+1 +0x1.4341c8p+2 +-0x1.0b672p+0 +-0x1.5a6124p+2 +-0x1.0b1c5ap+0 +-0x1.8bcc6cp+1 +-0x1.9185bcp-1 +-0x1.5a6124p+2 +-0x1.9185bcp-1 +0x1.4341c8p+2 +-0x1.9185bcp-1 +0x1.5d6672p-1 +-0x1.5a56f4p+2 +0x0p+0 +-0x1.ef6b66p+1 +0x1.5d6672p-1 +-0x1.ef7124p+1 +0x1.4337dap+2 +-0x1.0b3704p+0 +-0x1.5a56f4p+2 +-0x1.0b4888p+0 +-0x1.8bcc6cp+1 +-0x1.9185bcp-1 +0x1.5d6672p-1 +-0x1.ef60c4p+1 +0x1.4337dap+2 +-0x1.5a56f4p+2 +-0x1.0b4244p+0 +-0x1.8bcc6cp+1 +0x0p+0 +-0x1.4a1ad2p+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x1.8493d8p-32 +0x0p+0 +-0x1.8493dap-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.1ce356p+2 +-0x1.a1a99ap-1 +-0x1.960e08p+2 +-0x1.a1a99ap-1 +-0x1.ac286p-1 +-0x1.22729ep+2 +-0x1.ac2588p-1 +-0x1.9d465ap+2 +-0x1.ac263ap-1 +-0x1.9d465ap+2 +-0x1.22729ep+2 +0x0p+0 +0x1.f82de8p-9 +0x1.4b24b4p-6 +0x1.f82de8p-9 +0x1.3c614cp-8 +0x0p+0 +0x1.3c56dap-8 +0x1.9f8d2ep-6 +0x1.3c6ecap-8 +0x1.9f8d2ep-6 +0x0p+0 +0x1.55ae36p-1 +-0x1.ae10c6p-1 +-0x1.fa17bcp+0 +-0x1.ae10c6p-1 +-0x1.bbcdep-1 +0x1.795c86p-1 +-0x1.bbcd4ap-1 +-0x1.0f5726p+1 +-0x1.bbccf8p-1 +-0x1.0f5726p+1 +0x1.795c86p-1 +0x1.98df72p+0 +-0x1.0338a8p+0 +-0x1.1e1212p+2 +-0x1.0338a8p+0 +-0x1.0e70d4p+0 +0x1.a47d56p+0 +-0x1.0e6a06p+0 +-0x1.21efb4p+2 +-0x1.0e6b38p+0 +-0x1.21efb4p+2 +0x1.a47d56p+0 +0x1.e50418p-4 +0x0p+0 +0x1.a3b146p-4 +0x1.e50418p-4 +0x1.756012p-4 +0x1.a3b146p-4 +0x1.09fc38p-4 +0x1.756012p-4 +0x1.9f2ddep-6 +0x1.09fc38p-4 +-0x1.aeb56cp-6 +0x1.9f2ddep-6 +-0x1.076926p-4 +-0x1.aeb56cp-6 +-0x1.69e116p-4 +-0x1.076926p-4 +-0x1.a2c93ep-4 +-0x1.69e116p-4 +-0x1.f40c86p-4 +-0x1.a2c93ep-4 +0x0p+0 +-0x1.f40c86p-4 +0x0p+0 +0x1.e148c6p-4 +0x1.e1b3acp-4 +0x1.b944b4p-4 +0x1.b9b8cap-4 +0x1.938b6ep-4 +0x1.9410cap-4 +0x1.235cfep-4 +0x1.24f7ccp-4 +0x1.b2d8e4p-6 +0x1.bccc44p-6 +-0x1.c75506p-6 +-0x1.bc9672p-6 +-0x1.20bfb6p-4 +-0x1.1ed066p-4 +-0x1.88483ap-4 +-0x1.87374cp-4 +-0x1.b8364p-4 +-0x1.b78b8p-4 +-0x1.ef50ccp-4 +-0x1.eeb1c4p-4 +0x0p+0 +0x0p+0 +0x1.e12aacp-4 +0x1.e16f94p-4 +0x1.b94ee6p-4 +0x1.b9d5c4p-4 +0x1.92e97ep-4 +0x1.938bb4p-4 +0x1.22f552p-4 +0x1.24ae36p-4 +0x1.b19f6ep-6 +0x1.bbaf46p-6 +-0x1.c62bep-6 +-0x1.bb5ddcp-6 +-0x1.20541ep-4 +-0x1.1e7712p-4 +-0x1.87c004p-4 +-0x1.86cc74p-4 +-0x1.b84a2ep-4 +-0x1.b7bcb6p-4 +-0x1.ef01acp-4 +-0x1.ee63fcp-4 +0x0p+0 +0x0p+0 +0x1.e0fb2p-4 +0x1.e13598p-4 +0x1.b9842cp-4 +0x1.ba0682p-4 +0x1.92847ep-4 +0x1.93216p-4 +0x1.22b4bcp-4 +0x1.246bb6p-4 +0x1.b0a386p-6 +0x1.baaa56p-6 +-0x1.c53894p-6 +-0x1.ba5f26p-6 +-0x1.20163p-4 +-0x1.1e336ep-4 +-0x1.8774f4p-4 +-0x1.867b46p-4 +-0x1.b8795ap-4 +-0x1.b7ec72p-4 +-0x1.eeb34ep-4 +-0x1.ee175ep-4 +0x0p+0 +0x1.e0bf54p-4 +0x1.b9ac24p-4 +0x1.921a38p-4 +0x1.22712ep-4 +0x1.afb95ep-6 +-0x1.c41f38p-6 +-0x1.1fcb5p-4 +-0x1.872726p-4 +-0x1.b8a772p-4 +-0x1.ee6606p-4 +0x0p+0 +-0x1.5a8d62p-8 +-0x1.61a19cp-8 +-0x1.74820ep-8 +-0x1.9989b6p-8 +-0x1.caf4b6p-8 +-0x1.f02edep-8 +-0x1.04789ep-7 +-0x1.0ba4bep-7 +-0x1.0e73e4p-7 +-0x1.0ef80cp-7 +0x0p+0 +-0x1.59c0dp-1 +0x1.f1721ep+1 +-0x1.96b438p-1 +-0x1.47b502p+2 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +-0x1.081d12p+0 +-0x1.954338p-4 +-0x1.1afa34p+0 +-0x1.14c24cp+1 +-0x1.e3a0bcp+0 +-0x1.4f65dp+1 +-0x1.031754p+0 +-0x1.50c174p+2 +-0x1.84638ep+1 +-0x1.a1a99ap-1 +-0x1.1ce356p+2 +-0x1.960e08p+2 +0x1.f82de8p-9 +0x0p+0 +0x1.4b24b4p-6 +-0x1.d643dcp-2 +0x1.478dd8p-6 +0x1.2ea028p-2 +-0x1.ae10c6p-1 +0x1.55ae36p-1 +-0x1.fa17bcp+0 +-0x1.e637dp+1 +0x1.8707bp-1 +0x1.4ecb08p+2 +-0x1.0338a8p+0 +0x1.98df72p+0 +-0x1.1e1212p+2 +0x1.e50418p-4 +0x1.a3b146p-4 +0x1.756012p-4 +0x1.09fc38p-4 +0x1.9f2ddep-6 +-0x1.aeb56cp-6 +-0x1.076926p-4 +-0x1.69e116p-4 +-0x1.a2c93ep-4 +-0x1.f40c86p-4 +0x0p+0 +0x1.f1721ep+1 +0x0p+0 +0x1.056c7ap+2 +0x0p+0 +0x1.07be9p+2 +0x0p+0 +0x1.040e34p+2 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.66e79cp+2 +0x0p+0 +0x1.5f363ep+2 +0x0p+0 +0x1.193788p+2 +0x0p+0 +0x1.1641dp+2 +0x0p+0 +0x1.3e079cp+1 +0x0p+0 +0x1.34dea8p+1 +0x0p+0 +0x1.4ecb08p+2 +0x0p+0 +0x1.4337dap+2 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x1.8493d8p-32 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x0p+0 +0x1.501872p+2 +0x0p+0 +0x1.54adcep+2 +0x0p+0 +0x1.8bcaaap+2 +0x0p+0 +0x1.7cbfdap+2 +0x0p+0 +0x1.4b6128p+2 +0x0p+0 +0x1.4e5efcp+2 +0x0p+0 +0x1.8707bp-1 +0x0p+0 +0x1.5d6672p-1 +0x0p+0 +0x1.5c5d9ep+2 +0x0p+0 +0x1.5aa618p+2 +0x0p+0 +0x1.5f493p+2 +0x0p+0 +0x1.5feefep+2 +0x0p+0 +0x1.55ae36p-1 +0x0p+0 +0x1.795c86p-1 +0x0p+0 +0x1.1399c8p+2 +0x0p+0 +0x1.0a7424p+2 +0x0p+0 +0x1.9fdbdep+1 +0x0p+0 +0x1.9873p+1 +0x0p+0 +0x1.5159ep+2 +0x0p+0 +0x1.4f4f24p+2 +0x0p+0 +0x1.193788p+2 +0x0p+0 +0x1.1641dp+2 +0x0p+0 +0x1.057908p+0 +0x0p+0 +0x1.be461p-1 +0x0p+0 +0x1.51518cp+2 +0x0p+0 +0x1.4e84e8p+2 +0x0p+0 +0x1.d0369p+0 +0x0p+0 +0x1.c0c008p+0 +0x0p+0 +0x1.98df72p+0 +0x0p+0 +0x1.a47d56p+0 +0x0p+0 +0x1.8e3164p+2 +0x0p+0 +0x1.86f912p+2 +0x0p+0 +0x1.5dea82p+2 +0x0p+0 +0x1.5c9aeep+2 +0x0p+0 +0x1.d4f18p+0 +0x0p+0 +0x1.beb46p+0 +0x0p+0 +0x1.a3b146p-4 +0x0p+0 +0x1.b9ac24p-4 +0x0p+0 +0x1.8b9492p+2 +0x0p+0 +0x1.8b3d18p+2 +-0x1.6f4f9ap-8 +-0x1.75f68p-8 +-0x1.75f68p-8 +-0x1.87eefp-8 +-0x1.87eefp-8 +-0x1.aba2d4p-8 +-0x1.aba2d4p-8 +-0x1.db74a4p-8 +-0x1.db74a4p-8 +-0x1.feaee2p-8 +-0x1.feaee2p-8 +-0x1.0acb3ep-7 +-0x1.0acb3ep-7 +-0x1.11386p-7 +-0x1.11386p-7 +-0x1.138e24p-7 +-0x1.138e24p-7 +-0x1.13dc1ap-7 +-0x1.852784p-8 +-0x1.89e22cp-8 +-0x1.9e3a2ap-8 +-0x1.70cb3ep-8 +-0x1.8a4ff4p-8 +-0x1.985e0cp-8 +-0x1.babdc4p-8 +-0x1.67cc9ap-8 +-0x1.988c2ap-8 +-0x1.b76204p-8 +-0x1.dca0a2p-8 +-0x1.73023p-8 +-0x1.b6405ep-8 +-0x1.f12d86p-8 +-0x1.04524ep-7 +-0x1.9ee3aep-8 +-0x1.ed9152p-8 +-0x1.06e89p-7 +-0x1.23d858p-7 +-0x1.b4469ep-8 +-0x1.071124p-7 +-0x1.10142cp-7 +-0x1.334672p-7 +-0x1.c8633cp-8 +-0x1.111694p-7 +-0x1.15805cp-7 +-0x1.3771dp-7 +-0x1.dee04p-8 +-0x1.16cb02p-7 +-0x1.171366p-7 +-0x1.32dc2cp-7 +-0x1.f66134p-8 +-0x1.1856d8p-7 +-0x1.1624f6p-7 +-0x1.272e4cp-7 +-0x1.075ec2p-7 +-0x1.84b62ap-8 +-0x1.89ecf8p-8 +-0x1.9da8cep-8 +-0x1.70f61p-8 +-0x1.8a4bfap-8 +-0x1.993c16p-8 +-0x1.ba6cf2p-8 +-0x1.68f75ep-8 +-0x1.9948c2p-8 +-0x1.ba42dep-8 +-0x1.dcf3acp-8 +-0x1.764b8p-8 +-0x1.b8d83ep-8 +-0x1.eea714p-8 +-0x1.054cbep-7 +-0x1.9d01a8p-8 +-0x1.eba4a6p-8 +-0x1.06d39p-7 +-0x1.22833ap-7 +-0x1.b4d914p-8 +-0x1.06dc2ap-7 +-0x1.107aa6p-7 +-0x1.32a7a4p-7 +-0x1.ca01cp-8 +-0x1.116444p-7 +-0x1.15f28p-7 +-0x1.375c2ep-7 +-0x1.e0892p-8 +-0x1.173364p-7 +-0x1.1792ap-7 +-0x1.32fd9ep-7 +-0x1.f7ec3p-8 +-0x1.18cfc2p-7 +-0x1.17103cp-7 +-0x1.277ff2p-7 +-0x1.0870e8p-7 +-0x1.84539p-8 +-0x1.8a0a04p-8 +-0x1.9d255ep-8 +-0x1.7133f2p-8 +-0x1.8a58p-8 +-0x1.9a3f38p-8 +-0x1.ba2e5ap-8 +-0x1.6a44f2p-8 +-0x1.9a2bdap-8 +-0x1.bc4386p-8 +-0x1.dd63bcp-8 +-0x1.78be9ep-8 +-0x1.baae92p-8 +-0x1.ecf68cp-8 +-0x1.05eeap-7 +-0x1.9be49p-8 +-0x1.ea5b9ap-8 +-0x1.06b47cp-7 +-0x1.217e6p-7 +-0x1.b55a7ep-8 +-0x1.06a8e4p-7 +-0x1.10cf8p-7 +-0x1.32098p-7 +-0x1.cb7f2ep-8 +-0x1.11a368p-7 +-0x1.165f9p-7 +-0x1.3739a2p-7 +-0x1.e224a4p-8 +-0x1.1795fep-7 +-0x1.1818cep-7 +-0x1.3319bp-7 +-0x1.f9843cp-8 +-0x1.194e52p-7 +-0x1.17ed4ep-7 +-0x1.27d7d6p-7 +-0x1.097448p-7 +-0x1.8401eep-8 +-0x1.8a3592p-8 +-0x1.9b4b24p-8 +-0x1.bdb3cp-8 +-0x1.ebd258p-8 +-0x1.069428p-7 +-0x1.111694p-7 +-0x1.16c81cp-7 +-0x1.18a3ep-7 +-0x1.18bcfcp-7 +0x0p+0 +-0x1.974bbcp-1 +0x1.056c7ap+2 +-0x1.d4d6a8p-1 +0x1.121fe6p+2 +-0x1.d4d6a8p-1 +0x1.121fe6p+2 +-0x1.9185bcp-1 +-0x1.5a56f4p+2 +-0x1.9185bcp-1 +0x1.4337dap+2 +-0x1.9185bcp-1 +0x1.5d6672p-1 +-0x1.5a56f4p+2 +0x0p+0 +0x1.5d6672p-1 +-0x1.ef60c4p+1 +0x1.4337dap+2 +-0x1.ef60c4p+1 +-0x1.5a56f4p+2 +-0x1.0b4244p+0 +-0x1.8bcc6cp+1 +-0x1.0b4244p+0 +-0x1.697dfep-1 +-0x1.6399ap+2 +-0x1.697dfep-1 +0x1.37851p+2 +-0x1.697dfep-1 +0x1.33c534p-1 +-0x1.638706p+2 +0x0p+0 +-0x1.f86bdep+1 +0x1.33c534p-1 +-0x1.f86f94p+1 +0x1.3781aap+2 +-0x1.15ea38p+0 +-0x1.638706p+2 +-0x1.1618ep+0 +-0x1.93354ap+1 +-0x1.697dfep-1 +-0x1.638706p+2 +-0x1.697dfep-1 +0x1.3781aap+2 +-0x1.697dfep-1 +0x1.33c534p-1 +-0x1.6374dcp+2 +0x0p+0 +-0x1.f85828p+1 +0x1.33c534p-1 +-0x1.f860ap+1 +0x1.377e3ep+2 +-0x1.160728p+0 +-0x1.6374dcp+2 +-0x1.162d16p+0 +-0x1.93354ap+1 +-0x1.697dfep-1 +-0x1.6374dcp+2 +-0x1.697dfep-1 +0x1.377e3ep+2 +-0x1.697dfep-1 +0x1.33c534p-1 +-0x1.63632ep+2 +0x0p+0 +-0x1.f84f42p+1 +0x1.33c534p-1 +-0x1.f85578p+1 +0x1.377adp+2 +-0x1.161f6cp+0 +-0x1.63632ep+2 +-0x1.164296p+0 +-0x1.93354ap+1 +-0x1.697dfep-1 +0x1.33c534p-1 +-0x1.f845ap+1 +0x1.377adp+2 +-0x1.63632ep+2 +-0x1.16361p+0 +-0x1.93354ap+1 +0x0p+0 +-0x1.4c80a2p+2 +0x0p+0 diff --git a/libc/AOR_v20.02/math/test/ulp.c b/libc/AOR_v20.02/math/test/ulp.c new file mode 100644 index 00000000000000..3821986f7cb485 --- /dev/null +++ b/libc/AOR_v20.02/math/test/ulp.c @@ -0,0 +1,852 @@ +/* + * ULP error checking tool for math functions. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "mathlib.h" + +/* Don't depend on mpfr by default. */ +#ifndef USE_MPFR +# define USE_MPFR 0 +#endif +#if USE_MPFR +# include +#endif + +#ifndef WANT_VMATH +/* Enable the build of vector math code. */ +# define WANT_VMATH 1 +#endif + +static inline uint64_t +asuint64 (double f) +{ + union + { + double f; + uint64_t i; + } u = {f}; + return u.i; +} + +static inline double +asdouble (uint64_t i) +{ + union + { + uint64_t i; + double f; + } u = {i}; + return u.f; +} + +static inline uint32_t +asuint (float f) +{ + union + { + float f; + uint32_t i; + } u = {f}; + return u.i; +} + +static inline float +asfloat (uint32_t i) +{ + union + { + uint32_t i; + float f; + } u = {i}; + return u.f; +} + +static uint64_t seed = 0x0123456789abcdef; +static uint64_t +rand64 (void) +{ + seed = 6364136223846793005ull * seed + 1; + return seed ^ (seed >> 32); +} + +/* Uniform random in [0,n]. */ +static uint64_t +randn (uint64_t n) +{ + uint64_t r, m; + + if (n == 0) + return 0; + n++; + if (n == 0) + return rand64 (); + for (;;) + { + r = rand64 (); + m = r % n; + if (r - m <= -n) + return m; + } +} + +struct gen +{ + uint64_t start; + uint64_t len; + uint64_t start2; + uint64_t len2; + uint64_t off; + uint64_t step; + uint64_t cnt; +}; + +struct args_f1 +{ + float x; +}; + +struct args_f2 +{ + float x; + float x2; +}; + +struct args_d1 +{ + double x; +}; + +struct args_d2 +{ + double x; + double x2; +}; + +/* result = y + tail*2^ulpexp. */ +struct ret_f +{ + float y; + double tail; + int ulpexp; + int ex; + int ex_may; +}; + +struct ret_d +{ + double y; + double tail; + int ulpexp; + int ex; + int ex_may; +}; + +static inline uint64_t +next1 (struct gen *g) +{ + /* For single argument use randomized incremental steps, + that produce dense sampling without collisions and allow + testing all inputs in a range. */ + uint64_t r = g->start + g->off; + g->off += g->step + randn (g->step / 2); + if (g->off > g->len) + g->off -= g->len; /* hack. */ + return r; +} + +static inline uint64_t +next2 (uint64_t *x2, struct gen *g) +{ + /* For two arguments use uniform random sampling. */ + uint64_t r = g->start + randn (g->len); + *x2 = g->start2 + randn (g->len2); + return r; +} + +static struct args_f1 +next_f1 (void *g) +{ + return (struct args_f1){asfloat (next1 (g))}; +} + +static struct args_f2 +next_f2 (void *g) +{ + uint64_t x2; + uint64_t x = next2 (&x2, g); + return (struct args_f2){asfloat (x), asfloat (x2)}; +} + +static struct args_d1 +next_d1 (void *g) +{ + return (struct args_d1){asdouble (next1 (g))}; +} + +static struct args_d2 +next_d2 (void *g) +{ + uint64_t x2; + uint64_t x = next2 (&x2, g); + return (struct args_d2){asdouble (x), asdouble (x2)}; +} + +struct conf +{ + int r; + int rc; + int quiet; + int mpfr; + int fenv; + unsigned long long n; + double softlim; + double errlim; +}; + +/* Wrappers for sincos. */ +static float sincosf_sinf(float x) {(void)cosf(x); return sinf(x);} +static float sincosf_cosf(float x) {(void)sinf(x); return cosf(x);} +static double sincos_sin(double x) {(void)cos(x); return sin(x);} +static double sincos_cos(double x) {(void)sin(x); return cos(x);} +#if USE_MPFR +static int sincos_mpfr_sin(mpfr_t y, const mpfr_t x, mpfr_rnd_t r) { mpfr_cos(y,x,r); return mpfr_sin(y,x,r); } +static int sincos_mpfr_cos(mpfr_t y, const mpfr_t x, mpfr_rnd_t r) { mpfr_sin(y,x,r); return mpfr_cos(y,x,r); } +#endif + +/* A bit of a hack: call vector functions twice with the same + input in lane 0 but a different value in other lanes: once + with an in-range value and then with a special case value. */ +static int secondcall; + +/* Wrappers for vector functions. */ +#if __aarch64__ && WANT_VMATH +typedef __f32x4_t v_float; +typedef __f64x2_t v_double; +static const float fv[2] = {1.0f, -INFINITY}; +static const double dv[2] = {1.0, -INFINITY}; +static inline v_float argf(float x) { return (v_float){x,x,x,fv[secondcall]}; } +static inline v_double argd(double x) { return (v_double){x,dv[secondcall]}; } + +static float v_sinf(float x) { return __v_sinf(argf(x))[0]; } +static float v_cosf(float x) { return __v_cosf(argf(x))[0]; } +static float v_expf_1u(float x) { return __v_expf_1u(argf(x))[0]; } +static float v_expf(float x) { return __v_expf(argf(x))[0]; } +static float v_exp2f_1u(float x) { return __v_exp2f_1u(argf(x))[0]; } +static float v_exp2f(float x) { return __v_exp2f(argf(x))[0]; } +static float v_logf(float x) { return __v_logf(argf(x))[0]; } +static float v_powf(float x, float y) { return __v_powf(argf(x),argf(y))[0]; } +static double v_sin(double x) { return __v_sin(argd(x))[0]; } +static double v_cos(double x) { return __v_cos(argd(x))[0]; } +static double v_exp(double x) { return __v_exp(argd(x))[0]; } +static double v_log(double x) { return __v_log(argd(x))[0]; } +static double v_pow(double x, double y) { return __v_pow(argd(x),argd(y))[0]; } +#ifdef __vpcs +static float vn_sinf(float x) { return __vn_sinf(argf(x))[0]; } +static float vn_cosf(float x) { return __vn_cosf(argf(x))[0]; } +static float vn_expf_1u(float x) { return __vn_expf_1u(argf(x))[0]; } +static float vn_expf(float x) { return __vn_expf(argf(x))[0]; } +static float vn_exp2f_1u(float x) { return __vn_exp2f_1u(argf(x))[0]; } +static float vn_exp2f(float x) { return __vn_exp2f(argf(x))[0]; } +static float vn_logf(float x) { return __vn_logf(argf(x))[0]; } +static float vn_powf(float x, float y) { return __vn_powf(argf(x),argf(y))[0]; } +static double vn_sin(double x) { return __vn_sin(argd(x))[0]; } +static double vn_cos(double x) { return __vn_cos(argd(x))[0]; } +static double vn_exp(double x) { return __vn_exp(argd(x))[0]; } +static double vn_log(double x) { return __vn_log(argd(x))[0]; } +static double vn_pow(double x, double y) { return __vn_pow(argd(x),argd(y))[0]; } +static float Z_sinf(float x) { return _ZGVnN4v_sinf(argf(x))[0]; } +static float Z_cosf(float x) { return _ZGVnN4v_cosf(argf(x))[0]; } +static float Z_expf(float x) { return _ZGVnN4v_expf(argf(x))[0]; } +static float Z_exp2f(float x) { return _ZGVnN4v_exp2f(argf(x))[0]; } +static float Z_logf(float x) { return _ZGVnN4v_logf(argf(x))[0]; } +static float Z_powf(float x, float y) { return _ZGVnN4vv_powf(argf(x),argf(y))[0]; } +static double Z_sin(double x) { return _ZGVnN2v_sin(argd(x))[0]; } +static double Z_cos(double x) { return _ZGVnN2v_cos(argd(x))[0]; } +static double Z_exp(double x) { return _ZGVnN2v_exp(argd(x))[0]; } +static double Z_log(double x) { return _ZGVnN2v_log(argd(x))[0]; } +static double Z_pow(double x, double y) { return _ZGVnN2vv_pow(argd(x),argd(y))[0]; } +#endif +#endif + +struct fun +{ + const char *name; + int arity; + int singleprec; + int twice; + union + { + float (*f1) (float); + float (*f2) (float, float); + double (*d1) (double); + double (*d2) (double, double); + } fun; + union + { + double (*f1) (double); + double (*f2) (double, double); + long double (*d1) (long double); + long double (*d2) (long double, long double); + } fun_long; +#if USE_MPFR + union + { + int (*f1) (mpfr_t, const mpfr_t, mpfr_rnd_t); + int (*f2) (mpfr_t, const mpfr_t, const mpfr_t, mpfr_rnd_t); + int (*d1) (mpfr_t, const mpfr_t, mpfr_rnd_t); + int (*d2) (mpfr_t, const mpfr_t, const mpfr_t, mpfr_rnd_t); + } fun_mpfr; +#endif +}; + +static const struct fun fun[] = { +#if USE_MPFR +# define F(x, x_wrap, x_long, x_mpfr, a, s, t, twice) \ + {#x, a, s, twice, {.t = x_wrap}, {.t = x_long}, {.t = x_mpfr}}, +#else +# define F(x, x_wrap, x_long, x_mpfr, a, s, t, twice) \ + {#x, a, s, twice, {.t = x_wrap}, {.t = x_long}}, +#endif +#define F1(x) F (x##f, x##f, x, mpfr_##x, 1, 1, f1, 0) +#define F2(x) F (x##f, x##f, x, mpfr_##x, 2, 1, f2, 0) +#define D1(x) F (x, x, x##l, mpfr_##x, 1, 0, d1, 0) +#define D2(x) F (x, x, x##l, mpfr_##x, 2, 0, d2, 0) + F1 (sin) + F1 (cos) + F (sincosf_sinf, sincosf_sinf, sincos_sin, sincos_mpfr_sin, 1, 1, f1, 0) + F (sincosf_cosf, sincosf_cosf, sincos_cos, sincos_mpfr_cos, 1, 1, f1, 0) + F1 (exp) + F1 (exp2) + F1 (log) + F1 (log2) + F2 (pow) + D1 (exp) + D1 (exp2) + D1 (log) + D1 (log2) + D2 (pow) +#if WANT_VMATH + F (__s_sinf, __s_sinf, sin, mpfr_sin, 1, 1, f1, 0) + F (__s_cosf, __s_cosf, cos, mpfr_cos, 1, 1, f1, 0) + F (__s_expf_1u, __s_expf_1u, exp, mpfr_exp, 1, 1, f1, 0) + F (__s_expf, __s_expf, exp, mpfr_exp, 1, 1, f1, 0) + F (__s_exp2f_1u, __s_exp2f_1u, exp2, mpfr_exp2, 1, 1, f1, 0) + F (__s_exp2f, __s_exp2f, exp2, mpfr_exp2, 1, 1, f1, 0) + F (__s_powf, __s_powf, pow, mpfr_pow, 2, 1, f2, 0) + F (__s_logf, __s_logf, log, mpfr_log, 1, 1, f1, 0) + F (__s_sin, __s_sin, sinl, mpfr_sin, 1, 0, d1, 0) + F (__s_cos, __s_cos, cosl, mpfr_cos, 1, 0, d1, 0) + F (__s_exp, __s_exp, expl, mpfr_exp, 1, 0, d1, 0) + F (__s_log, __s_log, logl, mpfr_log, 1, 0, d1, 0) + F (__s_pow, __s_pow, powl, mpfr_pow, 2, 0, d2, 0) +#if __aarch64__ + F (__v_sinf, v_sinf, sin, mpfr_sin, 1, 1, f1, 1) + F (__v_cosf, v_cosf, cos, mpfr_cos, 1, 1, f1, 1) + F (__v_expf_1u, v_expf_1u, exp, mpfr_exp, 1, 1, f1, 1) + F (__v_expf, v_expf, exp, mpfr_exp, 1, 1, f1, 1) + F (__v_exp2f_1u, v_exp2f_1u, exp2, mpfr_exp2, 1, 1, f1, 1) + F (__v_exp2f, v_exp2f, exp2, mpfr_exp2, 1, 1, f1, 1) + F (__v_logf, v_logf, log, mpfr_log, 1, 1, f1, 1) + F (__v_powf, v_powf, pow, mpfr_pow, 2, 1, f2, 1) + F (__v_sin, v_sin, sinl, mpfr_sin, 1, 0, d1, 1) + F (__v_cos, v_cos, cosl, mpfr_cos, 1, 0, d1, 1) + F (__v_exp, v_exp, expl, mpfr_exp, 1, 0, d1, 1) + F (__v_log, v_log, logl, mpfr_log, 1, 0, d1, 1) + F (__v_pow, v_pow, powl, mpfr_pow, 2, 0, d2, 1) +#ifdef __vpcs + F (__vn_sinf, vn_sinf, sin, mpfr_sin, 1, 1, f1, 1) + F (__vn_cosf, vn_cosf, cos, mpfr_cos, 1, 1, f1, 1) + F (__vn_expf_1u, vn_expf_1u, exp, mpfr_exp, 1, 1, f1, 1) + F (__vn_expf, vn_expf, exp, mpfr_exp, 1, 1, f1, 1) + F (__vn_exp2f_1u, vn_exp2f_1u, exp2, mpfr_exp2, 1, 1, f1, 1) + F (__vn_exp2f, vn_exp2f, exp2, mpfr_exp2, 1, 1, f1, 1) + F (__vn_logf, vn_logf, log, mpfr_log, 1, 1, f1, 1) + F (__vn_powf, vn_powf, pow, mpfr_pow, 2, 1, f2, 1) + F (__vn_sin, vn_sin, sinl, mpfr_sin, 1, 0, d1, 1) + F (__vn_cos, vn_cos, cosl, mpfr_cos, 1, 0, d1, 1) + F (__vn_exp, vn_exp, expl, mpfr_exp, 1, 0, d1, 1) + F (__vn_log, vn_log, logl, mpfr_log, 1, 0, d1, 1) + F (__vn_pow, vn_pow, powl, mpfr_pow, 2, 0, d2, 1) + F (_ZGVnN4v_sinf, Z_sinf, sin, mpfr_sin, 1, 1, f1, 1) + F (_ZGVnN4v_cosf, Z_cosf, cos, mpfr_cos, 1, 1, f1, 1) + F (_ZGVnN4v_expf, Z_expf, exp, mpfr_exp, 1, 1, f1, 1) + F (_ZGVnN4v_exp2f, Z_exp2f, exp2, mpfr_exp2, 1, 1, f1, 1) + F (_ZGVnN4v_logf, Z_logf, log, mpfr_log, 1, 1, f1, 1) + F (_ZGVnN4vv_powf, Z_powf, pow, mpfr_pow, 2, 1, f2, 1) + F (_ZGVnN2v_sin, Z_sin, sinl, mpfr_sin, 1, 0, d1, 1) + F (_ZGVnN2v_cos, Z_cos, cosl, mpfr_cos, 1, 0, d1, 1) + F (_ZGVnN2v_exp, Z_exp, expl, mpfr_exp, 1, 0, d1, 1) + F (_ZGVnN2v_log, Z_log, logl, mpfr_log, 1, 0, d1, 1) + F (_ZGVnN2vv_pow, Z_pow, powl, mpfr_pow, 2, 0, d2, 1) +#endif +#endif +#endif +#undef F +#undef F1 +#undef F2 +#undef D1 +#undef D2 + {0}}; + +/* Boilerplate for generic calls. */ + +static inline int +ulpscale_f (float x) +{ + int e = asuint (x) >> 23 & 0xff; + if (!e) + e++; + return e - 0x7f - 23; +} +static inline int +ulpscale_d (double x) +{ + int e = asuint64 (x) >> 52 & 0x7ff; + if (!e) + e++; + return e - 0x3ff - 52; +} +static inline float +call_f1 (const struct fun *f, struct args_f1 a) +{ + return f->fun.f1 (a.x); +} +static inline float +call_f2 (const struct fun *f, struct args_f2 a) +{ + return f->fun.f2 (a.x, a.x2); +} + +static inline double +call_d1 (const struct fun *f, struct args_d1 a) +{ + return f->fun.d1 (a.x); +} +static inline double +call_d2 (const struct fun *f, struct args_d2 a) +{ + return f->fun.d2 (a.x, a.x2); +} +static inline double +call_long_f1 (const struct fun *f, struct args_f1 a) +{ + return f->fun_long.f1 (a.x); +} +static inline double +call_long_f2 (const struct fun *f, struct args_f2 a) +{ + return f->fun_long.f2 (a.x, a.x2); +} +static inline long double +call_long_d1 (const struct fun *f, struct args_d1 a) +{ + return f->fun_long.d1 (a.x); +} +static inline long double +call_long_d2 (const struct fun *f, struct args_d2 a) +{ + return f->fun_long.d2 (a.x, a.x2); +} +static inline void +printcall_f1 (const struct fun *f, struct args_f1 a) +{ + printf ("%s(%a)", f->name, a.x); +} +static inline void +printcall_f2 (const struct fun *f, struct args_f2 a) +{ + printf ("%s(%a, %a)", f->name, a.x, a.x2); +} +static inline void +printcall_d1 (const struct fun *f, struct args_d1 a) +{ + printf ("%s(%a)", f->name, a.x); +} +static inline void +printcall_d2 (const struct fun *f, struct args_d2 a) +{ + printf ("%s(%a, %a)", f->name, a.x, a.x2); +} +static inline void +printgen_f1 (const struct fun *f, struct gen *gen) +{ + printf ("%s in [%a;%a]", f->name, asfloat (gen->start), + asfloat (gen->start + gen->len)); +} +static inline void +printgen_f2 (const struct fun *f, struct gen *gen) +{ + printf ("%s in [%a;%a] x [%a;%a]", f->name, asfloat (gen->start), + asfloat (gen->start + gen->len), asfloat (gen->start2), + asfloat (gen->start2 + gen->len2)); +} +static inline void +printgen_d1 (const struct fun *f, struct gen *gen) +{ + printf ("%s in [%a;%a]", f->name, asdouble (gen->start), + asdouble (gen->start + gen->len)); +} +static inline void +printgen_d2 (const struct fun *f, struct gen *gen) +{ + printf ("%s in [%a;%a] x [%a;%a]", f->name, asdouble (gen->start), + asdouble (gen->start + gen->len), asdouble (gen->start2), + asdouble (gen->start2 + gen->len2)); +} + +#define reduce_f1(a, f, op) (f (a.x)) +#define reduce_f2(a, f, op) (f (a.x) op f (a.x2)) +#define reduce_d1(a, f, op) (f (a.x)) +#define reduce_d2(a, f, op) (f (a.x) op f (a.x2)) + +#ifndef IEEE_754_2008_SNAN +# define IEEE_754_2008_SNAN 1 +#endif +static inline int +issignaling_f (float x) +{ + uint32_t ix = asuint (x); + if (!IEEE_754_2008_SNAN) + return (ix & 0x7fc00000) == 0x7fc00000; + return 2 * (ix ^ 0x00400000) > 2u * 0x7fc00000; +} +static inline int +issignaling_d (double x) +{ + uint64_t ix = asuint64 (x); + if (!IEEE_754_2008_SNAN) + return (ix & 0x7ff8000000000000) == 0x7ff8000000000000; + return 2 * (ix ^ 0x0008000000000000) > 2 * 0x7ff8000000000000ULL; +} + +#if USE_MPFR +static mpfr_rnd_t +rmap (int r) +{ + switch (r) + { + case FE_TONEAREST: + return MPFR_RNDN; + case FE_TOWARDZERO: + return MPFR_RNDZ; + case FE_UPWARD: + return MPFR_RNDU; + case FE_DOWNWARD: + return MPFR_RNDD; + } + return -1; +} + +#define prec_mpfr_f 50 +#define prec_mpfr_d 80 +#define prec_f 24 +#define prec_d 53 +#define emin_f -148 +#define emin_d -1073 +#define emax_f 128 +#define emax_d 1024 +static inline int +call_mpfr_f1 (mpfr_t y, const struct fun *f, struct args_f1 a, mpfr_rnd_t r) +{ + MPFR_DECL_INIT (x, prec_f); + mpfr_set_flt (x, a.x, MPFR_RNDN); + return f->fun_mpfr.f1 (y, x, r); +} +static inline int +call_mpfr_f2 (mpfr_t y, const struct fun *f, struct args_f2 a, mpfr_rnd_t r) +{ + MPFR_DECL_INIT (x, prec_f); + MPFR_DECL_INIT (x2, prec_f); + mpfr_set_flt (x, a.x, MPFR_RNDN); + mpfr_set_flt (x2, a.x2, MPFR_RNDN); + return f->fun_mpfr.f2 (y, x, x2, r); +} +static inline int +call_mpfr_d1 (mpfr_t y, const struct fun *f, struct args_d1 a, mpfr_rnd_t r) +{ + MPFR_DECL_INIT (x, prec_d); + mpfr_set_d (x, a.x, MPFR_RNDN); + return f->fun_mpfr.d1 (y, x, r); +} +static inline int +call_mpfr_d2 (mpfr_t y, const struct fun *f, struct args_d2 a, mpfr_rnd_t r) +{ + MPFR_DECL_INIT (x, prec_d); + MPFR_DECL_INIT (x2, prec_d); + mpfr_set_d (x, a.x, MPFR_RNDN); + mpfr_set_d (x2, a.x2, MPFR_RNDN); + return f->fun_mpfr.d2 (y, x, x2, r); +} +#endif + +#define float_f float +#define double_f double +#define copysign_f copysignf +#define nextafter_f nextafterf +#define fabs_f fabsf +#define asuint_f asuint +#define asfloat_f asfloat +#define scalbn_f scalbnf +#define lscalbn_f scalbn +#define halfinf_f 0x1p127f +#define min_normal_f 0x1p-126f + +#define float_d double +#define double_d long double +#define copysign_d copysign +#define nextafter_d nextafter +#define fabs_d fabs +#define asuint_d asuint64 +#define asfloat_d asdouble +#define scalbn_d scalbn +#define lscalbn_d scalbnl +#define halfinf_d 0x1p1023 +#define min_normal_d 0x1p-1022 + +#define NEW_RT +#define RT(x) x##_f +#define T(x) x##_f1 +#include "ulp.h" +#undef T +#define T(x) x##_f2 +#include "ulp.h" +#undef T +#undef RT + +#define NEW_RT +#define RT(x) x##_d +#define T(x) x##_d1 +#include "ulp.h" +#undef T +#define T(x) x##_d2 +#include "ulp.h" +#undef T +#undef RT + +static void +usage (void) +{ + puts ("./ulp [-q] [-m] [-f] [-r nudz] [-l soft-ulplimit] [-e ulplimit] func " + "lo [hi [x lo2 hi2] [count]]"); + puts ("Compares func against a higher precision implementation in [lo; hi]."); + puts ("-q: quiet."); + puts ("-m: use mpfr even if faster method is available."); + puts ("-f: disable fenv testing (rounding modes and exceptions)."); + puts ("Supported func:"); + for (const struct fun *f = fun; f->name; f++) + printf ("\t%s\n", f->name); + exit (1); +} + +static int +cmp (const struct fun *f, struct gen *gen, const struct conf *conf) +{ + int r = 1; + if (f->arity == 1 && f->singleprec) + r = cmp_f1 (f, gen, conf); + else if (f->arity == 2 && f->singleprec) + r = cmp_f2 (f, gen, conf); + else if (f->arity == 1 && !f->singleprec) + r = cmp_d1 (f, gen, conf); + else if (f->arity == 2 && !f->singleprec) + r = cmp_d2 (f, gen, conf); + else + usage (); + return r; +} + +static uint64_t +getnum (const char *s, int singleprec) +{ + // int i; + uint64_t sign = 0; + // char buf[12]; + + if (s[0] == '+') + s++; + else if (s[0] == '-') + { + sign = singleprec ? 1ULL << 31 : 1ULL << 63; + s++; + } + /* 0xXXXX is treated as bit representation, '-' flips the sign bit. */ + if (s[0] == '0' && tolower (s[1]) == 'x' && strchr (s, 'p') == 0) + return sign ^ strtoull (s, 0, 0); + // /* SNaN, QNaN, NaN, Inf. */ + // for (i=0; s[i] && i < sizeof buf; i++) + // buf[i] = tolower(s[i]); + // buf[i] = 0; + // if (strcmp(buf, "snan") == 0) + // return sign | (singleprec ? 0x7fa00000 : 0x7ff4000000000000); + // if (strcmp(buf, "qnan") == 0 || strcmp(buf, "nan") == 0) + // return sign | (singleprec ? 0x7fc00000 : 0x7ff8000000000000); + // if (strcmp(buf, "inf") == 0 || strcmp(buf, "infinity") == 0) + // return sign | (singleprec ? 0x7f800000 : 0x7ff0000000000000); + /* Otherwise assume it's a floating-point literal. */ + return sign + | (singleprec ? asuint (strtof (s, 0)) : asuint64 (strtod (s, 0))); +} + +static void +parsegen (struct gen *g, int argc, char *argv[], const struct fun *f) +{ + int singleprec = f->singleprec; + int arity = f->arity; + uint64_t a, b, a2, b2, n; + if (argc < 1) + usage (); + b = a = getnum (argv[0], singleprec); + n = 0; + if (argc > 1 && strcmp (argv[1], "x") == 0) + { + argc -= 2; + argv += 2; + } + else if (argc > 1) + { + b = getnum (argv[1], singleprec); + if (argc > 2 && strcmp (argv[2], "x") == 0) + { + argc -= 3; + argv += 3; + } + } + b2 = a2 = getnum (argv[0], singleprec); + if (argc > 1) + b2 = getnum (argv[1], singleprec); + if (argc > 2) + n = strtoull (argv[2], 0, 0); + if (argc > 3) + usage (); + //printf("ab %lx %lx ab2 %lx %lx n %lu\n", a, b, a2, b2, n); + if (arity == 1) + { + g->start = a; + g->len = b - a; + if (n - 1 > b - a) + n = b - a + 1; + g->off = 0; + g->step = n ? (g->len + 1) / n : 1; + g->start2 = g->len2 = 0; + g->cnt = n; + } + else if (arity == 2) + { + g->start = a; + g->len = b - a; + g->off = g->step = 0; + g->start2 = a2; + g->len2 = b2 - a2; + g->cnt = n; + } + else + usage (); +} + +int +main (int argc, char *argv[]) +{ + const struct fun *f; + struct gen gen; + struct conf conf; + conf.rc = 'n'; + conf.quiet = 0; + conf.mpfr = 0; + conf.fenv = 1; + conf.softlim = 0; + conf.errlim = INFINITY; + for (;;) + { + argc--; + argv++; + if (argc < 1) + usage (); + if (argv[0][0] != '-') + break; + switch (argv[0][1]) + { + case 'e': + argc--; + argv++; + if (argc < 1) + usage (); + conf.errlim = strtod (argv[0], 0); + break; + case 'f': + conf.fenv = 0; + break; + case 'l': + argc--; + argv++; + if (argc < 1) + usage (); + conf.softlim = strtod (argv[0], 0); + break; + case 'm': + conf.mpfr = 1; + break; + case 'q': + conf.quiet = 1; + break; + case 'r': + conf.rc = argv[0][2]; + if (!conf.rc) + { + argc--; + argv++; + if (argc < 1) + usage (); + conf.rc = argv[0][0]; + } + break; + default: + usage (); + } + } + switch (conf.rc) + { + case 'n': + conf.r = FE_TONEAREST; + break; + case 'u': + conf.r = FE_UPWARD; + break; + case 'd': + conf.r = FE_DOWNWARD; + break; + case 'z': + conf.r = FE_TOWARDZERO; + break; + default: + usage (); + } + for (f = fun; f->name; f++) + if (strcmp (argv[0], f->name) == 0) + break; + if (!f->name) + usage (); + if (!f->singleprec && LDBL_MANT_DIG == DBL_MANT_DIG) + conf.mpfr = 1; /* Use mpfr if long double has no extra precision. */ + if (!USE_MPFR && conf.mpfr) + { + puts ("mpfr is not available."); + return 0; + } + argc--; + argv++; + parsegen (&gen, argc, argv, f); + conf.n = gen.cnt; + return cmp (f, &gen, &conf); +} diff --git a/libc/AOR_v20.02/math/test/ulp.h b/libc/AOR_v20.02/math/test/ulp.h new file mode 100644 index 00000000000000..2743dc59b5a4b9 --- /dev/null +++ b/libc/AOR_v20.02/math/test/ulp.h @@ -0,0 +1,363 @@ +/* + * Generic functions for ULP error estimation. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* For each different math function type, + T(x) should add a different suffix to x. + RT(x) should add a return type specific suffix to x. */ + +#ifdef NEW_RT +#undef NEW_RT + +# if USE_MPFR +static int RT(ulpscale_mpfr) (mpfr_t x, int t) +{ + /* TODO: pow of 2 cases. */ + if (mpfr_regular_p (x)) + { + mpfr_exp_t e = mpfr_get_exp (x) - RT(prec); + if (e < RT(emin)) + e = RT(emin) - 1; + if (e > RT(emax) - RT(prec)) + e = RT(emax) - RT(prec); + return e; + } + if (mpfr_zero_p (x)) + return RT(emin) - 1; + if (mpfr_inf_p (x)) + return RT(emax) - RT(prec); + /* NaN. */ + return 0; +} +# endif + +/* Difference between exact result and closest real number that + gets rounded to got, i.e. error before rounding, for a correctly + rounded result the difference is 0. */ +static double RT(ulperr) (RT(float) got, const struct RT(ret) * p, int r) +{ + RT(float) want = p->y; + RT(float) d; + double e; + + if (RT(asuint) (got) == RT(asuint) (want)) + return 0.0; + if (signbit (got) != signbit (want)) + /* May have false positives with NaN. */ + //return isnan(got) && isnan(want) ? 0 : INFINITY; + return INFINITY; + if (!isfinite (want) || !isfinite (got)) + { + if (isnan (got) != isnan (want)) + return INFINITY; + if (isnan (want)) + return 0; + if (isinf (got)) + { + got = RT(copysign) (RT(halfinf), got); + want *= 0.5f; + } + if (isinf (want)) + { + want = RT(copysign) (RT(halfinf), want); + got *= 0.5f; + } + } + if (r == FE_TONEAREST) + { + // TODO: incorrect when got vs want cross a powof2 boundary + /* error = got > want + ? got - want - tail ulp - 0.5 ulp + : got - want - tail ulp + 0.5 ulp; */ + d = got - want; + e = d > 0 ? -p->tail - 0.5 : -p->tail + 0.5; + } + else + { + if ((r == FE_DOWNWARD && got < want) || (r == FE_UPWARD && got > want) + || (r == FE_TOWARDZERO && fabs (got) < fabs (want))) + got = RT(nextafter) (got, want); + d = got - want; + e = -p->tail; + } + return RT(scalbn) (d, -p->ulpexp) + e; +} + +static int RT(isok) (RT(float) ygot, int exgot, RT(float) ywant, int exwant, + int exmay) +{ + return RT(asuint) (ygot) == RT(asuint) (ywant) + && ((exgot ^ exwant) & ~exmay) == 0; +} + +static int RT(isok_nofenv) (RT(float) ygot, RT(float) ywant) +{ + return RT(asuint) (ygot) == RT(asuint) (ywant); +} +#endif + +static inline void T(call_fenv) (const struct fun *f, struct T(args) a, int r, + RT(float) * y, int *ex) +{ + if (r != FE_TONEAREST) + fesetround (r); + feclearexcept (FE_ALL_EXCEPT); + *y = T(call) (f, a); + *ex = fetestexcept (FE_ALL_EXCEPT); + if (r != FE_TONEAREST) + fesetround (FE_TONEAREST); +} + +static inline void T(call_nofenv) (const struct fun *f, struct T(args) a, + int r, RT(float) * y, int *ex) +{ + *y = T(call) (f, a); + *ex = 0; +} + +static inline int T(call_long_fenv) (const struct fun *f, struct T(args) a, + int r, struct RT(ret) * p, + RT(float) ygot, int exgot) +{ + if (r != FE_TONEAREST) + fesetround (r); + feclearexcept (FE_ALL_EXCEPT); + volatile struct T(args) va = a; // TODO: barrier + a = va; + RT(double) yl = T(call_long) (f, a); + p->y = (RT(float)) yl; + volatile RT(float) vy = p->y; // TODO: barrier + (void) vy; + p->ex = fetestexcept (FE_ALL_EXCEPT); + if (r != FE_TONEAREST) + fesetround (FE_TONEAREST); + p->ex_may = FE_INEXACT; + if (RT(isok) (ygot, exgot, p->y, p->ex, p->ex_may)) + return 1; + p->ulpexp = RT(ulpscale) (p->y); + if (isinf (p->y)) + p->tail = RT(lscalbn) (yl - (RT(double)) 2 * RT(halfinf), -p->ulpexp); + else + p->tail = RT(lscalbn) (yl - p->y, -p->ulpexp); + if (RT(fabs) (p->y) < RT(min_normal)) + { + /* TODO: subnormal result is treated as undeflow even if it's + exact since call_long may not raise inexact correctly. */ + if (p->y != 0 || (p->ex & FE_INEXACT)) + p->ex |= FE_UNDERFLOW | FE_INEXACT; + } + return 0; +} +static inline int T(call_long_nofenv) (const struct fun *f, struct T(args) a, + int r, struct RT(ret) * p, + RT(float) ygot, int exgot) +{ + RT(double) yl = T(call_long) (f, a); + p->y = (RT(float)) yl; + if (RT(isok_nofenv) (ygot, p->y)) + return 1; + p->ulpexp = RT(ulpscale) (p->y); + if (isinf (p->y)) + p->tail = RT(lscalbn) (yl - (RT(double)) 2 * RT(halfinf), -p->ulpexp); + else + p->tail = RT(lscalbn) (yl - p->y, -p->ulpexp); + return 0; +} + +/* There are nan input args and all quiet. */ +static inline int T(qnanpropagation) (struct T(args) a) +{ + return T(reduce) (a, isnan, ||) && !T(reduce) (a, RT(issignaling), ||); +} +static inline RT(float) T(sum) (struct T(args) a) +{ + return T(reduce) (a, , +); +} + +/* returns 1 if the got result is ok. */ +static inline int T(call_mpfr_fix) (const struct fun *f, struct T(args) a, + int r_fenv, struct RT(ret) * p, + RT(float) ygot, int exgot) +{ +#if USE_MPFR + int t, t2; + mpfr_rnd_t r = rmap (r_fenv); + MPFR_DECL_INIT(my, RT(prec_mpfr)); + MPFR_DECL_INIT(mr, RT(prec)); + MPFR_DECL_INIT(me, RT(prec_mpfr)); + mpfr_clear_flags (); + t = T(call_mpfr) (my, f, a, r); + /* Double rounding. */ + t2 = mpfr_set (mr, my, r); + if (t2) + t = t2; + mpfr_set_emin (RT(emin)); + mpfr_set_emax (RT(emax)); + t = mpfr_check_range (mr, t, r); + t = mpfr_subnormalize (mr, t, r); + mpfr_set_emax (MPFR_EMAX_DEFAULT); + mpfr_set_emin (MPFR_EMIN_DEFAULT); + p->y = mpfr_get_d (mr, r); + p->ex = t ? FE_INEXACT : 0; + p->ex_may = FE_INEXACT; + if (mpfr_underflow_p () && (p->ex & FE_INEXACT)) + /* TODO: handle before and after rounding uflow cases. */ + p->ex |= FE_UNDERFLOW; + if (mpfr_overflow_p ()) + p->ex |= FE_OVERFLOW | FE_INEXACT; + if (mpfr_divby0_p ()) + p->ex |= FE_DIVBYZERO; + //if (mpfr_erangeflag_p ()) + // p->ex |= FE_INVALID; + if (!mpfr_nanflag_p () && RT(isok) (ygot, exgot, p->y, p->ex, p->ex_may)) + return 1; + if (mpfr_nanflag_p () && !T(qnanpropagation) (a)) + p->ex |= FE_INVALID; + p->ulpexp = RT(ulpscale_mpfr) (my, t); + if (!isfinite (p->y)) + { + p->tail = 0; + if (isnan (p->y)) + { + /* If an input was nan keep its sign. */ + p->y = T(sum) (a); + if (!isnan (p->y)) + p->y = (p->y - p->y) / (p->y - p->y); + return RT(isok) (ygot, exgot, p->y, p->ex, p->ex_may); + } + mpfr_set_si_2exp (mr, signbit (p->y) ? -1 : 1, 1024, MPFR_RNDN); + if (mpfr_cmpabs (my, mr) >= 0) + return RT(isok) (ygot, exgot, p->y, p->ex, p->ex_may); + } + mpfr_sub (me, my, mr, MPFR_RNDN); + mpfr_mul_2si (me, me, -p->ulpexp, MPFR_RNDN); + p->tail = mpfr_get_d (me, MPFR_RNDN); + return 0; +#else + abort (); +#endif +} + +static int T(cmp) (const struct fun *f, struct gen *gen, + const struct conf *conf) +{ + double maxerr = 0; + uint64_t cnt = 0; + uint64_t cnt1 = 0; + uint64_t cnt2 = 0; + uint64_t cntfail = 0; + int r = conf->r; + int use_mpfr = conf->mpfr; + int fenv = conf->fenv; + for (;;) + { + struct RT(ret) want; + struct T(args) a = T(next) (gen); + int exgot; + int exgot2; + RT(float) ygot; + RT(float) ygot2; + int fail = 0; + if (fenv) + T(call_fenv) (f, a, r, &ygot, &exgot); + else + T(call_nofenv) (f, a, r, &ygot, &exgot); + if (f->twice) { + secondcall = 1; + if (fenv) + T(call_fenv) (f, a, r, &ygot2, &exgot2); + else + T(call_nofenv) (f, a, r, &ygot2, &exgot2); + secondcall = 0; + if (RT(asuint) (ygot) != RT(asuint) (ygot2)) + { + fail = 1; + cntfail++; + T(printcall) (f, a); + printf (" got %a then %a for same input\n", ygot, ygot2); + } + } + cnt++; + int ok = use_mpfr + ? T(call_mpfr_fix) (f, a, r, &want, ygot, exgot) + : (fenv ? T(call_long_fenv) (f, a, r, &want, ygot, exgot) + : T(call_long_nofenv) (f, a, r, &want, ygot, exgot)); + if (!ok) + { + int print = 0; + double err = RT(ulperr) (ygot, &want, r); + double abserr = fabs (err); + // TODO: count errors below accuracy limit. + if (abserr > 0) + cnt1++; + if (abserr > 1) + cnt2++; + if (abserr > conf->errlim) + { + print = 1; + if (!fail) + { + fail = 1; + cntfail++; + } + } + if (abserr > maxerr) + { + maxerr = abserr; + if (!conf->quiet && abserr > conf->softlim) + print = 1; + } + if (print) + { + T(printcall) (f, a); + // TODO: inf ulp handling + printf (" got %a want %a %+g ulp err %g\n", ygot, want.y, + want.tail, err); + } + int diff = fenv ? exgot ^ want.ex : 0; + if (fenv && (diff & ~want.ex_may)) + { + if (!fail) + { + fail = 1; + cntfail++; + } + T(printcall) (f, a); + printf (" is %a %+g ulp, got except 0x%0x", want.y, want.tail, + exgot); + if (diff & exgot) + printf (" wrongly set: 0x%x", diff & exgot); + if (diff & ~exgot) + printf (" wrongly clear: 0x%x", diff & ~exgot); + putchar ('\n'); + } + } + if (cnt >= conf->n) + break; + if (!conf->quiet && cnt % 0x100000 == 0) + printf ("progress: %6.3f%% cnt %llu cnt1 %llu cnt2 %llu cntfail %llu " + "maxerr %g\n", + 100.0 * cnt / conf->n, (unsigned long long) cnt, + (unsigned long long) cnt1, (unsigned long long) cnt2, + (unsigned long long) cntfail, maxerr); + } + double cc = cnt; + if (cntfail) + printf ("FAIL "); + else + printf ("PASS "); + T(printgen) (f, gen); + printf (" round %c errlim %g maxerr %g %s cnt %llu cnt1 %llu %g%% cnt2 %llu " + "%g%% cntfail %llu %g%%\n", + conf->rc, conf->errlim, + maxerr, conf->r == FE_TONEAREST ? "+0.5" : "+1.0", + (unsigned long long) cnt, + (unsigned long long) cnt1, 100.0 * cnt1 / cc, + (unsigned long long) cnt2, 100.0 * cnt2 / cc, + (unsigned long long) cntfail, 100.0 * cntfail / cc); + return !!cntfail; +} diff --git a/libc/AOR_v20.02/math/tools/cos.sollya b/libc/AOR_v20.02/math/tools/cos.sollya new file mode 100644 index 00000000000000..71d45965decb9f --- /dev/null +++ b/libc/AOR_v20.02/math/tools/cos.sollya @@ -0,0 +1,32 @@ +// polynomial for approximating cos(x) +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 8; // polynomial degree +a = -pi/4; // interval +b = pi/4; + +// find even polynomial with minimal abs error compared to cos(x) + +f = cos(x); + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)| +approx = proc(poly,d) { + return remez(f(x)-poly(x), deg-d, [a;b], x^d, 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = 1; +for i from 1 to deg/2 do { + p = roundcoefficients(approx(poly,2*i), [|D ...|]); + poly = poly + x^(2*i)*coeff(p,0); +}; + +display = hexadecimal; +print("rel error:", accurateinfnorm(1-poly(x)/f(x), [a;b], 30)); +print("abs error:", accurateinfnorm(f(x)-poly(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/exp.sollya b/libc/AOR_v20.02/math/tools/exp.sollya new file mode 100644 index 00000000000000..1877b0761197bc --- /dev/null +++ b/libc/AOR_v20.02/math/tools/exp.sollya @@ -0,0 +1,36 @@ +// polynomial for approximating e^x +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 5; // poly degree +N = 128; // table entries +b = log(2)/(2*N); // interval +b = b + b*0x1p-16; // increase interval for non-nearest rounding (TOINT_NARROW) +a = -b; + +// find polynomial with minimal abs error + +// return p that minimizes |exp(x) - poly(x) - x^d*p(x)| +approx = proc(poly,d) { + return remez(exp(x)-poly(x), deg-d, [a;b], x^d, 1e-10); +}; + +// first 2 coeffs are fixed, iteratively find optimal double prec coeffs +poly = 1 + x; +for i from 2 to deg do { + p = roundcoefficients(approx(poly,i), [|D ...|]); + poly = poly + x^i*coeff(p,0); +}; + +display = hexadecimal; +print("rel error:", accurateinfnorm(1-poly(x)/exp(x), [a;b], 30)); +print("abs error:", accurateinfnorm(exp(x)-poly(x), [a;b], 30)); +print("in [",a,b,"]"); +// double interval error for non-nearest rounding +print("rel2 error:", accurateinfnorm(1-poly(x)/exp(x), [2*a;2*b], 30)); +print("abs2 error:", accurateinfnorm(exp(x)-poly(x), [2*a;2*b], 30)); +print("in [",2*a,2*b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/exp2.sollya b/libc/AOR_v20.02/math/tools/exp2.sollya new file mode 100644 index 00000000000000..7980eefbff5ff2 --- /dev/null +++ b/libc/AOR_v20.02/math/tools/exp2.sollya @@ -0,0 +1,49 @@ +// polynomial for approximating 2^x +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +// exp2f parameters +deg = 3; // poly degree +N = 32; // table entries +b = 1/(2*N); // interval +a = -b; + +//// exp2 parameters +//deg = 5; // poly degree +//N = 128; // table entries +//b = 1/(2*N); // interval +//a = -b; + +// find polynomial with minimal relative error + +f = 2^x; + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)|/|f(x)| +approx = proc(poly,d) { + return remez(1 - poly(x)/f(x), deg-d, [a;b], x^d/f(x), 1e-10); +}; +// return p that minimizes |f(x) - poly(x) - x^d*p(x)| +approx_abs = proc(poly,d) { + return remez(f(x) - poly(x), deg-d, [a;b], x^d, 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = 1; +for i from 1 to deg do { + p = roundcoefficients(approx(poly,i), [|D ...|]); +// p = roundcoefficients(approx_abs(poly,i), [|D ...|]); + poly = poly + x^i*coeff(p,0); +}; + +display = hexadecimal; +print("rel error:", accurateinfnorm(1-poly(x)/2^x, [a;b], 30)); +print("abs error:", accurateinfnorm(2^x-poly(x), [a;b], 30)); +print("in [",a,b,"]"); +// double interval error for non-nearest rounding: +print("rel2 error:", accurateinfnorm(1-poly(x)/2^x, [2*a;2*b], 30)); +print("abs2 error:", accurateinfnorm(2^x-poly(x), [2*a;2*b], 30)); +print("in [",2*a,2*b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/log.sollya b/libc/AOR_v20.02/math/tools/log.sollya new file mode 100644 index 00000000000000..41072395eb92ab --- /dev/null +++ b/libc/AOR_v20.02/math/tools/log.sollya @@ -0,0 +1,36 @@ +// polynomial for approximating log(1+x) +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 12; // poly degree +// |log(1+x)| > 0x1p-4 outside the interval +a = -0x1p-4; +b = 0x1.09p-4; + +// find log(1+x)/x polynomial with minimal relative error +// (minimal relative error polynomial for log(1+x) is the same * x) +deg = deg-1; // because of /x + +// f = log(1+x)/x; using taylor series +f = 0; +for i from 0 to 60 do { f = f + (-x)^i/(i+1); }; + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)|/|f(x)| +approx = proc(poly,d) { + return remez(1 - poly(x)/f(x), deg-d, [a;b], x^d/f(x), 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = 1; +for i from 1 to deg do { + p = roundcoefficients(approx(poly,i), [|D ...|]); + poly = poly + x^i*coeff(p,0); +}; + +display = hexadecimal; +print("rel error:", accurateinfnorm(1-poly(x)/f(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/log2.sollya b/libc/AOR_v20.02/math/tools/log2.sollya new file mode 100644 index 00000000000000..6b3e867b77a955 --- /dev/null +++ b/libc/AOR_v20.02/math/tools/log2.sollya @@ -0,0 +1,43 @@ +// polynomial for approximating log2(1+x) +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 11; // poly degree +// |log2(1+x)| > 0x1p-4 outside the interval +a = -0x1.5b51p-5; +b = 0x1.6ab2p-5; + +ln2 = evaluate(log(2),0); +invln2hi = double(1/ln2 + 0x1p21) - 0x1p21; // round away last 21 bits +invln2lo = double(1/ln2 - invln2hi); + +// find log2(1+x)/x polynomial with minimal relative error +// (minimal relative error polynomial for log2(1+x) is the same * x) +deg = deg-1; // because of /x + +// f = log(1+x)/x; using taylor series +f = 0; +for i from 0 to 60 do { f = f + (-x)^i/(i+1); }; +f = f/ln2; + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)|/|f(x)| +approx = proc(poly,d) { + return remez(1 - poly(x)/f(x), deg-d, [a;b], x^d/f(x), 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = invln2hi + invln2lo; +for i from 1 to deg do { + p = roundcoefficients(approx(poly,i), [|D ...|]); + poly = poly + x^i*coeff(p,0); +}; + +display = hexadecimal; +print("invln2hi:", invln2hi); +print("invln2lo:", invln2lo); +print("rel error:", accurateinfnorm(1-poly(x)/f(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/log2_abs.sollya b/libc/AOR_v20.02/math/tools/log2_abs.sollya new file mode 100644 index 00000000000000..ecbc7e075003f0 --- /dev/null +++ b/libc/AOR_v20.02/math/tools/log2_abs.sollya @@ -0,0 +1,42 @@ +// polynomial for approximating log2(1+x) +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 7; // poly degree +// interval ~= 1/(2*N), where N is the table entries +a= -0x1.f45p-8; +b= 0x1.f45p-8; + +ln2 = evaluate(log(2),0); +invln2hi = double(1/ln2 + 0x1p21) - 0x1p21; // round away last 21 bits +invln2lo = double(1/ln2 - invln2hi); + +// find log2(1+x) polynomial with minimal absolute error +f = log(1+x)/ln2; + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)| +approx = proc(poly,d) { + return remez(f(x) - poly(x), deg-d, [a;b], x^d, 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = x*(invln2lo + invln2hi); +for i from 2 to deg do { + p = roundcoefficients(approx(poly,i), [|D ...|]); + poly = poly + x^i*coeff(p,0); +}; + +display = hexadecimal; +print("invln2hi:", invln2hi); +print("invln2lo:", invln2lo); +print("abs error:", accurateinfnorm(f(x)-poly(x), [a;b], 30)); +//// relative error computation fails if f(0)==0 +//// g = f(x)/x = log2(1+x)/x; using taylor series +//g = 0; +//for i from 0 to 60 do { g = g + (-x)^i/(i+1)/ln2; }; +//print("rel error:", accurateinfnorm(1-(poly(x)/x)/g(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/log_abs.sollya b/libc/AOR_v20.02/math/tools/log_abs.sollya new file mode 100644 index 00000000000000..c12242364869e6 --- /dev/null +++ b/libc/AOR_v20.02/math/tools/log_abs.sollya @@ -0,0 +1,36 @@ +// polynomial for approximating log(1+x) +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 6; // poly degree +// interval ~= 1/(2*N), where N is the table entries +a = -0x1.fp-9; +b = 0x1.fp-9; + +// find log(1+x) polynomial with minimal absolute error +f = log(1+x); + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)| +approx = proc(poly,d) { + return remez(f(x) - poly(x), deg-d, [a;b], x^d, 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = x; +for i from 2 to deg do { + p = roundcoefficients(approx(poly,i), [|D ...|]); + poly = poly + x^i*coeff(p,0); +}; + +display = hexadecimal; +print("abs error:", accurateinfnorm(f(x)-poly(x), [a;b], 30)); +// relative error computation fails if f(0)==0 +// g = f(x)/x = log(1+x)/x; using taylor series +g = 0; +for i from 0 to 60 do { g = g + (-x)^i/(i+1); }; +print("rel error:", accurateinfnorm(1-poly(x)/x/g(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/plot.py b/libc/AOR_v20.02/math/tools/plot.py new file mode 100755 index 00000000000000..611c99a9e69f2a --- /dev/null +++ b/libc/AOR_v20.02/math/tools/plot.py @@ -0,0 +1,62 @@ +#!/usr/bin/python + +# ULP error plot tool. +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +import numpy as np +import matplotlib.pyplot as plt +import sys +import re + +# example usage: +# build/bin/ulp -e .0001 log 0.5 2.0 2345678 | math/tools/plot.py + +def fhex(s): + return float.fromhex(s) + +def parse(f): + xs = [] + gs = [] + ys = [] + es = [] + # Has to match the format used in ulp.c + r = re.compile(r'[^ (]+\(([^ )]*)\) got ([^ ]+) want ([^ ]+) [^ ]+ ulp err ([^ ]+)') + for line in f: + m = r.match(line) + if m: + x = fhex(m.group(1)) + g = fhex(m.group(2)) + y = fhex(m.group(3)) + e = float(m.group(4)) + xs.append(x) + gs.append(g) + ys.append(y) + es.append(e) + elif line.startswith('PASS') or line.startswith('FAIL'): + # Print the summary line + print(line) + return xs, gs, ys, es + +def plot(xs, gs, ys, es): + if len(xs) < 2: + print('not enough samples') + return + a = min(xs) + b = max(xs) + fig, (ax0,ax1) = plt.subplots(nrows=2) + es = np.abs(es) # ignore the sign + emax = max(es) + ax0.text(a+(b-a)*0.7, emax*0.8, '%s\n%g'%(emax.hex(),emax)) + ax0.plot(xs,es,'r.') + ax0.grid() + ax1.plot(xs,ys,'r.',label='want') + ax1.plot(xs,gs,'b.',label='got') + ax1.grid() + ax1.legend() + plt.show() + +xs, gs, ys, es = parse(sys.stdin) +plot(xs, gs, ys, es) diff --git a/libc/AOR_v20.02/math/tools/remez.jl b/libc/AOR_v20.02/math/tools/remez.jl new file mode 100755 index 00000000000000..bf934f4a7c1151 --- /dev/null +++ b/libc/AOR_v20.02/math/tools/remez.jl @@ -0,0 +1,1335 @@ +#!/usr/bin/env julia +# -*- julia -*- + +# remez.jl - implementation of the Remez algorithm for polynomial approximation +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +import Base.\ + +# ---------------------------------------------------------------------- +# Helper functions to cope with different Julia versions. +if VERSION >= v"0.7.0" + array1d(T, d) = Array{T, 1}(undef, d) + array2d(T, d1, d2) = Array{T, 2}(undef, d1, d2) +else + array1d(T, d) = Array(T, d) + array2d(T, d1, d2) = Array(T, d1, d2) +end +if VERSION < v"0.5.0" + String = ASCIIString +end +if VERSION >= v"0.6.0" + # Use Base.invokelatest to run functions made using eval(), to + # avoid "world age" error + run(f, x...) = Base.invokelatest(f, x...) +else + # Prior to 0.6.0, invokelatest doesn't exist (but fortunately the + # world age problem also doesn't seem to exist) + run(f, x...) = f(x...) +end + +# ---------------------------------------------------------------------- +# Global variables configured by command-line options. +floatsuffix = "" # adjusted by --floatsuffix +xvarname = "x" # adjusted by --variable +epsbits = 256 # adjusted by --bits +debug_facilities = Set() # adjusted by --debug +full_output = false # adjusted by --full +array_format = false # adjusted by --array +preliminary_commands = array1d(String, 0) # adjusted by --pre + +# ---------------------------------------------------------------------- +# Diagnostic and utility functions. + +# Enable debugging printouts from a particular subpart of this +# program. +# +# Arguments: +# facility Name of the facility to debug. For a list of facility names, +# look through the code for calls to debug(). +# +# Return value is a BigFloat. +function enable_debug(facility) + push!(debug_facilities, facility) +end + +# Print a diagnostic. +# +# Arguments: +# facility Name of the facility for which this is a debug message. +# printargs Arguments to println() if debugging of that facility is +# enabled. +macro debug(facility, printargs...) + printit = quote + print("[", $facility, "] ") + end + for arg in printargs + printit = quote + $printit + print($(esc(arg))) + end + end + return quote + if $facility in debug_facilities + $printit + println() + end + end +end + +# Evaluate a polynomial. + +# Arguments: +# coeffs Array of BigFloats giving the coefficients of the polynomial. +# Starts with the constant term, i.e. coeffs[i] is the +# coefficient of x^(i-1) (because Julia arrays are 1-based). +# x Point at which to evaluate the polynomial. +# +# Return value is a BigFloat. +function poly_eval(coeffs::Array{BigFloat}, x::BigFloat) + n = length(coeffs) + if n == 0 + return BigFloat(0) + elseif n == 1 + return coeffs[1] + else + return coeffs[1] + x * poly_eval(coeffs[2:n], x) + end +end + +# Evaluate a rational function. + +# Arguments: +# ncoeffs Array of BigFloats giving the coefficients of the numerator. +# Starts with the constant term, and 1-based, as above. +# dcoeffs Array of BigFloats giving the coefficients of the denominator. +# Starts with the constant term, and 1-based, as above. +# x Point at which to evaluate the function. +# +# Return value is a BigFloat. +function ratfn_eval(ncoeffs::Array{BigFloat}, dcoeffs::Array{BigFloat}, + x::BigFloat) + return poly_eval(ncoeffs, x) / poly_eval(dcoeffs, x) +end + +# Format a BigFloat into an appropriate output format. +# Arguments: +# x BigFloat to format. +# +# Return value is a string. +function float_to_str(x) + return string(x) * floatsuffix +end + +# Format a polynomial into an arithmetic expression, for pasting into +# other tools such as gnuplot. + +# Arguments: +# coeffs Array of BigFloats giving the coefficients of the polynomial. +# Starts with the constant term, and 1-based, as above. +# +# Return value is a string. +function poly_to_string(coeffs::Array{BigFloat}) + n = length(coeffs) + if n == 0 + return "0" + elseif n == 1 + return float_to_str(coeffs[1]) + else + return string(float_to_str(coeffs[1]), "+", xvarname, "*(", + poly_to_string(coeffs[2:n]), ")") + end +end + +# Format a rational function into a string. + +# Arguments: +# ncoeffs Array of BigFloats giving the coefficients of the numerator. +# Starts with the constant term, and 1-based, as above. +# dcoeffs Array of BigFloats giving the coefficients of the denominator. +# Starts with the constant term, and 1-based, as above. +# +# Return value is a string. +function ratfn_to_string(ncoeffs::Array{BigFloat}, dcoeffs::Array{BigFloat}) + if length(dcoeffs) == 1 && dcoeffs[1] == 1 + # Special case: if the denominator is just 1, leave it out. + return poly_to_string(ncoeffs) + else + return string("(", poly_to_string(ncoeffs), ")/(", + poly_to_string(dcoeffs), ")") + end +end + +# Format a list of x,y pairs into a string. + +# Arguments: +# xys Array of (x,y) pairs of BigFloats. +# +# Return value is a string. +function format_xylist(xys::Array{Tuple{BigFloat,BigFloat}}) + return ("[\n" * + join([" "*string(x)*" -> "*string(y) for (x,y) in xys], "\n") * + "\n]") +end + +# ---------------------------------------------------------------------- +# Matrix-equation solver for matrices of BigFloat. +# +# I had hoped that Julia's type-genericity would allow me to solve the +# matrix equation Mx=V by just writing 'M \ V'. Unfortunately, that +# works by translating the inputs into double precision and handing +# off to an optimised library, which misses the point when I have a +# matrix and vector of BigFloat and want my result in _better_ than +# double precision. So I have to implement my own specialisation of +# the \ operator for that case. +# +# Fortunately, the point of using BigFloats is that we have precision +# to burn, so I can do completely naïve Gaussian elimination without +# worrying about instability. + +# Arguments: +# matrix_in 2-dimensional array of BigFloats, representing a matrix M +# in row-first order, i.e. matrix_in[r,c] represents the +# entry in row r col c. +# vector_in 1-dimensional array of BigFloats, representing a vector V. +# +# Return value: a 1-dimensional array X of BigFloats, satisfying M X = V. +# +# Expects the input to be an invertible square matrix and a vector of +# the corresponding size, on pain of failing an assertion. +function \(matrix_in :: Array{BigFloat,2}, + vector_in :: Array{BigFloat,1}) + # Copy the inputs, because we'll be mutating them as we go. + M = copy(matrix_in) + V = copy(vector_in) + + # Input consistency criteria: matrix is square, and vector has + # length to match. + n = length(V) + @assert(n > 0) + @assert(size(M) == (n,n)) + + @debug("gausselim", "starting, n=", n) + + for i = 1:1:n + # Straightforward Gaussian elimination: find the largest + # non-zero entry in column i (and in a row we haven't sorted + # out already), swap it into row i, scale that row to + # normalise it to 1, then zero out the rest of the column by + # subtracting a multiple of that row from each other row. + + @debug("gausselim", "matrix=", repr(M)) + @debug("gausselim", "vector=", repr(V)) + + # Find the best pivot. + bestrow = 0 + bestval = 0 + for j = i:1:n + if abs(M[j,i]) > bestval + bestrow = j + bestval = M[j,i] + end + end + @assert(bestrow > 0) # make sure we did actually find one + + @debug("gausselim", "bestrow=", bestrow) + + # Swap it into row i. + if bestrow != i + for k = 1:1:n + M[bestrow,k],M[i,k] = M[i,k],M[bestrow,k] + end + V[bestrow],V[i] = V[i],V[bestrow] + end + + # Scale that row so that M[i,i] becomes 1. + divisor = M[i,i] + for k = 1:1:n + M[i,k] = M[i,k] / divisor + end + V[i] = V[i] / divisor + @assert(M[i,i] == 1) + + # Zero out all other entries in column i, by subtracting + # multiples of this row. + for j = 1:1:n + if j != i + factor = M[j,i] + for k = 1:1:n + M[j,k] = M[j,k] - M[i,k] * factor + end + V[j] = V[j] - V[i] * factor + @assert(M[j,i] == 0) + end + end + end + + @debug("gausselim", "matrix=", repr(M)) + @debug("gausselim", "vector=", repr(V)) + @debug("gausselim", "done!") + + # Now we're done: M is the identity matrix, so the equation Mx=V + # becomes just x=V, i.e. V is already exactly the vector we want + # to return. + return V +end + +# ---------------------------------------------------------------------- +# Least-squares fitting of a rational function to a set of (x,y) +# points. +# +# We use this to get an initial starting point for the Remez +# iteration. Therefore, it doesn't really need to be particularly +# accurate; it only needs to be good enough to wiggle back and forth +# across the target function the right number of times (so as to give +# enough error extrema to start optimising from) and not have any +# poles in the target interval. +# +# Least-squares fitting of a _polynomial_ is actually a sensible thing +# to do, and minimises the rms error. Doing the following trick with a +# rational function P/Q is less sensible, because it cannot be made to +# minimise the error function (P/Q-f)^2 that you actually wanted; +# instead it minimises (P-fQ)^2. But that should be good enough to +# have the properties described above. +# +# Some theory: suppose you're trying to choose a set of parameters a_i +# so as to minimise the sum of squares of some error function E_i. +# Basic calculus says, if you do this in one variable, just +# differentiate and solve for zero. In this case, that works fine even +# with multiple variables, because you _partially_ differentiate with +# respect to each a_i, giving a system of equations, and that system +# turns out to be linear so we just solve it as a matrix. +# +# In this case, our parameters are the coefficients of P and Q; to +# avoid underdetermining the system we'll fix Q's constant term at 1, +# so that our error function (as described above) is +# +# E = \sum (p_0 + p_1 x + ... + p_n x^n - y - y q_1 x - ... - y q_d x^d)^2 +# +# where the sum is over all (x,y) coordinate pairs. Setting dE/dp_j=0 +# (for each j) gives an equation of the form +# +# 0 = \sum 2(p_0 + p_1 x + ... + p_n x^n - y - y q_1 x - ... - y q_d x^d) x^j +# +# and setting dE/dq_j=0 gives one of the form +# +# 0 = \sum 2(p_0 + p_1 x + ... + p_n x^n - y - y q_1 x - ... - y q_d x^d) y x^j +# +# And both of those row types, treated as multivariate linear +# equations in the p,q values, have each coefficient being a value of +# the form \sum x^i, \sum y x^i or \sum y^2 x^i, for various i. (Times +# a factor of 2, but we can throw that away.) So we can go through the +# list of input coordinates summing all of those things, and then we +# have enough information to construct our matrix and solve it +# straight off for the rational function coefficients. + +# Arguments: +# f The function to be approximated. Maps BigFloat -> BigFloat. +# xvals Array of BigFloats, giving the list of x-coordinates at which +# to evaluate f. +# n Degree of the numerator polynomial of the desired rational +# function. +# d Degree of the denominator polynomial of the desired rational +# function. +# w Error-weighting function. Takes two BigFloat arguments x,y +# and returns a scaling factor for the error at that location. +# A larger value indicates that the error should be given +# greater weight in the square sum we try to minimise. +# If unspecified, defaults to giving everything the same weight. +# +# Return values: a pair of arrays of BigFloats (N,D) giving the +# coefficients of the returned rational function. N has size n+1; D +# has size d+1. Both start with the constant term, i.e. N[i] is the +# coefficient of x^(i-1) (because Julia arrays are 1-based). D[1] will +# be 1. +function ratfn_leastsquares(f::Function, xvals::Array{BigFloat}, n, d, + w = (x,y)->BigFloat(1)) + # Accumulate sums of x^i y^j, for j={0,1,2} and a range of x. + # Again because Julia arrays are 1-based, we'll have sums[i,j] + # being the sum of x^(i-1) y^(j-1). + maxpow = max(n,d) * 2 + 1 + sums = zeros(BigFloat, maxpow, 3) + for x = xvals + y = f(x) + weight = w(x,y) + for i = 1:1:maxpow + for j = 1:1:3 + sums[i,j] += x^(i-1) * y^(j-1) * weight + end + end + end + + @debug("leastsquares", "sums=", repr(sums)) + + # Build the matrix. We're solving n+d+1 equations in n+d+1 + # unknowns. (We actually have to return n+d+2 coefficients, but + # one of them is hardwired to 1.) + matrix = array2d(BigFloat, n+d+1, n+d+1) + vector = array1d(BigFloat, n+d+1) + for i = 0:1:n + # Equation obtained by differentiating with respect to p_i, + # i.e. the numerator coefficient of x^i. + row = 1+i + for j = 0:1:n + matrix[row, 1+j] = sums[1+i+j, 1] + end + for j = 1:1:d + matrix[row, 1+n+j] = -sums[1+i+j, 2] + end + vector[row] = sums[1+i, 2] + end + for i = 1:1:d + # Equation obtained by differentiating with respect to q_i, + # i.e. the denominator coefficient of x^i. + row = 1+n+i + for j = 0:1:n + matrix[row, 1+j] = sums[1+i+j, 2] + end + for j = 1:1:d + matrix[row, 1+n+j] = -sums[1+i+j, 3] + end + vector[row] = sums[1+i, 3] + end + + @debug("leastsquares", "matrix=", repr(matrix)) + @debug("leastsquares", "vector=", repr(vector)) + + # Solve the matrix equation. + all_coeffs = matrix \ vector + + @debug("leastsquares", "all_coeffs=", repr(all_coeffs)) + + # And marshal the results into two separate polynomial vectors to + # return. + ncoeffs = all_coeffs[1:n+1] + dcoeffs = vcat([1], all_coeffs[n+2:n+d+1]) + return (ncoeffs, dcoeffs) +end + +# ---------------------------------------------------------------------- +# Golden-section search to find a maximum of a function. + +# Arguments: +# f Function to be maximised/minimised. Maps BigFloat -> BigFloat. +# a,b,c BigFloats bracketing a maximum of the function. +# +# Expects: +# a,b,c are in order (either a<=b<=c or c<=b<=a) +# a != c (but b can equal one or the other if it wants to) +# f(a) <= f(b) >= f(c) +# +# Return value is an (x,y) pair of BigFloats giving the extremal input +# and output. (That is, y=f(x).) +function goldensection(f::Function, a::BigFloat, b::BigFloat, c::BigFloat) + # Decide on a 'good enough' threshold. + threshold = abs(c-a) * 2^(-epsbits/2) + + # We'll need the golden ratio phi, of course. Or rather, in this + # case, we need 1/phi = 0.618... + one_over_phi = 2 / (1 + sqrt(BigFloat(5))) + + # Flip round the interval endpoints so that the interval [a,b] is + # at least as large as [b,c]. (Then we can always pick our new + # point in [a,b] without having to handle lots of special cases.) + if abs(b-a) < abs(c-a) + a, c = c, a + end + + # Evaluate the function at the initial points. + fa = f(a) + fb = f(b) + fc = f(c) + + @debug("goldensection", "starting") + + while abs(c-a) > threshold + @debug("goldensection", "a: ", a, " -> ", fa) + @debug("goldensection", "b: ", b, " -> ", fb) + @debug("goldensection", "c: ", c, " -> ", fc) + + # Check invariants. + @assert(a <= b <= c || c <= b <= a) + @assert(fa <= fb >= fc) + + # Subdivide the larger of the intervals [a,b] and [b,c]. We've + # arranged that this is always [a,b], for simplicity. + d = a + (b-a) * one_over_phi + + # Now we have an interval looking like this (possibly + # reversed): + # + # a d b c + # + # and we know f(b) is bigger than either f(a) or f(c). We have + # two cases: either f(d) > f(b), or vice versa. In either + # case, we can narrow to an interval of 1/phi the size, and + # still satisfy all our invariants (three ordered points, + # [a,b] at least the width of [b,c], f(a)<=f(b)>=f(c)). + fd = f(d) + @debug("goldensection", "d: ", d, " -> ", fd) + if fd > fb + a, b, c = a, d, b + fa, fb, fc = fa, fd, fb + @debug("goldensection", "adb case") + else + a, b, c = c, b, d + fa, fb, fc = fc, fb, fd + @debug("goldensection", "cbd case") + end + end + + @debug("goldensection", "done: ", b, " -> ", fb) + return (b, fb) +end + +# ---------------------------------------------------------------------- +# Find the extrema of a function within a given interval. + +# Arguments: +# f The function to be approximated. Maps BigFloat -> BigFloat. +# grid A set of points at which to evaluate f. Must be high enough +# resolution to make extrema obvious. +# +# Returns an array of (x,y) pairs of BigFloats, with each x,y giving +# the extremum location and its value (i.e. y=f(x)). +function find_extrema(f::Function, grid::Array{BigFloat}) + len = length(grid) + extrema = array1d(Tuple{BigFloat, BigFloat}, 0) + for i = 1:1:len + # We have to provide goldensection() with three points + # bracketing the extremum. If the extremum is at one end of + # the interval, then the only way we can do that is to set two + # of the points equal (which goldensection() will cope with). + prev = max(1, i-1) + next = min(i+1, len) + + # Find our three pairs of (x,y) coordinates. + xp, xi, xn = grid[prev], grid[i], grid[next] + yp, yi, yn = f(xp), f(xi), f(xn) + + # See if they look like an extremum, and if so, ask + # goldensection() to give a more exact location for it. + if yp <= yi >= yn + push!(extrema, goldensection(f, xp, xi, xn)) + elseif yp >= yi <= yn + x, y = goldensection(x->-f(x), xp, xi, xn) + push!(extrema, (x, -y)) + end + end + return extrema +end + +# ---------------------------------------------------------------------- +# Winnow a list of a function's extrema to give a subsequence of a +# specified length, with the extrema in the subsequence alternating +# signs, and with the smallest absolute value of an extremum in the +# subsequence as large as possible. +# +# We do this using a dynamic-programming approach. We work along the +# provided array of extrema, and at all times, we track the best set +# of extrema we have so far seen for each possible (length, sign of +# last extremum) pair. Each new extremum is evaluated to see whether +# it can be added to any previously seen best subsequence to make a +# new subsequence that beats the previous record holder in its slot. + +# Arguments: +# extrema An array of (x,y) pairs of BigFloats giving the input extrema. +# n Number of extrema required as output. +# +# Returns a new array of (x,y) pairs which is a subsequence of the +# original sequence. (So, in particular, if the input was sorted by x +# then so will the output be.) +function winnow_extrema(extrema::Array{Tuple{BigFloat,BigFloat}}, n) + # best[i,j] gives the best sequence so far of length i and with + # sign j (where signs are coded as 1=positive, 2=negative), in the + # form of a tuple (cost, actual array of x,y pairs). + best = fill((BigFloat(0), array1d(Tuple{BigFloat,BigFloat}, 0)), n, 2) + + for (x,y) = extrema + if y > 0 + sign = 1 + elseif y < 0 + sign = 2 + else + # A zero-valued extremum cannot possibly contribute to any + # optimal sequence, so we simply ignore it! + continue + end + + for i = 1:1:n + # See if we can create a new entry for best[i,sign] by + # appending our current (x,y) to some previous thing. + if i == 1 + # Special case: we don't store a best zero-length + # sequence :-) + candidate = (abs(y), [(x,y)]) + else + othersign = 3-sign # map 1->2 and 2->1 + oldscore, oldlist = best[i-1, othersign] + newscore = min(abs(y), oldscore) + newlist = vcat(oldlist, [(x,y)]) + candidate = (newscore, newlist) + end + # If our new candidate improves on the previous value of + # best[i,sign], then replace it. + if candidate[1] > best[i,sign][1] + best[i,sign] = candidate + end + end + end + + # Our ultimate return value has to be either best[n,1] or + # best[n,2], but it could be either. See which one has the higher + # score. + if best[n,1][1] > best[n,2][1] + ret = best[n,1][2] + else + ret = best[n,2][2] + end + # Make sure we did actually _find_ a good answer. + @assert(length(ret) == n) + return ret +end + +# ---------------------------------------------------------------------- +# Construct a rational-function approximation with equal and +# alternating weighted deviation at a specific set of x-coordinates. + +# Arguments: +# f The function to be approximated. Maps BigFloat -> BigFloat. +# coords An array of BigFloats giving the x-coordinates. There should +# be n+d+2 of them. +# n, d The degrees of the numerator and denominator of the desired +# approximation. +# prev_err A plausible value for the alternating weighted deviation. +# (Required to kickstart a binary search in the nonlinear case; +# see comments below.) +# w Error-weighting function. Takes two BigFloat arguments x,y +# and returns a scaling factor for the error at that location. +# The returned approximation R should have the minimum possible +# maximum value of abs((f(x)-R(x)) * w(x,f(x))). Optional +# parameter, defaulting to the always-return-1 function. +# +# Return values: a pair of arrays of BigFloats (N,D) giving the +# coefficients of the returned rational function. N has size n+1; D +# has size d+1. Both start with the constant term, i.e. N[i] is the +# coefficient of x^(i-1) (because Julia arrays are 1-based). D[1] will +# be 1. +function ratfn_equal_deviation(f::Function, coords::Array{BigFloat}, + n, d, prev_err::BigFloat, + w = (x,y)->BigFloat(1)) + @debug("equaldev", "n=", n, " d=", d, " coords=", repr(coords)) + @assert(length(coords) == n+d+2) + + if d == 0 + # Special case: we're after a polynomial. In this case, we + # have the particularly easy job of just constructing and + # solving a system of n+2 linear equations, to find the n+1 + # coefficients of the polynomial and also the amount of + # deviation at the specified coordinates. Each equation is of + # the form + # + # p_0 x^0 + p_1 x^1 + ... + p_n x^n ± e/w(x) = f(x) + # + # in which the p_i and e are the variables, and the powers of + # x and calls to w and f are the coefficients. + + matrix = array2d(BigFloat, n+2, n+2) + vector = array1d(BigFloat, n+2) + currsign = +1 + for i = 1:1:n+2 + x = coords[i] + for j = 0:1:n + matrix[i,1+j] = x^j + end + y = f(x) + vector[i] = y + matrix[i, n+2] = currsign / w(x,y) + currsign = -currsign + end + + @debug("equaldev", "matrix=", repr(matrix)) + @debug("equaldev", "vector=", repr(vector)) + + outvector = matrix \ vector + + @debug("equaldev", "outvector=", repr(outvector)) + + ncoeffs = outvector[1:n+1] + dcoeffs = [BigFloat(1)] + return ncoeffs, dcoeffs + else + # For a nontrivial rational function, the system of equations + # we need to solve becomes nonlinear, because each equation + # now takes the form + # + # p_0 x^0 + p_1 x^1 + ... + p_n x^n + # --------------------------------- ± e/w(x) = f(x) + # x^0 + q_1 x^1 + ... + q_d x^d + # + # and multiplying up by the denominator gives you a lot of + # terms containing e × q_i. So we can't do this the really + # easy way using a matrix equation as above. + # + # Fortunately, this is a fairly easy kind of nonlinear system. + # The equations all become linear if you switch to treating e + # as a constant, so a reasonably sensible approach is to pick + # a candidate value of e, solve all but one of the equations + # for the remaining unknowns, and then see what the error + # turns out to be in the final equation. The Chebyshev + # alternation theorem guarantees that that error in the last + # equation will be anti-monotonic in the input e, so we can + # just binary-search until we get the two as close to equal as + # we need them. + + function try_e(e) + # Try a given value of e, derive the coefficients of the + # resulting rational function by setting up equations + # based on the first n+d+1 of the n+d+2 coordinates, and + # see what the error turns out to be at the final + # coordinate. + matrix = array2d(BigFloat, n+d+1, n+d+1) + vector = array1d(BigFloat, n+d+1) + currsign = +1 + for i = 1:1:n+d+1 + x = coords[i] + y = f(x) + y_adj = y - currsign * e / w(x,y) + for j = 0:1:n + matrix[i,1+j] = x^j + end + for j = 1:1:d + matrix[i,1+n+j] = -x^j * y_adj + end + vector[i] = y_adj + currsign = -currsign + end + + @debug("equaldev", "trying e=", e) + @debug("equaldev", "matrix=", repr(matrix)) + @debug("equaldev", "vector=", repr(vector)) + + outvector = matrix \ vector + + @debug("equaldev", "outvector=", repr(outvector)) + + ncoeffs = outvector[1:n+1] + dcoeffs = vcat([BigFloat(1)], outvector[n+2:n+d+1]) + + x = coords[n+d+2] + y = f(x) + last_e = (ratfn_eval(ncoeffs, dcoeffs, x) - y) * w(x,y) * -currsign + + @debug("equaldev", "last e=", last_e) + + return ncoeffs, dcoeffs, last_e + end + + threshold = 2^(-epsbits/2) # convergence threshold + + # Start by trying our previous iteration's error value. This + # value (e0) will be one end of our binary-search interval, + # and whatever it caused the last point's error to be, that + # (e1) will be the other end. + e0 = prev_err + @debug("equaldev", "e0 = ", e0) + nc, dc, e1 = try_e(e0) + @debug("equaldev", "e1 = ", e1) + if abs(e1-e0) <= threshold + # If we're _really_ lucky, we hit the error right on the + # nose just by doing that! + return nc, dc + end + s = sign(e1-e0) + @debug("equaldev", "s = ", s) + + # Verify by assertion that trying our other interval endpoint + # e1 gives a value that's wrong in the other direction. + # (Otherwise our binary search won't get a sensible answer at + # all.) + nc, dc, e2 = try_e(e1) + @debug("equaldev", "e2 = ", e2) + @assert(sign(e2-e1) == -s) + + # Now binary-search until our two endpoints narrow enough. + local emid + while abs(e1-e0) > threshold + emid = (e1+e0)/2 + nc, dc, enew = try_e(emid) + if sign(enew-emid) == s + e0 = emid + else + e1 = emid + end + end + + @debug("equaldev", "final e=", emid) + return nc, dc + end +end + +# ---------------------------------------------------------------------- +# Top-level function to find a minimax rational-function approximation. + +# Arguments: +# f The function to be approximated. Maps BigFloat -> BigFloat. +# interval A pair of BigFloats giving the endpoints of the interval +# (in either order) on which to approximate f. +# n, d The degrees of the numerator and denominator of the desired +# approximation. +# w Error-weighting function. Takes two BigFloat arguments x,y +# and returns a scaling factor for the error at that location. +# The returned approximation R should have the minimum possible +# maximum value of abs((f(x)-R(x)) * w(x,f(x))). Optional +# parameter, defaulting to the always-return-1 function. +# +# Return values: a tuple (N,D,E,X), where + +# N,D A pair of arrays of BigFloats giving the coefficients +# of the returned rational function. N has size n+1; D +# has size d+1. Both start with the constant term, i.e. +# N[i] is the coefficient of x^(i-1) (because Julia +# arrays are 1-based). D[1] will be 1. +# E The maximum weighted error (BigFloat). +# X An array of pairs of BigFloats giving the locations of n+2 +# points and the weighted error at each of those points. The +# weighted error values will have alternating signs, which +# means that the Chebyshev alternation theorem guarantees +# that any other function of the same degree must exceed +# the error of this one at at least one of those points. +function ratfn_minimax(f::Function, interval::Tuple{BigFloat,BigFloat}, n, d, + w = (x,y)->BigFloat(1)) + # We start off by finding a least-squares approximation. This + # doesn't need to be perfect, but if we can get it reasonably good + # then it'll save iterations in the refining stage. + # + # Least-squares approximations tend to look nicer in a minimax + # sense if you evaluate the function at a big pile of Chebyshev + # nodes rather than uniformly spaced points. These values will + # also make a good grid to use for the initial search for error + # extrema, so we'll keep them around for that reason too. + + # Construct the grid. + lo, hi = minimum(interval), maximum(interval) + local grid + let + mid = (hi+lo)/2 + halfwid = (hi-lo)/2 + nnodes = 16 * (n+d+1) + pi = 2*asin(BigFloat(1)) + grid = [ mid - halfwid * cos(pi*i/nnodes) for i=0:1:nnodes ] + end + + # Find the initial least-squares approximation. + (nc, dc) = ratfn_leastsquares(f, grid, n, d, w) + @debug("minimax", "initial leastsquares approx = ", + ratfn_to_string(nc, dc)) + + # Threshold of convergence. We stop when the relative difference + # between the min and max (winnowed) error extrema is less than + # this. + # + # This is set to the cube root of machine epsilon on a more or + # less empirical basis, because the rational-function case will + # not converge reliably if you set it to only the square root. + # (Repeatable by using the --test mode.) On the assumption that + # input and output error in each iteration can be expected to be + # related by a simple power law (because it'll just be down to how + # many leading terms of a Taylor series are zero), the cube root + # was the next thing to try. + threshold = 2^(-epsbits/3) + + # Main loop. + while true + # Find all the error extrema we can. + function compute_error(x) + real_y = f(x) + approx_y = ratfn_eval(nc, dc, x) + return (approx_y - real_y) * w(x, real_y) + end + extrema = find_extrema(compute_error, grid) + @debug("minimax", "all extrema = ", format_xylist(extrema)) + + # Winnow the extrema down to the right number, and ensure they + # have alternating sign. + extrema = winnow_extrema(extrema, n+d+2) + @debug("minimax", "winnowed extrema = ", format_xylist(extrema)) + + # See if we've finished. + min_err = minimum([abs(y) for (x,y) = extrema]) + max_err = maximum([abs(y) for (x,y) = extrema]) + variation = (max_err - min_err) / max_err + @debug("minimax", "extremum variation = ", variation) + if variation < threshold + @debug("minimax", "done!") + return nc, dc, max_err, extrema + end + + # If not, refine our function by equalising the error at the + # extrema points, and go round again. + (nc, dc) = ratfn_equal_deviation(f, map(x->x[1], extrema), + n, d, max_err, w) + @debug("minimax", "refined approx = ", ratfn_to_string(nc, dc)) + end +end + +# ---------------------------------------------------------------------- +# Check if a polynomial is well-conditioned for accurate evaluation in +# a given interval by Horner's rule. +# +# This is true if at every step where Horner's rule computes +# (coefficient + x*value_so_far), the constant coefficient you're +# adding on is of larger magnitude than the x*value_so_far operand. +# And this has to be true for every x in the interval. +# +# Arguments: +# coeffs The coefficients of the polynomial under test. Starts with +# the constant term, i.e. coeffs[i] is the coefficient of +# x^(i-1) (because Julia arrays are 1-based). +# lo, hi The bounds of the interval. +# +# Return value: the largest ratio (x*value_so_far / coefficient), at +# any step of evaluation, for any x in the interval. If this is less +# than 1, the polynomial is at least somewhat well-conditioned; +# ideally you want it to be more like 1/8 or 1/16 or so, so that the +# relative rounding error accumulated at each step are reduced by +# several factors of 2 when the next coefficient is added on. + +function wellcond(coeffs, lo, hi) + x = max(abs(lo), abs(hi)) + worst = 0 + so_far = 0 + for i = length(coeffs):-1:1 + coeff = abs(coeffs[i]) + so_far *= x + if coeff != 0 + thisval = so_far / coeff + worst = max(worst, thisval) + so_far += coeff + end + end + return worst +end + +# ---------------------------------------------------------------------- +# Small set of unit tests. + +function test() + passes = 0 + fails = 0 + + function approx_eq(x, y, limit=1e-6) + return abs(x - y) < limit + end + + function test(condition) + if condition + passes += 1 + else + println("fail") + fails += 1 + end + end + + # Test Gaussian elimination. + println("Gaussian test 1:") + m = BigFloat[1 1 2; 3 5 8; 13 34 21] + v = BigFloat[1, -1, 2] + ret = m \ v + println(" ",repr(ret)) + test(approx_eq(ret[1], 109/26)) + test(approx_eq(ret[2], -105/130)) + test(approx_eq(ret[3], -31/26)) + + # Test leastsquares rational functions. + println("Leastsquares test 1:") + n = 10000 + a = array1d(BigFloat, n+1) + for i = 0:1:n + a[1+i] = i/BigFloat(n) + end + (nc, dc) = ratfn_leastsquares(x->exp(x), a, 2, 2) + println(" ",ratfn_to_string(nc, dc)) + for x = a + test(approx_eq(exp(x), ratfn_eval(nc, dc, x), 1e-4)) + end + + # Test golden section search. + println("Golden section test 1:") + x, y = goldensection(x->sin(x), + BigFloat(0), BigFloat(1)/10, BigFloat(4)) + println(" ", x, " -> ", y) + test(approx_eq(x, asin(BigFloat(1)))) + test(approx_eq(y, 1)) + + # Test extrema-winnowing algorithm. + println("Winnow test 1:") + extrema = [(x, sin(20*x)*sin(197*x)) + for x in BigFloat(0):BigFloat(1)/1000:BigFloat(1)] + winnowed = winnow_extrema(extrema, 12) + println(" ret = ", format_xylist(winnowed)) + prevx, prevy = -1, 0 + for (x,y) = winnowed + test(x > prevx) + test(y != 0) + test(prevy * y <= 0) # tolerates initial prevx having no sign + test(abs(y) > 0.9) + prevx, prevy = x, y + end + + # Test actual minimax approximation. + println("Minimax test 1 (polynomial):") + (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 4, 0) + println(" ",e) + println(" ",ratfn_to_string(nc, dc)) + test(0 < e < 1e-3) + for x = 0:BigFloat(1)/1000:1 + test(abs(ratfn_eval(nc, dc, x) - exp(x)) <= e * 1.0000001) + end + + println("Minimax test 2 (rational):") + (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 2, 2) + println(" ",e) + println(" ",ratfn_to_string(nc, dc)) + test(0 < e < 1e-3) + for x = 0:BigFloat(1)/1000:1 + test(abs(ratfn_eval(nc, dc, x) - exp(x)) <= e * 1.0000001) + end + + println("Minimax test 3 (polynomial, weighted):") + (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 4, 0, + (x,y)->1/y) + println(" ",e) + println(" ",ratfn_to_string(nc, dc)) + test(0 < e < 1e-3) + for x = 0:BigFloat(1)/1000:1 + test(abs(ratfn_eval(nc, dc, x) - exp(x))/exp(x) <= e * 1.0000001) + end + + println("Minimax test 4 (rational, weighted):") + (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 2, 2, + (x,y)->1/y) + println(" ",e) + println(" ",ratfn_to_string(nc, dc)) + test(0 < e < 1e-3) + for x = 0:BigFloat(1)/1000:1 + test(abs(ratfn_eval(nc, dc, x) - exp(x))/exp(x) <= e * 1.0000001) + end + + println("Minimax test 5 (rational, weighted, odd degree):") + (nc, dc, e, x) = ratfn_minimax(x->exp(x), (BigFloat(0), BigFloat(1)), 2, 1, + (x,y)->1/y) + println(" ",e) + println(" ",ratfn_to_string(nc, dc)) + test(0 < e < 1e-3) + for x = 0:BigFloat(1)/1000:1 + test(abs(ratfn_eval(nc, dc, x) - exp(x))/exp(x) <= e * 1.0000001) + end + + total = passes + fails + println(passes, " passes ", fails, " fails ", total, " total") +end + +# ---------------------------------------------------------------------- +# Online help. +function help() + print(""" +Usage: + + remez.jl [options] [] + +Arguments: + + , + + Bounds of the interval on which to approximate the target + function. These are parsed and evaluated as Julia expressions, + so you can write things like '1/BigFloat(6)' to get an + accurate representation of 1/6, or '4*atan(BigFloat(1))' to + get pi. (Unfortunately, the obvious 'BigFloat(pi)' doesn't + work in Julia.) + + , + + The desired degree of polynomial(s) you want for your + approximation. These should be non-negative integers. If you + want a rational function as output, set to the degree of + the numerator, and the denominator. If you just want an + ordinary polynomial, set to 0, and to the degree of + the polynomial you want. + + + + A Julia expression giving the function to be approximated on + the interval. The input value is predefined as 'x' when this + expression is evaluated, so you should write something along + the lines of 'sin(x)' or 'sqrt(1+tan(x)^2)' etc. + + + + If provided, a Julia expression giving the weighting factor + for the approximation error. The output polynomial will + minimise the largest absolute value of (P-f) * w at any point + in the interval, where P is the value of the polynomial, f is + the value of the target function given by , and w is the + weight given by this function. + + When this expression is evaluated, the input value to P and f + is predefined as 'x', and also the true output value f(x) is + predefined as 'y'. So you can minimise the relative error by + simply writing '1/y'. + + If the argument is not provided, the default + weighting function always returns 1, so that the polynomial + will minimise the maximum absolute error |P-f|. + +Computation options: + + --pre= + + Evaluate the Julia expression before starting + the computation. This permits you to pre-define variables or + functions which the Julia expressions in your main arguments + can refer to. All of , , and can make + use of things defined by . + + One internal remez.jl function that you might sometimes find + useful in this expression is 'goldensection', which finds the + location and value of a maximum of a function. For example, + one implementation strategy for the gamma function involves + translating it to put its unique local minimum at the origin, + in which case you can write something like this + + --pre='(m,my) = goldensection(x -> -gamma(x), + BigFloat(1), BigFloat(1.5), BigFloat(2))' + + to predefine 'm' as the location of gamma's minimum, and 'my' + as the (negated) value that gamma actually takes at that + point, i.e. -gamma(m). + + (Since 'goldensection' always finds a maximum, we had to + negate gamma in the input function to make it find a minimum + instead. Consult the comments in the source for more details + on the use of this function.) + + If you use this option more than once, all the expressions you + provide will be run in sequence. + + --bits= + + Specify the accuracy to which you want the output polynomial, + in bits. Default 256, which should be more than enough. + + --bigfloatbits= + + Turn up the precision used by Julia for its BigFloat + evaluation. Default is Julia's default (also 256). You might + want to try setting this higher than the --bits value if the + algorithm is failing to converge for some reason. + +Output options: + + --full + + Instead of just printing the approximation function itself, + also print auxiliary information: + - the locations of the error extrema, and the actual + (weighted) error at each of those locations + - the overall maximum error of the function + - a 'well-conditioning quotient', giving the worst-case ratio + between any polynomial coefficient and the largest possible + value of the higher-order terms it will be added to. + + The well-conditioning quotient should be less than 1, ideally + by several factors of two, for accurate evaluation in the + target precision. If you request a rational function, a + separate well-conditioning quotient will be printed for the + numerator and denominator. + + Use this option when deciding how wide an interval to + approximate your function on, and what degree of polynomial + you need. + + --variable= + + When writing the output polynomial or rational function in its + usual form as an arithmetic expression, use as + the name of the input variable. Default is 'x'. + + --suffix= + + When writing the output polynomial or rational function in its + usual form as an arithmetic expression, write after + every floating-point literal. For example, '--suffix=F' will + generate a C expression in which the coefficients are literals + of type 'float' rather than 'double'. + + --array + + Instead of writing the output polynomial as an arithmetic + expression in Horner's rule form, write out just its + coefficients, one per line, each with a trailing comma. + Suitable for pasting into a C array declaration. + + This option is not currently supported if the output is a + rational function, because you'd need two separate arrays for + the numerator and denominator coefficients and there's no + obviously right way to provide both of those together. + +Debug and test options: + + --debug= + + Enable debugging output from various parts of the Remez + calculation. should be the name of one of the + classes of diagnostic output implemented in the program. + Useful values include 'gausselim', 'leastsquares', + 'goldensection', 'equaldev', 'minimax'. This is probably + mostly useful to people debugging problems with the script, so + consult the source code for more information about what the + diagnostic output for each of those facilities will be. + + If you want diagnostics from more than one facility, specify + this option multiple times with different arguments. + + --test + + Run remez.jl's internal test suite. No arguments needed. + +Miscellaneous options: + + --help + + Display this text and exit. No arguments needed. + +""") +end + +# ---------------------------------------------------------------------- +# Main program. + +function main() + nargs = length(argwords) + if nargs != 5 && nargs != 6 + error("usage: remez.jl []\n" * + " run 'remez.jl --help' for more help") + end + + for preliminary_command in preliminary_commands + eval(Meta.parse(preliminary_command)) + end + + lo = BigFloat(eval(Meta.parse(argwords[1]))) + hi = BigFloat(eval(Meta.parse(argwords[2]))) + n = parse(Int,argwords[3]) + d = parse(Int,argwords[4]) + f = eval(Meta.parse("x -> " * argwords[5])) + + # Wrap the user-provided function with a function of our own. This + # arranges to detect silly FP values (inf,nan) early and diagnose + # them sensibly, and also lets us log all evaluations of the + # function in case you suspect it's doing the wrong thing at some + # special-case point. + function func(x) + y = run(f,x) + @debug("f", x, " -> ", y) + if !isfinite(y) + error("f(" * string(x) * ") returned non-finite value " * string(y)) + end + return y + end + + if nargs == 6 + # Wrap the user-provided weight function similarly. + w = eval(Meta.parse("(x,y) -> " * argwords[6])) + function wrapped_weight(x,y) + ww = run(w,x,y) + if !isfinite(ww) + error("w(" * string(x) * "," * string(y) * + ") returned non-finite value " * string(ww)) + end + return ww + end + weight = wrapped_weight + else + weight = (x,y)->BigFloat(1) + end + + (nc, dc, e, extrema) = ratfn_minimax(func, (lo, hi), n, d, weight) + if array_format + if d == 0 + functext = join([string(x)*",\n" for x=nc],"") + else + # It's unclear how you should best format an array of + # coefficients for a rational function, so I'll leave + # implementing this option until I have a use case. + error("--array unsupported for rational functions") + end + else + functext = ratfn_to_string(nc, dc) * "\n" + end + if full_output + # Print everything you might want to know about the function + println("extrema = ", format_xylist(extrema)) + println("maxerror = ", string(e)) + if length(dc) > 1 + println("wellconditioning_numerator = ", + string(wellcond(nc, lo, hi))) + println("wellconditioning_denominator = ", + string(wellcond(dc, lo, hi))) + else + println("wellconditioning = ", string(wellcond(nc, lo, hi))) + end + print("function = ", functext) + else + # Just print the text people will want to paste into their code + print(functext) + end +end + +# ---------------------------------------------------------------------- +# Top-level code: parse the argument list and decide what to do. + +what_to_do = main + +doing_opts = true +argwords = array1d(String, 0) +for arg = ARGS + global doing_opts, what_to_do, argwords + global full_output, array_format, xvarname, floatsuffix, epsbits + if doing_opts && startswith(arg, "-") + if arg == "--" + doing_opts = false + elseif arg == "--help" + what_to_do = help + elseif arg == "--test" + what_to_do = test + elseif arg == "--full" + full_output = true + elseif arg == "--array" + array_format = true + elseif startswith(arg, "--debug=") + enable_debug(arg[length("--debug=")+1:end]) + elseif startswith(arg, "--variable=") + xvarname = arg[length("--variable=")+1:end] + elseif startswith(arg, "--suffix=") + floatsuffix = arg[length("--suffix=")+1:end] + elseif startswith(arg, "--bits=") + epsbits = parse(Int,arg[length("--bits=")+1:end]) + elseif startswith(arg, "--bigfloatbits=") + set_bigfloat_precision( + parse(Int,arg[length("--bigfloatbits=")+1:end])) + elseif startswith(arg, "--pre=") + push!(preliminary_commands, arg[length("--pre=")+1:end]) + else + error("unrecognised option: ", arg) + end + else + push!(argwords, arg) + end +end + +what_to_do() diff --git a/libc/AOR_v20.02/math/tools/sin.sollya b/libc/AOR_v20.02/math/tools/sin.sollya new file mode 100644 index 00000000000000..f5c11ec2f191be --- /dev/null +++ b/libc/AOR_v20.02/math/tools/sin.sollya @@ -0,0 +1,38 @@ +// polynomial for approximating sin(x) +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 7; // polynomial degree +a = -pi/4; // interval +b = pi/4; + +// find even polynomial with minimal abs error compared to sin(x)/x + +// account for /x +deg = deg-1; + +// f = sin(x)/x; +f = 1; +c = 1; +for i from 1 to 60 do { c = 2*i*(2*i + 1)*c; f = f + (-1)^i*x^(2*i)/c; }; + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)| +approx = proc(poly,d) { + return remez(f(x)-poly(x), deg-d, [a;b], x^d, 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = 1; +for i from 1 to deg/2 do { + p = roundcoefficients(approx(poly,2*i), [|D ...|]); + poly = poly + x^(2*i)*coeff(p,0); +}; + +display = hexadecimal; +print("rel error:", accurateinfnorm(1-poly(x)/f(x), [a;b], 30)); +print("abs error:", accurateinfnorm(sin(x)-x*poly(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/v_exp.sollya b/libc/AOR_v20.02/math/tools/v_exp.sollya new file mode 100644 index 00000000000000..4ef477f9002008 --- /dev/null +++ b/libc/AOR_v20.02/math/tools/v_exp.sollya @@ -0,0 +1,31 @@ +// polynomial for approximating e^x +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 4; // poly degree +N = 128; // table entries +b = log(2)/(2*N); // interval +a = -b; + +// find polynomial with minimal abs error + +// return p that minimizes |exp(x) - poly(x) - x^d*p(x)| +approx = proc(poly,d) { + return remez(exp(x)-poly(x), deg-d, [a;b], x^d, 1e-10); +}; + +// first 2 coeffs are fixed, iteratively find optimal double prec coeffs +poly = 1 + x; +for i from 2 to deg do { + p = roundcoefficients(approx(poly,i), [|D ...|]); + poly = poly + x^i*coeff(p,0); +}; + +display = hexadecimal; +print("rel error:", accurateinfnorm(1-poly(x)/exp(x), [a;b], 30)); +print("abs error:", accurateinfnorm(exp(x)-poly(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/v_log.sollya b/libc/AOR_v20.02/math/tools/v_log.sollya new file mode 100644 index 00000000000000..d23b9da48460e5 --- /dev/null +++ b/libc/AOR_v20.02/math/tools/v_log.sollya @@ -0,0 +1,35 @@ +// polynomial used for __v_log(x) +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 6; // poly degree +a = -0x1.fc1p-9; +b = 0x1.009p-8; + +// find log(1+x)/x polynomial with minimal relative error +// (minimal relative error polynomial for log(1+x) is the same * x) +deg = deg-1; // because of /x + +// f = log(1+x)/x; using taylor series +f = 0; +for i from 0 to 60 do { f = f + (-x)^i/(i+1); }; + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)|/|f(x)| +approx = proc(poly,d) { + return remez(1 - poly(x)/f(x), deg-d, [a;b], x^d/f(x), 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = 1; +for i from 1 to deg do { + p = roundcoefficients(approx(poly,i), [|D ...|]); + poly = poly + x^i*coeff(p,0); +}; + +display = hexadecimal; +print("rel error:", accurateinfnorm(1-poly(x)/f(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/tools/v_sin.sollya b/libc/AOR_v20.02/math/tools/v_sin.sollya new file mode 100644 index 00000000000000..5c596427daab24 --- /dev/null +++ b/libc/AOR_v20.02/math/tools/v_sin.sollya @@ -0,0 +1,37 @@ +// polynomial for approximating sin(x) +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +deg = 15; // polynomial degree +a = -pi/2; // interval +b = pi/2; + +// find even polynomial with minimal abs error compared to sin(x)/x + +// account for /x +deg = deg-1; + +// f = sin(x)/x; +f = 1; +c = 1; +for i from 1 to 60 do { c = 2*i*(2*i + 1)*c; f = f + (-1)^i*x^(2*i)/c; }; + +// return p that minimizes |f(x) - poly(x) - x^d*p(x)| +approx = proc(poly,d) { + return remez(f(x)-poly(x), deg-d, [a;b], x^d, 1e-10); +}; + +// first coeff is fixed, iteratively find optimal double prec coeffs +poly = 1; +for i from 1 to deg/2 do { + p = roundcoefficients(approx(poly,2*i), [|D ...|]); + poly = poly + x^(2*i)*coeff(p,0); +}; + +display = hexadecimal; +print("abs error:", accurateinfnorm(sin(x)-x*poly(x), [a;b], 30)); +print("in [",a,b,"]"); +print("coeffs:"); +for i from 0 to deg do coeff(poly,i); diff --git a/libc/AOR_v20.02/math/v_cos.c b/libc/AOR_v20.02/math/v_cos.c new file mode 100644 index 00000000000000..1eebdbceeda04e --- /dev/null +++ b/libc/AOR_v20.02/math/v_cos.c @@ -0,0 +1,88 @@ +/* + * Double-precision vector cos function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const double Poly[] = { +/* worst-case error is 3.5 ulp. + abs error: 0x1.be222a58p-53 in [-pi/2, pi/2]. */ +-0x1.9f4a9c8b21dc9p-41, + 0x1.60e88a10163f2p-33, +-0x1.ae6361b7254e7p-26, + 0x1.71de382e8d62bp-19, +-0x1.a01a019aeb4ffp-13, + 0x1.111111110b25ep-7, +-0x1.55555555554c3p-3, +}; + +#define C7 v_f64 (Poly[0]) +#define C6 v_f64 (Poly[1]) +#define C5 v_f64 (Poly[2]) +#define C4 v_f64 (Poly[3]) +#define C3 v_f64 (Poly[4]) +#define C2 v_f64 (Poly[5]) +#define C1 v_f64 (Poly[6]) + +#define InvPi v_f64 (0x1.45f306dc9c883p-2) +#define HalfPi v_f64 (0x1.921fb54442d18p+0) +#define Pi1 v_f64 (0x1.921fb54442d18p+1) +#define Pi2 v_f64 (0x1.1a62633145c06p-53) +#define Pi3 v_f64 (0x1.c1cd129024e09p-106) +#define Shift v_f64 (0x1.8p52) +#define RangeVal v_f64 (0x1p23) +#define AbsMask v_u64 (0x7fffffffffffffff) + +VPCS_ATTR +__attribute__ ((noinline)) static v_f64_t +specialcase (v_f64_t x, v_f64_t y, v_u64_t cmp) +{ + return v_call_f64 (cos, x, y, cmp); +} + +VPCS_ATTR +v_f64_t +V_NAME(cos) (v_f64_t x) +{ + v_f64_t n, r, r2, y; + v_u64_t odd, cmp; + + r = v_as_f64_u64 (v_as_u64_f64 (x) & AbsMask); + cmp = v_cond_u64 (v_as_u64_f64 (r) >= v_as_u64_f64 (RangeVal)); + + /* n = rint((|x|+pi/2)/pi) - 0.5. */ + n = v_fma_f64 (InvPi, r + HalfPi, Shift); + odd = v_as_u64_f64 (n) << 63; + n -= Shift; + n -= v_f64 (0.5); + + /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2). */ + r = v_fma_f64 (-Pi1, n, r); + r = v_fma_f64 (-Pi2, n, r); + r = v_fma_f64 (-Pi3, n, r); + + /* sin(r) poly approx. */ + r2 = r * r; + y = v_fma_f64 (C7, r2, C6); + y = v_fma_f64 (y, r2, C5); + y = v_fma_f64 (y, r2, C4); + y = v_fma_f64 (y, r2, C3); + y = v_fma_f64 (y, r2, C2); + y = v_fma_f64 (y, r2, C1); + y = v_fma_f64 (y * r2, r, r); + + /* sign. */ + y = v_as_f64_u64 (v_as_u64_f64 (y) ^ odd); + + if (unlikely (v_any_u64 (cmp))) + return specialcase (x, y, cmp); + return y; +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_cosf.c b/libc/AOR_v20.02/math/v_cosf.c new file mode 100644 index 00000000000000..b9dcd486f4b2b5 --- /dev/null +++ b/libc/AOR_v20.02/math/v_cosf.c @@ -0,0 +1,77 @@ +/* + * Single-precision vector cos function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const float Poly[] = { + /* 1.886 ulp error */ + 0x1.5b2e76p-19f, + -0x1.9f42eap-13f, + 0x1.110df4p-7f, + -0x1.555548p-3f, +}; +#define Pi1 v_f32 (0x1.921fb6p+1f) +#define Pi2 v_f32 (-0x1.777a5cp-24f) +#define Pi3 v_f32 (-0x1.ee59dap-49f) +#define A3 v_f32 (Poly[3]) +#define A5 v_f32 (Poly[2]) +#define A7 v_f32 (Poly[1]) +#define A9 v_f32 (Poly[0]) +#define RangeVal v_f32 (0x1p20f) +#define InvPi v_f32 (0x1.45f306p-2f) +#define Shift v_f32 (0x1.8p+23f) +#define AbsMask v_u32 (0x7fffffff) +#define HalfPi v_f32 (0x1.921fb6p0f) + +VPCS_ATTR +static v_f32_t +specialcase (v_f32_t x, v_f32_t y, v_u32_t cmp) +{ + /* Fall back to scalar code. */ + return v_call_f32 (cosf, x, y, cmp); +} + +VPCS_ATTR +v_f32_t +V_NAME(cosf) (v_f32_t x) +{ + v_f32_t n, r, r2, y; + v_u32_t odd, cmp; + + r = v_as_f32_u32 (v_as_u32_f32 (x) & AbsMask); + cmp = v_cond_u32 (v_as_u32_f32 (r) >= v_as_u32_f32 (RangeVal)); + + /* n = rint((|x|+pi/2)/pi) - 0.5 */ + n = v_fma_f32 (InvPi, r + HalfPi, Shift); + odd = v_as_u32_f32 (n) << 31; + n -= Shift; + n -= v_f32 (0.5f); + + /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2) */ + r = v_fma_f32 (-Pi1, n, r); + r = v_fma_f32 (-Pi2, n, r); + r = v_fma_f32 (-Pi3, n, r); + + /* y = sin(r) */ + r2 = r * r; + y = v_fma_f32 (A9, r2, A7); + y = v_fma_f32 (y, r2, A5); + y = v_fma_f32 (y, r2, A3); + y = v_fma_f32 (y * r2, r, r); + + /* sign fix */ + y = v_as_f32_u32 (v_as_u32_f32 (y) ^ odd); + + if (unlikely (v_any_u32 (cmp))) + return specialcase (x, y, cmp); + return y; +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_exp.c b/libc/AOR_v20.02/math/v_exp.c new file mode 100644 index 00000000000000..9074cecdd1543b --- /dev/null +++ b/libc/AOR_v20.02/math/v_exp.c @@ -0,0 +1,95 @@ +/* + * Double-precision vector e^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED +#include "v_exp.h" + +#if V_EXP_TABLE_BITS == 7 +/* maxerr: 1.88 +0.5 ulp + rel error: 1.4337*2^-53 + abs error: 1.4299*2^-53 in [ -ln2/256, ln2/256 ]. */ +#define C1 v_f64 (0x1.ffffffffffd43p-2) +#define C2 v_f64 (0x1.55555c75adbb2p-3) +#define C3 v_f64 (0x1.55555da646206p-5) +#define InvLn2 v_f64 (0x1.71547652b82fep7) /* N/ln2. */ +#define Ln2hi v_f64 (0x1.62e42fefa39efp-8) /* ln2/N. */ +#define Ln2lo v_f64 (0x1.abc9e3b39803f3p-63) +#elif V_EXP_TABLE_BITS == 8 +/* maxerr: 0.54 +0.5 ulp + rel error: 1.4318*2^-58 + abs error: 1.4299*2^-58 in [ -ln2/512, ln2/512 ]. */ +#define C1 v_f64 (0x1.fffffffffffd4p-2) +#define C2 v_f64 (0x1.5555571d6b68cp-3) +#define C3 v_f64 (0x1.5555576a59599p-5) +#define InvLn2 v_f64 (0x1.71547652b82fep8) +#define Ln2hi v_f64 (0x1.62e42fefa39efp-9) +#define Ln2lo v_f64 (0x1.abc9e3b39803f3p-64) +#endif + +#define N (1 << V_EXP_TABLE_BITS) +#define Tab __v_exp_data +#define IndexMask v_u64 (N - 1) +#define Shift v_f64 (0x1.8p+52) +#define Thres v_f64 (704.0) + +VPCS_ATTR +static v_f64_t +specialcase (v_f64_t s, v_f64_t y, v_f64_t n) +{ + v_f64_t absn = v_abs_f64 (n); + + /* 2^(n/N) may overflow, break it up into s1*s2. */ + v_u64_t b = v_cond_u64 (n <= v_f64 (0.0)) & v_u64 (0x6000000000000000); + v_f64_t s1 = v_as_f64_u64 (v_u64 (0x7000000000000000) - b); + v_f64_t s2 = v_as_f64_u64 (v_as_u64_f64 (s) - v_u64 (0x3010000000000000) + b); + v_u64_t cmp = v_cond_u64 (absn > v_f64 (1280.0 * N)); + v_f64_t r1 = s1 * s1; + v_f64_t r0 = v_fma_f64 (y, s2, s2) * s1; + return v_as_f64_u64 ((cmp & v_as_u64_f64 (r1)) | (~cmp & v_as_u64_f64 (r0))); +} + +VPCS_ATTR +v_f64_t +V_NAME(exp) (v_f64_t x) +{ + v_f64_t n, r, r2, s, y, z; + v_u64_t cmp, u, e, i; + + cmp = v_cond_u64 (v_abs_f64 (x) > Thres); + + /* n = round(x/(ln2/N)). */ + z = v_fma_f64 (x, InvLn2, Shift); + u = v_as_u64_f64 (z); + n = z - Shift; + + /* r = x - n*ln2/N. */ + r = x; + r = v_fma_f64 (-Ln2hi, n, r); + r = v_fma_f64 (-Ln2lo, n, r); + + e = u << (52 - V_EXP_TABLE_BITS); + i = u & IndexMask; + + /* y = exp(r) - 1 ~= r + C1 r^2 + C2 r^3 + C3 r^4. */ + r2 = r * r; + y = v_fma_f64 (C2, r, C1); + y = v_fma_f64 (C3, r2, y); + y = v_fma_f64 (y, r2, r); + + /* s = 2^(n/N). */ + u = v_lookup_u64 (Tab, i); + s = v_as_f64_u64 (u + e); + + if (unlikely (v_any_u64 (cmp))) + return specialcase (s, y, n); + return v_fma_f64 (y, s, s); +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_exp.h b/libc/AOR_v20.02/math/v_exp.h new file mode 100644 index 00000000000000..251c85dc5255c5 --- /dev/null +++ b/libc/AOR_v20.02/math/v_exp.h @@ -0,0 +1,15 @@ +/* + * Declarations for double-precision e^x vector function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "v_math.h" +#if WANT_VMATH + +#define V_EXP_TABLE_BITS 7 + +extern const u64_t __v_exp_data[1 << V_EXP_TABLE_BITS] HIDDEN; +#endif diff --git a/libc/AOR_v20.02/math/v_exp2f.c b/libc/AOR_v20.02/math/v_exp2f.c new file mode 100644 index 00000000000000..876298fea53160 --- /dev/null +++ b/libc/AOR_v20.02/math/v_exp2f.c @@ -0,0 +1,79 @@ +/* + * Single-precision vector 2^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const float Poly[] = { + /* maxerr: 1.962 ulp. */ + 0x1.59977ap-10f, + 0x1.3ce9e4p-7f, + 0x1.c6bd32p-5f, + 0x1.ebf9bcp-3f, + 0x1.62e422p-1f, +}; +#define C0 v_f32 (Poly[0]) +#define C1 v_f32 (Poly[1]) +#define C2 v_f32 (Poly[2]) +#define C3 v_f32 (Poly[3]) +#define C4 v_f32 (Poly[4]) + +#define Shift v_f32 (0x1.8p23f) + +VPCS_ATTR +static v_f32_t +specialcase (v_f32_t poly, v_f32_t n, v_u32_t e, v_f32_t absn, v_u32_t cmp1, v_f32_t scale) +{ + /* 2^n may overflow, break it up into s1*s2. */ + v_u32_t b = v_cond_u32 (n <= v_f32 (0.0f)) & v_u32 (0x82000000); + v_f32_t s1 = v_as_f32_u32 (v_u32 (0x7f000000) + b); + v_f32_t s2 = v_as_f32_u32 (e - b); + v_u32_t cmp2 = v_cond_u32 (absn > v_f32 (192.0f)); + v_u32_t r2 = v_as_u32_f32 (s1 * s1); + v_u32_t r1 = v_as_u32_f32 (v_fma_f32 (poly, s2, s2) * s1); + /* Similar to r1 but avoids double rounding in the subnormal range. */ + v_u32_t r0 = v_as_u32_f32 (v_fma_f32 (poly, scale, scale)); + return v_as_f32_u32 ((cmp2 & r2) | (~cmp2 & cmp1 & r1) | (~cmp1 & r0)); +} + +VPCS_ATTR +v_f32_t +V_NAME(exp2f) (v_f32_t x) +{ + v_f32_t n, r, r2, scale, p, q, poly, absn; + v_u32_t cmp, e; + + /* exp2(x) = 2^n (1 + poly(r)), with 1 + poly(r) in [1/sqrt(2),sqrt(2)] + x = n + r, with r in [-1/2, 1/2]. */ +#if 0 + v_f32_t z; + z = x + Shift; + n = z - Shift; + r = x - n; + e = v_as_u32_f32 (z) << 23; +#else + n = v_round_f32 (x); + r = x - n; + e = v_as_u32_s32 (v_round_s32 (x)) << 23; +#endif + scale = v_as_f32_u32 (e + v_u32 (0x3f800000)); + absn = v_abs_f32 (n); + cmp = v_cond_u32 (absn > v_f32 (126.0f)); + r2 = r * r; + p = v_fma_f32 (C0, r, C1); + q = v_fma_f32 (C2, r, C3); + q = v_fma_f32 (p, r2, q); + p = C4 * r; + poly = v_fma_f32 (q, r2, p); + if (unlikely (v_any_u32 (cmp))) + return specialcase (poly, n, e, absn, cmp, scale); + return v_fma_f32 (poly, scale, scale); +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_exp2f_1u.c b/libc/AOR_v20.02/math/v_exp2f_1u.c new file mode 100644 index 00000000000000..d8b660e15f239b --- /dev/null +++ b/libc/AOR_v20.02/math/v_exp2f_1u.c @@ -0,0 +1,76 @@ +/* + * Single-precision vector 2^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const float Poly[] = { + /* maxerr: 0.878 ulp. */ + 0x1.416b5ep-13f, 0x1.5f082ep-10f, 0x1.3b2dep-7f, 0x1.c6af7cp-5f, 0x1.ebfbdcp-3f, 0x1.62e43p-1f +}; +#define C0 v_f32 (Poly[0]) +#define C1 v_f32 (Poly[1]) +#define C2 v_f32 (Poly[2]) +#define C3 v_f32 (Poly[3]) +#define C4 v_f32 (Poly[4]) +#define C5 v_f32 (Poly[5]) + +#define Shift v_f32 (0x1.8p23f) +#define InvLn2 v_f32 (0x1.715476p+0f) +#define Ln2hi v_f32 (0x1.62e4p-1f) +#define Ln2lo v_f32 (0x1.7f7d1cp-20f) + +VPCS_ATTR +static v_f32_t +specialcase (v_f32_t poly, v_f32_t n, v_u32_t e, v_f32_t absn) +{ + /* 2^n may overflow, break it up into s1*s2. */ + v_u32_t b = v_cond_u32 (n <= v_f32 (0.0f)) & v_u32 (0x83000000); + v_f32_t s1 = v_as_f32_u32 (v_u32 (0x7f000000) + b); + v_f32_t s2 = v_as_f32_u32 (e - b); + v_u32_t cmp = v_cond_u32 (absn > v_f32 (192.0f)); + v_f32_t r1 = s1 * s1; + v_f32_t r0 = poly * s1 * s2; + return v_as_f32_u32 ((cmp & v_as_u32_f32 (r1)) | (~cmp & v_as_u32_f32 (r0))); +} + +VPCS_ATTR +v_f32_t +V_NAME(exp2f_1u) (v_f32_t x) +{ + v_f32_t n, r, scale, poly, absn; + v_u32_t cmp, e; + + /* exp2(x) = 2^n * poly(r), with poly(r) in [1/sqrt(2),sqrt(2)] + x = n + r, with r in [-1/2, 1/2]. */ +#if 0 + v_f32_t z; + z = x + Shift; + n = z - Shift; + r = x - n; + e = v_as_u32_f32 (z) << 23; +#else + n = v_round_f32 (x); + r = x - n; + e = v_as_u32_s32 (v_round_s32 (x)) << 23; +#endif + scale = v_as_f32_u32 (e + v_u32 (0x3f800000)); + absn = v_abs_f32 (n); + cmp = v_cond_u32 (absn > v_f32 (126.0f)); + poly = v_fma_f32 (C0, r, C1); + poly = v_fma_f32 (poly, r, C2); + poly = v_fma_f32 (poly, r, C3); + poly = v_fma_f32 (poly, r, C4); + poly = v_fma_f32 (poly, r, C5); + poly = v_fma_f32 (poly, r, v_f32 (1.0f)); + if (unlikely (v_any_u32 (cmp))) + return specialcase (poly, n, e, absn); + return scale * poly; +} +#endif diff --git a/libc/AOR_v20.02/math/v_exp_data.c b/libc/AOR_v20.02/math/v_exp_data.c new file mode 100644 index 00000000000000..fc248e3ce479c9 --- /dev/null +++ b/libc/AOR_v20.02/math/v_exp_data.c @@ -0,0 +1,404 @@ +/* + * Lookup table for double-precision e^x vector function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "v_exp.h" +#if WANT_VMATH + +#define N (1 << V_EXP_TABLE_BITS) + +/* 2^(j/N), j=0..N. */ +const u64_t __v_exp_data[] = { +#if N == 128 +0x3ff0000000000000, +0x3feff63da9fb3335, +0x3fefec9a3e778061, +0x3fefe315e86e7f85, +0x3fefd9b0d3158574, +0x3fefd06b29ddf6de, +0x3fefc74518759bc8, +0x3fefbe3ecac6f383, +0x3fefb5586cf9890f, +0x3fefac922b7247f7, +0x3fefa3ec32d3d1a2, +0x3fef9b66affed31b, +0x3fef9301d0125b51, +0x3fef8abdc06c31cc, +0x3fef829aaea92de0, +0x3fef7a98c8a58e51, +0x3fef72b83c7d517b, +0x3fef6af9388c8dea, +0x3fef635beb6fcb75, +0x3fef5be084045cd4, +0x3fef54873168b9aa, +0x3fef4d5022fcd91d, +0x3fef463b88628cd6, +0x3fef3f49917ddc96, +0x3fef387a6e756238, +0x3fef31ce4fb2a63f, +0x3fef2b4565e27cdd, +0x3fef24dfe1f56381, +0x3fef1e9df51fdee1, +0x3fef187fd0dad990, +0x3fef1285a6e4030b, +0x3fef0cafa93e2f56, +0x3fef06fe0a31b715, +0x3fef0170fc4cd831, +0x3feefc08b26416ff, +0x3feef6c55f929ff1, +0x3feef1a7373aa9cb, +0x3feeecae6d05d866, +0x3feee7db34e59ff7, +0x3feee32dc313a8e5, +0x3feedea64c123422, +0x3feeda4504ac801c, +0x3feed60a21f72e2a, +0x3feed1f5d950a897, +0x3feece086061892d, +0x3feeca41ed1d0057, +0x3feec6a2b5c13cd0, +0x3feec32af0d7d3de, +0x3feebfdad5362a27, +0x3feebcb299fddd0d, +0x3feeb9b2769d2ca7, +0x3feeb6daa2cf6642, +0x3feeb42b569d4f82, +0x3feeb1a4ca5d920f, +0x3feeaf4736b527da, +0x3feead12d497c7fd, +0x3feeab07dd485429, +0x3feea9268a5946b7, +0x3feea76f15ad2148, +0x3feea5e1b976dc09, +0x3feea47eb03a5585, +0x3feea34634ccc320, +0x3feea23882552225, +0x3feea155d44ca973, +0x3feea09e667f3bcd, +0x3feea012750bdabf, +0x3fee9fb23c651a2f, +0x3fee9f7df9519484, +0x3fee9f75e8ec5f74, +0x3fee9f9a48a58174, +0x3fee9feb564267c9, +0x3feea0694fde5d3f, +0x3feea11473eb0187, +0x3feea1ed0130c132, +0x3feea2f336cf4e62, +0x3feea427543e1a12, +0x3feea589994cce13, +0x3feea71a4623c7ad, +0x3feea8d99b4492ed, +0x3feeaac7d98a6699, +0x3feeace5422aa0db, +0x3feeaf3216b5448c, +0x3feeb1ae99157736, +0x3feeb45b0b91ffc6, +0x3feeb737b0cdc5e5, +0x3feeba44cbc8520f, +0x3feebd829fde4e50, +0x3feec0f170ca07ba, +0x3feec49182a3f090, +0x3feec86319e32323, +0x3feecc667b5de565, +0x3feed09bec4a2d33, +0x3feed503b23e255d, +0x3feed99e1330b358, +0x3feede6b5579fdbf, +0x3feee36bbfd3f37a, +0x3feee89f995ad3ad, +0x3feeee07298db666, +0x3feef3a2b84f15fb, +0x3feef9728de5593a, +0x3feeff76f2fb5e47, +0x3fef05b030a1064a, +0x3fef0c1e904bc1d2, +0x3fef12c25bd71e09, +0x3fef199bdd85529c, +0x3fef20ab5fffd07a, +0x3fef27f12e57d14b, +0x3fef2f6d9406e7b5, +0x3fef3720dcef9069, +0x3fef3f0b555dc3fa, +0x3fef472d4a07897c, +0x3fef4f87080d89f2, +0x3fef5818dcfba487, +0x3fef60e316c98398, +0x3fef69e603db3285, +0x3fef7321f301b460, +0x3fef7c97337b9b5f, +0x3fef864614f5a129, +0x3fef902ee78b3ff6, +0x3fef9a51fbc74c83, +0x3fefa4afa2a490da, +0x3fefaf482d8e67f1, +0x3fefba1bee615a27, +0x3fefc52b376bba97, +0x3fefd0765b6e4540, +0x3fefdbfdad9cbe14, +0x3fefe7c1819e90d8, +0x3feff3c22b8f71f1, +#elif N == 256 +0x3ff0000000000000, +0x3feffb1afa5abcbf, +0x3feff63da9fb3335, +0x3feff168143b0281, +0x3fefec9a3e778061, +0x3fefe7d42e11bbcc, +0x3fefe315e86e7f85, +0x3fefde5f72f654b1, +0x3fefd9b0d3158574, +0x3fefd50a0e3c1f89, +0x3fefd06b29ddf6de, +0x3fefcbd42b72a836, +0x3fefc74518759bc8, +0x3fefc2bdf66607e0, +0x3fefbe3ecac6f383, +0x3fefb9c79b1f3919, +0x3fefb5586cf9890f, +0x3fefb0f145e46c85, +0x3fefac922b7247f7, +0x3fefa83b23395dec, +0x3fefa3ec32d3d1a2, +0x3fef9fa55fdfa9c5, +0x3fef9b66affed31b, +0x3fef973028d7233e, +0x3fef9301d0125b51, +0x3fef8edbab5e2ab6, +0x3fef8abdc06c31cc, +0x3fef86a814f204ab, +0x3fef829aaea92de0, +0x3fef7e95934f312e, +0x3fef7a98c8a58e51, +0x3fef76a45471c3c2, +0x3fef72b83c7d517b, +0x3fef6ed48695bbc0, +0x3fef6af9388c8dea, +0x3fef672658375d2f, +0x3fef635beb6fcb75, +0x3fef5f99f8138a1c, +0x3fef5be084045cd4, +0x3fef582f95281c6b, +0x3fef54873168b9aa, +0x3fef50e75eb44027, +0x3fef4d5022fcd91d, +0x3fef49c18438ce4d, +0x3fef463b88628cd6, +0x3fef42be3578a819, +0x3fef3f49917ddc96, +0x3fef3bdda27912d1, +0x3fef387a6e756238, +0x3fef351ffb82140a, +0x3fef31ce4fb2a63f, +0x3fef2e85711ece75, +0x3fef2b4565e27cdd, +0x3fef280e341ddf29, +0x3fef24dfe1f56381, +0x3fef21ba7591bb70, +0x3fef1e9df51fdee1, +0x3fef1b8a66d10f13, +0x3fef187fd0dad990, +0x3fef157e39771b2f, +0x3fef1285a6e4030b, +0x3fef0f961f641589, +0x3fef0cafa93e2f56, +0x3fef09d24abd886b, +0x3fef06fe0a31b715, +0x3fef0432edeeb2fd, +0x3fef0170fc4cd831, +0x3feefeb83ba8ea32, +0x3feefc08b26416ff, +0x3feef96266e3fa2d, +0x3feef6c55f929ff1, +0x3feef431a2de883b, +0x3feef1a7373aa9cb, +0x3feeef26231e754a, +0x3feeecae6d05d866, +0x3feeea401b7140ef, +0x3feee7db34e59ff7, +0x3feee57fbfec6cf4, +0x3feee32dc313a8e5, +0x3feee0e544ede173, +0x3feedea64c123422, +0x3feedc70df1c5175, +0x3feeda4504ac801c, +0x3feed822c367a024, +0x3feed60a21f72e2a, +0x3feed3fb2709468a, +0x3feed1f5d950a897, +0x3feecffa3f84b9d4, +0x3feece086061892d, +0x3feecc2042a7d232, +0x3feeca41ed1d0057, +0x3feec86d668b3237, +0x3feec6a2b5c13cd0, +0x3feec4e1e192aed2, +0x3feec32af0d7d3de, +0x3feec17dea6db7d7, +0x3feebfdad5362a27, +0x3feebe41b817c114, +0x3feebcb299fddd0d, +0x3feebb2d81d8abff, +0x3feeb9b2769d2ca7, +0x3feeb8417f4531ee, +0x3feeb6daa2cf6642, +0x3feeb57de83f4eef, +0x3feeb42b569d4f82, +0x3feeb2e2f4f6ad27, +0x3feeb1a4ca5d920f, +0x3feeb070dde910d2, +0x3feeaf4736b527da, +0x3feeae27dbe2c4cf, +0x3feead12d497c7fd, +0x3feeac0827ff07cc, +0x3feeab07dd485429, +0x3feeaa11fba87a03, +0x3feea9268a5946b7, +0x3feea84590998b93, +0x3feea76f15ad2148, +0x3feea6a320dceb71, +0x3feea5e1b976dc09, +0x3feea52ae6cdf6f4, +0x3feea47eb03a5585, +0x3feea3dd1d1929fd, +0x3feea34634ccc320, +0x3feea2b9febc8fb7, +0x3feea23882552225, +0x3feea1c1c70833f6, +0x3feea155d44ca973, +0x3feea0f4b19e9538, +0x3feea09e667f3bcd, +0x3feea052fa75173e, +0x3feea012750bdabf, +0x3fee9fdcddd47645, +0x3fee9fb23c651a2f, +0x3fee9f9298593ae5, +0x3fee9f7df9519484, +0x3fee9f7466f42e87, +0x3fee9f75e8ec5f74, +0x3fee9f8286ead08a, +0x3fee9f9a48a58174, +0x3fee9fbd35d7cbfd, +0x3fee9feb564267c9, +0x3feea024b1ab6e09, +0x3feea0694fde5d3f, +0x3feea0b938ac1cf6, +0x3feea11473eb0187, +0x3feea17b0976cfdb, +0x3feea1ed0130c132, +0x3feea26a62ff86f0, +0x3feea2f336cf4e62, +0x3feea3878491c491, +0x3feea427543e1a12, +0x3feea4d2add106d9, +0x3feea589994cce13, +0x3feea64c1eb941f7, +0x3feea71a4623c7ad, +0x3feea7f4179f5b21, +0x3feea8d99b4492ed, +0x3feea9cad931a436, +0x3feeaac7d98a6699, +0x3feeabd0a478580f, +0x3feeace5422aa0db, +0x3feeae05bad61778, +0x3feeaf3216b5448c, +0x3feeb06a5e0866d9, +0x3feeb1ae99157736, +0x3feeb2fed0282c8a, +0x3feeb45b0b91ffc6, +0x3feeb5c353aa2fe2, +0x3feeb737b0cdc5e5, +0x3feeb8b82b5f98e5, +0x3feeba44cbc8520f, +0x3feebbdd9a7670b3, +0x3feebd829fde4e50, +0x3feebf33e47a22a2, +0x3feec0f170ca07ba, +0x3feec2bb4d53fe0d, +0x3feec49182a3f090, +0x3feec674194bb8d5, +0x3feec86319e32323, +0x3feeca5e8d07f29e, +0x3feecc667b5de565, +0x3feece7aed8eb8bb, +0x3feed09bec4a2d33, +0x3feed2c980460ad8, +0x3feed503b23e255d, +0x3feed74a8af46052, +0x3feed99e1330b358, +0x3feedbfe53c12e59, +0x3feede6b5579fdbf, +0x3feee0e521356eba, +0x3feee36bbfd3f37a, +0x3feee5ff3a3c2774, +0x3feee89f995ad3ad, +0x3feeeb4ce622f2ff, +0x3feeee07298db666, +0x3feef0ce6c9a8952, +0x3feef3a2b84f15fb, +0x3feef68415b749b1, +0x3feef9728de5593a, +0x3feefc6e29f1c52a, +0x3feeff76f2fb5e47, +0x3fef028cf22749e4, +0x3fef05b030a1064a, +0x3fef08e0b79a6f1f, +0x3fef0c1e904bc1d2, +0x3fef0f69c3f3a207, +0x3fef12c25bd71e09, +0x3fef16286141b33d, +0x3fef199bdd85529c, +0x3fef1d1cd9fa652c, +0x3fef20ab5fffd07a, +0x3fef244778fafb22, +0x3fef27f12e57d14b, +0x3fef2ba88988c933, +0x3fef2f6d9406e7b5, +0x3fef33405751c4db, +0x3fef3720dcef9069, +0x3fef3b0f2e6d1675, +0x3fef3f0b555dc3fa, +0x3fef43155b5bab74, +0x3fef472d4a07897c, +0x3fef4b532b08c968, +0x3fef4f87080d89f2, +0x3fef53c8eacaa1d6, +0x3fef5818dcfba487, +0x3fef5c76e862e6d3, +0x3fef60e316c98398, +0x3fef655d71ff6075, +0x3fef69e603db3285, +0x3fef6e7cd63a8315, +0x3fef7321f301b460, +0x3fef77d5641c0658, +0x3fef7c97337b9b5f, +0x3fef81676b197d17, +0x3fef864614f5a129, +0x3fef8b333b16ee12, +0x3fef902ee78b3ff6, +0x3fef953924676d76, +0x3fef9a51fbc74c83, +0x3fef9f7977cdb740, +0x3fefa4afa2a490da, +0x3fefa9f4867cca6e, +0x3fefaf482d8e67f1, +0x3fefb4aaa2188510, +0x3fefba1bee615a27, +0x3fefbf9c1cb6412a, +0x3fefc52b376bba97, +0x3fefcac948dd7274, +0x3fefd0765b6e4540, +0x3fefd632798844f8, +0x3fefdbfdad9cbe14, +0x3fefe1d802243c89, +0x3fefe7c1819e90d8, +0x3fefedba3692d514, +0x3feff3c22b8f71f1, +0x3feff9d96b2a23d9, +#endif +}; +#endif diff --git a/libc/AOR_v20.02/math/v_expf.c b/libc/AOR_v20.02/math/v_expf.c new file mode 100644 index 00000000000000..b9223b2519b100 --- /dev/null +++ b/libc/AOR_v20.02/math/v_expf.c @@ -0,0 +1,84 @@ +/* + * Single-precision vector e^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const float Poly[] = { + /* maxerr: 1.45358 +0.5 ulp. */ + 0x1.0e4020p-7f, + 0x1.573e2ep-5f, + 0x1.555e66p-3f, + 0x1.fffdb6p-2f, + 0x1.ffffecp-1f, +}; +#define C0 v_f32 (Poly[0]) +#define C1 v_f32 (Poly[1]) +#define C2 v_f32 (Poly[2]) +#define C3 v_f32 (Poly[3]) +#define C4 v_f32 (Poly[4]) + +#define Shift v_f32 (0x1.8p23f) +#define InvLn2 v_f32 (0x1.715476p+0f) +#define Ln2hi v_f32 (0x1.62e4p-1f) +#define Ln2lo v_f32 (0x1.7f7d1cp-20f) + +VPCS_ATTR +static v_f32_t +specialcase (v_f32_t poly, v_f32_t n, v_u32_t e, v_f32_t absn, v_u32_t cmp1, v_f32_t scale) +{ + /* 2^n may overflow, break it up into s1*s2. */ + v_u32_t b = v_cond_u32 (n <= v_f32 (0.0f)) & v_u32 (0x82000000); + v_f32_t s1 = v_as_f32_u32 (v_u32 (0x7f000000) + b); + v_f32_t s2 = v_as_f32_u32 (e - b); + v_u32_t cmp2 = v_cond_u32 (absn > v_f32 (192.0f)); + v_u32_t r2 = v_as_u32_f32 (s1 * s1); + v_u32_t r1 = v_as_u32_f32 (v_fma_f32 (poly, s2, s2) * s1); + /* Similar to r1 but avoids double rounding in the subnormal range. */ + v_u32_t r0 = v_as_u32_f32 (v_fma_f32 (poly, scale, scale)); + return v_as_f32_u32 ((cmp2 & r2) | (~cmp2 & cmp1 & r1) | (~cmp1 & r0)); +} + +VPCS_ATTR +v_f32_t +V_NAME(expf) (v_f32_t x) +{ + v_f32_t n, r, r2, scale, p, q, poly, absn, z; + v_u32_t cmp, e; + + /* exp(x) = 2^n (1 + poly(r)), with 1 + poly(r) in [1/sqrt(2),sqrt(2)] + x = ln2*n + r, with r in [-ln2/2, ln2/2]. */ +#if 1 + z = v_fma_f32 (x, InvLn2, Shift); + n = z - Shift; + r = v_fma_f32 (n, -Ln2hi, x); + r = v_fma_f32 (n, -Ln2lo, r); + e = v_as_u32_f32 (z) << 23; +#else + z = x * InvLn2; + n = v_round_f32 (z); + r = v_fma_f32 (n, -Ln2hi, x); + r = v_fma_f32 (n, -Ln2lo, r); + e = v_as_u32_s32 (v_round_s32 (z)) << 23; +#endif + scale = v_as_f32_u32 (e + v_u32 (0x3f800000)); + absn = v_abs_f32 (n); + cmp = v_cond_u32 (absn > v_f32 (126.0f)); + r2 = r * r; + p = v_fma_f32 (C0, r, C1); + q = v_fma_f32 (C2, r, C3); + q = v_fma_f32 (p, r2, q); + p = C4 * r; + poly = v_fma_f32 (q, r2, p); + if (unlikely (v_any_u32 (cmp))) + return specialcase (poly, n, e, absn, cmp, scale); + return v_fma_f32 (poly, scale, scale); +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_expf_1u.c b/libc/AOR_v20.02/math/v_expf_1u.c new file mode 100644 index 00000000000000..640ca1f5cad64c --- /dev/null +++ b/libc/AOR_v20.02/math/v_expf_1u.c @@ -0,0 +1,81 @@ +/* + * Single-precision vector e^x function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const float Poly[] = { + /* maxerr: 0.36565 +0.5 ulp. */ + 0x1.6a6000p-10f, + 0x1.12718ep-7f, + 0x1.555af0p-5f, + 0x1.555430p-3f, + 0x1.fffff4p-2f, +}; +#define C0 v_f32 (Poly[0]) +#define C1 v_f32 (Poly[1]) +#define C2 v_f32 (Poly[2]) +#define C3 v_f32 (Poly[3]) +#define C4 v_f32 (Poly[4]) + +#define Shift v_f32 (0x1.8p23f) +#define InvLn2 v_f32 (0x1.715476p+0f) +#define Ln2hi v_f32 (0x1.62e4p-1f) +#define Ln2lo v_f32 (0x1.7f7d1cp-20f) + +VPCS_ATTR +static v_f32_t +specialcase (v_f32_t poly, v_f32_t n, v_u32_t e, v_f32_t absn) +{ + /* 2^n may overflow, break it up into s1*s2. */ + v_u32_t b = v_cond_u32 (n <= v_f32 (0.0f)) & v_u32 (0x83000000); + v_f32_t s1 = v_as_f32_u32 (v_u32 (0x7f000000) + b); + v_f32_t s2 = v_as_f32_u32 (e - b); + v_u32_t cmp = v_cond_u32 (absn > v_f32 (192.0f)); + v_f32_t r1 = s1 * s1; + v_f32_t r0 = poly * s1 * s2; + return v_as_f32_u32 ((cmp & v_as_u32_f32 (r1)) | (~cmp & v_as_u32_f32 (r0))); +} + +VPCS_ATTR +v_f32_t +V_NAME(expf_1u) (v_f32_t x) +{ + v_f32_t n, r, scale, poly, absn, z; + v_u32_t cmp, e; + + /* exp(x) = 2^n * poly(r), with poly(r) in [1/sqrt(2),sqrt(2)] + x = ln2*n + r, with r in [-ln2/2, ln2/2]. */ +#if 1 + z = v_fma_f32 (x, InvLn2, Shift); + n = z - Shift; + r = v_fma_f32 (n, -Ln2hi, x); + r = v_fma_f32 (n, -Ln2lo, r); + e = v_as_u32_f32 (z) << 23; +#else + z = x * InvLn2; + n = v_round_f32 (z); + r = v_fma_f32 (n, -Ln2hi, x); + r = v_fma_f32 (n, -Ln2lo, r); + e = v_as_u32_s32 (v_round_s32 (z)) << 23; +#endif + scale = v_as_f32_u32 (e + v_u32 (0x3f800000)); + absn = v_abs_f32 (n); + cmp = v_cond_u32 (absn > v_f32 (126.0f)); + poly = v_fma_f32 (C0, r, C1); + poly = v_fma_f32 (poly, r, C2); + poly = v_fma_f32 (poly, r, C3); + poly = v_fma_f32 (poly, r, C4); + poly = v_fma_f32 (poly, r, v_f32 (1.0f)); + poly = v_fma_f32 (poly, r, v_f32 (1.0f)); + if (unlikely (v_any_u32 (cmp))) + return specialcase (poly, n, e, absn); + return scale * poly; +} +#endif diff --git a/libc/AOR_v20.02/math/v_log.c b/libc/AOR_v20.02/math/v_log.c new file mode 100644 index 00000000000000..06340fe62584bc --- /dev/null +++ b/libc/AOR_v20.02/math/v_log.c @@ -0,0 +1,105 @@ +/* + * Double-precision vector log(x) function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#include "v_log.h" +#if V_SUPPORTED + +/* Worst-case error: 1.17 + 0.5 ulp. */ + +static const f64_t Poly[] = { + /* rel error: 0x1.6272e588p-56 in [ -0x1.fc1p-9 0x1.009p-8 ]. */ + -0x1.ffffffffffff7p-2, + 0x1.55555555170d4p-2, + -0x1.0000000399c27p-2, + 0x1.999b2e90e94cap-3, + -0x1.554e550bd501ep-3, +}; + +#define A0 v_f64 (Poly[0]) +#define A1 v_f64 (Poly[1]) +#define A2 v_f64 (Poly[2]) +#define A3 v_f64 (Poly[3]) +#define A4 v_f64 (Poly[4]) +#define Ln2 v_f64 (0x1.62e42fefa39efp-1) +#define N (1 << V_LOG_TABLE_BITS) +#define OFF v_u64 (0x3fe6900900000000) + +struct entry +{ + v_f64_t invc; + v_f64_t logc; +}; + +static inline struct entry +lookup (v_u64_t i) +{ + struct entry e; +#ifdef SCALAR + e.invc = __v_log_data[i].invc; + e.logc = __v_log_data[i].logc; +#else + e.invc[0] = __v_log_data[i[0]].invc; + e.logc[0] = __v_log_data[i[0]].logc; + e.invc[1] = __v_log_data[i[1]].invc; + e.logc[1] = __v_log_data[i[1]].logc; +#endif + return e; +} + +VPCS_ATTR +__attribute__ ((noinline)) static v_f64_t +specialcase (v_f64_t x, v_f64_t y, v_u64_t cmp) +{ + return v_call_f64 (log, x, y, cmp); +} + +VPCS_ATTR +v_f64_t +V_NAME(log) (v_f64_t x) +{ + v_f64_t z, r, r2, p, y, kd, hi; + v_u64_t ix, iz, tmp, top, i, cmp; + v_s64_t k; + struct entry e; + + ix = v_as_u64_f64 (x); + top = ix >> 48; + cmp = v_cond_u64 (top - v_u64 (0x0010) >= v_u64 (0x7ff0 - 0x0010)); + + /* x = 2^k z; where z is in range [OFF,2*OFF) and exact. + The range is split into N subintervals. + The ith subinterval contains z and c is near its center. */ + tmp = ix - OFF; + i = (tmp >> (52 - V_LOG_TABLE_BITS)) % N; + k = v_as_s64_u64 (tmp) >> 52; /* arithmetic shift */ + iz = ix - (tmp & v_u64 (0xfffULL << 52)); + z = v_as_f64_u64 (iz); + e = lookup (i); + + /* log(x) = log1p(z/c-1) + log(c) + k*Ln2. */ + r = v_fma_f64 (z, e.invc, v_f64 (-1.0)); + kd = v_to_f64_s64 (k); + + /* hi = r + log(c) + k*Ln2. */ + hi = v_fma_f64 (kd, Ln2, e.logc + r); + /* y = r2*(A0 + r*A1 + r2*(A2 + r*A3 + r2*A4)) + hi. */ + r2 = r * r; + y = v_fma_f64 (A3, r, A2); + p = v_fma_f64 (A1, r, A0); + y = v_fma_f64 (A4, r2, y); + y = v_fma_f64 (y, r2, p); + y = v_fma_f64 (y, r2, hi); + + if (unlikely (v_any_u64 (cmp))) + return specialcase (x, y, cmp); + return y; +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_log.h b/libc/AOR_v20.02/math/v_log.h new file mode 100644 index 00000000000000..a50fe9e4671b5b --- /dev/null +++ b/libc/AOR_v20.02/math/v_log.h @@ -0,0 +1,19 @@ +/* + * Declarations for double-precision log(x) vector function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "v_math.h" +#if WANT_VMATH + +#define V_LOG_TABLE_BITS 7 + +extern const struct v_log_data +{ + f64_t invc; + f64_t logc; +} __v_log_data[1 << V_LOG_TABLE_BITS] HIDDEN; +#endif diff --git a/libc/AOR_v20.02/math/v_log_data.c b/libc/AOR_v20.02/math/v_log_data.c new file mode 100644 index 00000000000000..a7da633648a8c0 --- /dev/null +++ b/libc/AOR_v20.02/math/v_log_data.c @@ -0,0 +1,159 @@ +/* + * Lookup table for double-precision log(x) vector function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "v_log.h" +#if WANT_VMATH + +#define N (1 << V_LOG_TABLE_BITS) + +/* Algorithm: + + x = 2^k z + log(x) = k ln2 + log(c) + poly(z/c - 1) + +where z is in [a;2a) which is split into N subintervals (a=0x1.69009p-1,N=128) +and log(c) and 1/c for the ith subinterval comes from a lookup table: + + tab[i].invc = 1/c + tab[i].logc = (double)log(c) + +where c is near the center of the subinterval and is chosen by trying several +floating point invc candidates around 1/center and selecting one for which +the error in (double)log(c) is minimized (< 0x1p-74), except the subinterval +that contains 1 and the previous one got tweaked to avoid cancellation. */ +const struct v_log_data __v_log_data[N] = { +{0x1.6a133d0dec120p+0, -0x1.62fe995eb963ap-2}, +{0x1.6815f2f3e42edp+0, -0x1.5d5a48dad6b67p-2}, +{0x1.661e39be1ac9ep+0, -0x1.57bde257d2769p-2}, +{0x1.642bfa30ac371p+0, -0x1.52294fbf2af55p-2}, +{0x1.623f1d916f323p+0, -0x1.4c9c7b598aa38p-2}, +{0x1.60578da220f65p+0, -0x1.47174fc5ff560p-2}, +{0x1.5e75349dea571p+0, -0x1.4199b7fa7b5cap-2}, +{0x1.5c97fd387a75ap+0, -0x1.3c239f48cfb99p-2}, +{0x1.5abfd2981f200p+0, -0x1.36b4f154d2aebp-2}, +{0x1.58eca051dc99cp+0, -0x1.314d9a0ff32fbp-2}, +{0x1.571e526d9df12p+0, -0x1.2bed85cca3cffp-2}, +{0x1.5554d555b3fcbp+0, -0x1.2694a11421af9p-2}, +{0x1.539015e2a20cdp+0, -0x1.2142d8d014fb2p-2}, +{0x1.51d0014ee0164p+0, -0x1.1bf81a2c77776p-2}, +{0x1.50148538cd9eep+0, -0x1.16b452a39c6a4p-2}, +{0x1.4e5d8f9f698a1p+0, -0x1.11776ffa6c67ep-2}, +{0x1.4cab0edca66bep+0, -0x1.0c416035020e0p-2}, +{0x1.4afcf1a9db874p+0, -0x1.071211aa10fdap-2}, +{0x1.495327136e16fp+0, -0x1.01e972e293b1bp-2}, +{0x1.47ad9e84af28fp+0, -0x1.f98ee587fd434p-3}, +{0x1.460c47b39ae15p+0, -0x1.ef5800ad716fbp-3}, +{0x1.446f12b278001p+0, -0x1.e52e160484698p-3}, +{0x1.42d5efdd720ecp+0, -0x1.db1104b19352ep-3}, +{0x1.4140cfe001a0fp+0, -0x1.d100ac59e0bd6p-3}, +{0x1.3fafa3b421f69p+0, -0x1.c6fced287c3bdp-3}, +{0x1.3e225c9c8ece5p+0, -0x1.bd05a7b317c29p-3}, +{0x1.3c98ec29a211ap+0, -0x1.b31abd229164fp-3}, +{0x1.3b13442a413fep+0, -0x1.a93c0edadb0a3p-3}, +{0x1.399156baa3c54p+0, -0x1.9f697ee30d7ddp-3}, +{0x1.38131639b4cdbp+0, -0x1.95a2efa9aa40ap-3}, +{0x1.36987540fbf53p+0, -0x1.8be843d796044p-3}, +{0x1.352166b648f61p+0, -0x1.82395ecc477edp-3}, +{0x1.33adddb3eb575p+0, -0x1.7896240966422p-3}, +{0x1.323dcd99fc1d3p+0, -0x1.6efe77aca8c55p-3}, +{0x1.30d129fefc7d2p+0, -0x1.65723e117ec5cp-3}, +{0x1.2f67e6b72fe7dp+0, -0x1.5bf15c0955706p-3}, +{0x1.2e01f7cf8b187p+0, -0x1.527bb6c111da1p-3}, +{0x1.2c9f518ddc86ep+0, -0x1.491133c939f8fp-3}, +{0x1.2b3fe86e5f413p+0, -0x1.3fb1b90c7fc58p-3}, +{0x1.29e3b1211b25cp+0, -0x1.365d2cc485f8dp-3}, +{0x1.288aa08b373cfp+0, -0x1.2d13758970de7p-3}, +{0x1.2734abcaa8467p+0, -0x1.23d47a721fd47p-3}, +{0x1.25e1c82459b81p+0, -0x1.1aa0229f25ec2p-3}, +{0x1.2491eb1ad59c5p+0, -0x1.117655ddebc3bp-3}, +{0x1.23450a54048b5p+0, -0x1.0856fbf83ab6bp-3}, +{0x1.21fb1bb09e578p+0, -0x1.fe83fabbaa106p-4}, +{0x1.20b415346d8f7p+0, -0x1.ec6e8507a56cdp-4}, +{0x1.1f6fed179a1acp+0, -0x1.da6d68c7cc2eap-4}, +{0x1.1e2e99b93c7b3p+0, -0x1.c88078462be0cp-4}, +{0x1.1cf011a7a882ap+0, -0x1.b6a786a423565p-4}, +{0x1.1bb44b97dba5ap+0, -0x1.a4e2676ac7f85p-4}, +{0x1.1a7b3e66cdd4fp+0, -0x1.9330eea777e76p-4}, +{0x1.1944e11dc56cdp+0, -0x1.8192f134d5ad9p-4}, +{0x1.18112aebb1a6ep+0, -0x1.70084464f0538p-4}, +{0x1.16e013231b7e9p+0, -0x1.5e90bdec5cb1fp-4}, +{0x1.15b1913f156cfp+0, -0x1.4d2c3433c5536p-4}, +{0x1.14859cdedde13p+0, -0x1.3bda7e219879ap-4}, +{0x1.135c2dc68cfa4p+0, -0x1.2a9b732d27194p-4}, +{0x1.12353bdb01684p+0, -0x1.196eeb2b10807p-4}, +{0x1.1110bf25b85b4p+0, -0x1.0854be8ef8a7ep-4}, +{0x1.0feeafd2f8577p+0, -0x1.ee998cb277432p-5}, +{0x1.0ecf062c51c3bp+0, -0x1.ccadb79919fb9p-5}, +{0x1.0db1baa076c8bp+0, -0x1.aae5b1d8618b0p-5}, +{0x1.0c96c5bb3048ep+0, -0x1.89413015d7442p-5}, +{0x1.0b7e20263e070p+0, -0x1.67bfe7bf158dep-5}, +{0x1.0a67c2acd0ce3p+0, -0x1.46618f83941bep-5}, +{0x1.0953a6391e982p+0, -0x1.2525df1b0618ap-5}, +{0x1.0841c3caea380p+0, -0x1.040c8e2f77c6ap-5}, +{0x1.07321489b13eap+0, -0x1.c62aad39f738ap-6}, +{0x1.062491aee9904p+0, -0x1.847fe3bdead9cp-6}, +{0x1.05193497a7cc5p+0, -0x1.43183683400acp-6}, +{0x1.040ff6b5f5e9fp+0, -0x1.01f31c4e1d544p-6}, +{0x1.0308d19aa6127p+0, -0x1.82201d1e6b69ap-7}, +{0x1.0203beedb0c67p+0, -0x1.00dd0f3e1bfd6p-7}, +{0x1.010037d38bcc2p+0, -0x1.ff6fe1feb4e53p-9}, +{1.0, 0.0}, +{0x1.fc06d493cca10p-1, 0x1.fe91885ec8e20p-8}, +{0x1.f81e6ac3b918fp-1, 0x1.fc516f716296dp-7}, +{0x1.f44546ef18996p-1, 0x1.7bb4dd70a015bp-6}, +{0x1.f07b10382c84bp-1, 0x1.f84c99b34b674p-6}, +{0x1.ecbf7070e59d4p-1, 0x1.39f9ce4fb2d71p-5}, +{0x1.e91213f715939p-1, 0x1.7756c0fd22e78p-5}, +{0x1.e572a9a75f7b7p-1, 0x1.b43ee82db8f3ap-5}, +{0x1.e1e0e2c530207p-1, 0x1.f0b3fced60034p-5}, +{0x1.de5c72d8a8be3p-1, 0x1.165bd78d4878ep-4}, +{0x1.dae50fa5658ccp-1, 0x1.3425d2715ebe6p-4}, +{0x1.d77a71145a2dap-1, 0x1.51b8bd91b7915p-4}, +{0x1.d41c51166623ep-1, 0x1.6f15632c76a47p-4}, +{0x1.d0ca6ba0bb29fp-1, 0x1.8c3c88ecbe503p-4}, +{0x1.cd847e8e59681p-1, 0x1.a92ef077625dap-4}, +{0x1.ca4a499693e00p-1, 0x1.c5ed5745fa006p-4}, +{0x1.c71b8e399e821p-1, 0x1.e27876de1c993p-4}, +{0x1.c3f80faf19077p-1, 0x1.fed104fce4cdcp-4}, +{0x1.c0df92dc2b0ecp-1, 0x1.0d7bd9c17d78bp-3}, +{0x1.bdd1de3cbb542p-1, 0x1.1b76986cef97bp-3}, +{0x1.baceb9e1007a3p-1, 0x1.295913d24f750p-3}, +{0x1.b7d5ef543e55ep-1, 0x1.37239fa295d17p-3}, +{0x1.b4e749977d953p-1, 0x1.44d68dd78714bp-3}, +{0x1.b20295155478ep-1, 0x1.52722ebe5d780p-3}, +{0x1.af279f8e82be2p-1, 0x1.5ff6d12671f98p-3}, +{0x1.ac5638197fdf3p-1, 0x1.6d64c2389484bp-3}, +{0x1.a98e2f102e087p-1, 0x1.7abc4da40fddap-3}, +{0x1.a6cf5606d05c1p-1, 0x1.87fdbda1e8452p-3}, +{0x1.a4197fc04d746p-1, 0x1.95295b06a5f37p-3}, +{0x1.a16c80293dc01p-1, 0x1.a23f6d34abbc5p-3}, +{0x1.9ec82c4dc5bc9p-1, 0x1.af403a28e04f2p-3}, +{0x1.9c2c5a491f534p-1, 0x1.bc2c06a85721ap-3}, +{0x1.9998e1480b618p-1, 0x1.c903161240163p-3}, +{0x1.970d9977c6c2dp-1, 0x1.d5c5aa93287ebp-3}, +{0x1.948a5c023d212p-1, 0x1.e274051823fa9p-3}, +{0x1.920f0303d6809p-1, 0x1.ef0e656300c16p-3}, +{0x1.8f9b698a98b45p-1, 0x1.fb9509f05aa2ap-3}, +{0x1.8d2f6b81726f6p-1, 0x1.04041821f37afp-2}, +{0x1.8acae5bb55badp-1, 0x1.0a340a49b3029p-2}, +{0x1.886db5d9275b8p-1, 0x1.105a7918a126dp-2}, +{0x1.8617ba567c13cp-1, 0x1.1677819812b84p-2}, +{0x1.83c8d27487800p-1, 0x1.1c8b405b40c0ep-2}, +{0x1.8180de3c5dbe7p-1, 0x1.2295d16cfa6b1p-2}, +{0x1.7f3fbe71cdb71p-1, 0x1.28975066318a2p-2}, +{0x1.7d055498071c1p-1, 0x1.2e8fd855d86fcp-2}, +{0x1.7ad182e54f65ap-1, 0x1.347f83d605e59p-2}, +{0x1.78a42c3c90125p-1, 0x1.3a666d1244588p-2}, +{0x1.767d342f76944p-1, 0x1.4044adb6f8ec4p-2}, +{0x1.745c7ef26b00ap-1, 0x1.461a5f077558cp-2}, +{0x1.7241f15769d0fp-1, 0x1.4be799e20b9c8p-2}, +{0x1.702d70d396e41p-1, 0x1.51ac76a6b79dfp-2}, +{0x1.6e1ee3700cd11p-1, 0x1.57690d5744a45p-2}, +{0x1.6c162fc9cbe02p-1, 0x1.5d1d758e45217p-2}, +}; +#endif diff --git a/libc/AOR_v20.02/math/v_logf.c b/libc/AOR_v20.02/math/v_logf.c new file mode 100644 index 00000000000000..dbe2acef8c049f --- /dev/null +++ b/libc/AOR_v20.02/math/v_logf.c @@ -0,0 +1,74 @@ +/* + * Single-precision vector log function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const float Poly[] = { + /* 3.34 ulp error */ + -0x1.3e737cp-3f, 0x1.5a9aa2p-3f, -0x1.4f9934p-3f, 0x1.961348p-3f, + -0x1.00187cp-2f, 0x1.555d7cp-2f, -0x1.ffffc8p-2f, +}; +#define P7 v_f32 (Poly[0]) +#define P6 v_f32 (Poly[1]) +#define P5 v_f32 (Poly[2]) +#define P4 v_f32 (Poly[3]) +#define P3 v_f32 (Poly[4]) +#define P2 v_f32 (Poly[5]) +#define P1 v_f32 (Poly[6]) + +#define Ln2 v_f32 (0x1.62e43p-1f) /* 0x3f317218 */ +#define Min v_u32 (0x00800000) +#define Max v_u32 (0x7f800000) +#define Mask v_u32 (0x007fffff) +#define Off v_u32 (0x3f2aaaab) /* 0.666667 */ + +VPCS_ATTR +__attribute__ ((noinline)) static v_f32_t +specialcase (v_f32_t x, v_f32_t y, v_u32_t cmp) +{ + /* Fall back to scalar code. */ + return v_call_f32 (logf, x, y, cmp); +} + +VPCS_ATTR +v_f32_t +V_NAME(logf) (v_f32_t x) +{ + v_f32_t n, p, q, r, r2, y; + v_u32_t u, cmp; + + u = v_as_u32_f32 (x); + cmp = v_cond_u32 (u - Min >= Max - Min); + + /* x = 2^n * (1+r), where 2/3 < 1+r < 4/3 */ + u -= Off; + n = v_to_f32_s32 (v_as_s32_u32 (u) >> 23); /* signextend */ + u &= Mask; + u += Off; + r = v_as_f32_u32 (u) - v_f32 (1.0f); + + /* y = log(1+r) + n*ln2. */ + r2 = r * r; + /* n*ln2 + r + r2*(P1 + r*P2 + r2*(P3 + r*P4 + r2*(P5 + r*P6 + r2*P7))). */ + p = v_fma_f32 (P6, r, P5); + q = v_fma_f32 (P4, r, P3); + y = v_fma_f32 (P2, r, P1); + p = v_fma_f32 (P7, r2, p); + q = v_fma_f32 (p, r2, q); + y = v_fma_f32 (q, r2, y); + p = v_fma_f32 (Ln2, n, r); + y = v_fma_f32 (y, r2, p); + + if (unlikely (v_any_u32 (cmp))) + return specialcase (x, y, cmp); + return y; +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_math.h b/libc/AOR_v20.02/math/v_math.h new file mode 100644 index 00000000000000..4b2a6d19faaf57 --- /dev/null +++ b/libc/AOR_v20.02/math/v_math.h @@ -0,0 +1,642 @@ +/* + * Vector math abstractions. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef _V_MATH_H +#define _V_MATH_H + +#ifndef WANT_VMATH +/* Enable the build of vector math code. */ +# define WANT_VMATH 1 +#endif +#if WANT_VMATH + +/* The goal of this header is to allow vector and scalar + build of the same algorithm, the provided intrinsic + wrappers are also vector length agnostic so they can + be implemented for SVE too (or other simd architectures) + and then the code should work on those targets too. */ + +#if SCALAR +#define V_NAME(x) __s_##x +#elif VPCS && __aarch64__ +#define V_NAME(x) __vn_##x +#define VPCS_ATTR __attribute__ ((aarch64_vector_pcs)) +#else +#define V_NAME(x) __v_##x +#endif + +#ifndef VPCS_ATTR +#define VPCS_ATTR +#endif +#ifndef VPCS_ALIAS +#define VPCS_ALIAS +#endif + +#include +#include "math_config.h" + +typedef float f32_t; +typedef uint32_t u32_t; +typedef int32_t s32_t; +typedef double f64_t; +typedef uint64_t u64_t; +typedef int64_t s64_t; + +/* reinterpret as type1 from type2. */ +static inline u32_t +as_u32_f32 (f32_t x) +{ + union { f32_t f; u32_t u; } r = {x}; + return r.u; +} +static inline f32_t +as_f32_u32 (u32_t x) +{ + union { u32_t u; f32_t f; } r = {x}; + return r.f; +} +static inline s32_t +as_s32_u32 (u32_t x) +{ + union { u32_t u; s32_t i; } r = {x}; + return r.i; +} +static inline u32_t +as_u32_s32 (s32_t x) +{ + union { s32_t i; u32_t u; } r = {x}; + return r.u; +} +static inline u64_t +as_u64_f64 (f64_t x) +{ + union { f64_t f; u64_t u; } r = {x}; + return r.u; +} +static inline f64_t +as_f64_u64 (u64_t x) +{ + union { u64_t u; f64_t f; } r = {x}; + return r.f; +} +static inline s64_t +as_s64_u64 (u64_t x) +{ + union { u64_t u; s64_t i; } r = {x}; + return r.i; +} +static inline u64_t +as_u64_s64 (s64_t x) +{ + union { s64_t i; u64_t u; } r = {x}; + return r.u; +} + +#if SCALAR +#define V_SUPPORTED 1 +typedef f32_t v_f32_t; +typedef u32_t v_u32_t; +typedef s32_t v_s32_t; +typedef f64_t v_f64_t; +typedef u64_t v_u64_t; +typedef s64_t v_s64_t; + +static inline int +v_lanes32 (void) +{ + return 1; +} + +static inline v_f32_t +v_f32 (f32_t x) +{ + return x; +} +static inline v_u32_t +v_u32 (u32_t x) +{ + return x; +} +static inline v_s32_t +v_s32 (s32_t x) +{ + return x; +} + +static inline f32_t +v_get_f32 (v_f32_t x, int i) +{ + return x; +} +static inline u32_t +v_get_u32 (v_u32_t x, int i) +{ + return x; +} +static inline s32_t +v_get_s32 (v_s32_t x, int i) +{ + return x; +} + +static inline void +v_set_f32 (v_f32_t *x, int i, f32_t v) +{ + *x = v; +} +static inline void +v_set_u32 (v_u32_t *x, int i, u32_t v) +{ + *x = v; +} +static inline void +v_set_s32 (v_s32_t *x, int i, s32_t v) +{ + *x = v; +} + +/* true if any elements of a v_cond result is non-zero. */ +static inline int +v_any_u32 (v_u32_t x) +{ + return x != 0; +} +/* to wrap the result of relational operators. */ +static inline v_u32_t +v_cond_u32 (v_u32_t x) +{ + return x ? -1 : 0; +} +static inline v_f32_t +v_abs_f32 (v_f32_t x) +{ + return __builtin_fabsf (x); +} +static inline v_f32_t +v_fma_f32 (v_f32_t x, v_f32_t y, v_f32_t z) +{ + return __builtin_fmaf (x, y, z); +} +static inline v_f32_t +v_round_f32 (v_f32_t x) +{ + return __builtin_roundf (x); +} +static inline v_s32_t +v_round_s32 (v_f32_t x) +{ + return __builtin_lroundf (x); /* relies on -fno-math-errno. */ +} +/* convert to type1 from type2. */ +static inline v_f32_t +v_to_f32_s32 (v_s32_t x) +{ + return x; +} +static inline v_f32_t +v_to_f32_u32 (v_u32_t x) +{ + return x; +} +/* reinterpret as type1 from type2. */ +static inline v_u32_t +v_as_u32_f32 (v_f32_t x) +{ + union { v_f32_t f; v_u32_t u; } r = {x}; + return r.u; +} +static inline v_f32_t +v_as_f32_u32 (v_u32_t x) +{ + union { v_u32_t u; v_f32_t f; } r = {x}; + return r.f; +} +static inline v_s32_t +v_as_s32_u32 (v_u32_t x) +{ + union { v_u32_t u; v_s32_t i; } r = {x}; + return r.i; +} +static inline v_u32_t +v_as_u32_s32 (v_s32_t x) +{ + union { v_s32_t i; v_u32_t u; } r = {x}; + return r.u; +} +static inline v_f32_t +v_lookup_f32 (const f32_t *tab, v_u32_t idx) +{ + return tab[idx]; +} +static inline v_u32_t +v_lookup_u32 (const u32_t *tab, v_u32_t idx) +{ + return tab[idx]; +} +static inline v_f32_t +v_call_f32 (f32_t (*f) (f32_t), v_f32_t x, v_f32_t y, v_u32_t p) +{ + return f (x); +} +static inline v_f32_t +v_call2_f32 (f32_t (*f) (f32_t, f32_t), v_f32_t x1, v_f32_t x2, v_f32_t y, + v_u32_t p) +{ + return f (x1, x2); +} + +static inline int +v_lanes64 (void) +{ + return 1; +} +static inline v_f64_t +v_f64 (f64_t x) +{ + return x; +} +static inline v_u64_t +v_u64 (u64_t x) +{ + return x; +} +static inline v_s64_t +v_s64 (s64_t x) +{ + return x; +} +static inline f64_t +v_get_f64 (v_f64_t x, int i) +{ + return x; +} +static inline void +v_set_f64 (v_f64_t *x, int i, f64_t v) +{ + *x = v; +} +/* true if any elements of a v_cond result is non-zero. */ +static inline int +v_any_u64 (v_u64_t x) +{ + return x != 0; +} +/* to wrap the result of relational operators. */ +static inline v_u64_t +v_cond_u64 (v_u64_t x) +{ + return x ? -1 : 0; +} +static inline v_f64_t +v_abs_f64 (v_f64_t x) +{ + return __builtin_fabs (x); +} +static inline v_f64_t +v_fma_f64 (v_f64_t x, v_f64_t y, v_f64_t z) +{ + return __builtin_fma (x, y, z); +} +static inline v_f64_t +v_round_f64 (v_f64_t x) +{ + return __builtin_round (x); +} +static inline v_s64_t +v_round_s64 (v_f64_t x) +{ + return __builtin_lround (x); /* relies on -fno-math-errno. */ +} +/* convert to type1 from type2. */ +static inline v_f64_t +v_to_f64_s64 (v_s64_t x) +{ + return x; +} +static inline v_f64_t +v_to_f64_u64 (v_u64_t x) +{ + return x; +} +/* reinterpret as type1 from type2. */ +static inline v_u64_t +v_as_u64_f64 (v_f64_t x) +{ + union { v_f64_t f; v_u64_t u; } r = {x}; + return r.u; +} +static inline v_f64_t +v_as_f64_u64 (v_u64_t x) +{ + union { v_u64_t u; v_f64_t f; } r = {x}; + return r.f; +} +static inline v_s64_t +v_as_s64_u64 (v_u64_t x) +{ + union { v_u64_t u; v_s64_t i; } r = {x}; + return r.i; +} +static inline v_u64_t +v_as_u64_s64 (v_s64_t x) +{ + union { v_s64_t i; v_u64_t u; } r = {x}; + return r.u; +} +static inline v_f64_t +v_lookup_f64 (const f64_t *tab, v_u64_t idx) +{ + return tab[idx]; +} +static inline v_u64_t +v_lookup_u64 (const u64_t *tab, v_u64_t idx) +{ + return tab[idx]; +} +static inline v_f64_t +v_call_f64 (f64_t (*f) (f64_t), v_f64_t x, v_f64_t y, v_u64_t p) +{ + return f (x); +} + +#elif __aarch64__ +#define V_SUPPORTED 1 +#include +typedef float32x4_t v_f32_t; +typedef uint32x4_t v_u32_t; +typedef int32x4_t v_s32_t; +typedef float64x2_t v_f64_t; +typedef uint64x2_t v_u64_t; +typedef int64x2_t v_s64_t; + +static inline int +v_lanes32 (void) +{ + return 4; +} + +static inline v_f32_t +v_f32 (f32_t x) +{ + return (v_f32_t){x, x, x, x}; +} +static inline v_u32_t +v_u32 (u32_t x) +{ + return (v_u32_t){x, x, x, x}; +} +static inline v_s32_t +v_s32 (s32_t x) +{ + return (v_s32_t){x, x, x, x}; +} + +static inline f32_t +v_get_f32 (v_f32_t x, int i) +{ + return x[i]; +} +static inline u32_t +v_get_u32 (v_u32_t x, int i) +{ + return x[i]; +} +static inline s32_t +v_get_s32 (v_s32_t x, int i) +{ + return x[i]; +} + +static inline void +v_set_f32 (v_f32_t *x, int i, f32_t v) +{ + (*x)[i] = v; +} +static inline void +v_set_u32 (v_u32_t *x, int i, u32_t v) +{ + (*x)[i] = v; +} +static inline void +v_set_s32 (v_s32_t *x, int i, s32_t v) +{ + (*x)[i] = v; +} + +/* true if any elements of a v_cond result is non-zero. */ +static inline int +v_any_u32 (v_u32_t x) +{ + /* assume elements in x are either 0 or -1u. */ + return vpaddd_u64 (vreinterpretq_u64_u32 (x)) != 0; +} +/* to wrap the result of relational operators. */ +static inline v_u32_t +v_cond_u32 (v_u32_t x) +{ + return x; +} +static inline v_f32_t +v_abs_f32 (v_f32_t x) +{ + return vabsq_f32 (x); +} +static inline v_f32_t +v_fma_f32 (v_f32_t x, v_f32_t y, v_f32_t z) +{ + return vfmaq_f32 (z, x, y); +} +static inline v_f32_t +v_round_f32 (v_f32_t x) +{ + return vrndaq_f32 (x); +} +static inline v_s32_t +v_round_s32 (v_f32_t x) +{ + return vcvtaq_s32_f32 (x); +} +/* convert to type1 from type2. */ +static inline v_f32_t +v_to_f32_s32 (v_s32_t x) +{ + return (v_f32_t){x[0], x[1], x[2], x[3]}; +} +static inline v_f32_t +v_to_f32_u32 (v_u32_t x) +{ + return (v_f32_t){x[0], x[1], x[2], x[3]}; +} +/* reinterpret as type1 from type2. */ +static inline v_u32_t +v_as_u32_f32 (v_f32_t x) +{ + union { v_f32_t f; v_u32_t u; } r = {x}; + return r.u; +} +static inline v_f32_t +v_as_f32_u32 (v_u32_t x) +{ + union { v_u32_t u; v_f32_t f; } r = {x}; + return r.f; +} +static inline v_s32_t +v_as_s32_u32 (v_u32_t x) +{ + union { v_u32_t u; v_s32_t i; } r = {x}; + return r.i; +} +static inline v_u32_t +v_as_u32_s32 (v_s32_t x) +{ + union { v_s32_t i; v_u32_t u; } r = {x}; + return r.u; +} +static inline v_f32_t +v_lookup_f32 (const f32_t *tab, v_u32_t idx) +{ + return (v_f32_t){tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]}; +} +static inline v_u32_t +v_lookup_u32 (const u32_t *tab, v_u32_t idx) +{ + return (v_u32_t){tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]}; +} +static inline v_f32_t +v_call_f32 (f32_t (*f) (f32_t), v_f32_t x, v_f32_t y, v_u32_t p) +{ + return (v_f32_t){p[0] ? f (x[0]) : y[0], p[1] ? f (x[1]) : y[1], + p[2] ? f (x[2]) : y[2], p[3] ? f (x[3]) : y[3]}; +} +static inline v_f32_t +v_call2_f32 (f32_t (*f) (f32_t, f32_t), v_f32_t x1, v_f32_t x2, v_f32_t y, + v_u32_t p) +{ + return ( + v_f32_t){p[0] ? f (x1[0], x2[0]) : y[0], p[1] ? f (x1[1], x2[1]) : y[1], + p[2] ? f (x1[2], x2[2]) : y[2], p[3] ? f (x1[3], x2[3]) : y[3]}; +} + +static inline int +v_lanes64 (void) +{ + return 2; +} +static inline v_f64_t +v_f64 (f64_t x) +{ + return (v_f64_t){x, x}; +} +static inline v_u64_t +v_u64 (u64_t x) +{ + return (v_u64_t){x, x}; +} +static inline v_s64_t +v_s64 (s64_t x) +{ + return (v_s64_t){x, x}; +} +static inline f64_t +v_get_f64 (v_f64_t x, int i) +{ + return x[i]; +} +static inline void +v_set_f64 (v_f64_t *x, int i, f64_t v) +{ + (*x)[i] = v; +} +/* true if any elements of a v_cond result is non-zero. */ +static inline int +v_any_u64 (v_u64_t x) +{ + /* assume elements in x are either 0 or -1u. */ + return vpaddd_u64 (x) != 0; +} +/* to wrap the result of relational operators. */ +static inline v_u64_t +v_cond_u64 (v_u64_t x) +{ + return x; +} +static inline v_f64_t +v_abs_f64 (v_f64_t x) +{ + return vabsq_f64 (x); +} +static inline v_f64_t +v_fma_f64 (v_f64_t x, v_f64_t y, v_f64_t z) +{ + return vfmaq_f64 (z, x, y); +} +static inline v_f64_t +v_round_f64 (v_f64_t x) +{ + return vrndaq_f64 (x); +} +static inline v_s64_t +v_round_s64 (v_f64_t x) +{ + return vcvtaq_s64_f64 (x); +} +/* convert to type1 from type2. */ +static inline v_f64_t +v_to_f64_s64 (v_s64_t x) +{ + return (v_f64_t){x[0], x[1]}; +} +static inline v_f64_t +v_to_f64_u64 (v_u64_t x) +{ + return (v_f64_t){x[0], x[1]}; +} +/* reinterpret as type1 from type2. */ +static inline v_u64_t +v_as_u64_f64 (v_f64_t x) +{ + union { v_f64_t f; v_u64_t u; } r = {x}; + return r.u; +} +static inline v_f64_t +v_as_f64_u64 (v_u64_t x) +{ + union { v_u64_t u; v_f64_t f; } r = {x}; + return r.f; +} +static inline v_s64_t +v_as_s64_u64 (v_u64_t x) +{ + union { v_u64_t u; v_s64_t i; } r = {x}; + return r.i; +} +static inline v_u64_t +v_as_u64_s64 (v_s64_t x) +{ + union { v_s64_t i; v_u64_t u; } r = {x}; + return r.u; +} +static inline v_f64_t +v_lookup_f64 (const f64_t *tab, v_u64_t idx) +{ + return (v_f64_t){tab[idx[0]], tab[idx[1]]}; +} +static inline v_u64_t +v_lookup_u64 (const u64_t *tab, v_u64_t idx) +{ + return (v_u64_t){tab[idx[0]], tab[idx[1]]}; +} +static inline v_f64_t +v_call_f64 (f64_t (*f) (f64_t), v_f64_t x, v_f64_t y, v_u64_t p) +{ + return (v_f64_t){p[0] ? f (x[0]) : y[0], p[1] ? f (x[1]) : y[1]}; +} +#endif + +#endif +#endif diff --git a/libc/AOR_v20.02/math/v_pow.c b/libc/AOR_v20.02/math/v_pow.c new file mode 100644 index 00000000000000..e42873416f7424 --- /dev/null +++ b/libc/AOR_v20.02/math/v_pow.c @@ -0,0 +1,28 @@ +/* + * Double-precision vector pow function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +VPCS_ATTR +v_f64_t +V_NAME(pow) (v_f64_t x, v_f64_t y) +{ + v_f64_t z; + for (int lane = 0; lane < v_lanes64 (); lane++) + { + f64_t sx = v_get_f64 (x, lane); + f64_t sy = v_get_f64 (y, lane); + f64_t sz = pow (sx, sy); + v_set_f64 (&z, lane, sz); + } + return z; +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_powf.c b/libc/AOR_v20.02/math/v_powf.c new file mode 100644 index 00000000000000..c4d8db0e38fa17 --- /dev/null +++ b/libc/AOR_v20.02/math/v_powf.c @@ -0,0 +1,236 @@ +/* + * Single-precision vector powf function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +#define Min v_u32 (0x00800000) +#define Max v_u32 (0x7f800000) +#define SBITS 5 +#define Tlog v__powf_log2_data.tab +#define Texp v__exp2f_data.tab +#define A v__powf_log2_data.poly +#define C v__exp2f_data.poly +#define LOGDEG 4 + +#if LOGDEG == 5 +/* 1.01 ulp */ +#define OFF v_u32 (0x3f330000) +#define TBITS 4 +#elif LOGDEG == 4 +/* 2.6 ulp ~ 0.5 + 2^24 (128*Ln2*relerr_log2 + relerr_exp2) */ +#define OFF v_u32 (0x3f35d000) +#define TBITS 5 +#endif + +#define V_EXP2F_TABLE_BITS SBITS +#define V_EXP2F_POLY_ORDER 3 +struct v_exp2f_data +{ + uint64_t tab[1 << V_EXP2F_TABLE_BITS]; + double poly[V_EXP2F_POLY_ORDER]; +}; + +#define V_POWF_LOG2_TABLE_BITS TBITS +#define V_POWF_LOG2_POLY_ORDER LOGDEG +#define SCALE ((double) (1 << SBITS)) +struct v_powf_log2_data +{ + struct + { + double invc, logc; + } tab[1 << V_POWF_LOG2_TABLE_BITS]; + double poly[V_POWF_LOG2_POLY_ORDER]; +}; + +static const struct v_powf_log2_data v__powf_log2_data = { +#if LOGDEG == 5 + .tab = { +{ 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2 * SCALE }, +{ 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2 * SCALE }, +{ 0x1.49539f0f010bp+0, -0x1.7418b0a1fb77bp-2 * SCALE }, +{ 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2 * SCALE }, +{ 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2 * SCALE }, +{ 0x1.25e227b0b8eap+0, -0x1.97c1d1b3b7afp-3 * SCALE }, +{ 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3 * SCALE }, +{ 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4 * SCALE }, +{ 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5 * SCALE }, +{ 0x1p+0, 0x0p+0 * SCALE }, +{ 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4 * SCALE }, +{ 0x1.ca4b31f026aap-1, 0x1.476a9543891bap-3 * SCALE }, +{ 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3 * SCALE }, +{ 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2 * SCALE }, +{ 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2 * SCALE }, +{ 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2 * SCALE }, + }, +/* rel err: 1.46 * 2^-32 */ + .poly = { +0x1.27616c9496e0bp-2 * SCALE, -0x1.71969a075c67ap-2 * SCALE, +0x1.ec70a6ca7baddp-2 * SCALE, -0x1.7154748bef6c8p-1 * SCALE, +0x1.71547652ab82bp0 * SCALE, + } +#elif LOGDEG == 4 + .tab = { +{0x1.6489890582816p+0, -0x1.e960f97b22702p-2 * SCALE}, +{0x1.5cf19b35e3472p+0, -0x1.c993406cd4db6p-2 * SCALE}, +{0x1.55aac0e956d65p+0, -0x1.aa711d9a7d0f3p-2 * SCALE}, +{0x1.4eb0022977e01p+0, -0x1.8bf37bacdce9bp-2 * SCALE}, +{0x1.47fcccda1dd1fp+0, -0x1.6e13b3519946ep-2 * SCALE}, +{0x1.418ceabab68c1p+0, -0x1.50cb8281e4089p-2 * SCALE}, +{0x1.3b5c788f1edb3p+0, -0x1.341504a237e2bp-2 * SCALE}, +{0x1.3567de48e9c9ap+0, -0x1.17eaab624ffbbp-2 * SCALE}, +{0x1.2fabc80fd19bap+0, -0x1.f88e708f8c853p-3 * SCALE}, +{0x1.2a25200ce536bp+0, -0x1.c24b6da113914p-3 * SCALE}, +{0x1.24d108e0152e3p+0, -0x1.8d02ee397cb1dp-3 * SCALE}, +{0x1.1facd8ab2fbe1p+0, -0x1.58ac1223408b3p-3 * SCALE}, +{0x1.1ab614a03efdfp+0, -0x1.253e6fd190e89p-3 * SCALE}, +{0x1.15ea6d03af9ffp+0, -0x1.e5641882c12ffp-4 * SCALE}, +{0x1.1147b994bb776p+0, -0x1.81fea712926f7p-4 * SCALE}, +{0x1.0ccbf650593aap+0, -0x1.203e240de64a3p-4 * SCALE}, +{0x1.0875408477302p+0, -0x1.8029b86a78281p-5 * SCALE}, +{0x1.0441d42a93328p+0, -0x1.85d713190fb9p-6 * SCALE}, +{0x1p+0, 0x0p+0 * SCALE}, +{0x1.f1d006c855e86p-1, 0x1.4c1cc07312997p-5 * SCALE}, +{0x1.e28c3341aa301p-1, 0x1.5e1848ccec948p-4 * SCALE}, +{0x1.d4bdf9aa64747p-1, 0x1.04cfcb7f1196fp-3 * SCALE}, +{0x1.c7b45a24e5803p-1, 0x1.582813d463c21p-3 * SCALE}, +{0x1.bb5f5eb2ed60ap-1, 0x1.a936fa68760ccp-3 * SCALE}, +{0x1.afb0bff8fe6b4p-1, 0x1.f81bc31d6cc4ep-3 * SCALE}, +{0x1.a49badf7ab1f5p-1, 0x1.2279a09fae6b1p-2 * SCALE}, +{0x1.9a14a111fc4c9p-1, 0x1.47ec0b6df5526p-2 * SCALE}, +{0x1.901131f5b2fdcp-1, 0x1.6c71762280f1p-2 * SCALE}, +{0x1.8687f73f6d865p-1, 0x1.90155070798dap-2 * SCALE}, +{0x1.7d7067eb77986p-1, 0x1.b2e23b1d3068cp-2 * SCALE}, +{0x1.74c2c1cf97b65p-1, 0x1.d4e21b0daa86ap-2 * SCALE}, +{0x1.6c77f37cff2a1p-1, 0x1.f61e2a2f67f3fp-2 * SCALE}, + }, +/* rel err: 1.5 * 2^-30 */ + .poly = { + -0x1.6ff5daa3b3d7cp-2 * SCALE, + 0x1.ec81d03c01aebp-2 * SCALE, + -0x1.71547bb43f101p-1 * SCALE, + 0x1.7154764a815cbp0 * SCALE, + } +#endif +}; + +static const struct v_exp2f_data v__exp2f_data = { + .tab = { +0x3ff0000000000000, 0x3fefd9b0d3158574, 0x3fefb5586cf9890f, 0x3fef9301d0125b51, +0x3fef72b83c7d517b, 0x3fef54873168b9aa, 0x3fef387a6e756238, 0x3fef1e9df51fdee1, +0x3fef06fe0a31b715, 0x3feef1a7373aa9cb, 0x3feedea64c123422, 0x3feece086061892d, +0x3feebfdad5362a27, 0x3feeb42b569d4f82, 0x3feeab07dd485429, 0x3feea47eb03a5585, +0x3feea09e667f3bcd, 0x3fee9f75e8ec5f74, 0x3feea11473eb0187, 0x3feea589994cce13, +0x3feeace5422aa0db, 0x3feeb737b0cdc5e5, 0x3feec49182a3f090, 0x3feed503b23e255d, +0x3feee89f995ad3ad, 0x3feeff76f2fb5e47, 0x3fef199bdd85529c, 0x3fef3720dcef9069, +0x3fef5818dcfba487, 0x3fef7c97337b9b5f, 0x3fefa4afa2a490da, 0x3fefd0765b6e4540, + }, +/* rel err: 1.69 * 2^-34 */ + .poly = { +0x1.c6af84b912394p-5/SCALE/SCALE/SCALE, 0x1.ebfce50fac4f3p-3/SCALE/SCALE, 0x1.62e42ff0c52d6p-1/SCALE + }, +}; + +VPCS_ATTR +__attribute__ ((noinline)) static v_f32_t +specialcase (v_f32_t x, v_f32_t y, v_f32_t ret, v_u32_t cmp) +{ + return v_call2_f32 (powf, x, y, ret, cmp); +} + +VPCS_ATTR +v_f32_t +V_NAME(powf) (v_f32_t x, v_f32_t y) +{ + v_u32_t u, tmp, cmp, i, top, iz; + v_s32_t k; + v_f32_t ret; + + u = v_as_u32_f32 (x); + cmp = v_cond_u32 (u - Min >= Max - Min); + tmp = u - OFF; + i = (tmp >> (23 - TBITS)) % (1 << TBITS); + top = tmp & 0xff800000; + iz = u - top; + k = v_as_s32_u32 (top) >> (23 - SBITS); /* arithmetic shift */ + + for (int lane = 0; lane < v_lanes32 (); lane++) + { + uint32_t si, siz; + int32_t sk; + float sy; + + /* Use double precision for each lane. */ + double invc, logc, z, r, p, y0, logx, ylogx, kd, s; + uint64_t ki, t; + + si = v_get_u32 (i, lane); + siz = v_get_u32 (iz, lane); + sk = v_get_s32 (k, lane); + sy = v_get_f32 (y, lane); + + invc = Tlog[si].invc; + logc = Tlog[si].logc; + z = (double) as_f32_u32 (siz); + + /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ + r = __builtin_fma (z, invc, -1.0); + y0 = logc + (double) sk; + + /* Polynomial to approximate log1p(r)/ln2. */ +#if LOGDEG == 5 + logx = A[0]; + logx = r * logx + A[1]; + logx = r * logx + A[2]; + logx = r * logx + A[3]; + logx = r * logx + A[4]; + logx = r * logx + y0; +#elif LOGDEG == 4 + logx = A[0]; + logx = r * logx + A[1]; + logx = r * logx + A[2]; + logx = r * logx + A[3]; + logx = r * logx + y0; +#endif + ylogx = sy * logx; + v_set_u32 (&cmp, lane, + (as_u64_f64 (ylogx) >> 47 & 0xffff) + >= as_u64_f64 (126.0 * (1 << SBITS)) >> 47 + ? 1 + : v_get_u32 (cmp, lane)); + + /* N*x = k + r with r in [-1/2, 1/2] */ +#if TOINT_INTRINSICS + kd = roundtoint (ylogx); /* k */ + ki = converttoint (ylogx); +#else +# define SHIFT 0x1.8p52 + kd = eval_as_double (ylogx + SHIFT); + ki = asuint64 (kd); + kd -= SHIFT; +#endif + r = ylogx - kd; + + /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ + t = Texp[ki % (1 << SBITS)]; + t += ki << (52 - SBITS); + s = as_f64_u64 (t); + p = C[0]; + p = __builtin_fma (p, r, C[1]); + p = __builtin_fma (p, r, C[2]); + p = __builtin_fma (p, s * r, s); + + v_set_f32 (&ret, lane, p); + } + if (unlikely (v_any_u32 (cmp))) + return specialcase (x, y, ret, cmp); + return ret; +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_sin.c b/libc/AOR_v20.02/math/v_sin.c new file mode 100644 index 00000000000000..899d1f558089e2 --- /dev/null +++ b/libc/AOR_v20.02/math/v_sin.c @@ -0,0 +1,87 @@ +/* + * Double-precision vector sin function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const double Poly[] = { +/* worst-case error is 3.5 ulp. + abs error: 0x1.be222a58p-53 in [-pi/2, pi/2]. */ +-0x1.9f4a9c8b21dc9p-41, + 0x1.60e88a10163f2p-33, +-0x1.ae6361b7254e7p-26, + 0x1.71de382e8d62bp-19, +-0x1.a01a019aeb4ffp-13, + 0x1.111111110b25ep-7, +-0x1.55555555554c3p-3, +}; + +#define C7 v_f64 (Poly[0]) +#define C6 v_f64 (Poly[1]) +#define C5 v_f64 (Poly[2]) +#define C4 v_f64 (Poly[3]) +#define C3 v_f64 (Poly[4]) +#define C2 v_f64 (Poly[5]) +#define C1 v_f64 (Poly[6]) + +#define InvPi v_f64 (0x1.45f306dc9c883p-2) +#define Pi1 v_f64 (0x1.921fb54442d18p+1) +#define Pi2 v_f64 (0x1.1a62633145c06p-53) +#define Pi3 v_f64 (0x1.c1cd129024e09p-106) +#define Shift v_f64 (0x1.8p52) +#define RangeVal v_f64 (0x1p23) +#define AbsMask v_u64 (0x7fffffffffffffff) + +VPCS_ATTR +__attribute__ ((noinline)) static v_f64_t +specialcase (v_f64_t x, v_f64_t y, v_u64_t cmp) +{ + return v_call_f64 (sin, x, y, cmp); +} + +VPCS_ATTR +v_f64_t +V_NAME(sin) (v_f64_t x) +{ + v_f64_t n, r, r2, y; + v_u64_t sign, odd, cmp; + + r = v_as_f64_u64 (v_as_u64_f64 (x) & AbsMask); + sign = v_as_u64_f64 (x) & ~AbsMask; + cmp = v_cond_u64 (v_as_u64_f64 (r) >= v_as_u64_f64 (RangeVal)); + + /* n = rint(|x|/pi). */ + n = v_fma_f64 (InvPi, r, Shift); + odd = v_as_u64_f64 (n) << 63; + n -= Shift; + + /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2). */ + r = v_fma_f64 (-Pi1, n, r); + r = v_fma_f64 (-Pi2, n, r); + r = v_fma_f64 (-Pi3, n, r); + + /* sin(r) poly approx. */ + r2 = r * r; + y = v_fma_f64 (C7, r2, C6); + y = v_fma_f64 (y, r2, C5); + y = v_fma_f64 (y, r2, C4); + y = v_fma_f64 (y, r2, C3); + y = v_fma_f64 (y, r2, C2); + y = v_fma_f64 (y, r2, C1); + y = v_fma_f64 (y * r2, r, r); + + /* sign. */ + y = v_as_f64_u64 (v_as_u64_f64 (y) ^ sign ^ odd); + + if (unlikely (v_any_u64 (cmp))) + return specialcase (x, y, cmp); + return y; +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/v_sinf.c b/libc/AOR_v20.02/math/v_sinf.c new file mode 100644 index 00000000000000..de7a18f3e4ff1e --- /dev/null +++ b/libc/AOR_v20.02/math/v_sinf.c @@ -0,0 +1,76 @@ +/* + * Single-precision vector sin function. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "mathlib.h" +#include "v_math.h" +#if V_SUPPORTED + +static const float Poly[] = { + /* 1.886 ulp error */ + 0x1.5b2e76p-19f, + -0x1.9f42eap-13f, + 0x1.110df4p-7f, + -0x1.555548p-3f, +}; +#define Pi1 v_f32 (0x1.921fb6p+1f) +#define Pi2 v_f32 (-0x1.777a5cp-24f) +#define Pi3 v_f32 (-0x1.ee59dap-49f) +#define A3 v_f32 (Poly[3]) +#define A5 v_f32 (Poly[2]) +#define A7 v_f32 (Poly[1]) +#define A9 v_f32 (Poly[0]) +#define RangeVal v_f32 (0x1p20f) +#define InvPi v_f32 (0x1.45f306p-2f) +#define Shift v_f32 (0x1.8p+23f) +#define AbsMask v_u32 (0x7fffffff) + +VPCS_ATTR +static v_f32_t +specialcase (v_f32_t x, v_f32_t y, v_u32_t cmp) +{ + /* Fall back to scalar code. */ + return v_call_f32 (sinf, x, y, cmp); +} + +VPCS_ATTR +v_f32_t +V_NAME(sinf) (v_f32_t x) +{ + v_f32_t n, r, r2, y; + v_u32_t sign, odd, cmp; + + r = v_as_f32_u32 (v_as_u32_f32 (x) & AbsMask); + sign = v_as_u32_f32 (x) & ~AbsMask; + cmp = v_cond_u32 (v_as_u32_f32 (r) >= v_as_u32_f32 (RangeVal)); + + /* n = rint(|x|/pi) */ + n = v_fma_f32 (InvPi, r, Shift); + odd = v_as_u32_f32 (n) << 31; + n -= Shift; + + /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2) */ + r = v_fma_f32 (-Pi1, n, r); + r = v_fma_f32 (-Pi2, n, r); + r = v_fma_f32 (-Pi3, n, r); + + /* y = sin(r) */ + r2 = r * r; + y = v_fma_f32 (A9, r2, A7); + y = v_fma_f32 (y, r2, A5); + y = v_fma_f32 (y, r2, A3); + y = v_fma_f32 (y * r2, r, r); + + /* sign fix */ + y = v_as_f32_u32 (v_as_u32_f32 (y) ^ sign ^ odd); + + if (unlikely (v_any_u32 (cmp))) + return specialcase (x, y, cmp); + return y; +} +VPCS_ALIAS +#endif diff --git a/libc/AOR_v20.02/math/vn_cos.c b/libc/AOR_v20.02/math/vn_cos.c new file mode 100644 index 00000000000000..76fc8b86657f23 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_cos.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_cos. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_cos, _ZGVnN2v_cos) +#include "v_cos.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_cosf.c b/libc/AOR_v20.02/math/vn_cosf.c new file mode 100644 index 00000000000000..2ed24ae059355a --- /dev/null +++ b/libc/AOR_v20.02/math/vn_cosf.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_cosf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_cosf, _ZGVnN4v_cosf) +#include "v_cosf.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_exp.c b/libc/AOR_v20.02/math/vn_exp.c new file mode 100644 index 00000000000000..7492014dca07ab --- /dev/null +++ b/libc/AOR_v20.02/math/vn_exp.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_exp. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_exp, _ZGVnN2v_exp) +#include "v_exp.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_exp2f.c b/libc/AOR_v20.02/math/vn_exp2f.c new file mode 100644 index 00000000000000..df3d56fd17f7d4 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_exp2f.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_exp2f. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_exp2f, _ZGVnN4v_exp2f) +#include "v_exp2f.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_exp2f_1u.c b/libc/AOR_v20.02/math/vn_exp2f_1u.c new file mode 100644 index 00000000000000..b974e5b18bcc03 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_exp2f_1u.c @@ -0,0 +1,12 @@ +/* + * AdvSIMD vector PCS variant of __v_exp2f_1u. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#include "v_exp2f_1u.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_expf.c b/libc/AOR_v20.02/math/vn_expf.c new file mode 100644 index 00000000000000..de5a8cf4f316fc --- /dev/null +++ b/libc/AOR_v20.02/math/vn_expf.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_expf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_expf, _ZGVnN4v_expf) +#include "v_expf.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_expf_1u.c b/libc/AOR_v20.02/math/vn_expf_1u.c new file mode 100644 index 00000000000000..20b625b25aa702 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_expf_1u.c @@ -0,0 +1,12 @@ +/* + * AdvSIMD vector PCS variant of __v_expf_1u. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#include "v_expf_1u.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_log.c b/libc/AOR_v20.02/math/vn_log.c new file mode 100644 index 00000000000000..c766d727d60dbb --- /dev/null +++ b/libc/AOR_v20.02/math/vn_log.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_log. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_log, _ZGVnN2v_log) +#include "v_log.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_logf.c b/libc/AOR_v20.02/math/vn_logf.c new file mode 100644 index 00000000000000..03edb1961dc4f5 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_logf.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_logf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_logf, _ZGVnN4v_logf) +#include "v_logf.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_pow.c b/libc/AOR_v20.02/math/vn_pow.c new file mode 100644 index 00000000000000..dbad0aaa4f27e7 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_pow.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_pow. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_pow, _ZGVnN2vv_pow) +#include "v_pow.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_powf.c b/libc/AOR_v20.02/math/vn_powf.c new file mode 100644 index 00000000000000..6fd4c76527c724 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_powf.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_powf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_powf, _ZGVnN4vv_powf) +#include "v_powf.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_sin.c b/libc/AOR_v20.02/math/vn_sin.c new file mode 100644 index 00000000000000..be0585be8ad9a7 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_sin.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_sin. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_sin, _ZGVnN2v_sin) +#include "v_sin.c" +#endif diff --git a/libc/AOR_v20.02/math/vn_sinf.c b/libc/AOR_v20.02/math/vn_sinf.c new file mode 100644 index 00000000000000..32cd11e2fdbae7 --- /dev/null +++ b/libc/AOR_v20.02/math/vn_sinf.c @@ -0,0 +1,13 @@ +/* + * AdvSIMD vector PCS variant of __v_sinf. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ +#include "mathlib.h" +#ifdef __vpcs +#define VPCS 1 +#define VPCS_ALIAS strong_alias (__vn_sinf, _ZGVnN4v_sinf) +#include "v_sinf.c" +#endif diff --git a/libc/AOR_v20.02/networking/Dir.mk b/libc/AOR_v20.02/networking/Dir.mk new file mode 100644 index 00000000000000..68bc94b41e3d6d --- /dev/null +++ b/libc/AOR_v20.02/networking/Dir.mk @@ -0,0 +1,77 @@ +# Makefile fragment - requires GNU make +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +S := $(srcdir)/networking +B := build/networking + +ifeq ($(ARCH),) +all-networking check-networking install-networking clean-networking: + @echo "*** Please set ARCH in config.mk. ***" + @exit 1 +else + +networking-lib-srcs := $(wildcard $(S)/*.[cS]) $(wildcard $(S)/$(ARCH)/*.[cS]) +networking-test-srcs := $(wildcard $(S)/test/*.c) + +networking-includes := $(patsubst $(S)/%,build/%,$(wildcard $(S)/include/*.h)) + +networking-libs := \ + build/lib/libnetworking.so \ + build/lib/libnetworking.a \ + +networking-tools := \ + build/bin/test/chksum + +networking-lib-objs := $(patsubst $(S)/%,$(B)/%.o,$(basename $(networking-lib-srcs))) +networking-test-objs := $(patsubst $(S)/%,$(B)/%.o,$(basename $(networking-test-srcs))) + +networking-objs := \ + $(networking-lib-objs) \ + $(networking-lib-objs:%.o=%.os) \ + $(networking-test-objs) \ + +networking-files := \ + $(networking-objs) \ + $(networking-libs) \ + $(networking-tools) \ + $(networking-includes) \ + +all-networking: $(networking-libs) $(networking-tools) $(networking-includes) + +$(networking-objs): $(networking-includes) +$(networking-objs): CFLAGS_ALL += $(networking-cflags) + +build/lib/libnetworking.so: $(networking-lib-objs:%.o=%.os) + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -shared -o $@ $^ + +build/lib/libnetworkinglib.a: $(networking-lib-objs) + rm -f $@ + $(AR) rc $@ $^ + $(RANLIB) $@ + +build/bin/test/%: $(B)/test/%.o build/lib/libnetworkinglib.a + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -static -o $@ $^ $(LDLIBS) + +build/include/%.h: $(S)/include/%.h + cp $< $@ + +build/bin/%.sh: $(S)/test/%.sh + cp $< $@ + +check-networking: $(networking-tools) + $(EMULATOR) build/bin/test/chksum -i simple + $(EMULATOR) build/bin/test/chksum -i scalar + $(EMULATOR) build/bin/test/chksum -i simd || true # simd is not always available + +install-networking: \ + $(networking-libs:build/lib/%=$(DESTDIR)$(libdir)/%) \ + $(networking-includes:build/include/%=$(DESTDIR)$(includedir)/%) + +clean-networking: + rm -f $(networking-files) +endif + +.PHONY: all-networking check-networking install-networking clean-networking diff --git a/libc/AOR_v20.02/networking/aarch64/chksum_simd.c b/libc/AOR_v20.02/networking/aarch64/chksum_simd.c new file mode 100644 index 00000000000000..eaa0f3bc3e1709 --- /dev/null +++ b/libc/AOR_v20.02/networking/aarch64/chksum_simd.c @@ -0,0 +1,147 @@ +/* + * AArch64-specific checksum implementation using NEON + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "networking.h" +#include "../chksum_common.h" + +#ifndef __ARM_NEON +#pragma GCC target("+simd") +#endif + +#include + +always_inline +static inline uint64_t +slurp_head64(const void **pptr, uint32_t *nbytes) +{ + Assert(*nbytes >= 8); + uint64_t sum = 0; + uint32_t off = (uintptr_t) *pptr % 8; + if (likely(off != 0)) + { + /* Get rid of bytes 0..off-1 */ + const unsigned char *ptr64 = align_ptr(*pptr, 8); + uint64_t mask = ALL_ONES << (CHAR_BIT * off); + uint64_t val = load64(ptr64) & mask; + /* Fold 64-bit sum to 33 bits */ + sum = val >> 32; + sum += (uint32_t) val; + *pptr = ptr64 + 8; + *nbytes -= 8 - off; + } + return sum; +} + +always_inline +static inline uint64_t +slurp_tail64(uint64_t sum, const void *ptr, uint32_t nbytes) +{ + Assert(nbytes < 8); + if (likely(nbytes != 0)) + { + /* Get rid of bytes 7..nbytes */ + uint64_t mask = ALL_ONES >> (CHAR_BIT * (8 - nbytes)); + Assert(__builtin_popcountl(mask) / CHAR_BIT == nbytes); + uint64_t val = load64(ptr) & mask; + sum += val >> 32; + sum += (uint32_t) val; + nbytes = 0; + } + Assert(nbytes == 0); + return sum; +} + +unsigned short +__chksum_aarch64_simd(const void *ptr, unsigned int nbytes) +{ + bool swap = (uintptr_t) ptr & 1; + uint64_t sum; + + if (unlikely(nbytes < 50)) + { + sum = slurp_small(ptr, nbytes); + swap = false; + goto fold; + } + + /* 8-byte align pointer */ + Assert(nbytes >= 8); + sum = slurp_head64(&ptr, &nbytes); + Assert(((uintptr_t) ptr & 7) == 0); + + const uint32_t *may_alias ptr32 = ptr; + + uint64x2_t vsum0 = { 0, 0 }; + uint64x2_t vsum1 = { 0, 0 }; + uint64x2_t vsum2 = { 0, 0 }; + uint64x2_t vsum3 = { 0, 0 }; + + /* Sum groups of 64 bytes */ + for (uint32_t i = 0; i < nbytes / 64; i++) + { + uint32x4_t vtmp0 = vld1q_u32(ptr32); + uint32x4_t vtmp1 = vld1q_u32(ptr32 + 4); + uint32x4_t vtmp2 = vld1q_u32(ptr32 + 8); + uint32x4_t vtmp3 = vld1q_u32(ptr32 + 12); + vsum0 = vpadalq_u32(vsum0, vtmp0); + vsum1 = vpadalq_u32(vsum1, vtmp1); + vsum2 = vpadalq_u32(vsum2, vtmp2); + vsum3 = vpadalq_u32(vsum3, vtmp3); + ptr32 += 16; + } + nbytes %= 64; + + /* Fold vsum2 and vsum3 into vsum0 and vsum1 */ + vsum0 = vpadalq_u32(vsum0, vreinterpretq_u32_u64(vsum2)); + vsum1 = vpadalq_u32(vsum1, vreinterpretq_u32_u64(vsum3)); + + /* Add any trailing group of 32 bytes */ + if (nbytes & 32) + { + uint32x4_t vtmp0 = vld1q_u32(ptr32); + uint32x4_t vtmp1 = vld1q_u32(ptr32 + 4); + vsum0 = vpadalq_u32(vsum0, vtmp0); + vsum1 = vpadalq_u32(vsum1, vtmp1); + ptr32 += 8; + nbytes -= 32; + } + Assert(nbytes < 32); + + /* Fold vsum1 into vsum0 */ + vsum0 = vpadalq_u32(vsum0, vreinterpretq_u32_u64(vsum1)); + + /* Add any trailing group of 16 bytes */ + if (nbytes & 16) + { + uint32x4_t vtmp = vld1q_u32(ptr32); + vsum0 = vpadalq_u32(vsum0, vtmp); + ptr32 += 4; + nbytes -= 16; + } + Assert(nbytes < 16); + + /* Add any trailing group of 8 bytes */ + if (nbytes & 8) + { + uint32x2_t vtmp = vld1_u32(ptr32); + vsum0 = vaddw_u32(vsum0, vtmp); + ptr32 += 2; + nbytes -= 8; + } + Assert(nbytes < 8); + + uint64_t val = vaddlvq_u32(vreinterpretq_u32_u64(vsum0)); + sum += val >> 32; + sum += (uint32_t) val; + + /* Handle any trailing 0..7 bytes */ + sum = slurp_tail64(sum, ptr32, nbytes); + +fold: + return fold_and_swap(sum, swap); +} diff --git a/libc/AOR_v20.02/networking/arm/chksum_simd.c b/libc/AOR_v20.02/networking/arm/chksum_simd.c new file mode 100644 index 00000000000000..aa70a3c81e18e0 --- /dev/null +++ b/libc/AOR_v20.02/networking/arm/chksum_simd.c @@ -0,0 +1,150 @@ +/* + * Armv7-A specific checksum implementation using NEON + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "networking.h" +#include "../chksum_common.h" + +#ifndef __ARM_NEON +#pragma GCC target("+simd") +#endif + +#include + +unsigned short +__chksum_arm_simd(const void *ptr, unsigned int nbytes) +{ + bool swap = (uintptr_t) ptr & 1; + uint64x1_t vsum = { 0 }; + + if (unlikely(nbytes < 40)) + { + uint64_t sum = slurp_small(ptr, nbytes); + return fold_and_swap(sum, false); + } + + /* 8-byte align pointer */ + /* Inline slurp_head-like code since we use NEON here */ + Assert(nbytes >= 8); + uint32_t off = (uintptr_t) ptr & 7; + if (likely(off != 0)) + { + const uint64_t *may_alias ptr64 = align_ptr(ptr, 8); + uint64x1_t vword64 = vld1_u64(ptr64); + /* Get rid of bytes 0..off-1 */ + uint64x1_t vmask = vdup_n_u64(ALL_ONES); + int64x1_t vshiftl = vdup_n_s64(CHAR_BIT * off); + vmask = vshl_u64(vmask, vshiftl); + vword64 = vand_u64(vword64, vmask); + uint32x2_t vtmp = vreinterpret_u32_u64(vword64); + /* Set accumulator */ + vsum = vpaddl_u32(vtmp); + /* Update pointer and remaining size */ + ptr = (char *) ptr64 + 8; + nbytes -= 8 - off; + } + Assert(((uintptr_t) ptr & 7) == 0); + + /* Sum groups of 64 bytes */ + uint64x2_t vsum0 = { 0, 0 }; + uint64x2_t vsum1 = { 0, 0 }; + uint64x2_t vsum2 = { 0, 0 }; + uint64x2_t vsum3 = { 0, 0 }; + const uint32_t *may_alias ptr32 = ptr; + for (uint32_t i = 0; i < nbytes / 64; i++) + { + uint32x4_t vtmp0 = vld1q_u32(ptr32); + uint32x4_t vtmp1 = vld1q_u32(ptr32 + 4); + uint32x4_t vtmp2 = vld1q_u32(ptr32 + 8); + uint32x4_t vtmp3 = vld1q_u32(ptr32 + 12); + vsum0 = vpadalq_u32(vsum0, vtmp0); + vsum1 = vpadalq_u32(vsum1, vtmp1); + vsum2 = vpadalq_u32(vsum2, vtmp2); + vsum3 = vpadalq_u32(vsum3, vtmp3); + ptr32 += 16; + } + nbytes %= 64; + + /* Fold vsum1/vsum2/vsum3 into vsum0 */ + vsum0 = vpadalq_u32(vsum0, vreinterpretq_u32_u64(vsum2)); + vsum1 = vpadalq_u32(vsum1, vreinterpretq_u32_u64(vsum3)); + vsum0 = vpadalq_u32(vsum0, vreinterpretq_u32_u64(vsum1)); + + /* Add any trailing 16-byte groups */ + while (likely(nbytes >= 16)) + { + uint32x4_t vtmp0 = vld1q_u32(ptr32); + vsum0 = vpadalq_u32(vsum0, vtmp0); + ptr32 += 4; + nbytes -= 16; + } + Assert(nbytes < 16); + + /* Fold vsum0 into vsum */ + { + /* 4xu32 (4x32b) -> 2xu64 (2x33b) */ + vsum0 = vpaddlq_u32(vreinterpretq_u32_u64(vsum0)); + /* 4xu32 (2x(1b+32b)) -> 2xu64 (2x(0b+32b)) */ + vsum0 = vpaddlq_u32(vreinterpretq_u32_u64(vsum0)); + /* 4xu32 (4x32b) -> 2xu64 (2x33b) */ + Assert((vgetq_lane_u64(vsum0, 0) >> 32) == 0); + Assert((vgetq_lane_u64(vsum0, 1) >> 32) == 0); + uint32x2_t vtmp = vmovn_u64(vsum0); + /* Add to accumulator */ + vsum = vpadal_u32(vsum, vtmp); + } + + /* Add any trailing group of 8 bytes */ + if (nbytes & 8) + { + uint32x2_t vtmp = vld1_u32(ptr32); + /* Add to accumulator */ + vsum = vpadal_u32(vsum, vtmp); + ptr32 += 2; + nbytes -= 8; + } + Assert(nbytes < 8); + + /* Handle any trailing 1..7 bytes */ + if (likely(nbytes != 0)) + { + Assert(((uintptr_t) ptr32 & 7) == 0); + Assert(nbytes < 8); + uint64x1_t vword64 = vld1_u64((const uint64_t *) ptr32); + /* Get rid of bytes 7..nbytes */ + uint64x1_t vmask = vdup_n_u64(ALL_ONES); + int64x1_t vshiftr = vdup_n_s64(-CHAR_BIT * (8 - nbytes)); + vmask = vshl_u64(vmask, vshiftr);/* Shift right */ + vword64 = vand_u64(vword64, vmask); + /* Fold 64-bit sum to 33 bits */ + vword64 = vpaddl_u32(vreinterpret_u32_u64(vword64)); + /* Add to accumulator */ + vsum = vpadal_u32(vsum, vreinterpret_u32_u64(vword64)); + } + + /* Fold 64-bit vsum to 32 bits */ + vsum = vpaddl_u32(vreinterpret_u32_u64(vsum)); + vsum = vpaddl_u32(vreinterpret_u32_u64(vsum)); + Assert(vget_lane_u32(vreinterpret_u32_u64(vsum), 1) == 0); + + /* Fold 32-bit vsum to 16 bits */ + uint32x2_t vsum32 = vreinterpret_u32_u64(vsum); + vsum32 = vpaddl_u16(vreinterpret_u16_u32(vsum32)); + vsum32 = vpaddl_u16(vreinterpret_u16_u32(vsum32)); + Assert(vget_lane_u16(vreinterpret_u16_u32(vsum32), 1) == 0); + Assert(vget_lane_u16(vreinterpret_u16_u32(vsum32), 2) == 0); + Assert(vget_lane_u16(vreinterpret_u16_u32(vsum32), 3) == 0); + + /* Convert to 16-bit scalar */ + uint16_t sum = vget_lane_u16(vreinterpret_u16_u32(vsum32), 0); + + if (unlikely(swap))/* Odd base pointer is unexpected */ + { + sum = bswap16(sum); + } + return sum; +} diff --git a/libc/AOR_v20.02/networking/chksum.c b/libc/AOR_v20.02/networking/chksum.c new file mode 100644 index 00000000000000..5f9033402cd5fe --- /dev/null +++ b/libc/AOR_v20.02/networking/chksum.c @@ -0,0 +1,82 @@ +/* + * Compute 16-bit sum in ones' complement arithmetic (with end-around carry). + * This sum is often used as a simple checksum in networking. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include "networking.h" +#include "chksum_common.h" + +always_inline +static inline uint32_t +slurp_head32(const void **pptr, uint32_t *nbytes) +{ + uint32_t sum = 0; + Assert(*nbytes >= 4); + uint32_t off = (uintptr_t) *pptr % 4; + if (likely(off != 0)) + { + /* Get rid of bytes 0..off-1 */ + const unsigned char *ptr32 = align_ptr(*pptr, 4); + uint32_t mask = ~0U << (CHAR_BIT * off); + sum = load32(ptr32) & mask; + *pptr = ptr32 + 4; + *nbytes -= 4 - off; + } + return sum; +} + +/* Additional loop unrolling would help when not auto-vectorizing */ +unsigned short +__chksum(const void *ptr, unsigned int nbytes) +{ + bool swap = false; + uint64_t sum = 0; + + if (nbytes > 300) + { + /* 4-byte align pointer */ + swap = (uintptr_t) ptr & 1; + sum = slurp_head32(&ptr, &nbytes); + } + /* Else benefit of aligning not worth the overhead */ + + /* Sum all 16-byte chunks */ + const char *cptr = ptr; + for (uint32_t nquads = nbytes / 16; nquads != 0; nquads--) + { + uint64_t h0 = load32(cptr + 0); + uint64_t h1 = load32(cptr + 4); + uint64_t h2 = load32(cptr + 8); + uint64_t h3 = load32(cptr + 12); + sum += h0 + h1 + h2 + h3; + cptr += 16; + } + nbytes %= 16; + Assert(nbytes < 16); + + /* Handle any trailing 4-byte chunks */ + while (nbytes >= 4) + { + sum += load32(cptr); + cptr += 4; + nbytes -= 4; + } + Assert(nbytes < 4); + + if (nbytes & 2) + { + sum += load16(cptr); + cptr += 2; + } + + if (nbytes & 1) + { + sum += *(uint8_t *)cptr; + } + + return fold_and_swap(sum, swap); +} diff --git a/libc/AOR_v20.02/networking/chksum_common.h b/libc/AOR_v20.02/networking/chksum_common.h new file mode 100644 index 00000000000000..afb0552830f046 --- /dev/null +++ b/libc/AOR_v20.02/networking/chksum_common.h @@ -0,0 +1,133 @@ +/* + * Common code for checksum implementations + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef CHKSUM_COMMON_H +#define CHKSUM_COMMON_H + +#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__ +#error Only little endian supported +#endif + +#include +#include +#include +#include + +/* Assertions must be explicitly enabled */ +#if WANT_ASSERT +#undef NDEBUG +#include +#define Assert(exp) assert(exp) +#else +#define Assert(exp) (void) (exp) +#endif + +#ifdef __GNUC__ +#define likely(x) __builtin_expect(!!(x), 1) +#define unlikely(x) __builtin_expect(!!(x), 0) +#define may_alias __attribute__((__may_alias__)) +#define always_inline __attribute__((always_inline)) +#ifdef __clang__ +#define no_unroll_loops +#else +#define no_unroll_loops __attribute__((optimize("no-unroll-loops"))) +#endif +#define bswap16(x) __builtin_bswap16((x)) +#else +#define likely(x) (x) +#define unlikely(x) (x) +#define may_alias +#define always_inline +#define no_unroll_loops +#define bswap16(x) ((uint8_t)((x) >> 8) | ((uint8_t)(x) << 8)) +#endif + +#define ALL_ONES ~UINT64_C(0) + +static inline +uint64_t load64(const void *ptr) +{ + /* GCC will optimise this to a normal load instruction */ + uint64_t v; + memcpy(&v, ptr, sizeof v); + return v; +} + +static inline +uint32_t load32(const void *ptr) +{ + /* GCC will optimise this to a normal load instruction */ + uint32_t v; + memcpy(&v, ptr, sizeof v); + return v; +} + +static inline +uint16_t load16(const void *ptr) +{ + /* GCC will optimise this to a normal load instruction */ + uint16_t v; + memcpy(&v, ptr, sizeof v); + return v; +} + +/* slurp_small() is for small buffers, don't waste cycles on alignment */ +no_unroll_loops +always_inline +static inline uint64_t +slurp_small(const void *ptr, uint32_t nbytes) +{ + const unsigned char *cptr = ptr; + uint64_t sum = 0; + while (nbytes >= 4) + { + sum += load32(cptr); + cptr += 4; + nbytes -= 4; + } + if (nbytes & 2) + { + sum += load16(cptr); + cptr += 2; + } + if (nbytes & 1) + { + sum += (uint8_t) *cptr; + } + return sum; +} + +static inline const void * +align_ptr(const void *ptr, size_t bytes) +{ + return (void *) ((uintptr_t) ptr & -(uintptr_t) bytes); +} + +always_inline +static inline uint16_t +fold_and_swap(uint64_t sum, bool swap) +{ + /* Fold 64-bit sum to 32 bits */ + sum = (sum & 0xffffffff) + (sum >> 32); + sum = (sum & 0xffffffff) + (sum >> 32); + Assert(sum == (uint32_t) sum); + + /* Fold 32-bit sum to 16 bits */ + sum = (sum & 0xffff) + (sum >> 16); + sum = (sum & 0xffff) + (sum >> 16); + Assert(sum == (uint16_t) sum); + + if (unlikely(swap)) /* Odd base pointer is unexpected */ + { + sum = bswap16(sum); + } + + return (uint16_t) sum; +} + +#endif diff --git a/libc/AOR_v20.02/networking/include/networking.h b/libc/AOR_v20.02/networking/include/networking.h new file mode 100644 index 00000000000000..2f91a9efb883cc --- /dev/null +++ b/libc/AOR_v20.02/networking/include/networking.h @@ -0,0 +1,15 @@ +/* + * Public API. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +unsigned short __chksum (const void *, unsigned int); +#if __aarch64__ && __ARM_NEON +unsigned short __chksum_aarch64_simd (const void *, unsigned int); +#endif +#if __arm__ && __ARM_NEON +unsigned short __chksum_arm_simd (const void *, unsigned int); +#endif diff --git a/libc/AOR_v20.02/networking/test/chksum.c b/libc/AOR_v20.02/networking/test/chksum.c new file mode 100644 index 00000000000000..c4ac3fe6bf0093 --- /dev/null +++ b/libc/AOR_v20.02/networking/test/chksum.c @@ -0,0 +1,382 @@ +/* + * Ones' complement checksum test & benchmark + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "../include/networking.h" + +#if WANT_ASSERT +#undef NDEBUG +#include +#define Assert(exp) assert(exp) +#else +#define Assert(exp) (void) (exp) +#endif + +#ifdef __GNUC__ +#define may_alias __attribute__((__may_alias__)) +#else +#define may_alias +#endif + +#define CACHE_LINE 64 +#define ALIGN(x, y) (((x) + (y) - 1) & ~((y) - 1)) + +/* Reference implementation - do not modify! */ +static uint16_t +checksum_simple(const void *ptr, uint32_t nbytes) +{ + const uint16_t *may_alias hptr = ptr; + uint64_t sum = 0;/* Need 64-bit accumulator when nbytes > 64K */ + + /* Sum all halfwords, assume misaligned accesses are handled in HW */ + for (uint32_t nhalfs = nbytes >> 1; nhalfs != 0; nhalfs--) + { + sum += *hptr++; + } + + /* Add any trailing odd byte */ + if ((nbytes & 0x01) != 0) + { + sum += *(uint8_t *) hptr; + } + + /* Fold 64-bit sum to 32 bits */ + sum = (sum & 0xffffffff) + (sum >> 32); + sum = (sum & 0xffffffff) + (sum >> 32); + Assert(sum == (uint32_t) sum); + + /* Fold 32-bit sum to 16 bits */ + sum = (sum & 0xffff) + (sum >> 16); + sum = (sum & 0xffff) + (sum >> 16); + Assert(sum == (uint16_t) sum); + + return (uint16_t) sum; +} + +static struct +{ + uint16_t (*cksum_fp)(const void *, uint32_t); + const char *name; +} implementations[] = +{ + { checksum_simple, "simple"}, + { __chksum, "scalar"}, +#if __arm__ + { __chksum_arm_simd, "simd" }, +#elif __aarch64__ + { __chksum_aarch64_simd, "simd" }, +#endif + { NULL, NULL} +}; + +static int +find_impl(const char *name) +{ + for (int i = 0; implementations[i].name != NULL; i++) + { + if (strcmp(implementations[i].name, name) == 0) + { + return i; + } + } + return -1; +} + +static uint16_t (*CKSUM_FP)(const void *, uint32_t); +static volatile uint16_t SINK; + +static bool +verify(const void *data, uint32_t offset, uint32_t size) +{ + + uint16_t csum_expected = checksum_simple(data, size); + uint16_t csum_actual = CKSUM_FP(data, size); + if (csum_actual != csum_expected) + { + fprintf(stderr, "\nInvalid checksum for offset %u size %u: " + "actual %04x expected %04x (valid)", + offset, size, csum_actual, csum_expected); + if (size < 65536) + { + /* Fatal error */ + exit(EXIT_FAILURE); + } + /* Else some implementations only support sizes up to 2^16 */ + return false; + } + return true; +} + +static uint64_t +clock_get_ns(void) +{ + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return ts.tv_sec * (uint64_t) 1000000000 + ts.tv_nsec; +} + +static void +benchmark(const uint8_t *base, + size_t poolsize, + uint32_t blksize, + uint32_t numops, + uint64_t cpufreq) +{ + printf("%11u ", (unsigned int) blksize); fflush(stdout); + + uint64_t start = clock_get_ns(); + for (uint32_t i = 0; i < numops; i ++) + { + /* Read a random value from the pool */ + uint32_t random = ((uint32_t *) base)[i % (poolsize / 4)]; + /* Generate a random starting address */ + const void *data = &base[random % (poolsize - blksize)]; + SINK = CKSUM_FP(data, blksize); + } + uint64_t end = clock_get_ns(); + +#define MEGABYTE 1000000 /* Decimal megabyte (MB) */ + uint64_t elapsed_ns = end - start; + uint64_t elapsed_ms = elapsed_ns / 1000000; + uint32_t blks_per_s = (uint32_t) ((numops / elapsed_ms) * 1000); + uint64_t accbytes = (uint64_t) numops * blksize; + printf("%11ju ", (uintmax_t) ((accbytes / elapsed_ms) * 1000) / MEGABYTE); + unsigned int cyc_per_blk = cpufreq / blks_per_s; + printf("%11u ", cyc_per_blk); + if (blksize != 0) + { + unsigned int cyc_per_byte = 1000 * cyc_per_blk / blksize; + printf("%7u.%03u ", + cyc_per_byte / 1000, cyc_per_byte % 1000); + } + printf("\n"); +} + +int main(int argc, char *argv[]) +{ + int c; + bool DUMP = false; + uint32_t IMPL = 0;/* Simple implementation */ + uint64_t CPUFREQ = 0; + uint32_t BLKSIZE = 0; + uint32_t NUMOPS = 1000000; + uint32_t POOLSIZE = 512 * 1024;/* Typical ARM L2 cache size */ + + setvbuf(stdout, NULL, _IOLBF, 160); + while ((c = getopt(argc, argv, "b:df:i:n:p:")) != -1) + { + switch (c) + { + case 'b' : + { + int blksize = atoi(optarg); + if (blksize < 1 || blksize > POOLSIZE / 2) + { + fprintf(stderr, "Invalid block size %d\n", blksize); + exit(EXIT_FAILURE); + } + BLKSIZE = (unsigned) blksize; + break; + } + case 'd' : + DUMP = true; + break; + case 'f' : + { + int64_t cpufreq = atoll(optarg); + if (cpufreq < 1) + { + fprintf(stderr, "Invalid CPU frequency %"PRId64"\n", + cpufreq); + exit(EXIT_FAILURE); + } + CPUFREQ = cpufreq; + break; + } + case 'i' : + { + int impl = find_impl(optarg); + if (impl < 0) + { + fprintf(stderr, "Invalid implementation %s\n", optarg); + goto usage; + } + IMPL = (unsigned) impl; + break; + } + case 'n' : + { + int numops = atoi(optarg); + if (numops < 1) + { + fprintf(stderr, "Invalid number of operations %d\n", numops); + exit(EXIT_FAILURE); + } + NUMOPS = (unsigned) numops; + break; + } + case 'p' : + { + int poolsize = atoi(optarg); + if (poolsize < 4096) + { + fprintf(stderr, "Invalid pool size %d\n", poolsize); + exit(EXIT_FAILURE); + } + char c = optarg[strlen(optarg) - 1]; + if (c == 'M') + { + POOLSIZE = (unsigned) poolsize * 1024 * 1024; + } + else if (c == 'K') + { + POOLSIZE = (unsigned) poolsize * 1024; + } + else + { + POOLSIZE = (unsigned) poolsize; + } + break; + } + default : +usage : + fprintf(stderr, "Usage: checksum \n" + "-b Block size\n" + "-d Dump first 96 bytes of data\n" + "-f CPU frequency (Hz)\n" + "-i Implementation\n" + "-n Number of operations\n" + "-p Pool size (K or M suffix)\n" + ); + printf("Implementations:"); + for (int i = 0; implementations[i].name != NULL; i++) + { + printf(" %s", implementations[i].name); + } + printf("\n"); + exit(EXIT_FAILURE); + } + } + if (optind > argc) + { + goto usage; + } + + CKSUM_FP = implementations[IMPL].cksum_fp; + POOLSIZE = ALIGN(POOLSIZE, CACHE_LINE); + uint8_t *base = mmap(0, POOLSIZE, PROT_READ|PROT_WRITE, + MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); + if (base == MAP_FAILED) + { + perror("aligned_alloc"), exit(EXIT_FAILURE); + } + for (size_t i = 0; i < POOLSIZE / 4; i++) + { + ((uint32_t *) base)[i] = rand(); + } + + printf("Implementation: %s\n", implementations[IMPL].name); + printf("numops %u, poolsize ", NUMOPS); + if (POOLSIZE % (1024 * 1024) == 0) + { + printf("%uMiB", POOLSIZE / (1024 * 1024)); + } + else if (POOLSIZE % 1024 == 0) + { + printf("%uKiB", POOLSIZE / 1024); + } + else + { + printf("%uB", POOLSIZE); + } + printf(", blocksize %u, CPU frequency %juMHz\n", + BLKSIZE, (uintmax_t) (CPUFREQ / 1000000)); +#if WANT_ASSERT + printf("Warning: assertions are enabled\n"); +#endif + + if (DUMP) + { + /* Print out first 96 bytes of data for human debugging */ + for (int i = 0; i < 96; i++) + { + if (i % 8 == 0) + printf("%2u:", i); + printf(" %02x", base[i]); + if (i % 8 == 7) + printf("\n"); + } + } + + /* Verify that chosen algorithm handles all combinations of offsets and sizes */ + printf("Verifying..."); fflush(stdout); + bool success = true; + /* Check all (relevant) combinations of size and offset */ + for (int size = 0; size <= 256; size++) + { + for (int offset = 0; offset < 255; offset++) + { + /* Check at start of mapped memory */ + success &= verify(&base[offset], offset, size); + /* Check at end of mapped memory */ + uint8_t *p = base + POOLSIZE - (size + offset); + success &= verify(p, (uintptr_t) p % 64, size); + } + } + /* Check increasingly larger sizes */ + for (size_t size = 1; size < POOLSIZE; size *= 2) + { + success &= verify(base, 0, size); + } + /* Check the full size, this can detect accumulator overflows */ + success &= verify(base, 0, POOLSIZE); + printf("%s\n", success ? "OK" : "failure"); + + /* Print throughput in decimal megabyte (1000000B) per second */ + if (CPUFREQ != 0) + { + printf("%11s %11s %11s %11s\n", + "block size", "MB/s", "cycles/blk", "cycles/byte"); + } + else + { + printf("%11s %11s %11s %11s\n", + "block size", "MB/s", "ns/blk", "ns/byte"); + CPUFREQ = 1000000000; + } + if (BLKSIZE != 0) + { + benchmark(base, POOLSIZE, BLKSIZE, NUMOPS, CPUFREQ); + } + else + { + static const uint16_t sizes[] = + { 20, 42, 102, 250, 612, 1500, 3674, 9000, 0 }; + for (int i = 0; sizes[i] != 0; i++) + { + uint32_t numops = NUMOPS * 10000 / (40 + sizes[i]); + benchmark(base, POOLSIZE, sizes[i], numops, CPUFREQ); + } + } + + if (munmap(base, POOLSIZE) != 0) + { + perror("munmap"), exit(EXIT_FAILURE); + } + + return success ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/libc/AOR_v20.02/string/Dir.mk b/libc/AOR_v20.02/string/Dir.mk new file mode 100644 index 00000000000000..215452c8dc3861 --- /dev/null +++ b/libc/AOR_v20.02/string/Dir.mk @@ -0,0 +1,101 @@ +# Makefile fragment - requires GNU make +# +# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +# See https://llvm.org/LICENSE.txt for license information. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +S := $(srcdir)/string +B := build/string + +ifeq ($(ARCH),) +all-string check-string install-string clean-string: + @echo "*** Please set ARCH in config.mk. ***" + @exit 1 +else + +string-lib-srcs := $(wildcard $(S)/$(ARCH)/*.[cS]) +string-test-srcs := $(wildcard $(S)/test/*.c) + +string-includes := $(patsubst $(S)/%,build/%,$(wildcard $(S)/include/*.h)) + +string-libs := \ + build/lib/libstringlib.so \ + build/lib/libstringlib.a \ + +string-tools := \ + build/bin/test/memcpy \ + build/bin/test/memmove \ + build/bin/test/memset \ + build/bin/test/memchr \ + build/bin/test/memcmp \ + build/bin/test/strcpy \ + build/bin/test/stpcpy \ + build/bin/test/strcmp \ + build/bin/test/strchr \ + build/bin/test/strrchr \ + build/bin/test/strchrnul \ + build/bin/test/strlen \ + build/bin/test/strnlen \ + build/bin/test/strncmp + +string-lib-objs := $(patsubst $(S)/%,$(B)/%.o,$(basename $(string-lib-srcs))) +string-test-objs := $(patsubst $(S)/%,$(B)/%.o,$(basename $(string-test-srcs))) + +string-objs := \ + $(string-lib-objs) \ + $(string-lib-objs:%.o=%.os) \ + $(string-test-objs) \ + +string-files := \ + $(string-objs) \ + $(string-libs) \ + $(string-tools) \ + $(string-includes) \ + +all-string: $(string-libs) $(string-tools) $(string-includes) + +$(string-objs): $(string-includes) +$(string-objs): CFLAGS_ALL += $(string-cflags) + +build/lib/libstringlib.so: $(string-lib-objs:%.o=%.os) + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -shared -o $@ $^ + +build/lib/libstringlib.a: $(string-lib-objs) + rm -f $@ + $(AR) rc $@ $^ + $(RANLIB) $@ + +build/bin/test/%: $(B)/test/%.o build/lib/libstringlib.a + $(CC) $(CFLAGS_ALL) $(LDFLAGS) -static -o $@ $^ $(LDLIBS) + +build/include/%.h: $(S)/include/%.h + cp $< $@ + +build/bin/%.sh: $(S)/test/%.sh + cp $< $@ + +check-string: $(string-tools) + $(EMULATOR) build/bin/test/memcpy + $(EMULATOR) build/bin/test/memmove + $(EMULATOR) build/bin/test/memset + $(EMULATOR) build/bin/test/memchr + $(EMULATOR) build/bin/test/memcmp + $(EMULATOR) build/bin/test/strcpy + $(EMULATOR) build/bin/test/stpcpy + $(EMULATOR) build/bin/test/strcmp + $(EMULATOR) build/bin/test/strchr + $(EMULATOR) build/bin/test/strrchr + $(EMULATOR) build/bin/test/strchrnul + $(EMULATOR) build/bin/test/strlen + $(EMULATOR) build/bin/test/strnlen + $(EMULATOR) build/bin/test/strncmp + +install-string: \ + $(string-libs:build/lib/%=$(DESTDIR)$(libdir)/%) \ + $(string-includes:build/include/%=$(DESTDIR)$(includedir)/%) + +clean-string: + rm -f $(string-files) +endif + +.PHONY: all-string check-string install-string clean-string diff --git a/libc/AOR_v20.02/string/aarch64/check-arch.S b/libc/AOR_v20.02/string/aarch64/check-arch.S new file mode 100644 index 00000000000000..7783503b3c6678 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/check-arch.S @@ -0,0 +1,11 @@ +/* + * check ARCH setting. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if !__aarch64__ +# error ARCH setting does not match the compiler. +#endif diff --git a/libc/AOR_v20.02/string/aarch64/memchr-sve.S b/libc/AOR_v20.02/string/aarch64/memchr-sve.S new file mode 100644 index 00000000000000..d9c5fdd18673d0 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/memchr-sve.S @@ -0,0 +1,65 @@ +/* + * memchr - find a character in a memory zone + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + + .globl __memchr_aarch64_sve + .type __memchr_aarch64_sve, %function + .p2align 4 +__memchr_aarch64_sve: + dup z1.b, w1 /* duplicate c to a vector */ + setffr /* initialize FFR */ + mov x3, 0 /* initialize off */ + nop + +0: whilelo p1.b, x3, x2 /* make sure off < max */ + b.none 9f + + /* Read a vector's worth of bytes, bounded by max, + stopping on first fault. */ + ldff1b z0.b, p1/z, [x0, x3] + rdffrs p0.b, p1/z + b.nlast 2f + + /* First fault did not fail: the vector bounded by max is valid. + Avoid depending on the contents of FFR beyond the branch. */ + incb x3 /* speculate increment */ + cmpeq p2.b, p1/z, z0.b, z1.b /* search for c */ + b.none 0b + decb x3 /* undo speculate */ + + /* Found C. */ +1: brkb p2.b, p1/z, p2.b /* find the first c */ + add x0, x0, x3 /* form partial pointer */ + incp x0, p2.b /* form final pointer to c */ + ret + + /* First fault failed: only some of the vector is valid. + Perform the comparision only on the valid bytes. */ +2: cmpeq p2.b, p0/z, z0.b, z1.b + b.any 1b + + /* No C found. Re-init FFR, increment, and loop. */ + setffr + incp x3, p0.b + b 0b + + /* Found end of count. */ +9: mov x0, 0 /* return null */ + ret + + .size __memchr_aarch64_sve, . - __memchr_aarch64_sve +#endif diff --git a/libc/AOR_v20.02/string/aarch64/memchr.S b/libc/AOR_v20.02/string/aarch64/memchr.S new file mode 100644 index 00000000000000..a454d6b896af5b --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/memchr.S @@ -0,0 +1,144 @@ +/* + * memchr - find a character in a memory zone + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64 + * Neon Available. + */ + +#include "../asmdefs.h" + +/* Arguments and results. */ +#define srcin x0 +#define chrin w1 +#define cntin x2 + +#define result x0 + +#define src x3 +#define tmp x4 +#define wtmp2 w5 +#define synd x6 +#define soff x9 +#define cntrem x10 + +#define vrepchr v0 +#define vdata1 v1 +#define vdata2 v2 +#define vhas_chr1 v3 +#define vhas_chr2 v4 +#define vrepmask v5 +#define vend v6 + +/* + * Core algorithm: + * + * For each 32-byte chunk we calculate a 64-bit syndrome value, with two bits + * per byte. For each tuple, bit 0 is set if the relevant byte matched the + * requested character and bit 1 is not used (faster than using a 32bit + * syndrome). Since the bits in the syndrome reflect exactly the order in which + * things occur in the original string, counting trailing zeros allows to + * identify exactly which byte has matched. + */ + +ENTRY (__memchr_aarch64) + /* Do not dereference srcin if no bytes to compare. */ + cbz cntin, L(zero_length) + /* + * Magic constant 0x40100401 allows us to identify which lane matches + * the requested byte. + */ + mov wtmp2, #0x0401 + movk wtmp2, #0x4010, lsl #16 + dup vrepchr.16b, chrin + /* Work with aligned 32-byte chunks */ + bic src, srcin, #31 + dup vrepmask.4s, wtmp2 + ands soff, srcin, #31 + and cntrem, cntin, #31 + b.eq L(loop) + + /* + * Input string is not 32-byte aligned. We calculate the syndrome + * value for the aligned 32 bytes block containing the first bytes + * and mask the irrelevant part. + */ + + ld1 {vdata1.16b, vdata2.16b}, [src], #32 + sub tmp, soff, #32 + adds cntin, cntin, tmp + cmeq vhas_chr1.16b, vdata1.16b, vrepchr.16b + cmeq vhas_chr2.16b, vdata2.16b, vrepchr.16b + and vhas_chr1.16b, vhas_chr1.16b, vrepmask.16b + and vhas_chr2.16b, vhas_chr2.16b, vrepmask.16b + addp vend.16b, vhas_chr1.16b, vhas_chr2.16b /* 256->128 */ + addp vend.16b, vend.16b, vend.16b /* 128->64 */ + mov synd, vend.d[0] + /* Clear the soff*2 lower bits */ + lsl tmp, soff, #1 + lsr synd, synd, tmp + lsl synd, synd, tmp + /* The first block can also be the last */ + b.ls L(masklast) + /* Have we found something already? */ + cbnz synd, L(tail) + +L(loop): + ld1 {vdata1.16b, vdata2.16b}, [src], #32 + subs cntin, cntin, #32 + cmeq vhas_chr1.16b, vdata1.16b, vrepchr.16b + cmeq vhas_chr2.16b, vdata2.16b, vrepchr.16b + /* If we're out of data we finish regardless of the result */ + b.ls L(end) + /* Use a fast check for the termination condition */ + orr vend.16b, vhas_chr1.16b, vhas_chr2.16b + addp vend.2d, vend.2d, vend.2d + mov synd, vend.d[0] + /* We're not out of data, loop if we haven't found the character */ + cbz synd, L(loop) + +L(end): + /* Termination condition found, let's calculate the syndrome value */ + and vhas_chr1.16b, vhas_chr1.16b, vrepmask.16b + and vhas_chr2.16b, vhas_chr2.16b, vrepmask.16b + addp vend.16b, vhas_chr1.16b, vhas_chr2.16b /* 256->128 */ + addp vend.16b, vend.16b, vend.16b /* 128->64 */ + mov synd, vend.d[0] + /* Only do the clear for the last possible block */ + b.hi L(tail) + +L(masklast): + /* Clear the (32 - ((cntrem + soff) % 32)) * 2 upper bits */ + add tmp, cntrem, soff + and tmp, tmp, #31 + sub tmp, tmp, #32 + neg tmp, tmp, lsl #1 + lsl synd, synd, tmp + lsr synd, synd, tmp + +L(tail): + /* Count the trailing zeros using bit reversing */ + rbit synd, synd + /* Compensate the last post-increment */ + sub src, src, #32 + /* Check that we have found a character */ + cmp synd, #0 + /* And count the leading zeros */ + clz synd, synd + /* Compute the potential result */ + add result, src, synd, lsr #1 + /* Select result or NULL */ + csel result, xzr, result, eq + ret + +L(zero_length): + mov result, #0 + ret + +END (__memchr_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/memcmp-sve.S b/libc/AOR_v20.02/string/aarch64/memcmp-sve.S new file mode 100644 index 00000000000000..0a3962f587bfbb --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/memcmp-sve.S @@ -0,0 +1,51 @@ +/* + * memcmp - compare memory + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + + .globl __memcmp_aarch64_sve + .type __memcmp_aarch64_sve, %function + .p2align 4 +__memcmp_aarch64_sve: + mov x3, 0 /* initialize off */ + +0: whilelo p0.b, x3, x2 /* while off < max */ + b.none 9f + + ld1b z0.b, p0/z, [x0, x3] /* read vectors bounded by max. */ + ld1b z1.b, p0/z, [x1, x3] + + /* Increment for a whole vector, even if we've only read a partial. + This is significantly cheaper than INCP, and since OFF is not + used after the loop it is ok to increment OFF past MAX. */ + incb x3 + + cmpne p1.b, p0/z, z0.b, z1.b /* while no inequalities */ + b.none 0b + + /* Found inequality. */ +1: brkb p1.b, p0/z, p1.b /* find first such */ + lasta w0, p1, z0.b /* extract each byte */ + lasta w1, p1, z1.b + sub x0, x0, x1 /* return comparison */ + ret + + /* Found end-of-count. */ +9: mov x0, 0 /* return equality */ + ret + + .size __memcmp_aarch64_sve, . - __memcmp_aarch64_sve +#endif diff --git a/libc/AOR_v20.02/string/aarch64/memcmp.S b/libc/AOR_v20.02/string/aarch64/memcmp.S new file mode 100644 index 00000000000000..fab69b5320eeb8 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/memcmp.S @@ -0,0 +1,134 @@ +/* memcmp - compare memory + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64, unaligned accesses. + */ + +#include "../asmdefs.h" + +/* Parameters and result. */ +#define src1 x0 +#define src2 x1 +#define limit x2 +#define result w0 + +/* Internal variables. */ +#define data1 x3 +#define data1w w3 +#define data1h x4 +#define data2 x5 +#define data2w w5 +#define data2h x6 +#define tmp1 x7 +#define tmp2 x8 + +ENTRY (__memcmp_aarch64) + subs limit, limit, 8 + b.lo L(less8) + + ldr data1, [src1], 8 + ldr data2, [src2], 8 + cmp data1, data2 + b.ne L(return) + + subs limit, limit, 8 + b.gt L(more16) + + ldr data1, [src1, limit] + ldr data2, [src2, limit] + b L(return) + +L(more16): + ldr data1, [src1], 8 + ldr data2, [src2], 8 + cmp data1, data2 + bne L(return) + + /* Jump directly to comparing the last 16 bytes for 32 byte (or less) + strings. */ + subs limit, limit, 16 + b.ls L(last_bytes) + + /* We overlap loads between 0-32 bytes at either side of SRC1 when we + try to align, so limit it only to strings larger than 128 bytes. */ + cmp limit, 96 + b.ls L(loop16) + + /* Align src1 and adjust src2 with bytes not yet done. */ + and tmp1, src1, 15 + add limit, limit, tmp1 + sub src1, src1, tmp1 + sub src2, src2, tmp1 + + /* Loop performing 16 bytes per iteration using aligned src1. + Limit is pre-decremented by 16 and must be larger than zero. + Exit if <= 16 bytes left to do or if the data is not equal. */ + .p2align 4 +L(loop16): + ldp data1, data1h, [src1], 16 + ldp data2, data2h, [src2], 16 + subs limit, limit, 16 + ccmp data1, data2, 0, hi + ccmp data1h, data2h, 0, eq + b.eq L(loop16) + + cmp data1, data2 + bne L(return) + mov data1, data1h + mov data2, data2h + cmp data1, data2 + bne L(return) + + /* Compare last 1-16 bytes using unaligned access. */ +L(last_bytes): + add src1, src1, limit + add src2, src2, limit + ldp data1, data1h, [src1] + ldp data2, data2h, [src2] + cmp data1, data2 + bne L(return) + mov data1, data1h + mov data2, data2h + cmp data1, data2 + + /* Compare data bytes and set return value to 0, -1 or 1. */ +L(return): +#ifndef __AARCH64EB__ + rev data1, data1 + rev data2, data2 +#endif + cmp data1, data2 +L(ret_eq): + cset result, ne + cneg result, result, lo + ret + + .p2align 4 + /* Compare up to 8 bytes. Limit is [-8..-1]. */ +L(less8): + adds limit, limit, 4 + b.lo L(less4) + ldr data1w, [src1], 4 + ldr data2w, [src2], 4 + cmp data1w, data2w + b.ne L(return) + sub limit, limit, 4 +L(less4): + adds limit, limit, 4 + beq L(ret_eq) +L(byte_loop): + ldrb data1w, [src1], 1 + ldrb data2w, [src2], 1 + subs limit, limit, 1 + ccmp data1w, data2w, 0, ne /* NZCV = 0b0000. */ + b.eq L(byte_loop) + sub result, data1w, data2w + ret + +END (__memcmp_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/memcpy-advsimd.S b/libc/AOR_v20.02/string/aarch64/memcpy-advsimd.S new file mode 100644 index 00000000000000..befd32bb98c724 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/memcpy-advsimd.S @@ -0,0 +1,202 @@ +/* + * memcpy - copy memory area + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64, Advanced SIMD, unaligned accesses. + * + */ + +#include "../asmdefs.h" + +#define dstin x0 +#define src x1 +#define count x2 +#define dst x3 +#define srcend x4 +#define dstend x5 +#define A_l x6 +#define A_lw w6 +#define A_h x7 +#define B_l x8 +#define B_lw w8 +#define B_h x9 +#define C_lw w10 +#define tmp1 x14 + +#define A_q q0 +#define B_q q1 +#define C_q q2 +#define D_q q3 +#define E_q q4 +#define F_q q5 +#define G_q q6 +#define H_q q7 + +/* This implementation handles overlaps and supports both memcpy and memmove + from a single entry point. It uses unaligned accesses and branchless + sequences to keep the code small, simple and improve performance. + + Copies are split into 3 main cases: small copies of up to 32 bytes, medium + copies of up to 128 bytes, and large copies. The overhead of the overlap + check is negligible since it is only required for large copies. + + Large copies use a software pipelined loop processing 64 bytes per iteration. + The source pointer is 16-byte aligned to minimize unaligned accesses. + The loop tail is handled by always copying 64 bytes from the end. +*/ + +ENTRY (__memcpy_aarch64_simd) +ENTRY_ALIAS (__memmove_aarch64_simd) + add srcend, src, count + add dstend, dstin, count + cmp count, 128 + b.hi L(copy_long) + cmp count, 32 + b.hi L(copy32_128) + + /* Small copies: 0..32 bytes. */ + cmp count, 16 + b.lo L(copy16) + ldr A_q, [src] + ldr B_q, [srcend, -16] + str A_q, [dstin] + str B_q, [dstend, -16] + ret + + /* Copy 8-15 bytes. */ +L(copy16): + tbz count, 3, L(copy8) + ldr A_l, [src] + ldr A_h, [srcend, -8] + str A_l, [dstin] + str A_h, [dstend, -8] + ret + + .p2align 3 + /* Copy 4-7 bytes. */ +L(copy8): + tbz count, 2, L(copy4) + ldr A_lw, [src] + ldr B_lw, [srcend, -4] + str A_lw, [dstin] + str B_lw, [dstend, -4] + ret + + /* Copy 0..3 bytes using a branchless sequence. */ +L(copy4): + cbz count, L(copy0) + lsr tmp1, count, 1 + ldrb A_lw, [src] + ldrb C_lw, [srcend, -1] + ldrb B_lw, [src, tmp1] + strb A_lw, [dstin] + strb B_lw, [dstin, tmp1] + strb C_lw, [dstend, -1] +L(copy0): + ret + + .p2align 4 + /* Medium copies: 33..128 bytes. */ +L(copy32_128): + ldp A_q, B_q, [src] + ldp C_q, D_q, [srcend, -32] + cmp count, 64 + b.hi L(copy128) + stp A_q, B_q, [dstin] + stp C_q, D_q, [dstend, -32] + ret + + .p2align 4 + /* Copy 65..128 bytes. */ +L(copy128): + ldp E_q, F_q, [src, 32] + cmp count, 96 + b.ls L(copy96) + ldp G_q, H_q, [srcend, -64] + stp G_q, H_q, [dstend, -64] +L(copy96): + stp A_q, B_q, [dstin] + stp E_q, F_q, [dstin, 32] + stp C_q, D_q, [dstend, -32] + ret + + /* Copy more than 128 bytes. */ +L(copy_long): + /* Use backwards copy if there is an overlap. */ + sub tmp1, dstin, src + cmp tmp1, count + b.lo L(copy_long_backwards) + + /* Copy 16 bytes and then align src to 16-byte alignment. */ + ldr D_q, [src] + and tmp1, src, 15 + bic src, src, 15 + sub dst, dstin, tmp1 + add count, count, tmp1 /* Count is now 16 too large. */ + ldp A_q, B_q, [src, 16] + str D_q, [dstin] + ldp C_q, D_q, [src, 48] + subs count, count, 128 + 16 /* Test and readjust count. */ + b.ls L(copy64_from_end) +L(loop64): + stp A_q, B_q, [dst, 16] + ldp A_q, B_q, [src, 80] + stp C_q, D_q, [dst, 48] + ldp C_q, D_q, [src, 112] + add src, src, 64 + add dst, dst, 64 + subs count, count, 64 + b.hi L(loop64) + + /* Write the last iteration and copy 64 bytes from the end. */ +L(copy64_from_end): + ldp E_q, F_q, [srcend, -64] + stp A_q, B_q, [dst, 16] + ldp A_q, B_q, [srcend, -32] + stp C_q, D_q, [dst, 48] + stp E_q, F_q, [dstend, -64] + stp A_q, B_q, [dstend, -32] + ret + + /* Large backwards copy for overlapping copies. + Copy 16 bytes and then align srcend to 16-byte alignment. */ +L(copy_long_backwards): + cbz tmp1, L(copy0) + ldr D_q, [srcend, -16] + and tmp1, srcend, 15 + bic srcend, srcend, 15 + sub count, count, tmp1 + ldp A_q, B_q, [srcend, -32] + str D_q, [dstend, -16] + ldp C_q, D_q, [srcend, -64] + sub dstend, dstend, tmp1 + subs count, count, 128 + b.ls L(copy64_from_start) + +L(loop64_backwards): + stp A_q, B_q, [dstend, -32] + ldp A_q, B_q, [srcend, -96] + stp C_q, D_q, [dstend, -64] + ldp C_q, D_q, [srcend, -128] + sub srcend, srcend, 64 + sub dstend, dstend, 64 + subs count, count, 64 + b.hi L(loop64_backwards) + + /* Write the last iteration and copy 64 bytes from the start. */ +L(copy64_from_start): + ldp E_q, F_q, [src, 32] + stp A_q, B_q, [dstend, -32] + ldp A_q, B_q, [src] + stp C_q, D_q, [dstend, -64] + stp E_q, F_q, [dstin, 32] + stp A_q, B_q, [dstin] + ret + +END (__memcpy_aarch64_simd) diff --git a/libc/AOR_v20.02/string/aarch64/memcpy.S b/libc/AOR_v20.02/string/aarch64/memcpy.S new file mode 100644 index 00000000000000..459e22848e2573 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/memcpy.S @@ -0,0 +1,240 @@ +/* + * memcpy - copy memory area + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64, unaligned accesses. + * + */ + +#include "../asmdefs.h" + +#define dstin x0 +#define src x1 +#define count x2 +#define dst x3 +#define srcend x4 +#define dstend x5 +#define A_l x6 +#define A_lw w6 +#define A_h x7 +#define B_l x8 +#define B_lw w8 +#define B_h x9 +#define C_l x10 +#define C_lw w10 +#define C_h x11 +#define D_l x12 +#define D_h x13 +#define E_l x14 +#define E_h x15 +#define F_l x16 +#define F_h x17 +#define G_l count +#define G_h dst +#define H_l src +#define H_h srcend +#define tmp1 x14 + +/* This implementation handles overlaps and supports both memcpy and memmove + from a single entry point. It uses unaligned accesses and branchless + sequences to keep the code small, simple and improve performance. + + Copies are split into 3 main cases: small copies of up to 32 bytes, medium + copies of up to 128 bytes, and large copies. The overhead of the overlap + check is negligible since it is only required for large copies. + + Large copies use a software pipelined loop processing 64 bytes per iteration. + The destination pointer is 16-byte aligned to minimize unaligned accesses. + The loop tail is handled by always copying 64 bytes from the end. +*/ + +ENTRY (__memcpy_aarch64) +ENTRY_ALIAS (__memmove_aarch64) + add srcend, src, count + add dstend, dstin, count + cmp count, 128 + b.hi L(copy_long) + cmp count, 32 + b.hi L(copy32_128) + + /* Small copies: 0..32 bytes. */ + cmp count, 16 + b.lo L(copy16) + ldp A_l, A_h, [src] + ldp D_l, D_h, [srcend, -16] + stp A_l, A_h, [dstin] + stp D_l, D_h, [dstend, -16] + ret + + /* Copy 8-15 bytes. */ +L(copy16): + tbz count, 3, L(copy8) + ldr A_l, [src] + ldr A_h, [srcend, -8] + str A_l, [dstin] + str A_h, [dstend, -8] + ret + + .p2align 3 + /* Copy 4-7 bytes. */ +L(copy8): + tbz count, 2, L(copy4) + ldr A_lw, [src] + ldr B_lw, [srcend, -4] + str A_lw, [dstin] + str B_lw, [dstend, -4] + ret + + /* Copy 0..3 bytes using a branchless sequence. */ +L(copy4): + cbz count, L(copy0) + lsr tmp1, count, 1 + ldrb A_lw, [src] + ldrb C_lw, [srcend, -1] + ldrb B_lw, [src, tmp1] + strb A_lw, [dstin] + strb B_lw, [dstin, tmp1] + strb C_lw, [dstend, -1] +L(copy0): + ret + + .p2align 4 + /* Medium copies: 33..128 bytes. */ +L(copy32_128): + ldp A_l, A_h, [src] + ldp B_l, B_h, [src, 16] + ldp C_l, C_h, [srcend, -32] + ldp D_l, D_h, [srcend, -16] + cmp count, 64 + b.hi L(copy128) + stp A_l, A_h, [dstin] + stp B_l, B_h, [dstin, 16] + stp C_l, C_h, [dstend, -32] + stp D_l, D_h, [dstend, -16] + ret + + .p2align 4 + /* Copy 65..128 bytes. */ +L(copy128): + ldp E_l, E_h, [src, 32] + ldp F_l, F_h, [src, 48] + cmp count, 96 + b.ls L(copy96) + ldp G_l, G_h, [srcend, -64] + ldp H_l, H_h, [srcend, -48] + stp G_l, G_h, [dstend, -64] + stp H_l, H_h, [dstend, -48] +L(copy96): + stp A_l, A_h, [dstin] + stp B_l, B_h, [dstin, 16] + stp E_l, E_h, [dstin, 32] + stp F_l, F_h, [dstin, 48] + stp C_l, C_h, [dstend, -32] + stp D_l, D_h, [dstend, -16] + ret + + .p2align 4 + /* Copy more than 128 bytes. */ +L(copy_long): + /* Use backwards copy if there is an overlap. */ + sub tmp1, dstin, src + cbz tmp1, L(copy0) + cmp tmp1, count + b.lo L(copy_long_backwards) + + /* Copy 16 bytes and then align dst to 16-byte alignment. */ + + ldp D_l, D_h, [src] + and tmp1, dstin, 15 + bic dst, dstin, 15 + sub src, src, tmp1 + add count, count, tmp1 /* Count is now 16 too large. */ + ldp A_l, A_h, [src, 16] + stp D_l, D_h, [dstin] + ldp B_l, B_h, [src, 32] + ldp C_l, C_h, [src, 48] + ldp D_l, D_h, [src, 64]! + subs count, count, 128 + 16 /* Test and readjust count. */ + b.ls L(copy64_from_end) + +L(loop64): + stp A_l, A_h, [dst, 16] + ldp A_l, A_h, [src, 16] + stp B_l, B_h, [dst, 32] + ldp B_l, B_h, [src, 32] + stp C_l, C_h, [dst, 48] + ldp C_l, C_h, [src, 48] + stp D_l, D_h, [dst, 64]! + ldp D_l, D_h, [src, 64]! + subs count, count, 64 + b.hi L(loop64) + + /* Write the last iteration and copy 64 bytes from the end. */ +L(copy64_from_end): + ldp E_l, E_h, [srcend, -64] + stp A_l, A_h, [dst, 16] + ldp A_l, A_h, [srcend, -48] + stp B_l, B_h, [dst, 32] + ldp B_l, B_h, [srcend, -32] + stp C_l, C_h, [dst, 48] + ldp C_l, C_h, [srcend, -16] + stp D_l, D_h, [dst, 64] + stp E_l, E_h, [dstend, -64] + stp A_l, A_h, [dstend, -48] + stp B_l, B_h, [dstend, -32] + stp C_l, C_h, [dstend, -16] + ret + + .p2align 4 + + /* Large backwards copy for overlapping copies. + Copy 16 bytes and then align dst to 16-byte alignment. */ +L(copy_long_backwards): + ldp D_l, D_h, [srcend, -16] + and tmp1, dstend, 15 + sub srcend, srcend, tmp1 + sub count, count, tmp1 + ldp A_l, A_h, [srcend, -16] + stp D_l, D_h, [dstend, -16] + ldp B_l, B_h, [srcend, -32] + ldp C_l, C_h, [srcend, -48] + ldp D_l, D_h, [srcend, -64]! + sub dstend, dstend, tmp1 + subs count, count, 128 + b.ls L(copy64_from_start) + +L(loop64_backwards): + stp A_l, A_h, [dstend, -16] + ldp A_l, A_h, [srcend, -16] + stp B_l, B_h, [dstend, -32] + ldp B_l, B_h, [srcend, -32] + stp C_l, C_h, [dstend, -48] + ldp C_l, C_h, [srcend, -48] + stp D_l, D_h, [dstend, -64]! + ldp D_l, D_h, [srcend, -64]! + subs count, count, 64 + b.hi L(loop64_backwards) + + /* Write the last iteration and copy 64 bytes from the start. */ +L(copy64_from_start): + ldp G_l, G_h, [src, 48] + stp A_l, A_h, [dstend, -16] + ldp A_l, A_h, [src, 32] + stp B_l, B_h, [dstend, -32] + ldp B_l, B_h, [src, 16] + stp C_l, C_h, [dstend, -48] + ldp C_l, C_h, [src] + stp D_l, D_h, [dstend, -64] + stp G_l, G_h, [dstin, 48] + stp A_l, A_h, [dstin, 32] + stp B_l, B_h, [dstin, 16] + stp C_l, C_h, [dstin] + ret + +END (__memcpy_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/memset.S b/libc/AOR_v20.02/string/aarch64/memset.S new file mode 100644 index 00000000000000..39c78dcd769410 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/memset.S @@ -0,0 +1,115 @@ +/* + * memset - fill memory with a constant byte + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64, Advanced SIMD, unaligned accesses. + * + */ + +#include "../asmdefs.h" + +#define dstin x0 +#define val x1 +#define valw w1 +#define count x2 +#define dst x3 +#define dstend x4 +#define zva_val x5 + +ENTRY (__memset_aarch64) + + dup v0.16B, valw + add dstend, dstin, count + + cmp count, 96 + b.hi L(set_long) + cmp count, 16 + b.hs L(set_medium) + mov val, v0.D[0] + + /* Set 0..15 bytes. */ + tbz count, 3, 1f + str val, [dstin] + str val, [dstend, -8] + ret + nop +1: tbz count, 2, 2f + str valw, [dstin] + str valw, [dstend, -4] + ret +2: cbz count, 3f + strb valw, [dstin] + tbz count, 1, 3f + strh valw, [dstend, -2] +3: ret + + /* Set 17..96 bytes. */ +L(set_medium): + str q0, [dstin] + tbnz count, 6, L(set96) + str q0, [dstend, -16] + tbz count, 5, 1f + str q0, [dstin, 16] + str q0, [dstend, -32] +1: ret + + .p2align 4 + /* Set 64..96 bytes. Write 64 bytes from the start and + 32 bytes from the end. */ +L(set96): + str q0, [dstin, 16] + stp q0, q0, [dstin, 32] + stp q0, q0, [dstend, -32] + ret + + .p2align 4 +L(set_long): + and valw, valw, 255 + bic dst, dstin, 15 + str q0, [dstin] + cmp count, 160 + ccmp valw, 0, 0, hs + b.ne L(no_zva) + +#ifndef SKIP_ZVA_CHECK + mrs zva_val, dczid_el0 + and zva_val, zva_val, 31 + cmp zva_val, 4 /* ZVA size is 64 bytes. */ + b.ne L(no_zva) +#endif + str q0, [dst, 16] + stp q0, q0, [dst, 32] + bic dst, dst, 63 + sub count, dstend, dst /* Count is now 64 too large. */ + sub count, count, 128 /* Adjust count and bias for loop. */ + + .p2align 4 +L(zva_loop): + add dst, dst, 64 + dc zva, dst + subs count, count, 64 + b.hi L(zva_loop) + stp q0, q0, [dstend, -64] + stp q0, q0, [dstend, -32] + ret + +L(no_zva): + sub count, dstend, dst /* Count is 16 too large. */ + sub dst, dst, 16 /* Dst is biased by -32. */ + sub count, count, 64 + 16 /* Adjust count and bias for loop. */ +L(no_zva_loop): + stp q0, q0, [dst, 32] + stp q0, q0, [dst, 64]! + subs count, count, 64 + b.hi L(no_zva_loop) + stp q0, q0, [dstend, -64] + stp q0, q0, [dstend, -32] + ret + +END (__memset_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/stpcpy-sve.S b/libc/AOR_v20.02/string/aarch64/stpcpy-sve.S new file mode 100644 index 00000000000000..54afdab725294c --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/stpcpy-sve.S @@ -0,0 +1,11 @@ +/* + * stpcpy - copy a string returning pointer to end. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#define BUILD_STPCPY 1 + +#include "strcpy-sve.S" diff --git a/libc/AOR_v20.02/string/aarch64/stpcpy.S b/libc/AOR_v20.02/string/aarch64/stpcpy.S new file mode 100644 index 00000000000000..8cf98db4ba25a0 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/stpcpy.S @@ -0,0 +1,11 @@ +/* + * stpcpy - copy a string returning pointer to end. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#define BUILD_STPCPY 1 + +#include "strcpy.S" diff --git a/libc/AOR_v20.02/string/aarch64/strchr-mte.S b/libc/AOR_v20.02/string/aarch64/strchr-mte.S new file mode 100644 index 00000000000000..7c517916212a14 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strchr-mte.S @@ -0,0 +1,131 @@ +/* + * strchr - find a character in a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64 + * Neon Available. + */ + +#include "../asmdefs.h" + +/* Arguments and results. */ +#define srcin x0 +#define chrin w1 + +#define result x0 + +#define src x2 +#define tmp1 x3 +#define wtmp2 w4 +#define tmp3 x5 + +#define vrepchr v0 +#define qdata q1 +#define vdata v1 +#define vhas_nul v2 +#define vhas_chr v3 +#define vrepmask_0 v4 +#define vrepmask_c v5 +#define vend v6 + +#define L(l) .L ## l + +/* Core algorithm. + + For each 16-byte chunk we calculate a 64-bit syndrome value, with + four bits per byte (LSB is always in bits 0 and 1, for both big + and little-endian systems). For each tuple, bit 0 is set if + the relevant byte matched the requested character; bit 1 is set + if the relevant byte matched the NUL end of string (we trigger + off bit0 for the special case of looking for NUL) and bits 2 and 3 + are not used. + Since the bits in the syndrome reflect exactly the order in which + things occur in the original string a count_trailing_zeros() + operation will identify exactly which byte is causing the termination, + and why. */ + +/* Locals and temporaries. */ + +ENTRY(__strchr_aarch64_mte) + /* Magic constant 0x10011001 to allow us to identify which lane + matches the requested byte. Magic constant 0x20022002 used + similarly for NUL termination. */ + mov wtmp2, #0x1001 + movk wtmp2, #0x1001, lsl #16 + dup vrepchr.16b, chrin + bic src, srcin, #15 /* Work with aligned 16-byte chunks. */ + dup vrepmask_c.4s, wtmp2 + ands tmp1, srcin, #15 + add vrepmask_0.4s, vrepmask_c.4s, vrepmask_c.4s /* equiv: lsl #1 */ + b.eq L(loop) + + /* Input string is not 16-byte aligned. Rather than forcing + the padding bytes to a safe value, we calculate the syndrome + for all the bytes, but then mask off those bits of the + syndrome that are related to the padding. */ + ldr qdata, [src], #16 + cmeq vhas_nul.16b, vdata.16b, #0 + cmeq vhas_chr.16b, vdata.16b, vrepchr.16b + and vhas_nul.16b, vhas_nul.16b, vrepmask_0.16b + and vhas_chr.16b, vhas_chr.16b, vrepmask_c.16b + lsl tmp1, tmp1, #2 + orr vend.16b, vhas_nul.16b, vhas_chr.16b + mov tmp3, #~0 + addp vend.16b, vend.16b, vend.16b /* 128->64 */ + lsl tmp1, tmp3, tmp1 + + mov tmp3, vend.d[0] + ands tmp1, tmp3, tmp1 /* Mask padding bits. */ + b.ne L(tail) + +L(loop): + ldr qdata, [src], #32 + cmeq vhas_nul.16b, vdata.16b, #0 + cmeq vhas_chr.16b, vdata.16b, vrepchr.16b + /* Use a fast check for the termination condition. */ + orr vend.16b, vhas_nul.16b, vhas_chr.16b + addp vend.16b, vend.16b, vend.16b /* 128->64 */ + mov tmp1, vend.d[0] + cbnz tmp1, L(end) + + ldr qdata, [src, #-16] + cmeq vhas_nul.16b, vdata.16b, #0 + cmeq vhas_chr.16b, vdata.16b, vrepchr.16b + /* Use a fast check for the termination condition. */ + orr vend.16b, vhas_nul.16b, vhas_chr.16b + addp vend.16b, vend.16b, vend.16b /* 128->64 */ + mov tmp1, vend.d[0] + cbz tmp1, L(loop) + + /* Adjust src for next two subtractions. */ + add src, src, #16 +L(end): + /* Termination condition found. Now need to establish exactly why + we terminated. */ + and vhas_nul.16b, vhas_nul.16b, vrepmask_0.16b + and vhas_chr.16b, vhas_chr.16b, vrepmask_c.16b + sub src, src, #16 + orr vend.16b, vhas_nul.16b, vhas_chr.16b + addp vend.16b, vend.16b, vend.16b /* 128->64 */ + + mov tmp1, vend.d[0] +L(tail): + /* Count the trailing zeros, by bit reversing... */ + rbit tmp1, tmp1 + /* Re-bias source. */ + sub src, src, #16 + clz tmp1, tmp1 /* And counting the leading zeros. */ + /* Tmp1 is even if the target character was found first. Otherwise + we've found the end of string and we weren't looking for NUL. */ + tst tmp1, #1 + add result, src, tmp1, lsr #2 + csel result, result, xzr, eq + ret + +END(__strchr_aarch64_mte) diff --git a/libc/AOR_v20.02/string/aarch64/strchr-sve.S b/libc/AOR_v20.02/string/aarch64/strchr-sve.S new file mode 100644 index 00000000000000..3f7d782c002730 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strchr-sve.S @@ -0,0 +1,72 @@ +/* + * strchr/strchrnul - find a character in a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + +/* To build as strchrnul, define BUILD_STRCHRNUL before compiling this file. */ +#ifdef BUILD_STRCHRNUL +#define FUNC __strchrnul_aarch64_sve +#else +#define FUNC __strchr_aarch64_sve +#endif + + .globl FUNC + .type FUNC, %function + .p2align 4 +FUNC: + dup z1.b, w1 /* replicate byte across vector */ + setffr /* initialize FFR */ + ptrue p1.b /* all ones; loop invariant */ + + .p2align 4 + /* Read a vector's worth of bytes, stopping on first fault. */ +0: ldff1b z0.b, p1/z, [x0, xzr] + rdffrs p0.b, p1/z + b.nlast 2f + + /* First fault did not fail: the whole vector is valid. + Avoid depending on the contents of FFR beyond the branch. */ + incb x0 /* speculate increment */ + cmpeq p2.b, p1/z, z0.b, z1.b /* search for c */ + cmpeq p3.b, p1/z, z0.b, 0 /* search for 0 */ + orrs p4.b, p1/z, p2.b, p3.b /* c | 0 */ + b.none 0b + decb x0 /* undo speculate */ + + /* Found C or 0. */ +1: brka p4.b, p1/z, p4.b /* find first such */ + sub x0, x0, 1 /* adjust pointer for that byte */ + incp x0, p4.b +#ifndef BUILD_STRCHRNUL + ptest p4, p2.b /* was first in c? */ + csel x0, xzr, x0, none /* if there was no c, return null */ +#endif + ret + + /* First fault failed: only some of the vector is valid. + Perform the comparision only on the valid bytes. */ +2: cmpeq p2.b, p0/z, z0.b, z1.b /* search for c */ + cmpeq p3.b, p0/z, z0.b, 0 /* search for 0 */ + orrs p4.b, p0/z, p2.b, p3.b /* c | 0 */ + b.any 1b + + /* No C or 0 found. Re-init FFR, increment, and loop. */ + setffr + incp x0, p0.b + b 0b + + .size FUNC, . - FUNC +#endif diff --git a/libc/AOR_v20.02/string/aarch64/strchr.S b/libc/AOR_v20.02/string/aarch64/strchr.S new file mode 100644 index 00000000000000..4c7617f2194818 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strchr.S @@ -0,0 +1,132 @@ +/* + * strchr - find a character in a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64 + * Neon Available. + */ + +#include "../asmdefs.h" + +/* Arguments and results. */ +#define srcin x0 +#define chrin w1 + +#define result x0 + +#define src x2 +#define tmp1 x3 +#define wtmp2 w4 +#define tmp3 x5 + +#define vrepchr v0 +#define vdata1 v1 +#define vdata2 v2 +#define vhas_nul1 v3 +#define vhas_nul2 v4 +#define vhas_chr1 v5 +#define vhas_chr2 v6 +#define vrepmask_0 v7 +#define vrepmask_c v16 +#define vend1 v17 +#define vend2 v18 + +/* Core algorithm. + + For each 32-byte hunk we calculate a 64-bit syndrome value, with + two bits per byte (LSB is always in bits 0 and 1, for both big + and little-endian systems). For each tuple, bit 0 is set iff + the relevant byte matched the requested character; bit 1 is set + iff the relevant byte matched the NUL end of string (we trigger + off bit0 for the special case of looking for NUL). Since the bits + in the syndrome reflect exactly the order in which things occur + in the original string a count_trailing_zeros() operation will + identify exactly which byte is causing the termination, and why. */ + +/* Locals and temporaries. */ + +ENTRY (__strchr_aarch64) + /* Magic constant 0x40100401 to allow us to identify which lane + matches the requested byte. Magic constant 0x80200802 used + similarly for NUL termination. */ + mov wtmp2, #0x0401 + movk wtmp2, #0x4010, lsl #16 + dup vrepchr.16b, chrin + bic src, srcin, #31 /* Work with aligned 32-byte hunks. */ + dup vrepmask_c.4s, wtmp2 + ands tmp1, srcin, #31 + add vrepmask_0.4s, vrepmask_c.4s, vrepmask_c.4s /* equiv: lsl #1 */ + b.eq L(loop) + + /* Input string is not 32-byte aligned. Rather than forcing + the padding bytes to a safe value, we calculate the syndrome + for all the bytes, but then mask off those bits of the + syndrome that are related to the padding. */ + ld1 {vdata1.16b, vdata2.16b}, [src], #32 + neg tmp1, tmp1 + cmeq vhas_nul1.16b, vdata1.16b, #0 + cmeq vhas_chr1.16b, vdata1.16b, vrepchr.16b + cmeq vhas_nul2.16b, vdata2.16b, #0 + cmeq vhas_chr2.16b, vdata2.16b, vrepchr.16b + and vhas_nul1.16b, vhas_nul1.16b, vrepmask_0.16b + and vhas_nul2.16b, vhas_nul2.16b, vrepmask_0.16b + and vhas_chr1.16b, vhas_chr1.16b, vrepmask_c.16b + and vhas_chr2.16b, vhas_chr2.16b, vrepmask_c.16b + orr vend1.16b, vhas_nul1.16b, vhas_chr1.16b + orr vend2.16b, vhas_nul2.16b, vhas_chr2.16b + lsl tmp1, tmp1, #1 + addp vend1.16b, vend1.16b, vend2.16b // 256->128 + mov tmp3, #~0 + addp vend1.16b, vend1.16b, vend2.16b // 128->64 + lsr tmp1, tmp3, tmp1 + + mov tmp3, vend1.d[0] + bic tmp1, tmp3, tmp1 // Mask padding bits. + cbnz tmp1, L(tail) + +L(loop): + ld1 {vdata1.16b, vdata2.16b}, [src], #32 + cmeq vhas_nul1.16b, vdata1.16b, #0 + cmeq vhas_chr1.16b, vdata1.16b, vrepchr.16b + cmeq vhas_nul2.16b, vdata2.16b, #0 + cmeq vhas_chr2.16b, vdata2.16b, vrepchr.16b + /* Use a fast check for the termination condition. */ + orr vend1.16b, vhas_nul1.16b, vhas_chr1.16b + orr vend2.16b, vhas_nul2.16b, vhas_chr2.16b + orr vend1.16b, vend1.16b, vend2.16b + addp vend1.2d, vend1.2d, vend1.2d + mov tmp1, vend1.d[0] + cbz tmp1, L(loop) + + /* Termination condition found. Now need to establish exactly why + we terminated. */ + and vhas_nul1.16b, vhas_nul1.16b, vrepmask_0.16b + and vhas_nul2.16b, vhas_nul2.16b, vrepmask_0.16b + and vhas_chr1.16b, vhas_chr1.16b, vrepmask_c.16b + and vhas_chr2.16b, vhas_chr2.16b, vrepmask_c.16b + orr vend1.16b, vhas_nul1.16b, vhas_chr1.16b + orr vend2.16b, vhas_nul2.16b, vhas_chr2.16b + addp vend1.16b, vend1.16b, vend2.16b // 256->128 + addp vend1.16b, vend1.16b, vend2.16b // 128->64 + + mov tmp1, vend1.d[0] +L(tail): + /* Count the trailing zeros, by bit reversing... */ + rbit tmp1, tmp1 + /* Re-bias source. */ + sub src, src, #32 + clz tmp1, tmp1 /* And counting the leading zeros. */ + /* Tmp1 is even if the target charager was found first. Otherwise + we've found the end of string and we weren't looking for NUL. */ + tst tmp1, #1 + add result, src, tmp1, lsr #1 + csel result, result, xzr, eq + ret + +END (__strchr_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/strchrnul-sve.S b/libc/AOR_v20.02/string/aarch64/strchrnul-sve.S new file mode 100644 index 00000000000000..0a3a60bbece839 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strchrnul-sve.S @@ -0,0 +1,10 @@ +/* + * strchrnul - find a character or nul in a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#define BUILD_STRCHRNUL +#include "strchr-sve.S" diff --git a/libc/AOR_v20.02/string/aarch64/strchrnul.S b/libc/AOR_v20.02/string/aarch64/strchrnul.S new file mode 100644 index 00000000000000..50bd90c56922c8 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strchrnul.S @@ -0,0 +1,117 @@ +/* + * strchrnul - find a character or nul in a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64 + * Neon Available. + */ + +#include "../asmdefs.h" + +/* Arguments and results. */ +#define srcin x0 +#define chrin w1 + +#define result x0 + +#define src x2 +#define tmp1 x3 +#define wtmp2 w4 +#define tmp3 x5 + +#define vrepchr v0 +#define vdata1 v1 +#define vdata2 v2 +#define vhas_nul1 v3 +#define vhas_nul2 v4 +#define vhas_chr1 v5 +#define vhas_chr2 v6 +#define vrepmask v7 +#define vend1 v16 + +/* Core algorithm. + + For each 32-byte hunk we calculate a 64-bit syndrome value, with + two bits per byte (LSB is always in bits 0 and 1, for both big + and little-endian systems). For each tuple, bit 0 is set iff + the relevant byte matched the requested character or nul. Since the + bits in the syndrome reflect exactly the order in which things occur + in the original string a count_trailing_zeros() operation will + identify exactly which byte is causing the termination. */ + +/* Locals and temporaries. */ + +ENTRY (__strchrnul_aarch64) + /* Magic constant 0x40100401 to allow us to identify which lane + matches the termination condition. */ + mov wtmp2, #0x0401 + movk wtmp2, #0x4010, lsl #16 + dup vrepchr.16b, chrin + bic src, srcin, #31 /* Work with aligned 32-byte hunks. */ + dup vrepmask.4s, wtmp2 + ands tmp1, srcin, #31 + b.eq L(loop) + + /* Input string is not 32-byte aligned. Rather than forcing + the padding bytes to a safe value, we calculate the syndrome + for all the bytes, but then mask off those bits of the + syndrome that are related to the padding. */ + ld1 {vdata1.16b, vdata2.16b}, [src], #32 + neg tmp1, tmp1 + cmeq vhas_nul1.16b, vdata1.16b, #0 + cmeq vhas_chr1.16b, vdata1.16b, vrepchr.16b + cmeq vhas_nul2.16b, vdata2.16b, #0 + cmeq vhas_chr2.16b, vdata2.16b, vrepchr.16b + orr vhas_chr1.16b, vhas_chr1.16b, vhas_nul1.16b + orr vhas_chr2.16b, vhas_chr2.16b, vhas_nul2.16b + and vhas_chr1.16b, vhas_chr1.16b, vrepmask.16b + and vhas_chr2.16b, vhas_chr2.16b, vrepmask.16b + lsl tmp1, tmp1, #1 + addp vend1.16b, vhas_chr1.16b, vhas_chr2.16b // 256->128 + mov tmp3, #~0 + addp vend1.16b, vend1.16b, vend1.16b // 128->64 + lsr tmp1, tmp3, tmp1 + + mov tmp3, vend1.d[0] + bic tmp1, tmp3, tmp1 // Mask padding bits. + cbnz tmp1, L(tail) + +L(loop): + ld1 {vdata1.16b, vdata2.16b}, [src], #32 + cmeq vhas_nul1.16b, vdata1.16b, #0 + cmeq vhas_chr1.16b, vdata1.16b, vrepchr.16b + cmeq vhas_nul2.16b, vdata2.16b, #0 + cmeq vhas_chr2.16b, vdata2.16b, vrepchr.16b + /* Use a fast check for the termination condition. */ + orr vhas_chr1.16b, vhas_nul1.16b, vhas_chr1.16b + orr vhas_chr2.16b, vhas_nul2.16b, vhas_chr2.16b + orr vend1.16b, vhas_chr1.16b, vhas_chr2.16b + addp vend1.2d, vend1.2d, vend1.2d + mov tmp1, vend1.d[0] + cbz tmp1, L(loop) + + /* Termination condition found. Now need to establish exactly why + we terminated. */ + and vhas_chr1.16b, vhas_chr1.16b, vrepmask.16b + and vhas_chr2.16b, vhas_chr2.16b, vrepmask.16b + addp vend1.16b, vhas_chr1.16b, vhas_chr2.16b // 256->128 + addp vend1.16b, vend1.16b, vend1.16b // 128->64 + + mov tmp1, vend1.d[0] +L(tail): + /* Count the trailing zeros, by bit reversing... */ + rbit tmp1, tmp1 + /* Re-bias source. */ + sub src, src, #32 + clz tmp1, tmp1 /* ... and counting the leading zeros. */ + /* tmp1 is twice the offset into the fragment. */ + add result, src, tmp1, lsr #1 + ret + +END (__strchrnul_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/strcmp-sve.S b/libc/AOR_v20.02/string/aarch64/strcmp-sve.S new file mode 100644 index 00000000000000..35aac0b7d0d2aa --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strcmp-sve.S @@ -0,0 +1,60 @@ +/* + * __strcmp_aarch64_sve - compare two strings + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + + .globl __strcmp_aarch64_sve + .type __strcmp_aarch64_sve, %function + .p2align 4 +__strcmp_aarch64_sve: + setffr /* initialize FFR */ + ptrue p1.b, all /* all ones; loop invariant */ + mov x2, 0 /* initialize offset */ + nop + + /* Read a vector's worth of bytes, stopping on first fault. */ +0: ldff1b z0.b, p1/z, [x0, x2] + ldff1b z1.b, p1/z, [x1, x2] + rdffrs p0.b, p1/z + b.nlast 2f + + /* First fault did not fail: the whole vector is valid. + Avoid depending on the contents of FFR beyond the branch. */ + incb x2, all /* skip bytes for next round */ + cmpeq p2.b, p1/z, z0.b, z1.b /* compare strings */ + cmpne p3.b, p1/z, z0.b, 0 /* search for ~zero */ + nands p2.b, p1/z, p2.b, p3.b /* ~(eq & ~zero) -> ne | zero */ + b.none 0b + + /* Found end-of-string or inequality. */ +1: brkb p2.b, p1/z, p2.b /* find first such */ + lasta w0, p2, z0.b /* extract each char */ + lasta w1, p2, z1.b + sub x0, x0, x1 /* return comparison */ + ret + + /* First fault failed: only some of the vector is valid. + Perform the comparison only on the valid bytes. */ +2: incp x2, p0.b /* skip bytes for next round */ + setffr /* re-init FFR for next round */ + cmpeq p2.b, p0/z, z0.b, z1.b /* compare strings, as above */ + cmpne p3.b, p0/z, z0.b, 0 + nands p2.b, p0/z, p2.b, p3.b + b.none 0b + b 1b + + .size __strcmp_aarch64_sve, . - __strcmp_aarch64_sve +#endif diff --git a/libc/AOR_v20.02/string/aarch64/strcmp.S b/libc/AOR_v20.02/string/aarch64/strcmp.S new file mode 100644 index 00000000000000..0dc5031e732654 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strcmp.S @@ -0,0 +1,171 @@ +/* + * strcmp - compare two strings + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64 + */ + +#include "../asmdefs.h" + +#define REP8_01 0x0101010101010101 +#define REP8_7f 0x7f7f7f7f7f7f7f7f +#define REP8_80 0x8080808080808080 + +/* Parameters and result. */ +#define src1 x0 +#define src2 x1 +#define result x0 + +/* Internal variables. */ +#define data1 x2 +#define data1w w2 +#define data2 x3 +#define data2w w3 +#define has_nul x4 +#define diff x5 +#define syndrome x6 +#define tmp1 x7 +#define tmp2 x8 +#define tmp3 x9 +#define zeroones x10 +#define pos x11 + + /* Start of performance-critical section -- one 64B cache line. */ +ENTRY (__strcmp_aarch64) + eor tmp1, src1, src2 + mov zeroones, #REP8_01 + tst tmp1, #7 + b.ne L(misaligned8) + ands tmp1, src1, #7 + b.ne L(mutual_align) + /* NUL detection works on the principle that (X - 1) & (~X) & 0x80 + (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and + can be done in parallel across the entire word. */ +L(loop_aligned): + ldr data1, [src1], #8 + ldr data2, [src2], #8 +L(start_realigned): + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + eor diff, data1, data2 /* Non-zero if differences found. */ + bic has_nul, tmp1, tmp2 /* Non-zero if NUL terminator. */ + orr syndrome, diff, has_nul + cbz syndrome, L(loop_aligned) + /* End of performance-critical section -- one 64B cache line. */ + +L(end): +#ifndef __AARCH64EB__ + rev syndrome, syndrome + rev data1, data1 + /* The MS-non-zero bit of the syndrome marks either the first bit + that is different, or the top bit of the first zero byte. + Shifting left now will bring the critical information into the + top bits. */ + clz pos, syndrome + rev data2, data2 + lsl data1, data1, pos + lsl data2, data2, pos + /* But we need to zero-extend (char is unsigned) the value and then + perform a signed 32-bit subtraction. */ + lsr data1, data1, #56 + sub result, data1, data2, lsr #56 + ret +#else + /* For big-endian we cannot use the trick with the syndrome value + as carry-propagation can corrupt the upper bits if the trailing + bytes in the string contain 0x01. */ + /* However, if there is no NUL byte in the dword, we can generate + the result directly. We can't just subtract the bytes as the + MSB might be significant. */ + cbnz has_nul, 1f + cmp data1, data2 + cset result, ne + cneg result, result, lo + ret +1: + /* Re-compute the NUL-byte detection, using a byte-reversed value. */ + rev tmp3, data1 + sub tmp1, tmp3, zeroones + orr tmp2, tmp3, #REP8_7f + bic has_nul, tmp1, tmp2 + rev has_nul, has_nul + orr syndrome, diff, has_nul + clz pos, syndrome + /* The MS-non-zero bit of the syndrome marks either the first bit + that is different, or the top bit of the first zero byte. + Shifting left now will bring the critical information into the + top bits. */ + lsl data1, data1, pos + lsl data2, data2, pos + /* But we need to zero-extend (char is unsigned) the value and then + perform a signed 32-bit subtraction. */ + lsr data1, data1, #56 + sub result, data1, data2, lsr #56 + ret +#endif + +L(mutual_align): + /* Sources are mutually aligned, but are not currently at an + alignment boundary. Round down the addresses and then mask off + the bytes that preceed the start point. */ + bic src1, src1, #7 + bic src2, src2, #7 + lsl tmp1, tmp1, #3 /* Bytes beyond alignment -> bits. */ + ldr data1, [src1], #8 + neg tmp1, tmp1 /* Bits to alignment -64. */ + ldr data2, [src2], #8 + mov tmp2, #~0 +#ifdef __AARCH64EB__ + /* Big-endian. Early bytes are at MSB. */ + lsl tmp2, tmp2, tmp1 /* Shift (tmp1 & 63). */ +#else + /* Little-endian. Early bytes are at LSB. */ + lsr tmp2, tmp2, tmp1 /* Shift (tmp1 & 63). */ +#endif + orr data1, data1, tmp2 + orr data2, data2, tmp2 + b L(start_realigned) + +L(misaligned8): + /* Align SRC1 to 8 bytes and then compare 8 bytes at a time, always + checking to make sure that we don't access beyond page boundary in + SRC2. */ + tst src1, #7 + b.eq L(loop_misaligned) +L(do_misaligned): + ldrb data1w, [src1], #1 + ldrb data2w, [src2], #1 + cmp data1w, #1 + ccmp data1w, data2w, #0, cs /* NZCV = 0b0000. */ + b.ne L(done) + tst src1, #7 + b.ne L(do_misaligned) + +L(loop_misaligned): + /* Test if we are within the last dword of the end of a 4K page. If + yes then jump back to the misaligned loop to copy a byte at a time. */ + and tmp1, src2, #0xff8 + eor tmp1, tmp1, #0xff8 + cbz tmp1, L(do_misaligned) + ldr data1, [src1], #8 + ldr data2, [src2], #8 + + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + eor diff, data1, data2 /* Non-zero if differences found. */ + bic has_nul, tmp1, tmp2 /* Non-zero if NUL terminator. */ + orr syndrome, diff, has_nul + cbz syndrome, L(loop_misaligned) + b L(end) + +L(done): + sub result, data1, data2 + ret + +END (__strcmp_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/strcpy-sve.S b/libc/AOR_v20.02/string/aarch64/strcpy-sve.S new file mode 100644 index 00000000000000..43e7621b6261cd --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strcpy-sve.S @@ -0,0 +1,72 @@ +/* + * strcpy/stpcpy - copy a string returning pointer to start/end. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + +/* To build as stpcpy, define BUILD_STPCPY before compiling this file. */ +#ifdef BUILD_STPCPY +#define FUNC __stpcpy_aarch64_sve +#else +#define FUNC __strcpy_aarch64_sve +#endif + + .globl FUNC + .type FUNC, %function + .p2align 4 +FUNC: + setffr /* initialize FFR */ + ptrue p2.b, all /* all ones; loop invariant */ + mov x2, 0 /* initialize offset */ + + .p2align 4 + /* Read a vector's worth of bytes, stopping on first fault. */ +0: ldff1b z0.b, p2/z, [x1, x2] + rdffrs p0.b, p2/z + b.nlast 1f + + /* First fault did not fail: the whole vector is valid. + Avoid depending on the contexts of FFR beyond the branch. */ + cmpeq p1.b, p2/z, z0.b, 0 /* search for zeros */ + b.any 2f + + /* No zero found. Store the whole vector and loop. */ + st1b z0.b, p2, [x0, x2] + incb x2, all + b 0b + + /* First fault failed: only some of the vector is valid. + Perform the comparison only on the valid bytes. */ +1: cmpeq p1.b, p0/z, z0.b, 0 /* search for zeros */ + b.any 2f + + /* No zero found. Store the valid portion of the vector and loop. */ + setffr /* re-init FFR */ + st1b z0.b, p0, [x0, x2] + incp x2, p0.b + b 0b + + /* Zero found. Crop the vector to the found zero and finish. */ +2: brka p0.b, p2/z, p1.b + st1b z0.b, p0, [x0, x2] +#ifdef BUILD_STPCPY + add x0, x0, x2 + sub x0, x0, 1 + incp x0, p0.b +#endif + ret + + .size FUNC, . - FUNC +#endif diff --git a/libc/AOR_v20.02/string/aarch64/strcpy.S b/libc/AOR_v20.02/string/aarch64/strcpy.S new file mode 100644 index 00000000000000..dde9afbb7fb18c --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strcpy.S @@ -0,0 +1,309 @@ +/* + * strcpy/stpcpy - copy a string returning pointer to start/end. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64, unaligned accesses, min page size 4k. + */ + +#include "../asmdefs.h" + +/* To build as stpcpy, define BUILD_STPCPY before compiling this file. + + To test the page crossing code path more thoroughly, compile with + -DSTRCPY_TEST_PAGE_CROSS - this will force all copies through the slower + entry path. This option is not intended for production use. */ + +/* Arguments and results. */ +#define dstin x0 +#define srcin x1 + +/* Locals and temporaries. */ +#define src x2 +#define dst x3 +#define data1 x4 +#define data1w w4 +#define data2 x5 +#define data2w w5 +#define has_nul1 x6 +#define has_nul2 x7 +#define tmp1 x8 +#define tmp2 x9 +#define tmp3 x10 +#define tmp4 x11 +#define zeroones x12 +#define data1a x13 +#define data2a x14 +#define pos x15 +#define len x16 +#define to_align x17 + +#ifdef BUILD_STPCPY +#define STRCPY __stpcpy_aarch64 +#else +#define STRCPY __strcpy_aarch64 +#endif + + /* NUL detection works on the principle that (X - 1) & (~X) & 0x80 + (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and + can be done in parallel across the entire word. */ + +#define REP8_01 0x0101010101010101 +#define REP8_7f 0x7f7f7f7f7f7f7f7f +#define REP8_80 0x8080808080808080 + + /* AArch64 systems have a minimum page size of 4k. We can do a quick + page size check for crossing this boundary on entry and if we + do not, then we can short-circuit much of the entry code. We + expect early page-crossing strings to be rare (probability of + 16/MIN_PAGE_SIZE ~= 0.4%), so the branch should be quite + predictable, even with random strings. + + We don't bother checking for larger page sizes, the cost of setting + up the correct page size is just not worth the extra gain from + a small reduction in the cases taking the slow path. Note that + we only care about whether the first fetch, which may be + misaligned, crosses a page boundary - after that we move to aligned + fetches for the remainder of the string. */ + +#ifdef STRCPY_TEST_PAGE_CROSS + /* Make everything that isn't Qword aligned look like a page cross. */ +#define MIN_PAGE_P2 4 +#else +#define MIN_PAGE_P2 12 +#endif + +#define MIN_PAGE_SIZE (1 << MIN_PAGE_P2) + +ENTRY (STRCPY) + /* For moderately short strings, the fastest way to do the copy is to + calculate the length of the string in the same way as strlen, then + essentially do a memcpy of the result. This avoids the need for + multiple byte copies and further means that by the time we + reach the bulk copy loop we know we can always use DWord + accesses. We expect __strcpy_aarch64 to rarely be called repeatedly + with the same source string, so branch prediction is likely to + always be difficult - we mitigate against this by preferring + conditional select operations over branches whenever this is + feasible. */ + and tmp2, srcin, #(MIN_PAGE_SIZE - 1) + mov zeroones, #REP8_01 + and to_align, srcin, #15 + cmp tmp2, #(MIN_PAGE_SIZE - 16) + neg tmp1, to_align + /* The first fetch will straddle a (possible) page boundary iff + srcin + 15 causes bit[MIN_PAGE_P2] to change value. A 16-byte + aligned string will never fail the page align check, so will + always take the fast path. */ + b.gt L(page_cross) + +L(page_cross_ok): + ldp data1, data2, [srcin] +#ifdef __AARCH64EB__ + /* Because we expect the end to be found within 16 characters + (profiling shows this is the most common case), it's worth + swapping the bytes now to save having to recalculate the + termination syndrome later. We preserve data1 and data2 + so that we can re-use the values later on. */ + rev tmp2, data1 + sub tmp1, tmp2, zeroones + orr tmp2, tmp2, #REP8_7f + bics has_nul1, tmp1, tmp2 + b.ne L(fp_le8) + rev tmp4, data2 + sub tmp3, tmp4, zeroones + orr tmp4, tmp4, #REP8_7f +#else + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + bics has_nul1, tmp1, tmp2 + b.ne L(fp_le8) + sub tmp3, data2, zeroones + orr tmp4, data2, #REP8_7f +#endif + bics has_nul2, tmp3, tmp4 + b.eq L(bulk_entry) + + /* The string is short (<=16 bytes). We don't know exactly how + short though, yet. Work out the exact length so that we can + quickly select the optimal copy strategy. */ +L(fp_gt8): + rev has_nul2, has_nul2 + clz pos, has_nul2 + mov tmp2, #56 + add dst, dstin, pos, lsr #3 /* Bits to bytes. */ + sub pos, tmp2, pos +#ifdef __AARCH64EB__ + lsr data2, data2, pos +#else + lsl data2, data2, pos +#endif + str data2, [dst, #1] + str data1, [dstin] +#ifdef BUILD_STPCPY + add dstin, dst, #8 +#endif + ret + +L(fp_le8): + rev has_nul1, has_nul1 + clz pos, has_nul1 + add dst, dstin, pos, lsr #3 /* Bits to bytes. */ + subs tmp2, pos, #24 /* Pos in bits. */ + b.lt L(fp_lt4) +#ifdef __AARCH64EB__ + mov tmp2, #56 + sub pos, tmp2, pos + lsr data2, data1, pos + lsr data1, data1, #32 +#else + lsr data2, data1, tmp2 +#endif + /* 4->7 bytes to copy. */ + str data2w, [dst, #-3] + str data1w, [dstin] +#ifdef BUILD_STPCPY + mov dstin, dst +#endif + ret +L(fp_lt4): + cbz pos, L(fp_lt2) + /* 2->3 bytes to copy. */ +#ifdef __AARCH64EB__ + lsr data1, data1, #48 +#endif + strh data1w, [dstin] + /* Fall-through, one byte (max) to go. */ +L(fp_lt2): + /* Null-terminated string. Last character must be zero! */ + strb wzr, [dst] +#ifdef BUILD_STPCPY + mov dstin, dst +#endif + ret + + .p2align 6 + /* Aligning here ensures that the entry code and main loop all lies + within one 64-byte cache line. */ +L(bulk_entry): + sub to_align, to_align, #16 + stp data1, data2, [dstin] + sub src, srcin, to_align + sub dst, dstin, to_align + b L(entry_no_page_cross) + + /* The inner loop deals with two Dwords at a time. This has a + slightly higher start-up cost, but we should win quite quickly, + especially on cores with a high number of issue slots per + cycle, as we get much better parallelism out of the operations. */ +L(main_loop): + stp data1, data2, [dst], #16 +L(entry_no_page_cross): + ldp data1, data2, [src], #16 + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, #REP8_7f + bic has_nul1, tmp1, tmp2 + bics has_nul2, tmp3, tmp4 + ccmp has_nul1, #0, #0, eq /* NZCV = 0000 */ + b.eq L(main_loop) + + /* Since we know we are copying at least 16 bytes, the fastest way + to deal with the tail is to determine the location of the + trailing NUL, then (re)copy the 16 bytes leading up to that. */ + cmp has_nul1, #0 +#ifdef __AARCH64EB__ + /* For big-endian, carry propagation (if the final byte in the + string is 0x01) means we cannot use has_nul directly. The + easiest way to get the correct byte is to byte-swap the data + and calculate the syndrome a second time. */ + csel data1, data1, data2, ne + rev data1, data1 + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + bic has_nul1, tmp1, tmp2 +#else + csel has_nul1, has_nul1, has_nul2, ne +#endif + rev has_nul1, has_nul1 + clz pos, has_nul1 + add tmp1, pos, #72 + add pos, pos, #8 + csel pos, pos, tmp1, ne + add src, src, pos, lsr #3 + add dst, dst, pos, lsr #3 + ldp data1, data2, [src, #-32] + stp data1, data2, [dst, #-16] +#ifdef BUILD_STPCPY + sub dstin, dst, #1 +#endif + ret + +L(page_cross): + bic src, srcin, #15 + /* Start by loading two words at [srcin & ~15], then forcing the + bytes that precede srcin to 0xff. This means they never look + like termination bytes. */ + ldp data1, data2, [src] + lsl tmp1, tmp1, #3 /* Bytes beyond alignment -> bits. */ + tst to_align, #7 + csetm tmp2, ne +#ifdef __AARCH64EB__ + lsl tmp2, tmp2, tmp1 /* Shift (tmp1 & 63). */ +#else + lsr tmp2, tmp2, tmp1 /* Shift (tmp1 & 63). */ +#endif + orr data1, data1, tmp2 + orr data2a, data2, tmp2 + cmp to_align, #8 + csinv data1, data1, xzr, lt + csel data2, data2, data2a, lt + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, #REP8_7f + bic has_nul1, tmp1, tmp2 + bics has_nul2, tmp3, tmp4 + ccmp has_nul1, #0, #0, eq /* NZCV = 0000 */ + b.eq L(page_cross_ok) + /* We now need to make data1 and data2 look like they've been + loaded directly from srcin. Do a rotate on the 128-bit value. */ + lsl tmp1, to_align, #3 /* Bytes->bits. */ + neg tmp2, to_align, lsl #3 +#ifdef __AARCH64EB__ + lsl data1a, data1, tmp1 + lsr tmp4, data2, tmp2 + lsl data2, data2, tmp1 + orr tmp4, tmp4, data1a + cmp to_align, #8 + csel data1, tmp4, data2, lt + rev tmp2, data1 + rev tmp4, data2 + sub tmp1, tmp2, zeroones + orr tmp2, tmp2, #REP8_7f + sub tmp3, tmp4, zeroones + orr tmp4, tmp4, #REP8_7f +#else + lsr data1a, data1, tmp1 + lsl tmp4, data2, tmp2 + lsr data2, data2, tmp1 + orr tmp4, tmp4, data1a + cmp to_align, #8 + csel data1, tmp4, data2, lt + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, #REP8_7f +#endif + bic has_nul1, tmp1, tmp2 + cbnz has_nul1, L(fp_le8) + bic has_nul2, tmp3, tmp4 + b L(fp_gt8) + +END (STRCPY) diff --git a/libc/AOR_v20.02/string/aarch64/strlen-mte.S b/libc/AOR_v20.02/string/aarch64/strlen-mte.S new file mode 100644 index 00000000000000..8037abff865cdf --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strlen-mte.S @@ -0,0 +1,186 @@ +/* + * strlen - calculate the length of a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64. + */ + +#include "../asmdefs.h" + +/* Arguments and results. */ +#define srcin x0 +#define len x0 + +/* Locals and temporaries. */ +#define src x1 +#define data1 x2 +#define data2 x3 +#define has_nul1 x4 +#define has_nul2 x5 +#define tmp1 x4 +#define tmp2 x5 +#define tmp3 x6 +#define tmp4 x7 +#define zeroones x8 +#define offset x9 + + /* NUL detection works on the principle that (X - 1) & (~X) & 0x80 + (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and + can be done in parallel across the entire word. A faster check + (X - 1) & 0x80 is zero for non-NUL ASCII characters, but gives + false hits for characters 129..255. */ + +#define REP8_01 0x0101010101010101 +#define REP8_7f 0x7f7f7f7f7f7f7f7f + + /* This implementation is compatible with Memory Tagging. All loads + are 16 bytes in size and 16 bytes aligned. This also avoids the + need for page boundary checks. This implementation is correct + even without Memory Tagging, but other implementations could be + more beneficial if Memory Tagging is not enabled. + + First load is aligned down and can contain bytes that are located + before the string. This is handled by modifying the "zeroones" + mask. The bytes that need to be ignored are set to zero. + If the string is aligned in such a way that 8 or more bytes from + the first load should be ignored, there is a special case + (skip_first_8_bytes) which only compares the second 8 bytes. + + If there is a NUL byte in the first load, we calculate the length + from the 2 8-byte words using conditional select to reduce branch + mispredictions. + + If the string is longer than 16 bytes, we check 32 bytes per + iteration using the fast NUL check (main_loop). If we encounter + non-ASCII characters, we fallback to a second loop + (nonascii_loop) using the full NUL check. */ + +ENTRY(__strlen_aarch64_mte) + bic src, srcin, 15 /* Align down to 16 bytes. */ + mov zeroones, REP8_01 + /* (offset & 63) holds number of bits to ignore in a register.*/ + lsl offset, srcin, 3 + ldp data1, data2, [src], -16 + lsl tmp1, zeroones, offset /* Shift (offset & 63). */ +#ifdef __AARCH64EB__ + /* For big-endian, carry propagation (if the final byte in the + string is 0x01) means we cannot use has_nul1/2 directly. + e.g. 0x0100 - 0x0101 = 0xffff, so 0x01 will be mistaken for NUL. + Since we expect strings to be small and early-exit, + byte-swap the data now so has_null1/2 will be correct. */ + rev data1, data1 + rev data2, data2 +#endif + tbnz srcin, 3, L(skip_first_8_bytes) + sub tmp1, data1, tmp1 + orr tmp2, data1, REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + /* If comparison happens, C flag is always set. */ + ccmp has_nul2, 0, 0, eq + beq L(main_loop) + + /* Enter with C = has_nul1 == 0. */ + csel has_nul1, has_nul1, has_nul2, cc + and tmp2, srcin, 7 /* Bytes to ignore. */ + rev has_nul1, has_nul1 + neg tmp2, tmp2 + clz tmp1, has_nul1 /* Count bits before NUL. */ + /* Add 8 if NUL byte is not in first register. */ + add tmp3, tmp2, 8 + csel len, tmp2, tmp3, cc + add len, len, tmp1, lsr 3 + ret + +L(skip_first_8_bytes): + sub tmp1, data2, tmp1 + orr tmp2, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + beq L(main_loop) + + rev has_nul1, has_nul1 + lsl tmp1, has_nul1, offset /* Ignore bytes before string. */ + clz tmp1, tmp1 /* Count bits before NUL. */ + lsr len, tmp1, 3 + ret + + /* The inner loop processes 32 bytes per iteration and uses the fast + NUL check. If we encounter non-ASCII characters, use a second + loop with the accurate NUL check. */ + .p2align 4 +L(main_loop): + ldp data1, data2, [src, 32]! + sub tmp1, data1, zeroones + sub tmp3, data2, zeroones + orr tmp2, tmp1, tmp3 + tst tmp2, zeroones, lsl 7 + bne 1f + ldp data1, data2, [src, 16] + sub tmp1, data1, zeroones + sub tmp3, data2, zeroones + orr tmp2, tmp1, tmp3 + tst tmp2, zeroones, lsl 7 + beq L(main_loop) + add src, src, 16 +1: + /* The fast check failed, so do the slower, accurate NUL check. */ + orr tmp2, data1, REP8_7f + orr tmp4, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + ccmp has_nul2, 0, 0, eq + beq L(nonascii_loop) + + /* Enter with C = has_nul1 == 0. */ +L(tail): +#ifdef __AARCH64EB__ + /* For big-endian, carry propagation (if the final byte in the + string is 0x01) means we cannot use has_nul1/2 directly. The + easiest way to get the correct byte is to byte-swap the data + and calculate the syndrome a second time. */ + csel data1, data1, data2, cc + rev data1, data1 + sub tmp1, data1, zeroones + orr tmp2, data1, REP8_7f + bic has_nul1, tmp1, tmp2 +#else + csel has_nul1, has_nul1, has_nul2, cc +#endif + sub len, src, srcin + rev has_nul1, has_nul1 + add tmp2, len, 8 + clz tmp1, has_nul1 + csel len, len, tmp2, cc + add len, len, tmp1, lsr 3 + ret + +L(nonascii_loop): + ldp data1, data2, [src, 16]! + sub tmp1, data1, zeroones + orr tmp2, data1, REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + ccmp has_nul2, 0, 0, eq + bne L(tail) + ldp data1, data2, [src, 16]! + sub tmp1, data1, zeroones + orr tmp2, data1, REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + ccmp has_nul2, 0, 0, eq + beq L(nonascii_loop) + b L(tail) + +END(__strlen_aarch64_mte) diff --git a/libc/AOR_v20.02/string/aarch64/strlen-sve.S b/libc/AOR_v20.02/string/aarch64/strlen-sve.S new file mode 100644 index 00000000000000..88bf0ee91bcdf2 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strlen-sve.S @@ -0,0 +1,58 @@ +/* + * __strlen_aarch64_sve - compute the length of a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + + .globl __strlen_aarch64_sve + .type __strlen_aarch64_sve, %function + .p2align 4 +__strlen_aarch64_sve: + setffr /* initialize FFR */ + ptrue p2.b /* all ones; loop invariant */ + mov x1, 0 /* initialize length */ + nop + + /* Read a vector's worth of bytes, stopping on first fault. */ +0: ldff1b z0.b, p2/z, [x0, x1] + nop + rdffrs p0.b, p2/z + b.nlast 2f + + /* First fault did not fail: the whole vector is valid. + Avoid depending on the contents of FFR beyond the branch. */ + incb x1, all /* speculate increment */ + cmpeq p1.b, p2/z, z0.b, 0 /* loop if no zeros */ + b.none 0b + decb x1, all /* undo speculate */ + + /* Zero found. Select the bytes before the first and count them. */ +1: brkb p0.b, p2/z, p1.b + incp x1, p0.b + mov x0, x1 + ret + + /* First fault failed: only some of the vector is valid. + Perform the comparison only on the valid bytes. */ +2: cmpeq p1.b, p0/z, z0.b, 0 + b.any 1b + + /* No zero found. Re-init FFR, increment, and loop. */ + setffr + incp x1, p0.b + b 0b + + .size __strlen_aarch64_sve, . - __strlen_aarch64_sve +#endif diff --git a/libc/AOR_v20.02/string/aarch64/strlen.S b/libc/AOR_v20.02/string/aarch64/strlen.S new file mode 100644 index 00000000000000..2d560db2cfba1f --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strlen.S @@ -0,0 +1,207 @@ +/* + * strlen - calculate the length of a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64, unaligned accesses, min page size 4k. + */ + +#include "../asmdefs.h" + +/* To test the page crossing code path more thoroughly, compile with + -DTEST_PAGE_CROSS - this will force all calls through the slower + entry path. This option is not intended for production use. */ + +/* Arguments and results. */ +#define srcin x0 +#define len x0 + +/* Locals and temporaries. */ +#define src x1 +#define data1 x2 +#define data2 x3 +#define has_nul1 x4 +#define has_nul2 x5 +#define tmp1 x4 +#define tmp2 x5 +#define tmp3 x6 +#define tmp4 x7 +#define zeroones x8 + + /* NUL detection works on the principle that (X - 1) & (~X) & 0x80 + (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and + can be done in parallel across the entire word. A faster check + (X - 1) & 0x80 is zero for non-NUL ASCII characters, but gives + false hits for characters 129..255. */ + +#define REP8_01 0x0101010101010101 +#define REP8_7f 0x7f7f7f7f7f7f7f7f +#define REP8_80 0x8080808080808080 + +#ifdef TEST_PAGE_CROSS +# define MIN_PAGE_SIZE 15 +#else +# define MIN_PAGE_SIZE 4096 +#endif + + /* Since strings are short on average, we check the first 16 bytes + of the string for a NUL character. In order to do an unaligned ldp + safely we have to do a page cross check first. If there is a NUL + byte we calculate the length from the 2 8-byte words using + conditional select to reduce branch mispredictions (it is unlikely + __strlen_aarch64 will be repeatedly called on strings with the same length). + + If the string is longer than 16 bytes, we align src so don't need + further page cross checks, and process 32 bytes per iteration + using the fast NUL check. If we encounter non-ASCII characters, + fallback to a second loop using the full NUL check. + + If the page cross check fails, we read 16 bytes from an aligned + address, remove any characters before the string, and continue + in the main loop using aligned loads. Since strings crossing a + page in the first 16 bytes are rare (probability of + 16/MIN_PAGE_SIZE ~= 0.4%), this case does not need to be optimized. + + AArch64 systems have a minimum page size of 4k. We don't bother + checking for larger page sizes - the cost of setting up the correct + page size is just not worth the extra gain from a small reduction in + the cases taking the slow path. Note that we only care about + whether the first fetch, which may be misaligned, crosses a page + boundary. */ + +ENTRY (__strlen_aarch64) + and tmp1, srcin, MIN_PAGE_SIZE - 1 + mov zeroones, REP8_01 + cmp tmp1, MIN_PAGE_SIZE - 16 + b.gt L(page_cross) + ldp data1, data2, [srcin] +#ifdef __AARCH64EB__ + /* For big-endian, carry propagation (if the final byte in the + string is 0x01) means we cannot use has_nul1/2 directly. + Since we expect strings to be small and early-exit, + byte-swap the data now so has_null1/2 will be correct. */ + rev data1, data1 + rev data2, data2 +#endif + sub tmp1, data1, zeroones + orr tmp2, data1, REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + ccmp has_nul2, 0, 0, eq + beq L(main_loop_entry) + + /* Enter with C = has_nul1 == 0. */ + csel has_nul1, has_nul1, has_nul2, cc + mov len, 8 + rev has_nul1, has_nul1 + clz tmp1, has_nul1 + csel len, xzr, len, cc + add len, len, tmp1, lsr 3 + ret + + /* The inner loop processes 32 bytes per iteration and uses the fast + NUL check. If we encounter non-ASCII characters, use a second + loop with the accurate NUL check. */ + .p2align 4 +L(main_loop_entry): + bic src, srcin, 15 + sub src, src, 16 +L(main_loop): + ldp data1, data2, [src, 32]! +L(page_cross_entry): + sub tmp1, data1, zeroones + sub tmp3, data2, zeroones + orr tmp2, tmp1, tmp3 + tst tmp2, zeroones, lsl 7 + bne 1f + ldp data1, data2, [src, 16] + sub tmp1, data1, zeroones + sub tmp3, data2, zeroones + orr tmp2, tmp1, tmp3 + tst tmp2, zeroones, lsl 7 + beq L(main_loop) + add src, src, 16 +1: + /* The fast check failed, so do the slower, accurate NUL check. */ + orr tmp2, data1, REP8_7f + orr tmp4, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + ccmp has_nul2, 0, 0, eq + beq L(nonascii_loop) + + /* Enter with C = has_nul1 == 0. */ +L(tail): +#ifdef __AARCH64EB__ + /* For big-endian, carry propagation (if the final byte in the + string is 0x01) means we cannot use has_nul1/2 directly. The + easiest way to get the correct byte is to byte-swap the data + and calculate the syndrome a second time. */ + csel data1, data1, data2, cc + rev data1, data1 + sub tmp1, data1, zeroones + orr tmp2, data1, REP8_7f + bic has_nul1, tmp1, tmp2 +#else + csel has_nul1, has_nul1, has_nul2, cc +#endif + sub len, src, srcin + rev has_nul1, has_nul1 + add tmp2, len, 8 + clz tmp1, has_nul1 + csel len, len, tmp2, cc + add len, len, tmp1, lsr 3 + ret + +L(nonascii_loop): + ldp data1, data2, [src, 16]! + sub tmp1, data1, zeroones + orr tmp2, data1, REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + ccmp has_nul2, 0, 0, eq + bne L(tail) + ldp data1, data2, [src, 16]! + sub tmp1, data1, zeroones + orr tmp2, data1, REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, REP8_7f + bics has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + ccmp has_nul2, 0, 0, eq + beq L(nonascii_loop) + b L(tail) + + /* Load 16 bytes from [srcin & ~15] and force the bytes that precede + srcin to 0x7f, so we ignore any NUL bytes before the string. + Then continue in the aligned loop. */ +L(page_cross): + bic src, srcin, 15 + ldp data1, data2, [src] + lsl tmp1, srcin, 3 + mov tmp4, -1 +#ifdef __AARCH64EB__ + /* Big-endian. Early bytes are at MSB. */ + lsr tmp1, tmp4, tmp1 /* Shift (tmp1 & 63). */ +#else + /* Little-endian. Early bytes are at LSB. */ + lsl tmp1, tmp4, tmp1 /* Shift (tmp1 & 63). */ +#endif + orr tmp1, tmp1, REP8_80 + orn data1, data1, tmp1 + orn tmp2, data2, tmp1 + tst srcin, 8 + csel data1, data1, tmp4, eq + csel data2, data2, tmp2, eq + b L(page_cross_entry) + +END (__strlen_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/strncmp-sve.S b/libc/AOR_v20.02/string/aarch64/strncmp-sve.S new file mode 100644 index 00000000000000..f5d4f95fdf0fa4 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strncmp-sve.S @@ -0,0 +1,69 @@ +/* + * strncmp - compare two strings with limit + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + + .globl __strncmp_aarch64_sve + .type __strncmp_aarch64_sve, %function + .p2align 4 +__strncmp_aarch64_sve: + setffr /* initialize FFR */ + mov x3, 0 /* initialize off */ + +0: whilelo p0.b, x3, x2 /* while off < max */ + b.none 9f + + ldff1b z0.b, p0/z, [x0, x3] + ldff1b z1.b, p0/z, [x1, x3] + rdffrs p1.b, p0/z + b.nlast 2f + + /* First fault did not fail: the vector up to max is valid. + Avoid depending on the contents of FFR beyond the branch. + Increment for a whole vector, even if we've only read a partial. + This is significantly cheaper than INCP, and since OFF is not + used after the loop it is ok to increment OFF past MAX. */ + incb x3 + cmpeq p1.b, p0/z, z0.b, z1.b /* compare strings */ + cmpne p2.b, p0/z, z0.b, 0 /* search for ~zero */ + nands p2.b, p0/z, p1.b, p2.b /* ~(eq & ~zero) -> ne | zero */ + b.none 0b + + /* Found end-of-string or inequality. */ +1: brkb p2.b, p0/z, p2.b /* find first such */ + lasta w0, p2, z0.b /* extract each char */ + lasta w1, p2, z1.b + sub x0, x0, x1 /* return comparison */ + ret + + /* First fault failed: only some of the vector is valid. + Perform the comparison only on the valid bytes. */ +2: cmpeq p2.b, p1/z, z0.b, z1.b /* compare strings, as above */ + cmpne p3.b, p1/z, z0.b, 0 + nands p2.b, p1/z, p2.b, p3.b + b.any 1b + + /* No inequality or zero found. Re-init FFR, incr and loop. */ + setffr + incp x3, p1.b + b 0b + + /* Found end-of-count. */ +9: mov x0, 0 /* return equal */ + ret + + .size __strncmp_aarch64_sve, . - __strncmp_aarch64_sve +#endif diff --git a/libc/AOR_v20.02/string/aarch64/strncmp.S b/libc/AOR_v20.02/string/aarch64/strncmp.S new file mode 100644 index 00000000000000..d5a2752324e33e --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strncmp.S @@ -0,0 +1,262 @@ +/* + * strncmp - compare two strings + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64 + */ + +#include "../asmdefs.h" + +#define REP8_01 0x0101010101010101 +#define REP8_7f 0x7f7f7f7f7f7f7f7f +#define REP8_80 0x8080808080808080 + +/* Parameters and result. */ +#define src1 x0 +#define src2 x1 +#define limit x2 +#define result x0 + +/* Internal variables. */ +#define data1 x3 +#define data1w w3 +#define data2 x4 +#define data2w w4 +#define has_nul x5 +#define diff x6 +#define syndrome x7 +#define tmp1 x8 +#define tmp2 x9 +#define tmp3 x10 +#define zeroones x11 +#define pos x12 +#define limit_wd x13 +#define mask x14 +#define endloop x15 +#define count mask + + .text + .p2align 6 + .rep 7 + nop /* Pad so that the loop below fits a cache line. */ + .endr +ENTRY_ALIGN (__strncmp_aarch64, 0) + cbz limit, L(ret0) + eor tmp1, src1, src2 + mov zeroones, #REP8_01 + tst tmp1, #7 + and count, src1, #7 + b.ne L(misaligned8) + cbnz count, L(mutual_align) + /* Calculate the number of full and partial words -1. */ + sub limit_wd, limit, #1 /* limit != 0, so no underflow. */ + lsr limit_wd, limit_wd, #3 /* Convert to Dwords. */ + + /* NUL detection works on the principle that (X - 1) & (~X) & 0x80 + (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and + can be done in parallel across the entire word. */ + /* Start of performance-critical section -- one 64B cache line. */ +L(loop_aligned): + ldr data1, [src1], #8 + ldr data2, [src2], #8 +L(start_realigned): + subs limit_wd, limit_wd, #1 + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + eor diff, data1, data2 /* Non-zero if differences found. */ + csinv endloop, diff, xzr, pl /* Last Dword or differences. */ + bics has_nul, tmp1, tmp2 /* Non-zero if NUL terminator. */ + ccmp endloop, #0, #0, eq + b.eq L(loop_aligned) + /* End of performance-critical section -- one 64B cache line. */ + + /* Not reached the limit, must have found the end or a diff. */ + tbz limit_wd, #63, L(not_limit) + + /* Limit % 8 == 0 => all bytes significant. */ + ands limit, limit, #7 + b.eq L(not_limit) + + lsl limit, limit, #3 /* Bits -> bytes. */ + mov mask, #~0 +#ifdef __AARCH64EB__ + lsr mask, mask, limit +#else + lsl mask, mask, limit +#endif + bic data1, data1, mask + bic data2, data2, mask + + /* Make sure that the NUL byte is marked in the syndrome. */ + orr has_nul, has_nul, mask + +L(not_limit): + orr syndrome, diff, has_nul + +#ifndef __AARCH64EB__ + rev syndrome, syndrome + rev data1, data1 + /* The MS-non-zero bit of the syndrome marks either the first bit + that is different, or the top bit of the first zero byte. + Shifting left now will bring the critical information into the + top bits. */ + clz pos, syndrome + rev data2, data2 + lsl data1, data1, pos + lsl data2, data2, pos + /* But we need to zero-extend (char is unsigned) the value and then + perform a signed 32-bit subtraction. */ + lsr data1, data1, #56 + sub result, data1, data2, lsr #56 + ret +#else + /* For big-endian we cannot use the trick with the syndrome value + as carry-propagation can corrupt the upper bits if the trailing + bytes in the string contain 0x01. */ + /* However, if there is no NUL byte in the dword, we can generate + the result directly. We can't just subtract the bytes as the + MSB might be significant. */ + cbnz has_nul, 1f + cmp data1, data2 + cset result, ne + cneg result, result, lo + ret +1: + /* Re-compute the NUL-byte detection, using a byte-reversed value. */ + rev tmp3, data1 + sub tmp1, tmp3, zeroones + orr tmp2, tmp3, #REP8_7f + bic has_nul, tmp1, tmp2 + rev has_nul, has_nul + orr syndrome, diff, has_nul + clz pos, syndrome + /* The MS-non-zero bit of the syndrome marks either the first bit + that is different, or the top bit of the first zero byte. + Shifting left now will bring the critical information into the + top bits. */ + lsl data1, data1, pos + lsl data2, data2, pos + /* But we need to zero-extend (char is unsigned) the value and then + perform a signed 32-bit subtraction. */ + lsr data1, data1, #56 + sub result, data1, data2, lsr #56 + ret +#endif + +L(mutual_align): + /* Sources are mutually aligned, but are not currently at an + alignment boundary. Round down the addresses and then mask off + the bytes that precede the start point. + We also need to adjust the limit calculations, but without + overflowing if the limit is near ULONG_MAX. */ + bic src1, src1, #7 + bic src2, src2, #7 + ldr data1, [src1], #8 + neg tmp3, count, lsl #3 /* 64 - bits(bytes beyond align). */ + ldr data2, [src2], #8 + mov tmp2, #~0 + sub limit_wd, limit, #1 /* limit != 0, so no underflow. */ +#ifdef __AARCH64EB__ + /* Big-endian. Early bytes are at MSB. */ + lsl tmp2, tmp2, tmp3 /* Shift (count & 63). */ +#else + /* Little-endian. Early bytes are at LSB. */ + lsr tmp2, tmp2, tmp3 /* Shift (count & 63). */ +#endif + and tmp3, limit_wd, #7 + lsr limit_wd, limit_wd, #3 + /* Adjust the limit. Only low 3 bits used, so overflow irrelevant. */ + add limit, limit, count + add tmp3, tmp3, count + orr data1, data1, tmp2 + orr data2, data2, tmp2 + add limit_wd, limit_wd, tmp3, lsr #3 + b L(start_realigned) + + .p2align 6 + /* Don't bother with dwords for up to 16 bytes. */ +L(misaligned8): + cmp limit, #16 + b.hs L(try_misaligned_words) + +L(byte_loop): + /* Perhaps we can do better than this. */ + ldrb data1w, [src1], #1 + ldrb data2w, [src2], #1 + subs limit, limit, #1 + ccmp data1w, #1, #0, hi /* NZCV = 0b0000. */ + ccmp data1w, data2w, #0, cs /* NZCV = 0b0000. */ + b.eq L(byte_loop) +L(done): + sub result, data1, data2 + ret + /* Align the SRC1 to a dword by doing a bytewise compare and then do + the dword loop. */ +L(try_misaligned_words): + lsr limit_wd, limit, #3 + cbz count, L(do_misaligned) + + neg count, count + and count, count, #7 + sub limit, limit, count + lsr limit_wd, limit, #3 + +L(page_end_loop): + ldrb data1w, [src1], #1 + ldrb data2w, [src2], #1 + cmp data1w, #1 + ccmp data1w, data2w, #0, cs /* NZCV = 0b0000. */ + b.ne L(done) + subs count, count, #1 + b.hi L(page_end_loop) + +L(do_misaligned): + /* Prepare ourselves for the next page crossing. Unlike the aligned + loop, we fetch 1 less dword because we risk crossing bounds on + SRC2. */ + mov count, #8 + subs limit_wd, limit_wd, #1 + b.lo L(done_loop) +L(loop_misaligned): + and tmp2, src2, #0xff8 + eor tmp2, tmp2, #0xff8 + cbz tmp2, L(page_end_loop) + + ldr data1, [src1], #8 + ldr data2, [src2], #8 + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + eor diff, data1, data2 /* Non-zero if differences found. */ + bics has_nul, tmp1, tmp2 /* Non-zero if NUL terminator. */ + ccmp diff, #0, #0, eq + b.ne L(not_limit) + subs limit_wd, limit_wd, #1 + b.pl L(loop_misaligned) + +L(done_loop): + /* We found a difference or a NULL before the limit was reached. */ + and limit, limit, #7 + cbz limit, L(not_limit) + /* Read the last word. */ + sub src1, src1, 8 + sub src2, src2, 8 + ldr data1, [src1, limit] + ldr data2, [src2, limit] + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + eor diff, data1, data2 /* Non-zero if differences found. */ + bics has_nul, tmp1, tmp2 /* Non-zero if NUL terminator. */ + ccmp diff, #0, #0, eq + b.ne L(not_limit) + +L(ret0): + mov result, #0 + ret + +END ( __strncmp_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/strnlen-sve.S b/libc/AOR_v20.02/string/aarch64/strnlen-sve.S new file mode 100644 index 00000000000000..5d3957348a0c1d --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strnlen-sve.S @@ -0,0 +1,75 @@ +/* + * strnlen - calculate the length of a string with limit. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + + .globl __strnlen_aarch64_sve + .type __strnlen_aarch64_sve, %function + .p2align 4 +__strnlen_aarch64_sve: + setffr /* initialize FFR */ + mov x2, 0 /* initialize len */ + b 1f + + .p2align 4 + /* We have off + vl <= max, and so may read the whole vector. */ +0: ldff1b z0.b, p0/z, [x0, x2] + rdffrs p1.b, p0/z + b.nlast 2f + + /* First fault did not fail: the whole vector is valid. + Avoid depending on the contents of FFR beyond the branch. */ + cmpeq p2.b, p0/z, z0.b, 0 + b.any 8f + incb x2 + +1: whilelo p0.b, x2, x1 + b.last 0b + + /* We have off + vl < max. Test for off == max before proceeding. */ + b.none 9f + + ldff1b z0.b, p0/z, [x0, x2] + rdffrs p1.b, p0/z + b.nlast 2f + + /* First fault did not fail: the vector up to max is valid. + Avoid depending on the contents of FFR beyond the branch. + Compare for end-of-string, but there are no more bytes. */ + cmpeq p2.b, p0/z, z0.b, 0 + + /* Found end-of-string or zero. */ +8: brkb p2.b, p0/z, p2.b + mov x0, x2 + incp x0, p2.b + ret + + /* First fault failed: only some of the vector is valid. + Perform the comparison only on the valid bytes. */ +2: cmpeq p2.b, p1/z, z0.b, 0 + b.any 8b + + /* No inequality or zero found. Re-init FFR, incr and loop. */ + setffr + incp x2, p1.b + b 1b + + /* End of count. Return max. */ +9: mov x0, x2 + ret + + .size __strnlen_aarch64_sve, . - __strnlen_aarch64_sve +#endif diff --git a/libc/AOR_v20.02/string/aarch64/strnlen.S b/libc/AOR_v20.02/string/aarch64/strnlen.S new file mode 100644 index 00000000000000..72b74563a5a736 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strnlen.S @@ -0,0 +1,156 @@ +/* + * strnlen - calculate the length of a string with limit. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64 + */ + +#include "../asmdefs.h" + +/* Arguments and results. */ +#define srcin x0 +#define len x0 +#define limit x1 + +/* Locals and temporaries. */ +#define src x2 +#define data1 x3 +#define data2 x4 +#define data2a x5 +#define has_nul1 x6 +#define has_nul2 x7 +#define tmp1 x8 +#define tmp2 x9 +#define tmp3 x10 +#define tmp4 x11 +#define zeroones x12 +#define pos x13 +#define limit_wd x14 + +#define REP8_01 0x0101010101010101 +#define REP8_7f 0x7f7f7f7f7f7f7f7f +#define REP8_80 0x8080808080808080 + + .text + .p2align 6 +L(start): + /* Pre-pad to ensure critical loop begins an icache line. */ + .rep 7 + nop + .endr + /* Put this code here to avoid wasting more space with pre-padding. */ +L(hit_limit): + mov len, limit + ret + +ENTRY_ALIGN (__strnlen_aarch64, 0) + cbz limit, L(hit_limit) + mov zeroones, #REP8_01 + bic src, srcin, #15 + ands tmp1, srcin, #15 + b.ne L(misaligned) + /* Calculate the number of full and partial words -1. */ + sub limit_wd, limit, #1 /* Limit != 0, so no underflow. */ + lsr limit_wd, limit_wd, #4 /* Convert to Qwords. */ + + /* NUL detection works on the principle that (X - 1) & (~X) & 0x80 + (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and + can be done in parallel across the entire word. */ + /* The inner loop deals with two Dwords at a time. This has a + slightly higher start-up cost, but we should win quite quickly, + especially on cores with a high number of issue slots per + cycle, as we get much better parallelism out of the operations. */ + + /* Start of critial section -- keep to one 64Byte cache line. */ +L(loop): + ldp data1, data2, [src], #16 +L(realigned): + sub tmp1, data1, zeroones + orr tmp2, data1, #REP8_7f + sub tmp3, data2, zeroones + orr tmp4, data2, #REP8_7f + bic has_nul1, tmp1, tmp2 + bic has_nul2, tmp3, tmp4 + subs limit_wd, limit_wd, #1 + orr tmp1, has_nul1, has_nul2 + ccmp tmp1, #0, #0, pl /* NZCV = 0000 */ + b.eq L(loop) + /* End of critical section -- keep to one 64Byte cache line. */ + + orr tmp1, has_nul1, has_nul2 + cbz tmp1, L(hit_limit) /* No null in final Qword. */ + + /* We know there's a null in the final Qword. The easiest thing + to do now is work out the length of the string and return + MIN (len, limit). */ + + sub len, src, srcin + cbz has_nul1, L(nul_in_data2) +#ifdef __AARCH64EB__ + mov data2, data1 +#endif + sub len, len, #8 + mov has_nul2, has_nul1 +L(nul_in_data2): +#ifdef __AARCH64EB__ + /* For big-endian, carry propagation (if the final byte in the + string is 0x01) means we cannot use has_nul directly. The + easiest way to get the correct byte is to byte-swap the data + and calculate the syndrome a second time. */ + rev data2, data2 + sub tmp1, data2, zeroones + orr tmp2, data2, #REP8_7f + bic has_nul2, tmp1, tmp2 +#endif + sub len, len, #8 + rev has_nul2, has_nul2 + clz pos, has_nul2 + add len, len, pos, lsr #3 /* Bits to bytes. */ + cmp len, limit + csel len, len, limit, ls /* Return the lower value. */ + ret + +L(misaligned): + /* Deal with a partial first word. + We're doing two things in parallel here; + 1) Calculate the number of words (but avoiding overflow if + limit is near ULONG_MAX) - to do this we need to work out + limit + tmp1 - 1 as a 65-bit value before shifting it; + 2) Load and mask the initial data words - we force the bytes + before the ones we are interested in to 0xff - this ensures + early bytes will not hit any zero detection. */ + sub limit_wd, limit, #1 + neg tmp4, tmp1 + cmp tmp1, #8 + + and tmp3, limit_wd, #15 + lsr limit_wd, limit_wd, #4 + mov tmp2, #~0 + + ldp data1, data2, [src], #16 + lsl tmp4, tmp4, #3 /* Bytes beyond alignment -> bits. */ + add tmp3, tmp3, tmp1 + +#ifdef __AARCH64EB__ + /* Big-endian. Early bytes are at MSB. */ + lsl tmp2, tmp2, tmp4 /* Shift (tmp1 & 63). */ +#else + /* Little-endian. Early bytes are at LSB. */ + lsr tmp2, tmp2, tmp4 /* Shift (tmp1 & 63). */ +#endif + add limit_wd, limit_wd, tmp3, lsr #4 + + orr data1, data1, tmp2 + orr data2a, data2, tmp2 + + csinv data1, data1, xzr, le + csel data2, data2, data2a, le + b L(realigned) + +END (__strnlen_aarch64) diff --git a/libc/AOR_v20.02/string/aarch64/strrchr-sve.S b/libc/AOR_v20.02/string/aarch64/strrchr-sve.S new file mode 100644 index 00000000000000..0b4fcb06563190 --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strrchr-sve.S @@ -0,0 +1,86 @@ +/* + * strrchr - find the last of a character in a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_FEATURE_SVE +/* Assumptions: + * + * ARMv8-a, AArch64 + * SVE Available. + */ + + .arch armv8-a+sve + .text + + .globl __strrchr_aarch64_sve + .type __strrchr_aarch64_sve, %function + .p2align 4 +__strrchr_aarch64_sve: + dup z1.b, w1 /* replicate byte across vector */ + setffr /* initialize FFR */ + ptrue p1.b /* all ones; loop invariant */ + mov x2, 0 /* no match found so far */ + pfalse p2.b + + .p2align 4 + /* Read a vector's worth of bytes, stopping on first fault. */ +0: ldff1b z0.b, p1/z, [x0, xzr] + rdffrs p0.b, p1/z + b.nlast 1f + + /* First fault did not fail: the whole vector is valid. + Avoid depending on the contents of FFR beyond the branch. */ + incb x0, all /* skip bytes this round */ + cmpeq p3.b, p1/z, z0.b, 0 /* search for 0 */ + b.any 3f + + cmpeq p3.b, p1/z, z0.b, z1.b /* search for c; no eos */ + b.none 0b + + mov x2, x0 /* save advanced base */ + mov p2.b, p3.b /* save current search */ + b 0b + + /* First fault failed: only some of the vector is valid. + Perform the comparisions only on the valid bytes. */ +1: cmpeq p3.b, p0/z, z0.b, 0 /* search for 0 */ + b.any 2f + + cmpeq p3.b, p0/z, z0.b, z1.b /* search for c; no eos */ + mov x3, x0 + incp x0, p0.b /* skip bytes this round */ + setffr /* re-init FFR */ + b.none 0b + + addvl x2, x3, 1 /* save advanced base */ + mov p2.b, p3.b /* save current search */ + b 0b + + /* Found end-of-string. */ +2: incb x0, all /* advance base */ +3: brka p3.b, p1/z, p3.b /* mask after first 0 */ + cmpeq p3.b, p3/z, z0.b, z1.b /* search for c not after eos */ + b.any 4f + + /* No C within last vector. Did we have one before? */ + cbz x2, 5f + mov x0, x2 /* restore advanced base */ + mov p3.b, p2.b /* restore saved search */ + + /* Find the *last* match in the predicate. This is slightly + more complicated than finding the first match. */ +4: rev p3.b, p3.b /* reverse the bits */ + brka p3.b, p1/z, p3.b /* find position of last match */ + decp x0, p3.b /* retard pointer to last match */ + ret + + /* No C whatsoever. Return NULL. */ +5: mov x0, 0 + ret + + .size __strrchr_aarch64_sve, . - __strrchr_aarch64_sve +#endif diff --git a/libc/AOR_v20.02/string/aarch64/strrchr.S b/libc/AOR_v20.02/string/aarch64/strrchr.S new file mode 100644 index 00000000000000..48df4865064d3d --- /dev/null +++ b/libc/AOR_v20.02/string/aarch64/strrchr.S @@ -0,0 +1,148 @@ +/* + * strrchr - find last position of a character in a string. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* Assumptions: + * + * ARMv8-a, AArch64 + * Neon Available. + */ + +#include "../asmdefs.h" + +/* Arguments and results. */ +#define srcin x0 +#define chrin w1 + +#define result x0 + +#define src x2 +#define tmp1 x3 +#define wtmp2 w4 +#define tmp3 x5 +#define src_match x6 +#define src_offset x7 +#define const_m1 x8 +#define tmp4 x9 +#define nul_match x10 +#define chr_match x11 + +#define vrepchr v0 +#define vdata1 v1 +#define vdata2 v2 +#define vhas_nul1 v3 +#define vhas_nul2 v4 +#define vhas_chr1 v5 +#define vhas_chr2 v6 +#define vrepmask_0 v7 +#define vrepmask_c v16 +#define vend1 v17 +#define vend2 v18 + +/* Core algorithm. + + For each 32-byte hunk we calculate a 64-bit syndrome value, with + two bits per byte (LSB is always in bits 0 and 1, for both big + and little-endian systems). For each tuple, bit 0 is set iff + the relevant byte matched the requested character; bit 1 is set + iff the relevant byte matched the NUL end of string (we trigger + off bit0 for the special case of looking for NUL). Since the bits + in the syndrome reflect exactly the order in which things occur + in the original string a count_trailing_zeros() operation will + identify exactly which byte is causing the termination, and why. */ + +ENTRY (__strrchr_aarch64) + /* Magic constant 0x40100401 to allow us to identify which lane + matches the requested byte. Magic constant 0x80200802 used + similarly for NUL termination. */ + mov wtmp2, #0x0401 + movk wtmp2, #0x4010, lsl #16 + dup vrepchr.16b, chrin + bic src, srcin, #31 /* Work with aligned 32-byte hunks. */ + dup vrepmask_c.4s, wtmp2 + mov src_offset, #0 + ands tmp1, srcin, #31 + add vrepmask_0.4s, vrepmask_c.4s, vrepmask_c.4s /* equiv: lsl #1 */ + b.eq L(aligned) + + /* Input string is not 32-byte aligned. Rather than forcing + the padding bytes to a safe value, we calculate the syndrome + for all the bytes, but then mask off those bits of the + syndrome that are related to the padding. */ + ld1 {vdata1.16b, vdata2.16b}, [src], #32 + neg tmp1, tmp1 + cmeq vhas_nul1.16b, vdata1.16b, #0 + cmeq vhas_chr1.16b, vdata1.16b, vrepchr.16b + cmeq vhas_nul2.16b, vdata2.16b, #0 + cmeq vhas_chr2.16b, vdata2.16b, vrepchr.16b + and vhas_nul1.16b, vhas_nul1.16b, vrepmask_0.16b + and vhas_chr1.16b, vhas_chr1.16b, vrepmask_c.16b + and vhas_nul2.16b, vhas_nul2.16b, vrepmask_0.16b + and vhas_chr2.16b, vhas_chr2.16b, vrepmask_c.16b + addp vhas_nul1.16b, vhas_nul1.16b, vhas_nul2.16b // 256->128 + addp vhas_chr1.16b, vhas_chr1.16b, vhas_chr2.16b // 256->128 + addp vhas_nul1.16b, vhas_nul1.16b, vhas_nul1.16b // 128->64 + addp vhas_chr1.16b, vhas_chr1.16b, vhas_chr1.16b // 128->64 + mov nul_match, vhas_nul1.d[0] + lsl tmp1, tmp1, #1 + mov const_m1, #~0 + mov chr_match, vhas_chr1.d[0] + lsr tmp3, const_m1, tmp1 + + bic nul_match, nul_match, tmp3 // Mask padding bits. + bic chr_match, chr_match, tmp3 // Mask padding bits. + cbnz nul_match, L(tail) + +L(loop): + cmp chr_match, #0 + csel src_match, src, src_match, ne + csel src_offset, chr_match, src_offset, ne +L(aligned): + ld1 {vdata1.16b, vdata2.16b}, [src], #32 + cmeq vhas_nul1.16b, vdata1.16b, #0 + cmeq vhas_chr1.16b, vdata1.16b, vrepchr.16b + cmeq vhas_nul2.16b, vdata2.16b, #0 + cmeq vhas_chr2.16b, vdata2.16b, vrepchr.16b + addp vend1.16b, vhas_nul1.16b, vhas_nul2.16b // 256->128 + and vhas_chr1.16b, vhas_chr1.16b, vrepmask_c.16b + and vhas_chr2.16b, vhas_chr2.16b, vrepmask_c.16b + addp vhas_chr1.16b, vhas_chr1.16b, vhas_chr2.16b // 256->128 + addp vend1.16b, vend1.16b, vend1.16b // 128->64 + addp vhas_chr1.16b, vhas_chr1.16b, vhas_chr1.16b // 128->64 + mov nul_match, vend1.d[0] + mov chr_match, vhas_chr1.d[0] + cbz nul_match, L(loop) + + and vhas_nul1.16b, vhas_nul1.16b, vrepmask_0.16b + and vhas_nul2.16b, vhas_nul2.16b, vrepmask_0.16b + addp vhas_nul1.16b, vhas_nul1.16b, vhas_nul2.16b + addp vhas_nul1.16b, vhas_nul1.16b, vhas_nul1.16b + mov nul_match, vhas_nul1.d[0] + +L(tail): + /* Work out exactly where the string ends. */ + sub tmp4, nul_match, #1 + eor tmp4, tmp4, nul_match + ands chr_match, chr_match, tmp4 + /* And pick the values corresponding to the last match. */ + csel src_match, src, src_match, ne + csel src_offset, chr_match, src_offset, ne + + /* Count down from the top of the syndrome to find the last match. */ + clz tmp3, src_offset + /* Src_match points beyond the word containing the match, so we can + simply subtract half the bit-offset into the syndrome. Because + we are counting down, we need to go back one more character. */ + add tmp3, tmp3, #2 + sub result, src_match, tmp3, lsr #1 + /* But if the syndrome shows no match was found, then return NULL. */ + cmp src_offset, #0 + csel result, result, xzr, ne + + ret + +END (__strrchr_aarch64) diff --git a/libc/AOR_v20.02/string/arm/check-arch.S b/libc/AOR_v20.02/string/arm/check-arch.S new file mode 100644 index 00000000000000..64ffdd0eec7abe --- /dev/null +++ b/libc/AOR_v20.02/string/arm/check-arch.S @@ -0,0 +1,11 @@ +/* + * check ARCH setting. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if !__arm__ +# error ARCH setting does not match the compiler. +#endif diff --git a/libc/AOR_v20.02/string/arm/memchr.S b/libc/AOR_v20.02/string/arm/memchr.S new file mode 100644 index 00000000000000..a9bba052fb7eee --- /dev/null +++ b/libc/AOR_v20.02/string/arm/memchr.S @@ -0,0 +1,134 @@ +/* + * memchr - scan memory for a character + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* + Written by Dave Gilbert + + This __memchr_arm routine is optimised on a Cortex-A9 and should work on + all ARMv7 processors. It has a fast past for short sizes, and has + an optimised path for large data sets; the worst case is finding the + match early in a large data set. + + */ + +@ 2011-02-07 david.gilbert@linaro.org +@ Extracted from local git a5b438d861 +@ 2011-07-14 david.gilbert@linaro.org +@ Import endianness fix from local git ea786f1b +@ 2011-12-07 david.gilbert@linaro.org +@ Removed unneeded cbz from align loop + + .syntax unified + .arch armv7-a + +@ this lets us check a flag in a 00/ff byte easily in either endianness +#ifdef __ARMEB__ +#define CHARTSTMASK(c) 1<<(31-(c*8)) +#else +#define CHARTSTMASK(c) 1<<(c*8) +#endif + .text + .thumb + +@ --------------------------------------------------------------------------- + .thumb_func + .align 2 + .p2align 4,,15 + .global __memchr_arm + .type __memchr_arm,%function +__memchr_arm: + @ r0 = start of memory to scan + @ r1 = character to look for + @ r2 = length + @ returns r0 = pointer to character or NULL if not found + and r1,r1,#0xff @ Don't think we can trust the caller to actually pass a char + + cmp r2,#16 @ If it's short don't bother with anything clever + blt 20f + + tst r0, #7 @ If it's already aligned skip the next bit + beq 10f + + @ Work up to an aligned point +5: + ldrb r3, [r0],#1 + subs r2, r2, #1 + cmp r3, r1 + beq 50f @ If it matches exit found + tst r0, #7 + bne 5b @ If not aligned yet then do next byte + +10: + @ At this point, we are aligned, we know we have at least 8 bytes to work with + push {r4,r5,r6,r7} + orr r1, r1, r1, lsl #8 @ expand the match word across to all bytes + orr r1, r1, r1, lsl #16 + bic r4, r2, #7 @ Number of double words to work with + mvns r7, #0 @ all F's + movs r3, #0 + +15: + ldmia r0!,{r5,r6} + subs r4, r4, #8 + eor r5,r5, r1 @ Get it so that r5,r6 have 00's where the bytes match the target + eor r6,r6, r1 + uadd8 r5, r5, r7 @ Parallel add 0xff - sets the GE bits for anything that wasn't 0 + sel r5, r3, r7 @ bytes are 00 for none-00 bytes, or ff for 00 bytes - NOTE INVERSION + uadd8 r6, r6, r7 @ Parallel add 0xff - sets the GE bits for anything that wasn't 0 + sel r6, r5, r7 @ chained....bytes are 00 for none-00 bytes, or ff for 00 bytes - NOTE INVERSION + cbnz r6, 60f + bne 15b @ (Flags from the subs above) If not run out of bytes then go around again + + pop {r4,r5,r6,r7} + and r1,r1,#0xff @ Get r1 back to a single character from the expansion above + and r2,r2,#7 @ Leave the count remaining as the number after the double words have been done + +20: + cbz r2, 40f @ 0 length or hit the end already then not found + +21: @ Post aligned section, or just a short call + ldrb r3,[r0],#1 + subs r2,r2,#1 + eor r3,r3,r1 @ r3 = 0 if match - doesn't break flags from sub + cbz r3, 50f + bne 21b @ on r2 flags + +40: + movs r0,#0 @ not found + bx lr + +50: + subs r0,r0,#1 @ found + bx lr + +60: @ We're here because the fast path found a hit - now we have to track down exactly which word it was + @ r0 points to the start of the double word after the one that was tested + @ r5 has the 00/ff pattern for the first word, r6 has the chained value + cmp r5, #0 + itte eq + moveq r5, r6 @ the end is in the 2nd word + subeq r0,r0,#3 @ Points to 2nd byte of 2nd word + subne r0,r0,#7 @ or 2nd byte of 1st word + + @ r0 currently points to the 3rd byte of the word containing the hit + tst r5, # CHARTSTMASK(0) @ 1st character + bne 61f + adds r0,r0,#1 + tst r5, # CHARTSTMASK(1) @ 2nd character + ittt eq + addeq r0,r0,#1 + tsteq r5, # (3<<15) @ 2nd & 3rd character + @ If not the 3rd must be the last one + addeq r0,r0,#1 + +61: + pop {r4,r5,r6,r7} + subs r0,r0,#1 + bx lr + + .size __memchr_arm, . - __memchr_arm diff --git a/libc/AOR_v20.02/string/arm/memcpy.S b/libc/AOR_v20.02/string/arm/memcpy.S new file mode 100644 index 00000000000000..a410be5ba0f409 --- /dev/null +++ b/libc/AOR_v20.02/string/arm/memcpy.S @@ -0,0 +1,588 @@ +/* + * memcpy - copy memory area + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* + This memcpy routine is optimised for Cortex-A15 cores and takes advantage + of VFP or NEON when built with the appropriate flags. + + Assumptions: + + ARMv6 (ARMv7-a if using Neon) + ARM state + Unaligned accesses + + */ + +#include "../asmdefs.h" + + .syntax unified + /* This implementation requires ARM state. */ + .arm + +#ifdef __ARM_NEON__ + + .fpu neon + .arch armv7-a +# define FRAME_SIZE 4 +# define USE_VFP +# define USE_NEON + +#elif !defined (__SOFTFP__) + + .arch armv6 + .fpu vfpv2 +# define FRAME_SIZE 32 +# define USE_VFP + +#else + .arch armv6 +# define FRAME_SIZE 32 + +#endif + +/* Old versions of GAS incorrectly implement the NEON align semantics. */ +#ifdef BROKEN_ASM_NEON_ALIGN +#define ALIGN(addr, align) addr,:align +#else +#define ALIGN(addr, align) addr:align +#endif + +#define PC_OFFSET 8 /* PC pipeline compensation. */ +#define INSN_SIZE 4 + +/* Call parameters. */ +#define dstin r0 +#define src r1 +#define count r2 + +/* Locals. */ +#define tmp1 r3 +#define dst ip +#define tmp2 r10 + +#ifndef USE_NEON +/* For bulk copies using GP registers. */ +#define A_l r2 /* Call-clobbered. */ +#define A_h r3 /* Call-clobbered. */ +#define B_l r4 +#define B_h r5 +#define C_l r6 +#define C_h r7 +#define D_l r8 +#define D_h r9 +#endif + +/* Number of lines ahead to pre-fetch data. If you change this the code + below will need adjustment to compensate. */ + +#define prefetch_lines 5 + +#ifdef USE_VFP + .macro cpy_line_vfp vreg, base + vstr \vreg, [dst, #\base] + vldr \vreg, [src, #\base] + vstr d0, [dst, #\base + 8] + vldr d0, [src, #\base + 8] + vstr d1, [dst, #\base + 16] + vldr d1, [src, #\base + 16] + vstr d2, [dst, #\base + 24] + vldr d2, [src, #\base + 24] + vstr \vreg, [dst, #\base + 32] + vldr \vreg, [src, #\base + prefetch_lines * 64 - 32] + vstr d0, [dst, #\base + 40] + vldr d0, [src, #\base + 40] + vstr d1, [dst, #\base + 48] + vldr d1, [src, #\base + 48] + vstr d2, [dst, #\base + 56] + vldr d2, [src, #\base + 56] + .endm + + .macro cpy_tail_vfp vreg, base + vstr \vreg, [dst, #\base] + vldr \vreg, [src, #\base] + vstr d0, [dst, #\base + 8] + vldr d0, [src, #\base + 8] + vstr d1, [dst, #\base + 16] + vldr d1, [src, #\base + 16] + vstr d2, [dst, #\base + 24] + vldr d2, [src, #\base + 24] + vstr \vreg, [dst, #\base + 32] + vstr d0, [dst, #\base + 40] + vldr d0, [src, #\base + 40] + vstr d1, [dst, #\base + 48] + vldr d1, [src, #\base + 48] + vstr d2, [dst, #\base + 56] + vldr d2, [src, #\base + 56] + .endm +#endif + +ENTRY (__memcpy_arm) + + mov dst, dstin /* Preserve dstin, we need to return it. */ + cmp count, #64 + bge L(cpy_not_short) + /* Deal with small copies quickly by dropping straight into the + exit block. */ + +L(tail63unaligned): +#ifdef USE_NEON + and tmp1, count, #0x38 + rsb tmp1, tmp1, #(56 - PC_OFFSET + INSN_SIZE) + add pc, pc, tmp1 + vld1.8 {d0}, [src]! /* 14 words to go. */ + vst1.8 {d0}, [dst]! + vld1.8 {d0}, [src]! /* 12 words to go. */ + vst1.8 {d0}, [dst]! + vld1.8 {d0}, [src]! /* 10 words to go. */ + vst1.8 {d0}, [dst]! + vld1.8 {d0}, [src]! /* 8 words to go. */ + vst1.8 {d0}, [dst]! + vld1.8 {d0}, [src]! /* 6 words to go. */ + vst1.8 {d0}, [dst]! + vld1.8 {d0}, [src]! /* 4 words to go. */ + vst1.8 {d0}, [dst]! + vld1.8 {d0}, [src]! /* 2 words to go. */ + vst1.8 {d0}, [dst]! + + tst count, #4 + ldrne tmp1, [src], #4 + strne tmp1, [dst], #4 +#else + /* Copy up to 15 full words of data. May not be aligned. */ + /* Cannot use VFP for unaligned data. */ + and tmp1, count, #0x3c + add dst, dst, tmp1 + add src, src, tmp1 + rsb tmp1, tmp1, #(60 - PC_OFFSET/2 + INSN_SIZE/2) + /* Jump directly into the sequence below at the correct offset. */ + add pc, pc, tmp1, lsl #1 + + ldr tmp1, [src, #-60] /* 15 words to go. */ + str tmp1, [dst, #-60] + + ldr tmp1, [src, #-56] /* 14 words to go. */ + str tmp1, [dst, #-56] + ldr tmp1, [src, #-52] + str tmp1, [dst, #-52] + + ldr tmp1, [src, #-48] /* 12 words to go. */ + str tmp1, [dst, #-48] + ldr tmp1, [src, #-44] + str tmp1, [dst, #-44] + + ldr tmp1, [src, #-40] /* 10 words to go. */ + str tmp1, [dst, #-40] + ldr tmp1, [src, #-36] + str tmp1, [dst, #-36] + + ldr tmp1, [src, #-32] /* 8 words to go. */ + str tmp1, [dst, #-32] + ldr tmp1, [src, #-28] + str tmp1, [dst, #-28] + + ldr tmp1, [src, #-24] /* 6 words to go. */ + str tmp1, [dst, #-24] + ldr tmp1, [src, #-20] + str tmp1, [dst, #-20] + + ldr tmp1, [src, #-16] /* 4 words to go. */ + str tmp1, [dst, #-16] + ldr tmp1, [src, #-12] + str tmp1, [dst, #-12] + + ldr tmp1, [src, #-8] /* 2 words to go. */ + str tmp1, [dst, #-8] + ldr tmp1, [src, #-4] + str tmp1, [dst, #-4] +#endif + + lsls count, count, #31 + ldrhcs tmp1, [src], #2 + ldrbne src, [src] /* Src is dead, use as a scratch. */ + strhcs tmp1, [dst], #2 + strbne src, [dst] + bx lr + +L(cpy_not_short): + /* At least 64 bytes to copy, but don't know the alignment yet. */ + str tmp2, [sp, #-FRAME_SIZE]! + and tmp2, src, #7 + and tmp1, dst, #7 + cmp tmp1, tmp2 + bne L(cpy_notaligned) + +#ifdef USE_VFP + /* Magic dust alert! Force VFP on Cortex-A9. Experiments show + that the FP pipeline is much better at streaming loads and + stores. This is outside the critical loop. */ + vmov.f32 s0, s0 +#endif + + /* SRC and DST have the same mutual 64-bit alignment, but we may + still need to pre-copy some bytes to get to natural alignment. + We bring SRC and DST into full 64-bit alignment. */ + lsls tmp2, dst, #29 + beq 1f + rsbs tmp2, tmp2, #0 + sub count, count, tmp2, lsr #29 + ldrmi tmp1, [src], #4 + strmi tmp1, [dst], #4 + lsls tmp2, tmp2, #2 + ldrhcs tmp1, [src], #2 + ldrbne tmp2, [src], #1 + strhcs tmp1, [dst], #2 + strbne tmp2, [dst], #1 + +1: + subs tmp2, count, #64 /* Use tmp2 for count. */ + blt L(tail63aligned) + + cmp tmp2, #512 + bge L(cpy_body_long) + +L(cpy_body_medium): /* Count in tmp2. */ +#ifdef USE_VFP +1: + vldr d0, [src, #0] + subs tmp2, tmp2, #64 + vldr d1, [src, #8] + vstr d0, [dst, #0] + vldr d0, [src, #16] + vstr d1, [dst, #8] + vldr d1, [src, #24] + vstr d0, [dst, #16] + vldr d0, [src, #32] + vstr d1, [dst, #24] + vldr d1, [src, #40] + vstr d0, [dst, #32] + vldr d0, [src, #48] + vstr d1, [dst, #40] + vldr d1, [src, #56] + vstr d0, [dst, #48] + add src, src, #64 + vstr d1, [dst, #56] + add dst, dst, #64 + bge 1b + tst tmp2, #0x3f + beq L(done) + +L(tail63aligned): /* Count in tmp2. */ + and tmp1, tmp2, #0x38 + add dst, dst, tmp1 + add src, src, tmp1 + rsb tmp1, tmp1, #(56 - PC_OFFSET + INSN_SIZE) + add pc, pc, tmp1 + + vldr d0, [src, #-56] /* 14 words to go. */ + vstr d0, [dst, #-56] + vldr d0, [src, #-48] /* 12 words to go. */ + vstr d0, [dst, #-48] + vldr d0, [src, #-40] /* 10 words to go. */ + vstr d0, [dst, #-40] + vldr d0, [src, #-32] /* 8 words to go. */ + vstr d0, [dst, #-32] + vldr d0, [src, #-24] /* 6 words to go. */ + vstr d0, [dst, #-24] + vldr d0, [src, #-16] /* 4 words to go. */ + vstr d0, [dst, #-16] + vldr d0, [src, #-8] /* 2 words to go. */ + vstr d0, [dst, #-8] +#else + sub src, src, #8 + sub dst, dst, #8 +1: + ldrd A_l, A_h, [src, #8] + strd A_l, A_h, [dst, #8] + ldrd A_l, A_h, [src, #16] + strd A_l, A_h, [dst, #16] + ldrd A_l, A_h, [src, #24] + strd A_l, A_h, [dst, #24] + ldrd A_l, A_h, [src, #32] + strd A_l, A_h, [dst, #32] + ldrd A_l, A_h, [src, #40] + strd A_l, A_h, [dst, #40] + ldrd A_l, A_h, [src, #48] + strd A_l, A_h, [dst, #48] + ldrd A_l, A_h, [src, #56] + strd A_l, A_h, [dst, #56] + ldrd A_l, A_h, [src, #64]! + strd A_l, A_h, [dst, #64]! + subs tmp2, tmp2, #64 + bge 1b + tst tmp2, #0x3f + bne 1f + ldr tmp2,[sp], #FRAME_SIZE + bx lr +1: + add src, src, #8 + add dst, dst, #8 + +L(tail63aligned): /* Count in tmp2. */ + /* Copy up to 7 d-words of data. Similar to Ltail63unaligned, but + we know that the src and dest are 64-bit aligned so we can use + LDRD/STRD to improve efficiency. */ + /* TMP2 is now negative, but we don't care about that. The bottom + six bits still tell us how many bytes are left to copy. */ + + and tmp1, tmp2, #0x38 + add dst, dst, tmp1 + add src, src, tmp1 + rsb tmp1, tmp1, #(56 - PC_OFFSET + INSN_SIZE) + add pc, pc, tmp1 + ldrd A_l, A_h, [src, #-56] /* 14 words to go. */ + strd A_l, A_h, [dst, #-56] + ldrd A_l, A_h, [src, #-48] /* 12 words to go. */ + strd A_l, A_h, [dst, #-48] + ldrd A_l, A_h, [src, #-40] /* 10 words to go. */ + strd A_l, A_h, [dst, #-40] + ldrd A_l, A_h, [src, #-32] /* 8 words to go. */ + strd A_l, A_h, [dst, #-32] + ldrd A_l, A_h, [src, #-24] /* 6 words to go. */ + strd A_l, A_h, [dst, #-24] + ldrd A_l, A_h, [src, #-16] /* 4 words to go. */ + strd A_l, A_h, [dst, #-16] + ldrd A_l, A_h, [src, #-8] /* 2 words to go. */ + strd A_l, A_h, [dst, #-8] + +#endif + tst tmp2, #4 + ldrne tmp1, [src], #4 + strne tmp1, [dst], #4 + lsls tmp2, tmp2, #31 /* Count (tmp2) now dead. */ + ldrhcs tmp1, [src], #2 + ldrbne tmp2, [src] + strhcs tmp1, [dst], #2 + strbne tmp2, [dst] + +L(done): + ldr tmp2, [sp], #FRAME_SIZE + bx lr + +L(cpy_body_long): /* Count in tmp2. */ + + /* Long copy. We know that there's at least (prefetch_lines * 64) + bytes to go. */ +#ifdef USE_VFP + /* Don't use PLD. Instead, read some data in advance of the current + copy position into a register. This should act like a PLD + operation but we won't have to repeat the transfer. */ + + vldr d3, [src, #0] + vldr d4, [src, #64] + vldr d5, [src, #128] + vldr d6, [src, #192] + vldr d7, [src, #256] + + vldr d0, [src, #8] + vldr d1, [src, #16] + vldr d2, [src, #24] + add src, src, #32 + + subs tmp2, tmp2, #prefetch_lines * 64 * 2 + blt 2f +1: + cpy_line_vfp d3, 0 + cpy_line_vfp d4, 64 + cpy_line_vfp d5, 128 + add dst, dst, #3 * 64 + add src, src, #3 * 64 + cpy_line_vfp d6, 0 + cpy_line_vfp d7, 64 + add dst, dst, #2 * 64 + add src, src, #2 * 64 + subs tmp2, tmp2, #prefetch_lines * 64 + bge 1b + +2: + cpy_tail_vfp d3, 0 + cpy_tail_vfp d4, 64 + cpy_tail_vfp d5, 128 + add src, src, #3 * 64 + add dst, dst, #3 * 64 + cpy_tail_vfp d6, 0 + vstr d7, [dst, #64] + vldr d7, [src, #64] + vstr d0, [dst, #64 + 8] + vldr d0, [src, #64 + 8] + vstr d1, [dst, #64 + 16] + vldr d1, [src, #64 + 16] + vstr d2, [dst, #64 + 24] + vldr d2, [src, #64 + 24] + vstr d7, [dst, #64 + 32] + add src, src, #96 + vstr d0, [dst, #64 + 40] + vstr d1, [dst, #64 + 48] + vstr d2, [dst, #64 + 56] + add dst, dst, #128 + add tmp2, tmp2, #prefetch_lines * 64 + b L(cpy_body_medium) +#else + /* Long copy. Use an SMS style loop to maximize the I/O + bandwidth of the core. We don't have enough spare registers + to synthesise prefetching, so use PLD operations. */ + /* Pre-bias src and dst. */ + sub src, src, #8 + sub dst, dst, #8 + pld [src, #8] + pld [src, #72] + subs tmp2, tmp2, #64 + pld [src, #136] + ldrd A_l, A_h, [src, #8] + strd B_l, B_h, [sp, #8] + ldrd B_l, B_h, [src, #16] + strd C_l, C_h, [sp, #16] + ldrd C_l, C_h, [src, #24] + strd D_l, D_h, [sp, #24] + pld [src, #200] + ldrd D_l, D_h, [src, #32]! + b 1f + .p2align 6 +2: + pld [src, #232] + strd A_l, A_h, [dst, #40] + ldrd A_l, A_h, [src, #40] + strd B_l, B_h, [dst, #48] + ldrd B_l, B_h, [src, #48] + strd C_l, C_h, [dst, #56] + ldrd C_l, C_h, [src, #56] + strd D_l, D_h, [dst, #64]! + ldrd D_l, D_h, [src, #64]! + subs tmp2, tmp2, #64 +1: + strd A_l, A_h, [dst, #8] + ldrd A_l, A_h, [src, #8] + strd B_l, B_h, [dst, #16] + ldrd B_l, B_h, [src, #16] + strd C_l, C_h, [dst, #24] + ldrd C_l, C_h, [src, #24] + strd D_l, D_h, [dst, #32] + ldrd D_l, D_h, [src, #32] + bcs 2b + /* Save the remaining bytes and restore the callee-saved regs. */ + strd A_l, A_h, [dst, #40] + add src, src, #40 + strd B_l, B_h, [dst, #48] + ldrd B_l, B_h, [sp, #8] + strd C_l, C_h, [dst, #56] + ldrd C_l, C_h, [sp, #16] + strd D_l, D_h, [dst, #64] + ldrd D_l, D_h, [sp, #24] + add dst, dst, #72 + tst tmp2, #0x3f + bne L(tail63aligned) + ldr tmp2, [sp], #FRAME_SIZE + bx lr +#endif + +L(cpy_notaligned): + pld [src] + pld [src, #64] + /* There's at least 64 bytes to copy, but there is no mutual + alignment. */ + /* Bring DST to 64-bit alignment. */ + lsls tmp2, dst, #29 + pld [src, #(2 * 64)] + beq 1f + rsbs tmp2, tmp2, #0 + sub count, count, tmp2, lsr #29 + ldrmi tmp1, [src], #4 + strmi tmp1, [dst], #4 + lsls tmp2, tmp2, #2 + ldrbne tmp1, [src], #1 + ldrhcs tmp2, [src], #2 + strbne tmp1, [dst], #1 + strhcs tmp2, [dst], #2 +1: + pld [src, #(3 * 64)] + subs count, count, #64 + ldrmi tmp2, [sp], #FRAME_SIZE + bmi L(tail63unaligned) + pld [src, #(4 * 64)] + +#ifdef USE_NEON + vld1.8 {d0-d3}, [src]! + vld1.8 {d4-d7}, [src]! + subs count, count, #64 + bmi 2f +1: + pld [src, #(4 * 64)] + vst1.8 {d0-d3}, [ALIGN (dst, 64)]! + vld1.8 {d0-d3}, [src]! + vst1.8 {d4-d7}, [ALIGN (dst, 64)]! + vld1.8 {d4-d7}, [src]! + subs count, count, #64 + bpl 1b +2: + vst1.8 {d0-d3}, [ALIGN (dst, 64)]! + vst1.8 {d4-d7}, [ALIGN (dst, 64)]! + ands count, count, #0x3f +#else + /* Use an SMS style loop to maximize the I/O bandwidth. */ + sub src, src, #4 + sub dst, dst, #8 + subs tmp2, count, #64 /* Use tmp2 for count. */ + ldr A_l, [src, #4] + ldr A_h, [src, #8] + strd B_l, B_h, [sp, #8] + ldr B_l, [src, #12] + ldr B_h, [src, #16] + strd C_l, C_h, [sp, #16] + ldr C_l, [src, #20] + ldr C_h, [src, #24] + strd D_l, D_h, [sp, #24] + ldr D_l, [src, #28] + ldr D_h, [src, #32]! + b 1f + .p2align 6 +2: + pld [src, #(5 * 64) - (32 - 4)] + strd A_l, A_h, [dst, #40] + ldr A_l, [src, #36] + ldr A_h, [src, #40] + strd B_l, B_h, [dst, #48] + ldr B_l, [src, #44] + ldr B_h, [src, #48] + strd C_l, C_h, [dst, #56] + ldr C_l, [src, #52] + ldr C_h, [src, #56] + strd D_l, D_h, [dst, #64]! + ldr D_l, [src, #60] + ldr D_h, [src, #64]! + subs tmp2, tmp2, #64 +1: + strd A_l, A_h, [dst, #8] + ldr A_l, [src, #4] + ldr A_h, [src, #8] + strd B_l, B_h, [dst, #16] + ldr B_l, [src, #12] + ldr B_h, [src, #16] + strd C_l, C_h, [dst, #24] + ldr C_l, [src, #20] + ldr C_h, [src, #24] + strd D_l, D_h, [dst, #32] + ldr D_l, [src, #28] + ldr D_h, [src, #32] + bcs 2b + + /* Save the remaining bytes and restore the callee-saved regs. */ + strd A_l, A_h, [dst, #40] + add src, src, #36 + strd B_l, B_h, [dst, #48] + ldrd B_l, B_h, [sp, #8] + strd C_l, C_h, [dst, #56] + ldrd C_l, C_h, [sp, #16] + strd D_l, D_h, [dst, #64] + ldrd D_l, D_h, [sp, #24] + add dst, dst, #72 + ands count, tmp2, #0x3f +#endif + ldr tmp2, [sp], #FRAME_SIZE + bne L(tail63unaligned) + bx lr + +END (__memcpy_arm) diff --git a/libc/AOR_v20.02/string/arm/memset.S b/libc/AOR_v20.02/string/arm/memset.S new file mode 100644 index 00000000000000..a3185b957f2fd6 --- /dev/null +++ b/libc/AOR_v20.02/string/arm/memset.S @@ -0,0 +1,100 @@ +/* + * memset - fill memory with a constant + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +/* + Written by Dave Gilbert + + This memset routine is optimised on a Cortex-A9 and should work on + all ARMv7 processors. + + */ + + .syntax unified + .arch armv7-a + +@ 2011-08-30 david.gilbert@linaro.org +@ Extracted from local git 2f11b436 + +@ this lets us check a flag in a 00/ff byte easily in either endianness +#ifdef __ARMEB__ +#define CHARTSTMASK(c) 1<<(31-(c*8)) +#else +#define CHARTSTMASK(c) 1<<(c*8) +#endif + .text + .thumb + +@ --------------------------------------------------------------------------- + .thumb_func + .align 2 + .p2align 4,,15 + .global __memset_arm + .type __memset_arm,%function +__memset_arm: + @ r0 = address + @ r1 = character + @ r2 = count + @ returns original address in r0 + + mov r3, r0 @ Leave r0 alone + cbz r2, 10f @ Exit if 0 length + + tst r0, #7 + beq 2f @ Already aligned + + @ Ok, so we're misaligned here +1: + strb r1, [r3], #1 + subs r2,r2,#1 + tst r3, #7 + cbz r2, 10f @ Exit if we hit the end + bne 1b @ go round again if still misaligned + +2: + @ OK, so we're aligned + push {r4,r5,r6,r7} + bics r4, r2, #15 @ if less than 16 bytes then need to finish it off + beq 5f + +3: + @ POSIX says that ch is cast to an unsigned char. A uxtb is one + @ byte and takes two cycles, where an AND is four bytes but one + @ cycle. + and r1, #0xFF + orr r1, r1, r1, lsl#8 @ Same character into all bytes + orr r1, r1, r1, lsl#16 + mov r5,r1 + mov r6,r1 + mov r7,r1 + +4: + subs r4,r4,#16 + stmia r3!,{r1,r5,r6,r7} + bne 4b + and r2,r2,#15 + + @ At this point we're still aligned and we have upto align-1 bytes left to right + @ we can avoid some of the byte-at-a time now by testing for some big chunks + tst r2,#8 + itt ne + subne r2,r2,#8 + stmiane r3!,{r1,r5} + +5: + pop {r4,r5,r6,r7} + cbz r2, 10f + + @ Got to do any last < alignment bytes +6: + subs r2,r2,#1 + strb r1,[r3],#1 + bne 6b + +10: + bx lr @ goodbye + .size __memset_arm, . - __memset_arm diff --git a/libc/AOR_v20.02/string/arm/strcmp-armv6m.S b/libc/AOR_v20.02/string/arm/strcmp-armv6m.S new file mode 100644 index 00000000000000..462233d06004cb --- /dev/null +++ b/libc/AOR_v20.02/string/arm/strcmp-armv6m.S @@ -0,0 +1,118 @@ +/* + * strcmp for ARMv6-M (optimized for performance, not size) + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_ARCH == 6 && __ARM_ARCH_6M__ >= 1 + + .thumb_func + .syntax unified + .arch armv6-m + + .macro DoSub n, label + subs r0, r0, r1 +#ifdef __ARM_BIG_ENDIAN + lsrs r1, r4, \n +#else + lsls r1, r4, \n +#endif + orrs r1, r0 + bne \label + .endm + + .macro Byte_Test n, label + lsrs r0, r2, \n + lsrs r1, r3, \n + DoSub \n, \label + .endm + +ENTRY_ALIGN (__strcmp_armv6m, 4) + mov r2, r0 + push {r4, r5, r6, lr} + orrs r2, r1 + lsls r2, r2, #30 + bne 6f + ldr r5, =0x01010101 + lsls r6, r5, #7 +1: + ldmia r0!, {r2} + ldmia r1!, {r3} + subs r4, r2, r5 + bics r4, r2 + ands r4, r6 + beq 3f + +#ifdef __ARM_BIG_ENDIAN + Byte_Test #24, 4f + Byte_Test #16, 4f + Byte_Test #8, 4f + + b 7f +3: + cmp r2, r3 + beq 1b + cmp r2, r3 +#else + uxtb r0, r2 + uxtb r1, r3 + DoSub #24, 2f + + uxth r0, r2 + uxth r1, r3 + DoSub #16, 2f + + lsls r0, r2, #8 + lsls r1, r3, #8 + lsrs r0, r0, #8 + lsrs r1, r1, #8 + DoSub #8, 2f + + lsrs r0, r2, #24 + lsrs r1, r3, #24 + subs r0, r0, r1 +2: + pop {r4, r5, r6, pc} + +3: + cmp r2, r3 + beq 1b + rev r0, r2 + rev r1, r3 + cmp r0, r1 +#endif + + bls 5f + movs r0, #1 +4: + pop {r4, r5, r6, pc} +5: + movs r0, #0 + mvns r0, r0 + pop {r4, r5, r6, pc} +6: + ldrb r2, [r0, #0] + ldrb r3, [r1, #0] + adds r0, #1 + adds r1, #1 + cmp r2, #0 + beq 7f + cmp r2, r3 + bne 7f + ldrb r2, [r0, #0] + ldrb r3, [r1, #0] + adds r0, #1 + adds r1, #1 + cmp r2, #0 + beq 7f + cmp r2, r3 + beq 6b +7: + subs r0, r2, r3 + pop {r4, r5, r6, pc} + +END (__strcmp_armv6m) + +#endif /* __ARM_ARCH == 6 && __ARM_ARCH_6M__ >= 1 */ diff --git a/libc/AOR_v20.02/string/arm/strcmp.S b/libc/AOR_v20.02/string/arm/strcmp.S new file mode 100644 index 00000000000000..db7cc0549fe283 --- /dev/null +++ b/libc/AOR_v20.02/string/arm/strcmp.S @@ -0,0 +1,477 @@ +/* + * strcmp for ARMv7 + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_ARCH >= 7 && __ARM_ARCH_ISA_ARM >= 1 + +/* Implementation of strcmp for ARMv7 when DSP instructions are + available. Use ldrd to support wider loads, provided the data + is sufficiently aligned. Use saturating arithmetic to optimize + the compares. */ + +#include "../asmdefs.h" + +/* Build Options: + STRCMP_NO_PRECHECK: Don't run a quick pre-check of the first + byte in the string. If comparing completely random strings + the pre-check will save time, since there is a very high + probability of a mismatch in the first character: we save + significant overhead if this is the common case. However, + if strings are likely to be identical (eg because we're + verifying a hit in a hash table), then this check is largely + redundant. */ + +#define STRCMP_NO_PRECHECK 0 + + /* This version uses Thumb-2 code. */ + .thumb + .syntax unified + +#ifdef __ARM_BIG_ENDIAN +#define S2LO lsl +#define S2LOEQ lsleq +#define S2HI lsr +#define MSB 0x000000ff +#define LSB 0xff000000 +#define BYTE0_OFFSET 24 +#define BYTE1_OFFSET 16 +#define BYTE2_OFFSET 8 +#define BYTE3_OFFSET 0 +#else /* not __ARM_BIG_ENDIAN */ +#define S2LO lsr +#define S2LOEQ lsreq +#define S2HI lsl +#define BYTE0_OFFSET 0 +#define BYTE1_OFFSET 8 +#define BYTE2_OFFSET 16 +#define BYTE3_OFFSET 24 +#define MSB 0xff000000 +#define LSB 0x000000ff +#endif /* not __ARM_BIG_ENDIAN */ + +/* Parameters and result. */ +#define src1 r0 +#define src2 r1 +#define result r0 /* Overlaps src1. */ + +/* Internal variables. */ +#define tmp1 r4 +#define tmp2 r5 +#define const_m1 r12 + +/* Additional internal variables for 64-bit aligned data. */ +#define data1a r2 +#define data1b r3 +#define data2a r6 +#define data2b r7 +#define syndrome_a tmp1 +#define syndrome_b tmp2 + +/* Additional internal variables for 32-bit aligned data. */ +#define data1 r2 +#define data2 r3 +#define syndrome tmp2 + + + /* Macro to compute and return the result value for word-aligned + cases. */ + .macro strcmp_epilogue_aligned synd d1 d2 restore_r6 +#ifdef __ARM_BIG_ENDIAN + /* If data1 contains a zero byte, then syndrome will contain a 1 in + bit 7 of that byte. Otherwise, the highest set bit in the + syndrome will highlight the first different bit. It is therefore + sufficient to extract the eight bits starting with the syndrome + bit. */ + clz tmp1, \synd + lsl r1, \d2, tmp1 + .if \restore_r6 + ldrd r6, r7, [sp, #8] + .endif + .cfi_restore 6 + .cfi_restore 7 + lsl \d1, \d1, tmp1 + .cfi_remember_state + lsr result, \d1, #24 + ldrd r4, r5, [sp], #16 + .cfi_restore 4 + .cfi_restore 5 + sub result, result, r1, lsr #24 + bx lr +#else + /* To use the big-endian trick we'd have to reverse all three words. + that's slower than this approach. */ + rev \synd, \synd + clz tmp1, \synd + bic tmp1, tmp1, #7 + lsr r1, \d2, tmp1 + .cfi_remember_state + .if \restore_r6 + ldrd r6, r7, [sp, #8] + .endif + .cfi_restore 6 + .cfi_restore 7 + lsr \d1, \d1, tmp1 + and result, \d1, #255 + and r1, r1, #255 + ldrd r4, r5, [sp], #16 + .cfi_restore 4 + .cfi_restore 5 + sub result, result, r1 + + bx lr +#endif + .endm + + .text + .p2align 5 +L(strcmp_start_addr): +#if STRCMP_NO_PRECHECK == 0 +L(fastpath_exit): + sub r0, r2, r3 + bx lr + nop +#endif +ENTRY_ALIGN (__strcmp_arm, 0) +#if STRCMP_NO_PRECHECK == 0 + ldrb r2, [src1] + ldrb r3, [src2] + cmp r2, #1 + it cs + cmpcs r2, r3 + bne L(fastpath_exit) +#endif + strd r4, r5, [sp, #-16]! + .cfi_def_cfa_offset 16 + .cfi_offset 4, -16 + .cfi_offset 5, -12 + orr tmp1, src1, src2 + strd r6, r7, [sp, #8] + .cfi_offset 6, -8 + .cfi_offset 7, -4 + mvn const_m1, #0 + lsl r2, tmp1, #29 + cbz r2, L(loop_aligned8) + +L(not_aligned): + eor tmp1, src1, src2 + tst tmp1, #7 + bne L(misaligned8) + + /* Deal with mutual misalignment by aligning downwards and then + masking off the unwanted loaded data to prevent a difference. */ + and tmp1, src1, #7 + bic src1, src1, #7 + and tmp2, tmp1, #3 + bic src2, src2, #7 + lsl tmp2, tmp2, #3 /* Bytes -> bits. */ + ldrd data1a, data1b, [src1], #16 + tst tmp1, #4 + ldrd data2a, data2b, [src2], #16 + /* In thumb code we can't use MVN with a register shift, but + we do have ORN. */ + S2HI tmp1, const_m1, tmp2 + orn data1a, data1a, tmp1 + orn data2a, data2a, tmp1 + beq L(start_realigned8) + orn data1b, data1b, tmp1 + mov data1a, const_m1 + orn data2b, data2b, tmp1 + mov data2a, const_m1 + b L(start_realigned8) + + /* Unwind the inner loop by a factor of 2, giving 16 bytes per + pass. */ + .p2align 5,,12 /* Don't start in the tail bytes of a cache line. */ + .p2align 2 /* Always word aligned. */ +L(loop_aligned8): + ldrd data1a, data1b, [src1], #16 + ldrd data2a, data2b, [src2], #16 +L(start_realigned8): + uadd8 syndrome_b, data1a, const_m1 /* Only want GE bits, */ + eor syndrome_a, data1a, data2a + sel syndrome_a, syndrome_a, const_m1 + cbnz syndrome_a, L(diff_in_a) + uadd8 syndrome_b, data1b, const_m1 /* Only want GE bits. */ + eor syndrome_b, data1b, data2b + sel syndrome_b, syndrome_b, const_m1 + cbnz syndrome_b, L(diff_in_b) + + ldrd data1a, data1b, [src1, #-8] + ldrd data2a, data2b, [src2, #-8] + uadd8 syndrome_b, data1a, const_m1 /* Only want GE bits, */ + eor syndrome_a, data1a, data2a + sel syndrome_a, syndrome_a, const_m1 + uadd8 syndrome_b, data1b, const_m1 /* Only want GE bits. */ + eor syndrome_b, data1b, data2b + sel syndrome_b, syndrome_b, const_m1 + /* Can't use CBZ for backwards branch. */ + orrs syndrome_b, syndrome_b, syndrome_a /* Only need if s_a == 0 */ + beq L(loop_aligned8) + +L(diff_found): + cbnz syndrome_a, L(diff_in_a) + +L(diff_in_b): + strcmp_epilogue_aligned syndrome_b, data1b, data2b 1 + +L(diff_in_a): + .cfi_restore_state + strcmp_epilogue_aligned syndrome_a, data1a, data2a 1 + + .cfi_restore_state +L(misaligned8): + tst tmp1, #3 + bne L(misaligned4) + ands tmp1, src1, #3 + bne L(mutual_align4) + + /* Unrolled by a factor of 2, to reduce the number of post-increment + operations. */ +L(loop_aligned4): + ldr data1, [src1], #8 + ldr data2, [src2], #8 +L(start_realigned4): + uadd8 syndrome, data1, const_m1 /* Only need GE bits. */ + eor syndrome, data1, data2 + sel syndrome, syndrome, const_m1 + cbnz syndrome, L(aligned4_done) + ldr data1, [src1, #-4] + ldr data2, [src2, #-4] + uadd8 syndrome, data1, const_m1 + eor syndrome, data1, data2 + sel syndrome, syndrome, const_m1 + cmp syndrome, #0 + beq L(loop_aligned4) + +L(aligned4_done): + strcmp_epilogue_aligned syndrome, data1, data2, 0 + +L(mutual_align4): + .cfi_restore_state + /* Deal with mutual misalignment by aligning downwards and then + masking off the unwanted loaded data to prevent a difference. */ + lsl tmp1, tmp1, #3 /* Bytes -> bits. */ + bic src1, src1, #3 + ldr data1, [src1], #8 + bic src2, src2, #3 + ldr data2, [src2], #8 + + /* In thumb code we can't use MVN with a register shift, but + we do have ORN. */ + S2HI tmp1, const_m1, tmp1 + orn data1, data1, tmp1 + orn data2, data2, tmp1 + b L(start_realigned4) + +L(misaligned4): + ands tmp1, src1, #3 + beq L(src1_aligned) + sub src2, src2, tmp1 + bic src1, src1, #3 + lsls tmp1, tmp1, #31 + ldr data1, [src1], #4 + beq L(aligned_m2) + bcs L(aligned_m1) + +#if STRCMP_NO_PRECHECK == 1 + ldrb data2, [src2, #1] + uxtb tmp1, data1, ror #BYTE1_OFFSET + subs tmp1, tmp1, data2 + bne L(misaligned_exit) + cbz data2, L(misaligned_exit) + +L(aligned_m2): + ldrb data2, [src2, #2] + uxtb tmp1, data1, ror #BYTE2_OFFSET + subs tmp1, tmp1, data2 + bne L(misaligned_exit) + cbz data2, L(misaligned_exit) + +L(aligned_m1): + ldrb data2, [src2, #3] + uxtb tmp1, data1, ror #BYTE3_OFFSET + subs tmp1, tmp1, data2 + bne L(misaligned_exit) + add src2, src2, #4 + cbnz data2, L(src1_aligned) +#else /* STRCMP_NO_PRECHECK */ + /* If we've done the pre-check, then we don't need to check the + first byte again here. */ + ldrb data2, [src2, #2] + uxtb tmp1, data1, ror #BYTE2_OFFSET + subs tmp1, tmp1, data2 + bne L(misaligned_exit) + cbz data2, L(misaligned_exit) + +L(aligned_m2): + ldrb data2, [src2, #3] + uxtb tmp1, data1, ror #BYTE3_OFFSET + subs tmp1, tmp1, data2 + bne L(misaligned_exit) + cbnz data2, L(aligned_m1) +#endif + +L(misaligned_exit): + .cfi_remember_state + mov result, tmp1 + ldr r4, [sp], #16 + .cfi_restore 4 + bx lr + +#if STRCMP_NO_PRECHECK == 0 +L(aligned_m1): + add src2, src2, #4 +#endif +L(src1_aligned): + .cfi_restore_state + /* src1 is word aligned, but src2 has no common alignment + with it. */ + ldr data1, [src1], #4 + lsls tmp1, src2, #31 /* C=src2[1], Z=src2[0]. */ + + bic src2, src2, #3 + ldr data2, [src2], #4 + bhi L(overlap1) /* C=1, Z=0 => src2[1:0] = 0b11. */ + bcs L(overlap2) /* C=1, Z=1 => src2[1:0] = 0b10. */ + + /* (overlap3) C=0, Z=0 => src2[1:0] = 0b01. */ +L(overlap3): + bic tmp1, data1, #MSB + uadd8 syndrome, data1, const_m1 + eors syndrome, tmp1, data2, S2LO #8 + sel syndrome, syndrome, const_m1 + bne 4f + cbnz syndrome, 5f + ldr data2, [src2], #4 + eor tmp1, tmp1, data1 + cmp tmp1, data2, S2HI #24 + bne 6f + ldr data1, [src1], #4 + b L(overlap3) +4: + S2LO data2, data2, #8 + b L(strcmp_tail) + +5: + bics syndrome, syndrome, #MSB + bne L(strcmp_done_equal) + + /* We can only get here if the MSB of data1 contains 0, so + fast-path the exit. */ + ldrb result, [src2] + .cfi_remember_state + ldrd r4, r5, [sp], #16 + .cfi_restore 4 + .cfi_restore 5 + /* R6/7 Not used in this sequence. */ + .cfi_restore 6 + .cfi_restore 7 + neg result, result + bx lr + +6: + .cfi_restore_state + S2LO data1, data1, #24 + and data2, data2, #LSB + b L(strcmp_tail) + + .p2align 5,,12 /* Ensure at least 3 instructions in cache line. */ +L(overlap2): + and tmp1, data1, const_m1, S2LO #16 + uadd8 syndrome, data1, const_m1 + eors syndrome, tmp1, data2, S2LO #16 + sel syndrome, syndrome, const_m1 + bne 4f + cbnz syndrome, 5f + ldr data2, [src2], #4 + eor tmp1, tmp1, data1 + cmp tmp1, data2, S2HI #16 + bne 6f + ldr data1, [src1], #4 + b L(overlap2) +4: + S2LO data2, data2, #16 + b L(strcmp_tail) +5: + ands syndrome, syndrome, const_m1, S2LO #16 + bne L(strcmp_done_equal) + + ldrh data2, [src2] + S2LO data1, data1, #16 +#ifdef __ARM_BIG_ENDIAN + lsl data2, data2, #16 +#endif + b L(strcmp_tail) + +6: + S2LO data1, data1, #16 + and data2, data2, const_m1, S2LO #16 + b L(strcmp_tail) + + .p2align 5,,12 /* Ensure at least 3 instructions in cache line. */ +L(overlap1): + and tmp1, data1, #LSB + uadd8 syndrome, data1, const_m1 + eors syndrome, tmp1, data2, S2LO #24 + sel syndrome, syndrome, const_m1 + bne 4f + cbnz syndrome, 5f + ldr data2, [src2], #4 + eor tmp1, tmp1, data1 + cmp tmp1, data2, S2HI #8 + bne 6f + ldr data1, [src1], #4 + b L(overlap1) +4: + S2LO data2, data2, #24 + b L(strcmp_tail) +5: + tst syndrome, #LSB + bne L(strcmp_done_equal) + ldr data2, [src2] +6: + S2LO data1, data1, #8 + bic data2, data2, #MSB + b L(strcmp_tail) + +L(strcmp_done_equal): + mov result, #0 + .cfi_remember_state + ldrd r4, r5, [sp], #16 + .cfi_restore 4 + .cfi_restore 5 + /* R6/7 not used in this sequence. */ + .cfi_restore 6 + .cfi_restore 7 + bx lr + +L(strcmp_tail): + .cfi_restore_state +#ifndef __ARM_BIG_ENDIAN + rev data1, data1 + rev data2, data2 + /* Now everything looks big-endian... */ +#endif + uadd8 tmp1, data1, const_m1 + eor tmp1, data1, data2 + sel syndrome, tmp1, const_m1 + clz tmp1, syndrome + lsl data1, data1, tmp1 + lsl data2, data2, tmp1 + lsr result, data1, #24 + ldrd r4, r5, [sp], #16 + .cfi_restore 4 + .cfi_restore 5 + /* R6/7 not used in this sequence. */ + .cfi_restore 6 + .cfi_restore 7 + sub result, result, data2, lsr #24 + bx lr + +END (__strcmp_arm) + +#endif /* __ARM_ARCH >= 7 && __ARM_ARCH_ISA_ARM >= 1 */ diff --git a/libc/AOR_v20.02/string/arm/strcpy.c b/libc/AOR_v20.02/string/arm/strcpy.c new file mode 100644 index 00000000000000..ce472ced2c45d2 --- /dev/null +++ b/libc/AOR_v20.02/string/arm/strcpy.c @@ -0,0 +1,134 @@ +/* + * strcpy + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if defined (__thumb2__) && !defined (__thumb__) + +/* For GLIBC: +#include +#include + +#undef strcmp +*/ + +#ifdef __thumb2__ +#define magic1(REG) "#0x01010101" +#define magic2(REG) "#0x80808080" +#else +#define magic1(REG) #REG +#define magic2(REG) #REG ", lsl #7" +#endif + +char* __attribute__((naked)) +__strcpy_arm (char* dst, const char* src) +{ + __asm__ ( + "pld [r1, #0]\n\t" + "eor r2, r0, r1\n\t" + "mov ip, r0\n\t" + "tst r2, #3\n\t" + "bne 4f\n\t" + "tst r1, #3\n\t" + "bne 3f\n" + "5:\n\t" +# ifndef __thumb2__ + "str r5, [sp, #-4]!\n\t" + "mov r5, #0x01\n\t" + "orr r5, r5, r5, lsl #8\n\t" + "orr r5, r5, r5, lsl #16\n\t" +# endif + + "str r4, [sp, #-4]!\n\t" + "tst r1, #4\n\t" + "ldr r3, [r1], #4\n\t" + "beq 2f\n\t" + "sub r2, r3, "magic1(r5)"\n\t" + "bics r2, r2, r3\n\t" + "tst r2, "magic2(r5)"\n\t" + "itt eq\n\t" + "streq r3, [ip], #4\n\t" + "ldreq r3, [r1], #4\n" + "bne 1f\n\t" + /* Inner loop. We now know that r1 is 64-bit aligned, so we + can safely fetch up to two words. This allows us to avoid + load stalls. */ + ".p2align 2\n" + "2:\n\t" + "pld [r1, #8]\n\t" + "ldr r4, [r1], #4\n\t" + "sub r2, r3, "magic1(r5)"\n\t" + "bics r2, r2, r3\n\t" + "tst r2, "magic2(r5)"\n\t" + "sub r2, r4, "magic1(r5)"\n\t" + "bne 1f\n\t" + "str r3, [ip], #4\n\t" + "bics r2, r2, r4\n\t" + "tst r2, "magic2(r5)"\n\t" + "itt eq\n\t" + "ldreq r3, [r1], #4\n\t" + "streq r4, [ip], #4\n\t" + "beq 2b\n\t" + "mov r3, r4\n" + "1:\n\t" +# ifdef __ARMEB__ + "rors r3, r3, #24\n\t" +# endif + "strb r3, [ip], #1\n\t" + "tst r3, #0xff\n\t" +# ifdef __ARMEL__ + "ror r3, r3, #8\n\t" +# endif + "bne 1b\n\t" + "ldr r4, [sp], #4\n\t" +# ifndef __thumb2__ + "ldr r5, [sp], #4\n\t" +# endif + "BX LR\n" + + /* Strings have the same offset from word alignment, but it's + not zero. */ + "3:\n\t" + "tst r1, #1\n\t" + "beq 1f\n\t" + "ldrb r2, [r1], #1\n\t" + "strb r2, [ip], #1\n\t" + "cmp r2, #0\n\t" + "it eq\n" + "BXEQ LR\n" + "1:\n\t" + "tst r1, #2\n\t" + "beq 5b\n\t" + "ldrh r2, [r1], #2\n\t" +# ifdef __ARMEB__ + "tst r2, #0xff00\n\t" + "iteet ne\n\t" + "strneh r2, [ip], #2\n\t" + "lsreq r2, r2, #8\n\t" + "streqb r2, [ip]\n\t" + "tstne r2, #0xff\n\t" +# else + "tst r2, #0xff\n\t" + "itet ne\n\t" + "strneh r2, [ip], #2\n\t" + "streqb r2, [ip]\n\t" + "tstne r2, #0xff00\n\t" +# endif + "bne 5b\n\t" + "BX LR\n" + + /* src and dst do not have a common word-alignement. Fall back to + byte copying. */ + "4:\n\t" + "ldrb r2, [r1], #1\n\t" + "strb r2, [ip], #1\n\t" + "cmp r2, #0\n\t" + "bne 4b\n\t" + "BX LR"); +} +/* For GLIBC: libc_hidden_builtin_def (strcpy) */ + +#endif /* defined (__thumb2__) && !defined (__thumb__) */ diff --git a/libc/AOR_v20.02/string/arm/strlen-armv6t2.S b/libc/AOR_v20.02/string/arm/strlen-armv6t2.S new file mode 100644 index 00000000000000..e368e62336140b --- /dev/null +++ b/libc/AOR_v20.02/string/arm/strlen-armv6t2.S @@ -0,0 +1,125 @@ +/* + * strlen - calculate the length of a string + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if __ARM_ARCH >= 6 && __ARM_ARCH_ISA_THUMB == 2 + +/* + Assumes: + ARMv6T2, AArch32 + + */ + +#include "../asmdefs.h" + +#ifdef __ARMEB__ +#define S2LO lsl +#define S2HI lsr +#else +#define S2LO lsr +#define S2HI lsl +#endif + + /* This code requires Thumb. */ + .thumb + .syntax unified + +/* Parameters and result. */ +#define srcin r0 +#define result r0 + +/* Internal variables. */ +#define src r1 +#define data1a r2 +#define data1b r3 +#define const_m1 r12 +#define const_0 r4 +#define tmp1 r4 /* Overlaps const_0 */ +#define tmp2 r5 + +ENTRY (__strlen_armv6t2) + pld [srcin, #0] + strd r4, r5, [sp, #-8]! + bic src, srcin, #7 + mvn const_m1, #0 + ands tmp1, srcin, #7 /* (8 - bytes) to alignment. */ + pld [src, #32] + bne.w L(misaligned8) + mov const_0, #0 + mov result, #-8 +L(loop_aligned): + /* Bytes 0-7. */ + ldrd data1a, data1b, [src] + pld [src, #64] + add result, result, #8 +L(start_realigned): + uadd8 data1a, data1a, const_m1 /* Saturating GE<0:3> set. */ + sel data1a, const_0, const_m1 /* Select based on GE<0:3>. */ + uadd8 data1b, data1b, const_m1 + sel data1b, data1a, const_m1 /* Only used if d1a == 0. */ + cbnz data1b, L(null_found) + + /* Bytes 8-15. */ + ldrd data1a, data1b, [src, #8] + uadd8 data1a, data1a, const_m1 /* Saturating GE<0:3> set. */ + add result, result, #8 + sel data1a, const_0, const_m1 /* Select based on GE<0:3>. */ + uadd8 data1b, data1b, const_m1 + sel data1b, data1a, const_m1 /* Only used if d1a == 0. */ + cbnz data1b, L(null_found) + + /* Bytes 16-23. */ + ldrd data1a, data1b, [src, #16] + uadd8 data1a, data1a, const_m1 /* Saturating GE<0:3> set. */ + add result, result, #8 + sel data1a, const_0, const_m1 /* Select based on GE<0:3>. */ + uadd8 data1b, data1b, const_m1 + sel data1b, data1a, const_m1 /* Only used if d1a == 0. */ + cbnz data1b, L(null_found) + + /* Bytes 24-31. */ + ldrd data1a, data1b, [src, #24] + add src, src, #32 + uadd8 data1a, data1a, const_m1 /* Saturating GE<0:3> set. */ + add result, result, #8 + sel data1a, const_0, const_m1 /* Select based on GE<0:3>. */ + uadd8 data1b, data1b, const_m1 + sel data1b, data1a, const_m1 /* Only used if d1a == 0. */ + cmp data1b, #0 + beq L(loop_aligned) + +L(null_found): + cmp data1a, #0 + itt eq + addeq result, result, #4 + moveq data1a, data1b +#ifndef __ARMEB__ + rev data1a, data1a +#endif + clz data1a, data1a + ldrd r4, r5, [sp], #8 + add result, result, data1a, lsr #3 /* Bits -> Bytes. */ + bx lr + +L(misaligned8): + ldrd data1a, data1b, [src] + and tmp2, tmp1, #3 + rsb result, tmp1, #0 + lsl tmp2, tmp2, #3 /* Bytes -> bits. */ + tst tmp1, #4 + pld [src, #64] + S2HI tmp2, const_m1, tmp2 + orn data1a, data1a, tmp2 + itt ne + ornne data1b, data1b, tmp2 + movne data1a, const_m1 + mov const_0, #0 + b L(start_realigned) + +END (__strlen_armv6t2) + +#endif /* __ARM_ARCH >= 6 && __ARM_ARCH_ISA_THUMB == 2 */ diff --git a/libc/AOR_v20.02/string/asmdefs.h b/libc/AOR_v20.02/string/asmdefs.h new file mode 100644 index 00000000000000..dcdd109ca0c06a --- /dev/null +++ b/libc/AOR_v20.02/string/asmdefs.h @@ -0,0 +1,32 @@ +/* + * Macros for asm code. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#ifndef _ASMDEFS_H +#define _ASMDEFS_H + +#define ENTRY_ALIGN(name, alignment) \ + .global name; \ + .type name,%function; \ + .align alignment; \ + name: \ + .cfi_startproc; + +#define ENTRY(name) ENTRY_ALIGN(name, 6) + +#define ENTRY_ALIAS(name) \ + .global name; \ + .type name,%function; \ + name: + +#define END(name) \ + .cfi_endproc; \ + .size name, .-name; + +#define L(l) .L ## l + +#endif diff --git a/libc/AOR_v20.02/string/include/stringlib.h b/libc/AOR_v20.02/string/include/stringlib.h new file mode 100644 index 00000000000000..252df46cfab3bb --- /dev/null +++ b/libc/AOR_v20.02/string/include/stringlib.h @@ -0,0 +1,58 @@ +/* + * Public API. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include + +/* restrict is not needed, but kept for documenting the interface contract. */ +#ifndef __restrict +# define __restrict +#endif + +#if __aarch64__ +void *__memcpy_aarch64 (void *__restrict, const void *__restrict, size_t); +void *__memmove_aarch64 (void *, const void *, size_t); +void *__memset_aarch64 (void *, int, size_t); +void *__memchr_aarch64 (const void *, int, size_t); +int __memcmp_aarch64 (const void *, const void *, size_t); +char *__strcpy_aarch64 (char *__restrict, const char *__restrict); +char *__stpcpy_aarch64 (char *__restrict, const char *__restrict); +int __strcmp_aarch64 (const char *, const char *); +char *__strchr_aarch64 (const char *, int); +char *__strrchr_aarch64 (const char *, int); +char *__strchrnul_aarch64 (const char *, int ); +size_t __strlen_aarch64 (const char *); +size_t __strnlen_aarch64 (const char *, size_t); +int __strncmp_aarch64 (const char *, const char *, size_t); +char *__strchr_aarch64_mte (const char *, int); +size_t __strlen_aarch64_mte (const char *); +#if __ARM_NEON +void *__memcpy_aarch64_simd (void *__restrict, const void *__restrict, size_t); +void *__memmove_aarch64_simd (void *, const void *, size_t); +#endif +# if __ARM_FEATURE_SVE +void *__memchr_aarch64_sve (const void *, int, size_t); +int __memcmp_aarch64_sve (const void *, const void *, size_t); +char *__strchr_aarch64_sve (const char *, int); +char *__strrchr_aarch64_sve (const char *, int); +char *__strchrnul_aarch64_sve (const char *, int ); +int __strcmp_aarch64_sve (const char *, const char *); +char *__strcpy_aarch64_sve (char *__restrict, const char *__restrict); +char *__stpcpy_aarch64_sve (char *__restrict, const char *__restrict); +size_t __strlen_aarch64_sve (const char *); +size_t __strnlen_aarch64_sve (const char *, size_t); +int __strncmp_aarch64_sve (const char *, const char *, size_t); +# endif +#elif __arm__ +void *__memcpy_arm (void *__restrict, const void *__restrict, size_t); +void *__memset_arm (void *, int, size_t); +void *__memchr_arm (const void *, int, size_t); +char *__strcpy_arm (char *__restrict, const char *__restrict); +int __strcmp_arm (const char *, const char *); +int __strcmp_armv6m (const char *, const char *); +size_t __strlen_armv6t2 (const char *); +#endif diff --git a/libc/AOR_v20.02/string/test/memchr.c b/libc/AOR_v20.02/string/test/memchr.c new file mode 100644 index 00000000000000..ee7f2131a458e5 --- /dev/null +++ b/libc/AOR_v20.02/string/test/memchr.c @@ -0,0 +1,94 @@ +/* + * memchr test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + void *(*fun)(const void *, int c, size_t n); +} funtab[] = { +#define F(x) {#x, x}, +F(memchr) +#if __aarch64__ +F(__memchr_aarch64) +# if __ARM_FEATURE_SVE +F(__memchr_aarch64_sve) +# endif +#elif __arm__ +F(__memchr_arm) +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define SP 512 +#define LEN 250000 +static unsigned char sbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int align, int seekpos, int len) +{ + unsigned char *src = alignup(sbuf); + unsigned char *s = src + align; + unsigned char *f = len ? s + seekpos : 0; + int seekchar = 0x1; + int i; + void *p; + + if (len > LEN || seekpos >= len || align >= A) + abort(); + + for (i = 0; i < seekpos; i++) + s[i] = 'a' + i%23; + s[i++] = seekchar; + for (; i < len; i++) + s[i] = 'a' + i%23; + + p = fun->fun(s, seekchar, len); + + if (p != f) { + ERR("%s(%p,0x%02x,%d) returned %p\n", fun->name, s, seekchar, len, p); + ERR("expected: %p\n", f); + abort(); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int a = 0; a < A; a++) { + for (int n = 0; n < 100; n++) + for (int sp = 0; sp < n-1; sp++) + test(funtab+i, a, sp, n); + for (int n = 100; n < LEN; n *= 2) { + test(funtab+i, a, n-1, n); + test(funtab+i, a, n/2, n); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/memcmp.c b/libc/AOR_v20.02/string/test/memcmp.c new file mode 100644 index 00000000000000..ece23bc571b5fd --- /dev/null +++ b/libc/AOR_v20.02/string/test/memcmp.c @@ -0,0 +1,97 @@ +/* + * memcmp test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + int (*fun)(const void *s1, const void *s2, size_t n); +} funtab[] = { +#define F(x) {#x, x}, +F(memcmp) +#if __aarch64__ +F(__memcmp_aarch64) +# if __ARM_FEATURE_SVE +F(__memcmp_aarch64_sve) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define LEN 250000 +static unsigned char s1buf[LEN+2*A]; +static unsigned char s2buf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int s1align, int s2align, int len, int diffpos) +{ + unsigned char *src1 = alignup(s1buf); + unsigned char *src2 = alignup(s2buf); + unsigned char *s1 = src1 + s1align; + unsigned char *s2 = src2 + s2align; + int r; + + if (len > LEN || s1align >= A || s2align >= A) + abort(); + if (diffpos && diffpos >= len) + abort(); + + for (int i = 0; i < len+A; i++) + src1[i] = src2[i] = '?'; + for (int i = 0; i < len; i++) + s1[i] = s2[i] = 'a' + i%23; + if (diffpos) + s1[diffpos]++; + + r = fun->fun(s1, s2, len); + + if ((!diffpos && r != 0) || (diffpos && r == 0)) { + ERR("%s(align %d, align %d, %d) failed, returned %d\n", + fun->name, s1align, s2align, len, r); + ERR("src1: %.*s\n", s1align+len+1, src1); + ERR("src2: %.*s\n", s2align+len+1, src2); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int d = 0; d < A; d++) + for (int s = 0; s < A; s++) { + int n; + for (n = 0; n < 100; n++) { + test(funtab+i, d, s, n, 0); + test(funtab+i, d, s, n, n / 2); + } + for (; n < LEN; n *= 2) { + test(funtab+i, d, s, n, 0); + test(funtab+i, d, s, n, n / 2); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/memcpy.c b/libc/AOR_v20.02/string/test/memcpy.c new file mode 100644 index 00000000000000..62823af331ee74 --- /dev/null +++ b/libc/AOR_v20.02/string/test/memcpy.c @@ -0,0 +1,99 @@ +/* + * memcpy test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + void *(*fun)(void *, const void *, size_t); +} funtab[] = { +#define F(x) {#x, x}, +F(memcpy) +#if __aarch64__ +F(__memcpy_aarch64) +# if __ARM_NEON +F(__memcpy_aarch64_simd) +# endif +#elif __arm__ +F(__memcpy_arm) +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define LEN 250000 +static unsigned char dbuf[LEN+2*A]; +static unsigned char sbuf[LEN+2*A]; +static unsigned char wbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int dalign, int salign, int len) +{ + unsigned char *src = alignup(sbuf); + unsigned char *dst = alignup(dbuf); + unsigned char *want = wbuf; + unsigned char *s = src + salign; + unsigned char *d = dst + dalign; + unsigned char *w = want + dalign; + void *p; + int i; + + if (len > LEN || dalign >= A || salign >= A) + abort(); + for (i = 0; i < len+A; i++) { + src[i] = '?'; + want[i] = dst[i] = '*'; + } + for (i = 0; i < len; i++) + s[i] = w[i] = 'a' + i%23; + + p = fun->fun(d, s, len); + if (p != d) + ERR("%s(%p,..) returned %p\n", fun->name, d, p); + for (i = 0; i < len+A; i++) { + if (dst[i] != want[i]) { + ERR("%s(align %d, align %d, %d) failed\n", fun->name, dalign, salign, len); + ERR("got : %.*s\n", dalign+len+1, dst); + ERR("want: %.*s\n", dalign+len+1, want); + break; + } + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int d = 0; d < A; d++) + for (int s = 0; s < A; s++) { + int n; + for (n = 0; n < 100; n++) + test(funtab+i, d, s, n); + for (; n < LEN; n *= 2) + test(funtab+i, d, s, n); + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/memmove.c b/libc/AOR_v20.02/string/test/memmove.c new file mode 100644 index 00000000000000..6bb9eee1c3d978 --- /dev/null +++ b/libc/AOR_v20.02/string/test/memmove.c @@ -0,0 +1,145 @@ +/* + * memmove test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + void *(*fun)(void *, const void *, size_t); +} funtab[] = { +#define F(x) {#x, x}, +F(memmove) +#if __aarch64__ +F(__memmove_aarch64) +# if __ARM_NEON +F(__memmove_aarch64_simd) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define LEN 250000 +static unsigned char dbuf[LEN+2*A]; +static unsigned char sbuf[LEN+2*A]; +static unsigned char wbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int dalign, int salign, int len) +{ + unsigned char *src = alignup(sbuf); + unsigned char *dst = alignup(dbuf); + unsigned char *want = wbuf; + unsigned char *s = src + salign; + unsigned char *d = dst + dalign; + unsigned char *w = want + dalign; + void *p; + int i; + + if (len > LEN || dalign >= A || salign >= A) + abort(); + for (i = 0; i < len+A; i++) { + src[i] = '?'; + want[i] = dst[i] = '*'; + } + for (i = 0; i < len; i++) + s[i] = w[i] = 'a' + i%23; + + p = fun->fun(d, s, len); + if (p != d) + ERR("%s(%p,..) returned %p\n", fun->name, d, p); + for (i = 0; i < len+A; i++) { + if (dst[i] != want[i]) { + ERR("%s(align %d, align %d, %d) failed\n", fun->name, dalign, salign, len); + ERR("got : %.*s\n", dalign+len+1, dst); + ERR("want: %.*s\n", dalign+len+1, want); + break; + } + } +} + +static void test_overlap(const struct fun *fun, int dalign, int salign, int len) +{ + unsigned char *src = alignup(sbuf); + unsigned char *dst = alignup(sbuf); + unsigned char *want = wbuf; + unsigned char *s = src + salign; + unsigned char *d = dst + dalign; + unsigned char *w = wbuf + dalign; + void *p; + + if (len > LEN || dalign >= A || salign >= A) + abort(); + + for (int i = 0; i < len+A; i++) + src[i] = want[i] = '?'; + + for (int i = 0; i < len; i++) + s[i] = w[i] = 'a' + i%23; + + /* Copy the potential overlap range. */ + if (s < d) { + for (int i = 0; i < (uintptr_t)d-(uintptr_t)s; i++) + want[salign+i] = src[salign+i]; + } else { + for (int i = 0; i < (uintptr_t)s-(uintptr_t)d; i++) + want[len + dalign + i] = src[len + dalign + i]; + } + + p = fun->fun(d, s, len); + if (p != d) + ERR("%s(%p,..) returned %p\n", fun->name, d, p); + for (int i = 0; i < len+A; i++) { + if (dst[i] != want[i]) { + ERR("%s(align %d, align %d, %d) failed\n", fun->name, dalign, salign, len); + ERR("got : %.*s\n", dalign+len+1, dst); + ERR("want: %.*s\n", dalign+len+1, want); + abort(); + break; + } + } +} + +int main() +{ + test_overlap(funtab+0, 2, 1, 1); + + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int d = 0; d < A; d++) + for (int s = 0; s < A; s++) { + int n; + for (n = 0; n < 100; n++) { + test(funtab+i, d, s, n); + test_overlap(funtab+i, d, s, n); + } + for (; n < LEN; n *= 2) { + test(funtab+i, d, s, n); + test_overlap(funtab+i, d, s, n); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/memset.c b/libc/AOR_v20.02/string/test/memset.c new file mode 100644 index 00000000000000..b977ceeb3102d6 --- /dev/null +++ b/libc/AOR_v20.02/string/test/memset.c @@ -0,0 +1,112 @@ +/* + * memset test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + void *(*fun)(void *s, int c, size_t n); +} funtab[] = { +#define F(x) {#x, x}, +F(memset) +#if __aarch64__ +F(__memset_aarch64) +#elif __arm__ +F(__memset_arm) +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define LEN 250000 +static unsigned char sbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void err(const char *name, unsigned char *src, int salign, int c, int len) +{ + ERR("%s(align %d, %d, %d) failed\n", name, salign, c, len); + ERR("got : %.*s\n", salign+len+1, src); +} + +static void test(const struct fun *fun, int salign, int c, int len) +{ + unsigned char *src = alignup(sbuf); + unsigned char *s = src + salign; + void *p; + int i; + + if (len > LEN || salign >= A) + abort(); + for (i = 0; i < len+A; i++) + src[i] = '?'; + for (i = 0; i < len; i++) + s[i] = 'a' + i%23; + for (; ifun(s, c, len); + if (p != s) + ERR("%s(%p,..) returned %p\n", fun->name, s, p); + + for (i = 0; i < salign; i++) { + if (src[i] != '?') { + err(fun->name, src, salign, c, len); + return; + } + } + for (i = salign; i < len; i++) { + if (src[i] != (unsigned char)c) { + err(fun->name, src, salign, c, len); + return; + } + } + for (; i < len%A; i++) { + if (src[i] != '*') { + err(fun->name, src, salign, c, len); + return; + } + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int s = 0; s < A; s++) { + int n; + for (n = 0; n < 100; n++) { + test(funtab+i, s, 0, n); + test(funtab+i, s, 0x25, n); + test(funtab+i, s, 0xaa25, n); + } + for (; n < LEN; n *= 2) { + test(funtab+i, s, 0, n); + test(funtab+i, s, 0x25, n); + test(funtab+i, s, 0xaa25, n); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/stpcpy.c b/libc/AOR_v20.02/string/test/stpcpy.c new file mode 100644 index 00000000000000..eea9be1cac6ccd --- /dev/null +++ b/libc/AOR_v20.02/string/test/stpcpy.c @@ -0,0 +1,99 @@ +/* + * stpcpy test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + char *(*fun)(char *dest, const char *src); +} funtab[] = { +#define F(x) {#x, x}, +F(stpcpy) +#if __aarch64__ +F(__stpcpy_aarch64) +# if __ARM_FEATURE_SVE +F(__stpcpy_aarch64_sve) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define LEN 250000 +static char dbuf[LEN+2*A]; +static char sbuf[LEN+2*A]; +static char wbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int dalign, int salign, int len) +{ + char *src = alignup(sbuf); + char *dst = alignup(dbuf); + char *want = wbuf; + char *s = src + salign; + char *d = dst + dalign; + char *w = want + dalign; + void *p; + int i; + + if (len > LEN || dalign >= A || salign >= A) + abort(); + for (i = 0; i < len+A; i++) { + src[i] = '?'; + want[i] = dst[i] = '*'; + } + for (i = 0; i < len; i++) + s[i] = w[i] = 'a' + i%23; + s[i] = w[i] = '\0'; + + p = fun->fun(d, s); + if (p != d + len) + ERR("%s(%p,..) returned %p\n", fun->name, d, p); + for (i = 0; i < len+A; i++) { + if (dst[i] != want[i]) { + ERR("%s(align %d, align %d, %d) failed\n", fun->name, dalign, salign, len); + ERR("got : %.*s\n", dalign+len+1, dst); + ERR("want: %.*s\n", dalign+len+1, want); + break; + } + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int d = 0; d < A; d++) + for (int s = 0; s < A; s++) { + int n; + for (n = 0; n < 100; n++) + test(funtab+i, d, s, n); + for (; n < LEN; n *= 2) + test(funtab+i, d, s, n); + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/strchr.c b/libc/AOR_v20.02/string/test/strchr.c new file mode 100644 index 00000000000000..6076e038095554 --- /dev/null +++ b/libc/AOR_v20.02/string/test/strchr.c @@ -0,0 +1,99 @@ +/* + * strchr test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + char *(*fun)(const char *s, int c); +} funtab[] = { +#define F(x) {#x, x}, +F(strchr) +#if __aarch64__ +F(__strchr_aarch64) +F(__strchr_aarch64_mte) +# if __ARM_FEATURE_SVE +F(__strchr_aarch64_sve) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define SP 512 +#define LEN 250000 +static char sbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int align, int seekpos, int len) +{ + char *src = alignup(sbuf); + char *s = src + align; + char *f = seekpos != -1 ? s + seekpos : 0; + int seekchar = 0x1; + void *p; + + if (len > LEN || seekpos >= len - 1 || align >= A) + abort(); + if (seekchar >= 'a' && seekchar <= 'a' + 23) + abort(); + + for (int i = 0; i < len + A; i++) + src[i] = '?'; + for (int i = 0; i < len - 2; i++) + s[i] = 'a' + i%23; + if (seekpos != -1) + s[seekpos] = seekchar; + s[len - 1] = '\0'; + + p = fun->fun(s, seekchar); + + if (p != f) { + ERR("%s(%p,0x%02x,%d) returned %p\n", fun->name, s, seekchar, len, p); + ERR("expected: %p\n", f); + abort(); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int a = 0; a < A; a++) { + int n; + for (n = 1; n < 100; n++) { + for (int sp = 0; sp < n - 1; sp++) + test(funtab+i, a, sp, n); + test(funtab+i, a, -1, n); + } + for (; n < LEN; n *= 2) { + test(funtab+i, a, -1, n); + test(funtab+i, a, n / 2, n); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/strchrnul.c b/libc/AOR_v20.02/string/test/strchrnul.c new file mode 100644 index 00000000000000..6be1ec6f1dc091 --- /dev/null +++ b/libc/AOR_v20.02/string/test/strchrnul.c @@ -0,0 +1,100 @@ +/* + * strchrnul test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + char *(*fun)(const char *s, int c); +} funtab[] = { +#define F(x) {#x, x}, +F(strchrnul) +#if __aarch64__ +F(__strchrnul_aarch64) +# if __ARM_FEATURE_SVE +F(__strchrnul_aarch64_sve) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define SP 512 +#define LEN 250000 +static char sbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int align, int seekpos, int len) +{ + char *src = alignup(sbuf); + char *s = src + align; + char *f = seekpos != -1 ? s + seekpos : s + len - 1; + int seekchar = 0x1; + void *p; + + if (len > LEN || seekpos >= len - 1 || align >= A) + abort(); + if (seekchar >= 'a' && seekchar <= 'a' + 23) + abort(); + + for (int i = 0; i < len + A; i++) + src[i] = '?'; + for (int i = 0; i < len - 2; i++) + s[i] = 'a' + i%23; + if (seekpos != -1) + s[seekpos] = seekchar; + s[len - 1] = '\0'; + + p = fun->fun(s, seekchar); + + if (p != f) { + ERR("%s(%p,0x%02x,%d) returned %p\n", fun->name, s, seekchar, len, p); + ERR("expected: %p\n", f); + abort(); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int a = 0; a < A; a++) { + int n; + for (n = 1; n < 100; n++) { + for (int sp = 0; sp < n - 1; sp++) + test(funtab+i, a, sp, n); + test(funtab+i, a, -1, n); + } + for (; n < LEN; n *= 2) { + test(funtab+i, a, -1, n); + test(funtab+i, a, n / 2, n); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/strcmp.c b/libc/AOR_v20.02/string/test/strcmp.c new file mode 100644 index 00000000000000..40aa6fdf6cdd6f --- /dev/null +++ b/libc/AOR_v20.02/string/test/strcmp.c @@ -0,0 +1,104 @@ +/* + * strcmp test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + int (*fun)(const char *s1, const char *s2); +} funtab[] = { +#define F(x) {#x, x}, +F(strcmp) +#if __aarch64__ +F(__strcmp_aarch64) +# if __ARM_FEATURE_SVE +F(__strcmp_aarch64_sve) +# endif +#elif __arm__ +# if __ARM_ARCH >= 7 && __ARM_ARCH_ISA_ARM >= 1 +F(__strcmp_arm) +# elif __ARM_ARCH == 6 && __ARM_ARCH_6M__ >= 1 +F(__strcmp_armv6m) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define LEN 250000 +static char s1buf[LEN+2*A]; +static char s2buf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int s1align, int s2align, int len, int diffpos) +{ + char *src1 = alignup(s1buf); + char *src2 = alignup(s2buf); + char *s1 = src1 + s1align; + char *s2 = src2 + s2align; + int r; + + if (len > LEN || s1align >= A || s2align >= A) + abort(); + if (diffpos > 1 && diffpos >= len-1) + abort(); + + for (int i = 0; i < len+A; i++) + src1[i] = src2[i] = '?'; + for (int i = 0; i < len-1; i++) + s1[i] = s2[i] = 'a' + i%23; + if (diffpos > 1) + s1[diffpos]++; + s1[len] = s2[len] = '\0'; + + r = fun->fun(s1, s2); + + if (((diffpos <= 1) && r != 0) || (diffpos > 1 && r == 0)) { + ERR("%s(align %d, align %d, %d) failed, returned %d\n", + fun->name, s1align, s2align, len, r); + ERR("src1: %.*s\n", s1align+len+1, src1); + ERR("src2: %.*s\n", s2align+len+1, src2); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int d = 0; d < A; d++) + for (int s = 0; s < A; s++) { + int n; + for (n = 0; n < 100; n++) { + test(funtab+i, d, s, n, 0); + test(funtab+i, d, s, n, n / 2); + } + for (; n < LEN; n *= 2) { + test(funtab+i, d, s, n, 0); + test(funtab+i, d, s, n, n / 2); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/strcpy.c b/libc/AOR_v20.02/string/test/strcpy.c new file mode 100644 index 00000000000000..d00fbefd792d01 --- /dev/null +++ b/libc/AOR_v20.02/string/test/strcpy.c @@ -0,0 +1,100 @@ +/* + * strcpy test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + char *(*fun)(char *dest, const char *src); +} funtab[] = { +#define F(x) {#x, x}, +F(strcpy) +#if __aarch64__ +F(__strcpy_aarch64) +# if __ARM_FEATURE_SVE +F(__strcpy_aarch64_sve) +# endif +#elif __arm__ && defined (__thumb2__) && !defined (__thumb__) +F(__strcpy_arm) +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define LEN 250000 +static char dbuf[LEN+2*A]; +static char sbuf[LEN+2*A]; +static char wbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int dalign, int salign, int len) +{ + char *src = alignup(sbuf); + char *dst = alignup(dbuf); + char *want = wbuf; + char *s = src + salign; + char *d = dst + dalign; + char *w = want + dalign; + void *p; + int i; + + if (len > LEN || dalign >= A || salign >= A) + abort(); + for (i = 0; i < len+A; i++) { + src[i] = '?'; + want[i] = dst[i] = '*'; + } + for (i = 0; i < len; i++) + s[i] = w[i] = 'a' + i%23; + s[i] = w[i] = '\0'; + + p = fun->fun(d, s); + if (p != d) + ERR("%s(%p,..) returned %p\n", fun->name, d, p); + for (i = 0; i < len+A; i++) { + if (dst[i] != want[i]) { + ERR("%s(align %d, align %d, %d) failed\n", fun->name, dalign, salign, len); + ERR("got : %.*s\n", dalign+len+1, dst); + ERR("want: %.*s\n", dalign+len+1, want); + break; + } + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int d = 0; d < A; d++) + for (int s = 0; s < A; s++) { + int n; + for (n = 0; n < 100; n++) + test(funtab+i, d, s, n); + for (; n < LEN; n *= 2) + test(funtab+i, d, s, n); + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/strlen.c b/libc/AOR_v20.02/string/test/strlen.c new file mode 100644 index 00000000000000..16a9176495c512 --- /dev/null +++ b/libc/AOR_v20.02/string/test/strlen.c @@ -0,0 +1,92 @@ +/* + * strlen test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + size_t (*fun)(const char *s); +} funtab[] = { +#define F(x) {#x, x}, +F(strlen) +#if __aarch64__ +F(__strlen_aarch64) +F(__strlen_aarch64_mte) +# if __ARM_FEATURE_SVE +F(__strlen_aarch64_sve) +# endif +#elif __arm__ +# if __ARM_ARCH >= 6 && __ARM_ARCH_ISA_THUMB == 2 +F(__strlen_armv6t2) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define SP 512 +#define LEN 250000 +static char sbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int align, int len) +{ + char *src = alignup(sbuf); + char *s = src + align; + size_t r; + + if (len > LEN || align >= A) + abort(); + + for (int i = 0; i < len + A; i++) + src[i] = '?'; + for (int i = 0; i < len - 2; i++) + s[i] = 'a' + i%23; + s[len - 1] = '\0'; + + r = fun->fun(s); + if (r != len-1) { + ERR("%s(%p) returned %zu\n", fun->name, s, r); + ERR("input: %.*s\n", align+len+1, src); + ERR("expected: %d\n", len); + abort(); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int a = 0; a < A; a++) { + int n; + for (n = 1; n < 100; n++) + test(funtab+i, a, n); + for (; n < LEN; n *= 2) + test(funtab+i, a, n); + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/strncmp.c b/libc/AOR_v20.02/string/test/strncmp.c new file mode 100644 index 00000000000000..db2ef264aca1a4 --- /dev/null +++ b/libc/AOR_v20.02/string/test/strncmp.c @@ -0,0 +1,104 @@ +/* + * strncmp test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + int (*fun)(const char *, const char *, size_t); +} funtab[] = { +#define F(x) {#x, x}, +F(strncmp) +#if __aarch64__ +F(__strncmp_aarch64) +# if __ARM_FEATURE_SVE +F(__strncmp_aarch64_sve) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define LEN 250000 +static char s1buf[LEN+2*A]; +static char s2buf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int s1align, int s2align, int maxlen, int diffpos, int len) +{ + char *src1 = alignup(s1buf); + char *src2 = alignup(s2buf); + char *s1 = src1 + s1align; + char *s2 = src2 + s2align; + int r; + + if (len > LEN || s1align >= A || s2align >= A) + abort(); + if (diffpos > 1 && diffpos >= len-1) + abort(); + + for (int i = 0; i < len+A; i++) + src1[i] = src2[i] = '?'; + for (int i = 0; i < len-1; i++) + s1[i] = s2[i] = 'a' + i%23; + if (diffpos > 1) + s1[diffpos]++; + s1[len] = s2[len] = '\0'; + + r = fun->fun(s1, s2, maxlen); + + diffpos = maxlen <= diffpos ? 0 : diffpos; + + if (((diffpos <= 1) && r != 0) || (diffpos > 1 && r == 0)) { + ERR("%s(align %d, align %d, %d (%d)) failed, returned %d (%d)\n", + fun->name, s1align, s2align, maxlen, len, r, diffpos); + ERR("src1: %.*s\n", s1align+len+1, src1); + ERR("src2: %.*s\n", s2align+len+1, src2); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int d = 0; d < A; d++) + for (int s = 0; s < A; s++) { + int n; + for (n = 0; n < 100; n++) { + test(funtab+i, d, s, n, 0, n); + test(funtab+i, d, s, n, n/2, n); + test(funtab+i, d, s, n/2, 0, n); + test(funtab+i, d, s, n/2, n/2, n); + } + for (; n < LEN; n *= 2) { + test(funtab+i, d, s, n, 0, n); + test(funtab+i, d, s, n, n/2, n); + test(funtab+i, d, s, n/2, 0, n); + test(funtab+i, d, s, n/2, n/2, n); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/strnlen.c b/libc/AOR_v20.02/string/test/strnlen.c new file mode 100644 index 00000000000000..d71272f16db244 --- /dev/null +++ b/libc/AOR_v20.02/string/test/strnlen.c @@ -0,0 +1,94 @@ +/* + * strnlen test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#define _POSIX_C_SOURCE 200809L + +#include +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + size_t (*fun)(const char *s, size_t m); +} funtab[] = { +#define F(x) {#x, x}, +F(strnlen) +#if __aarch64__ +F(__strnlen_aarch64) +# if __ARM_FEATURE_SVE +F(__strnlen_aarch64_sve) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define SP 512 +#define LEN 250000 +static char sbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int align, int maxlen, int len) +{ + char *src = alignup(sbuf); + char *s = src + align; + size_t r; + size_t e = maxlen < len ? maxlen : len - 1; + + if (len > LEN || align >= A) + abort(); + + for (int i = 0; i < len + A; i++) + src[i] = '?'; + for (int i = 0; i < len - 2; i++) + s[i] = 'a' + i%23; + s[len - 1] = '\0'; + + r = fun->fun(s, maxlen); + if (r != e) { + ERR("%s(%p) returned %zu\n", fun->name, s, r); + ERR("input: %.*s\n", align+len+1, src); + ERR("expected: %d\n", len); + abort(); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int a = 0; a < A; a++) { + int n; + for (n = 1; n < 100; n++) + for (int maxlen = 0; maxlen < 100; maxlen++) + test(funtab+i, a, maxlen, n); + for (; n < LEN; n *= 2) { + test(funtab+i, a, n*2, n); + test(funtab+i, a, n, n); + test(funtab+i, a, n/2, n); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/test/strrchr.c b/libc/AOR_v20.02/string/test/strrchr.c new file mode 100644 index 00000000000000..b2c3c873fcb670 --- /dev/null +++ b/libc/AOR_v20.02/string/test/strrchr.c @@ -0,0 +1,98 @@ +/* + * strrchr test. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#include +#include +#include +#include +#include +#include "stringlib.h" + +static const struct fun +{ + const char *name; + char *(*fun)(const char *s, int c); +} funtab[] = { +#define F(x) {#x, x}, +F(strrchr) +#if __aarch64__ +F(__strrchr_aarch64) +# if __ARM_FEATURE_SVE +F(__strrchr_aarch64_sve) +# endif +#endif +#undef F + {0, 0} +}; + +static int test_status; +#define ERR(...) (test_status=1, printf(__VA_ARGS__)) + +#define A 32 +#define SP 512 +#define LEN 250000 +static char sbuf[LEN+2*A]; + +static void *alignup(void *p) +{ + return (void*)(((uintptr_t)p + A-1) & -A); +} + +static void test(const struct fun *fun, int align, int seekpos, int len) +{ + char *src = alignup(sbuf); + char *s = src + align; + char *f = seekpos != -1 ? s + seekpos : 0; + int seekchar = 0x1; + void *p; + + if (len > LEN || seekpos >= len - 1 || align >= A) + abort(); + if (seekchar >= 'a' && seekchar <= 'a' + 23) + abort(); + + for (int i = 0; i < len + A; i++) + src[i] = '?'; + for (int i = 0; i < len - 2; i++) + s[i] = 'a' + i%23; + if (seekpos != -1) + s[seekpos/2] = s[seekpos] = seekchar; + s[len - 1] = '\0'; + + p = fun->fun(s, seekchar); + + if (p != f) { + ERR("%s(%p,0x%02x,%d) returned %p\n", fun->name, s, seekchar, len, p); + ERR("expected: %p\n", f); + abort(); + } +} + +int main() +{ + int r = 0; + for (int i=0; funtab[i].name; i++) { + test_status = 0; + for (int a = 0; a < A; a++) { + int n; + for (n = 1; n < 100; n++) { + for (int sp = 0; sp < n - 1; sp++) + test(funtab+i, a, sp, n); + test(funtab+i, a, -1, n); + } + for (; n < LEN; n *= 2) { + test(funtab+i, a, -1, n); + test(funtab+i, a, n / 2, n); + } + } + printf("%s %s\n", test_status ? "FAIL" : "PASS", funtab[i].name); + if (test_status) + r = -1; + } + return r; +} diff --git a/libc/AOR_v20.02/string/x86_64/check-arch.S b/libc/AOR_v20.02/string/x86_64/check-arch.S new file mode 100644 index 00000000000000..8c29aa5a7b3f47 --- /dev/null +++ b/libc/AOR_v20.02/string/x86_64/check-arch.S @@ -0,0 +1,11 @@ +/* + * check ARCH setting. + * + * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. + * See https://llvm.org/LICENSE.txt for license information. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + */ + +#if !__x86_64__ +# error ARCH setting does not match the compiler. +#endif diff --git a/libcxx/test/support/msvc_stdlib_force_include.h b/libcxx/test/support/msvc_stdlib_force_include.h index fd47af4e7983b9..768558efe76ff5 100644 --- a/libcxx/test/support/msvc_stdlib_force_include.h +++ b/libcxx/test/support/msvc_stdlib_force_include.h @@ -91,7 +91,19 @@ const AssertionDialogAvoider assertion_dialog_avoider{}; #endif #define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST -#define _LIBCPP_SUPPRESS_DEPRECATED_PUSH -#define _LIBCPP_SUPPRESS_DEPRECATED_POP + +#ifdef __clang__ +#define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \ + _Pragma("GCC diagnostic push") \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated\"") +#define _LIBCPP_SUPPRESS_DEPRECATED_POP \ + _Pragma("GCC diagnostic pop") +#else // ^^^ clang / MSVC vvv +#define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \ + __pragma(warning(push)) \ + __pragma(warning(disable : 4996)) +#define _LIBCPP_SUPPRESS_DEPRECATED_POP \ + __pragma(warning(pop)) +#endif // __clang__ #endif // SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_H diff --git a/lld/COFF/Writer.cpp b/lld/COFF/Writer.cpp index bb583757cb6194..7e7aaafe18ed5e 100644 --- a/lld/COFF/Writer.cpp +++ b/lld/COFF/Writer.cpp @@ -102,7 +102,7 @@ class DebugDirectoryChunk : public NonSectionChunk { void writeTo(uint8_t *b) const override { auto *d = reinterpret_cast(b); - for (const std::pair record : records) { + for (const std::pair& record : records) { Chunk *c = record.second; OutputSection *os = c->getOutputSection(); uint64_t offs = os->getFileOff() + (c->getRVA() - os->getRVA()); diff --git a/lldb/source/Commands/CommandObjectExpression.cpp b/lldb/source/Commands/CommandObjectExpression.cpp index 388f9f0af66acb..7d8de573df0e8c 100644 --- a/lldb/source/Commands/CommandObjectExpression.cpp +++ b/lldb/source/Commands/CommandObjectExpression.cpp @@ -403,9 +403,9 @@ CommandObjectExpression::GetEvalOptions(const Target &target) { } bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr, - Stream *output_stream, - Stream *error_stream, - CommandReturnObject *result) { + Stream &output_stream, + Stream &error_stream, + CommandReturnObject &result) { // Don't use m_exe_ctx as this might be called asynchronously after the // command object DoExecute has finished when doing multi-line expression // that use an input reader... @@ -425,11 +425,10 @@ bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr, // We only tell you about the FixIt if we applied it. The compiler errors // will suggest the FixIt if it parsed. - if (error_stream && !m_fixed_expression.empty() && - target->GetEnableNotifyAboutFixIts()) { + if (!m_fixed_expression.empty() && target->GetEnableNotifyAboutFixIts()) { if (success == eExpressionCompleted) - error_stream->Printf(" Fix-it applied, fixed expression was: \n %s\n", - m_fixed_expression.c_str()); + error_stream.Printf(" Fix-it applied, fixed expression was: \n %s\n", + m_fixed_expression.c_str()); } if (result_valobj_sp) { @@ -443,10 +442,10 @@ bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr, if (m_varobj_options.elem_count > 0) { Status error(CanBeUsedForElementCountPrinting(*result_valobj_sp)); if (error.Fail()) { - result->AppendErrorWithFormat( + result.AppendErrorWithFormat( "expression cannot be used with --element-count %s\n", error.AsCString("")); - result->SetStatus(eReturnStatusFailed); + result.SetStatus(eReturnStatusFailed); return false; } } @@ -456,36 +455,33 @@ bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr, options.SetVariableFormatDisplayLanguage( result_valobj_sp->GetPreferredDisplayLanguage()); - result_valobj_sp->Dump(*output_stream, options); + result_valobj_sp->Dump(output_stream, options); - if (result) - result->SetStatus(eReturnStatusSuccessFinishResult); + result.SetStatus(eReturnStatusSuccessFinishResult); } } else { if (result_valobj_sp->GetError().GetError() == UserExpression::kNoResult) { if (format != eFormatVoid && GetDebugger().GetNotifyVoid()) { - error_stream->PutCString("(void)\n"); + error_stream.PutCString("(void)\n"); } - if (result) - result->SetStatus(eReturnStatusSuccessFinishResult); + result.SetStatus(eReturnStatusSuccessFinishResult); } else { const char *error_cstr = result_valobj_sp->GetError().AsCString(); if (error_cstr && error_cstr[0]) { const size_t error_cstr_len = strlen(error_cstr); const bool ends_with_newline = error_cstr[error_cstr_len - 1] == '\n'; if (strstr(error_cstr, "error:") != error_cstr) - error_stream->PutCString("error: "); - error_stream->Write(error_cstr, error_cstr_len); + error_stream.PutCString("error: "); + error_stream.Write(error_cstr, error_cstr_len); if (!ends_with_newline) - error_stream->EOL(); + error_stream.EOL(); } else { - error_stream->PutCString("error: unknown error\n"); + error_stream.PutCString("error: unknown error\n"); } - if (result) - result->SetStatus(eReturnStatusFailed); + result.SetStatus(eReturnStatusFailed); } } } @@ -502,7 +498,8 @@ void CommandObjectExpression::IOHandlerInputComplete(IOHandler &io_handler, StreamFileSP output_sp = io_handler.GetOutputStreamFileSP(); StreamFileSP error_sp = io_handler.GetErrorStreamFileSP(); - EvaluateExpression(line.c_str(), output_sp.get(), error_sp.get()); + CommandReturnObject return_obj; + EvaluateExpression(line.c_str(), *output_sp, *error_sp, return_obj); if (output_sp) output_sp->Flush(); if (error_sp) @@ -650,8 +647,8 @@ bool CommandObjectExpression::DoExecute(llvm::StringRef command, } Target &target = GetSelectedOrDummyTarget(); - if (EvaluateExpression(expr, &(result.GetOutputStream()), - &(result.GetErrorStream()), &result)) { + if (EvaluateExpression(expr, result.GetOutputStream(), + result.GetErrorStream(), result)) { if (!m_fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) { CommandHistory &history = m_interpreter.GetCommandHistory(); diff --git a/lldb/source/Commands/CommandObjectExpression.h b/lldb/source/Commands/CommandObjectExpression.h index b3bee3ca0e8cc3..ddee9c36924d74 100644 --- a/lldb/source/Commands/CommandObjectExpression.h +++ b/lldb/source/Commands/CommandObjectExpression.h @@ -71,9 +71,8 @@ class CommandObjectExpression : public CommandObjectRaw, /// expression in the given target. EvaluateExpressionOptions GetEvalOptions(const Target &target); - bool EvaluateExpression(llvm::StringRef expr, Stream *output_stream, - Stream *error_stream, - CommandReturnObject *result = nullptr); + bool EvaluateExpression(llvm::StringRef expr, Stream &output_stream, + Stream &error_stream, CommandReturnObject &result); void GetMultilineExpression(); diff --git a/lldb/source/Host/CMakeLists.txt b/lldb/source/Host/CMakeLists.txt index ac8655f3dd8869..35714043201020 100644 --- a/lldb/source/Host/CMakeLists.txt +++ b/lldb/source/Host/CMakeLists.txt @@ -115,7 +115,7 @@ else() elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD") add_host_subdirectory(netbsd - netbsd/Host.cpp + netbsd/HostNetBSD.cpp netbsd/HostInfoNetBSD.cpp ) diff --git a/lldb/source/Host/netbsd/Host.cpp b/lldb/source/Host/netbsd/HostNetBSD.cpp similarity index 99% rename from lldb/source/Host/netbsd/Host.cpp rename to lldb/source/Host/netbsd/HostNetBSD.cpp index 57f985129a6133..4708fb45deed0e 100644 --- a/lldb/source/Host/netbsd/Host.cpp +++ b/lldb/source/Host/netbsd/HostNetBSD.cpp @@ -1,4 +1,4 @@ -//===-- source/Host/netbsd/Host.cpp ---------------------------------------===// +//===-- source/Host/netbsd/HostNetBSD.cpp ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. diff --git a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp index e70ab1ce8d5aed..b9442872c785ac 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp @@ -427,7 +427,7 @@ bool IRForTarget::RewriteObjCConstString(llvm::GlobalVariable *ns_str, m_execution_unit.FindSymbol(g_CFStringCreateWithBytes_str, missing_weak); if (CFStringCreateWithBytes_addr == LLDB_INVALID_ADDRESS || missing_weak) { - log->PutCString("Couldn't find CFStringCreateWithBytes in the target"); + LLDB_LOG(log, "Couldn't find CFStringCreateWithBytes in the target"); m_error_stream.Printf("Error [IRForTarget]: Rewriting an Objective-C " "constant string requires " diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp index 1ed3e693d8d21d..73bd9fb0bed810 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp @@ -810,31 +810,9 @@ GDBRemoteCommunication::CheckForPacket(const uint8_t *src, size_t src_len, GDBRemotePacket::ePacketTypeRecv, total_length); // Copy the packet from m_bytes to packet_str expanding the run-length - // encoding in the process. Reserve enough byte for the most common case - // (no RLE used) - std ::string packet_str; - packet_str.reserve(m_bytes.length()); - for (std::string::const_iterator c = m_bytes.begin() + content_start; - c != m_bytes.begin() + content_end; ++c) { - if (*c == '*') { - // '*' indicates RLE. Next character will give us the repeat count - // and previous character is what is to be repeated. - char char_to_repeat = packet_str.back(); - // Number of time the previous character is repeated - int repeat_count = *++c + 3 - ' '; - // We have the char_to_repeat and repeat_count. Now push it in the - // packet. - for (int i = 0; i < repeat_count; ++i) - packet_str.push_back(char_to_repeat); - } else if (*c == 0x7d) { - // 0x7d is the escape character. The next character is to be XOR'd - // with 0x20. - char escapee = *++c ^ 0x20; - packet_str.push_back(escapee); - } else { - packet_str.push_back(*c); - } - } + // encoding in the process. + std ::string packet_str = + ExpandRLE(m_bytes.substr(content_start, content_end - content_start)); packet = StringExtractorGDBRemote(packet_str); if (m_bytes[0] == '$' || m_bytes[0] == '%') { @@ -1382,3 +1360,30 @@ void llvm::format_provider::format( break; } } + +std::string GDBRemoteCommunication::ExpandRLE(std::string packet) { + // Reserve enough byte for the most common case (no RLE used). + std::string decoded; + decoded.reserve(packet.size()); + for (std::string::const_iterator c = packet.begin(); c != packet.end(); ++c) { + if (*c == '*') { + // '*' indicates RLE. Next character will give us the repeat count and + // previous character is what is to be repeated. + char char_to_repeat = decoded.back(); + // Number of time the previous character is repeated. + int repeat_count = *++c + 3 - ' '; + // We have the char_to_repeat and repeat_count. Now push it in the + // packet. + for (int i = 0; i < repeat_count; ++i) + decoded.push_back(char_to_repeat); + } else if (*c == 0x7d) { + // 0x7d is the escape character. The next character is to be XOR'd with + // 0x20. + char escapee = *++c ^ 0x20; + decoded.push_back(escapee); + } else { + decoded.push_back(*c); + } + } + return decoded; +} diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h index 7c0ef197f89b47..4cc466667c820f 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h @@ -142,6 +142,9 @@ class GDBRemoteCommunication : public Communication { static llvm::Error ConnectLocally(GDBRemoteCommunication &client, GDBRemoteCommunication &server); + /// Expand GDB run-length encoding. + static std::string ExpandRLE(std::string); + protected: std::chrono::seconds m_packet_timeout; uint32_t m_echo_number; diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp index 8c6efe9ee9e27b..910dcf2cf5899e 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp @@ -131,22 +131,26 @@ GDBRemoteCommunicationReplayServer::GetPacketAndSendResponse( GDBRemotePacket entry = m_packet_history.back(); m_packet_history.pop_back(); + // Decode run-length encoding. + const std::string expanded_data = + GDBRemoteCommunication::ExpandRLE(entry.packet.data); + // We've handled the handshake implicitly before. Skip the packet and move // on. if (entry.packet.data == "+") continue; if (entry.type == GDBRemotePacket::ePacketTypeSend) { - if (unexpected(entry.packet.data, packet.GetStringRef())) { + if (unexpected(expanded_data, packet.GetStringRef())) { LLDB_LOG(log, "GDBRemoteCommunicationReplayServer expected packet: '{0}'", - entry.packet.data); + expanded_data); LLDB_LOG(log, "GDBRemoteCommunicationReplayServer actual packet: '{0}'", packet.GetStringRef()); #ifndef NDEBUG // This behaves like a regular assert, but prints the expected and // received packet before aborting. - printf("Reproducer expected packet: '%s'\n", entry.packet.data.c_str()); + printf("Reproducer expected packet: '%s'\n", expanded_data.c_str()); printf("Reproducer received packet: '%s'\n", packet.GetStringRef().data()); llvm::report_fatal_error("Encountered unexpected packet during replay"); @@ -155,7 +159,7 @@ GDBRemoteCommunicationReplayServer::GetPacketAndSendResponse( } // Ignore QEnvironment packets as they're handled earlier. - if (entry.packet.data.find("QEnvironment") == 1) { + if (expanded_data.find("QEnvironment") == 1) { assert(m_packet_history.back().type == GDBRemotePacket::ePacketTypeRecv); m_packet_history.pop_back(); diff --git a/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp b/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp index 42655ad6cc24d2..c278aef8949e79 100644 --- a/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp +++ b/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp @@ -1207,10 +1207,11 @@ CompilerType TypeSystemClang::CreateRecordType(DeclContext *decl_ctx, // complete definition just in case. bool has_name = !name.empty(); - - CXXRecordDecl *decl = CXXRecordDecl::Create( - ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(), SourceLocation(), - has_name ? &ast.Idents.get(name) : nullptr); + CXXRecordDecl *decl = CXXRecordDecl::CreateDeserialized(ast, 0); + decl->setTagKind(static_cast(kind)); + decl->setDeclContext(decl_ctx); + if (has_name) + decl->setDeclName(&ast.Idents.get(name)); if (!has_name) { // In C++ a lambda is also represented as an unnamed class. This is @@ -1331,9 +1332,12 @@ clang::FunctionTemplateDecl *TypeSystemClang::CreateFunctionTemplateDecl( TemplateParameterList *template_param_list = CreateTemplateParameterList( ast, template_param_infos, template_param_decls); - FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create( - ast, decl_ctx, func_decl->getLocation(), func_decl->getDeclName(), - template_param_list, func_decl); + FunctionTemplateDecl *func_tmpl_decl = + FunctionTemplateDecl::CreateDeserialized(ast, 0); + func_tmpl_decl->setDeclContext(decl_ctx); + func_tmpl_decl->setLocation(func_decl->getLocation()); + func_tmpl_decl->setDeclName(func_decl->getDeclName()); + func_tmpl_decl->init(func_decl, template_param_list); for (size_t i = 0, template_param_decl_count = template_param_decls.size(); i < template_param_decl_count; ++i) { @@ -1384,11 +1388,11 @@ ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl( TemplateParameterList *template_param_list = CreateTemplateParameterList( ast, template_param_infos, template_param_decls); - CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create( - ast, (TagDecl::TagKind)kind, - decl_ctx, // What decl context do we use here? TU? The actual decl - // context? - SourceLocation(), SourceLocation(), &identifier_info); + CXXRecordDecl *template_cxx_decl = CXXRecordDecl::CreateDeserialized(ast, 0); + template_cxx_decl->setTagKind(static_cast(kind)); + // What decl context do we use here? TU? The actual decl context? + template_cxx_decl->setDeclContext(decl_ctx); + template_cxx_decl->setDeclName(decl_name); for (size_t i = 0, template_param_decl_count = template_param_decls.size(); i < template_param_decl_count; ++i) { @@ -1400,11 +1404,11 @@ ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl( // template_cxx_decl->startDefinition(); // template_cxx_decl->completeDefinition(); - class_template_decl = ClassTemplateDecl::Create( - ast, - decl_ctx, // What decl context do we use here? TU? The actual decl - // context? - SourceLocation(), decl_name, template_param_list, template_cxx_decl); + class_template_decl = ClassTemplateDecl::CreateDeserialized(ast, 0); + // What decl context do we use here? TU? The actual decl context? + class_template_decl->setDeclContext(decl_ctx); + class_template_decl->setDeclName(decl_name); + class_template_decl->init(template_cxx_decl, template_param_list); template_cxx_decl->setDescribedClassTemplate(class_template_decl); if (class_template_decl) { @@ -1458,9 +1462,16 @@ TypeSystemClang::CreateClassTemplateSpecializationDecl( ast, template_param_infos.packed_args->args); } ClassTemplateSpecializationDecl *class_template_specialization_decl = - ClassTemplateSpecializationDecl::Create( - ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(), - SourceLocation(), class_template_decl, args, nullptr); + ClassTemplateSpecializationDecl::CreateDeserialized(ast, 0); + class_template_specialization_decl->setTagKind( + static_cast(kind)); + class_template_specialization_decl->setDeclContext(decl_ctx); + class_template_specialization_decl->setInstantiationOf(class_template_decl); + class_template_specialization_decl->setTemplateArgs( + TemplateArgumentList::CreateCopy(ast, args)); + ast.getTypeDeclType(class_template_specialization_decl, nullptr); + class_template_specialization_decl->setDeclName( + class_template_decl->getDeclName()); class_template_specialization_decl->setSpecializationKind( TSK_ExplicitSpecialization); @@ -1589,11 +1600,11 @@ CompilerType TypeSystemClang::CreateObjCClass(llvm::StringRef name, if (decl_ctx == nullptr) decl_ctx = ast.getTranslationUnitDecl(); - ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create( - ast, decl_ctx, SourceLocation(), &ast.Idents.get(name), nullptr, nullptr, - SourceLocation(), - /*isForwardDecl,*/ - isInternal); + ObjCInterfaceDecl *decl = ObjCInterfaceDecl::CreateDeserialized(ast, 0); + decl->setDeclContext(decl_ctx); + decl->setDeclName(&ast.Idents.get(name)); + /*isForwardDecl,*/ + decl->setImplicit(isInternal); if (decl && metadata) SetMetadata(decl, *metadata); @@ -1631,7 +1642,7 @@ TypeSystemClang::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl, #pragma mark Namespace Declarations NamespaceDecl *TypeSystemClang::GetUniqueNamespaceDeclaration( - const char *name, DeclContext *decl_ctx, bool is_inline) { + const char *name, clang::DeclContext *decl_ctx, bool is_inline) { NamespaceDecl *namespace_decl = nullptr; ASTContext &ast = getASTContext(); TranslationUnitDecl *translation_unit_decl = ast.getTranslationUnitDecl(); @@ -1690,9 +1701,10 @@ NamespaceDecl *TypeSystemClang::GetUniqueNamespaceDeclaration( clang::BlockDecl * TypeSystemClang::CreateBlockDeclaration(clang::DeclContext *ctx) { - if (ctx != nullptr) { + if (ctx) { clang::BlockDecl *decl = - clang::BlockDecl::Create(getASTContext(), ctx, clang::SourceLocation()); + clang::BlockDecl::CreateDeserialized(getASTContext(), 0); + decl->setDeclContext(ctx); ctx->addDecl(decl); return decl; } @@ -1718,15 +1730,16 @@ clang::DeclContext *FindLCABetweenDecls(clang::DeclContext *left, clang::UsingDirectiveDecl *TypeSystemClang::CreateUsingDirectiveDeclaration( clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl) { - if (decl_ctx != nullptr && ns_decl != nullptr) { + if (decl_ctx && ns_decl) { auto *translation_unit = getASTContext().getTranslationUnitDecl(); clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create( - getASTContext(), decl_ctx, clang::SourceLocation(), - clang::SourceLocation(), clang::NestedNameSpecifierLoc(), - clang::SourceLocation(), ns_decl, - FindLCABetweenDecls(decl_ctx, ns_decl, translation_unit)); - decl_ctx->addDecl(using_decl); - return using_decl; + getASTContext(), decl_ctx, clang::SourceLocation(), + clang::SourceLocation(), clang::NestedNameSpecifierLoc(), + clang::SourceLocation(), ns_decl, + FindLCABetweenDecls(decl_ctx, ns_decl, + translation_unit)); + decl_ctx->addDecl(using_decl); + return using_decl; } return nullptr; } @@ -1750,12 +1763,13 @@ TypeSystemClang::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx, clang::VarDecl *TypeSystemClang::CreateVariableDeclaration( clang::DeclContext *decl_context, const char *name, clang::QualType type) { - if (decl_context != nullptr) { - clang::VarDecl *var_decl = clang::VarDecl::Create( - getASTContext(), decl_context, clang::SourceLocation(), - clang::SourceLocation(), - name && name[0] ? &getASTContext().Idents.getOwn(name) : nullptr, type, - nullptr, clang::SC_None); + if (decl_context) { + clang::VarDecl *var_decl = + clang::VarDecl::CreateDeserialized(getASTContext(), 0); + var_decl->setDeclContext(decl_context); + if (name && name[0]) + var_decl->setDeclName(&getASTContext().Idents.getOwn(name)); + var_decl->setType(type); var_decl->setAccess(clang::AS_public); decl_context->addDecl(var_decl); return var_decl; @@ -1879,11 +1893,15 @@ FunctionDecl *TypeSystemClang::CreateFunctionDeclaration( clang::DeclarationName declarationName = GetDeclarationName(name, function_clang_type); - func_decl = FunctionDecl::Create( - ast, decl_ctx, SourceLocation(), SourceLocation(), declarationName, - ClangUtil::GetQualType(function_clang_type), nullptr, - (clang::StorageClass)storage, is_inline, hasWrittenPrototype, - isConstexprSpecified ? CSK_constexpr : CSK_unspecified); + func_decl = FunctionDecl::CreateDeserialized(ast, 0); + func_decl->setDeclContext(decl_ctx); + func_decl->setDeclName(declarationName); + func_decl->setType(ClangUtil::GetQualType(function_clang_type)); + func_decl->setStorageClass(static_cast(storage)); + func_decl->setInlineSpecified(is_inline); + func_decl->setHasWrittenPrototype(hasWrittenPrototype); + func_decl->setConstexprKind(isConstexprSpecified ? CSK_constexpr + : CSK_unspecified); if (func_decl) decl_ctx->addDecl(func_decl); @@ -1935,11 +1953,12 @@ ParmVarDecl *TypeSystemClang::CreateParameterDeclaration( clang::DeclContext *decl_ctx, const char *name, const CompilerType ¶m_type, int storage, bool add_decl) { ASTContext &ast = getASTContext(); - auto *decl = - ParmVarDecl::Create(ast, decl_ctx, SourceLocation(), SourceLocation(), - name && name[0] ? &ast.Idents.get(name) : nullptr, - ClangUtil::GetQualType(param_type), nullptr, - (clang::StorageClass)storage, nullptr); + auto *decl = ParmVarDecl::CreateDeserialized(ast, 0); + decl->setDeclContext(decl_ctx); + if (name && name[0]) + decl->setDeclName(&ast.Idents.get(name)); + decl->setType(ClangUtil::GetQualType(param_type)); + decl->setStorageClass(static_cast(storage)); if (add_decl) decl_ctx->addDecl(decl); @@ -2036,13 +2055,15 @@ TypeSystemClang::CreateEnumerationType(const char *name, DeclContext *decl_ctx, // like maybe filling in the SourceLocation with it... ASTContext &ast = getASTContext(); - EnumDecl *enum_decl = EnumDecl::Create( - ast, decl_ctx, SourceLocation(), SourceLocation(), - name && name[0] ? &ast.Idents.get(name) : nullptr, nullptr, - is_scoped, // IsScoped - is_scoped, // IsScopedUsingClassTag - false); // TODO: IsFixed - + // TODO: ask about these... + // const bool IsFixed = false; + EnumDecl *enum_decl = EnumDecl::CreateDeserialized(ast, 0); + enum_decl->setDeclContext(decl_ctx); + if (name && name[0]) + enum_decl->setDeclName(&ast.Idents.get(name)); + enum_decl->setScoped(is_scoped); + enum_decl->setScopedUsingClassTag(is_scoped); + enum_decl->setFixed(false); if (enum_decl) { if (decl_ctx) decl_ctx->addDecl(enum_decl); @@ -4243,10 +4264,11 @@ CompilerType TypeSystemClang::CreateTypedefType( if (decl_ctx == nullptr) decl_ctx = ast->getASTContext().getTranslationUnitDecl(); - clang::TypedefDecl *decl = clang::TypedefDecl::Create( - clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(), - &clang_ast.Idents.get(typedef_name), - clang_ast.getTrivialTypeSourceInfo(qual_type)); + clang::TypedefDecl *decl = + clang::TypedefDecl::CreateDeserialized(clang_ast, 0); + decl->setDeclContext(decl_ctx); + decl->setDeclName(&clang_ast.Idents.get(typedef_name)); + decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type)); decl->setAccess(clang::AS_public); // TODO respect proper access specifier @@ -4349,10 +4371,11 @@ TypeSystemClang::CreateTypedef(lldb::opaque_compiler_type_t type, if (decl_ctx == nullptr) decl_ctx = getASTContext().getTranslationUnitDecl(); - clang::TypedefDecl *decl = clang::TypedefDecl::Create( - clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(), - &clang_ast.Idents.get(typedef_name), - clang_ast.getTrivialTypeSourceInfo(qual_type)); + clang::TypedefDecl *decl = + clang::TypedefDecl::CreateDeserialized(clang_ast, 0); + decl->setDeclContext(decl_ctx); + decl->setDeclName(&clang_ast.Idents.get(typedef_name)); + decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type)); clang::TagDecl *tdecl = nullptr; if (!qual_type.isNull()) { @@ -6888,15 +6911,12 @@ clang::FieldDecl *TypeSystemClang::AddFieldToRecordType( clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type); if (record_decl) { - field = clang::FieldDecl::Create( - clang_ast, record_decl, clang::SourceLocation(), - clang::SourceLocation(), - ident, // Identifier - ClangUtil::GetQualType(field_clang_type), // Field type - nullptr, // TInfo * - bit_width, // BitWidth - false, // Mutable - clang::ICIS_NoInit); // HasInit + field = clang::FieldDecl::CreateDeserialized(clang_ast, 0); + field->setDeclContext(record_decl); + field->setDeclName(ident); + field->setType(ClangUtil::GetQualType(field_clang_type)); + if (bit_width) + field->setBitWidth(bit_width); if (name.empty()) { // Determine whether this field corresponds to an anonymous struct or @@ -6929,14 +6949,15 @@ clang::FieldDecl *TypeSystemClang::AddFieldToRecordType( field_clang_type.GetCompleteType(); - field = clang::ObjCIvarDecl::Create( - clang_ast, class_interface_decl, clang::SourceLocation(), - clang::SourceLocation(), - ident, // Identifier - ClangUtil::GetQualType(field_clang_type), // Field type - nullptr, // TypeSourceInfo * - ConvertAccessTypeToObjCIvarAccessControl(access), bit_width, - is_synthesized); + auto ivar = clang::ObjCIvarDecl::CreateDeserialized(clang_ast, 0); + ivar->setDeclContext(class_interface_decl); + ivar->setDeclName(ident); + ivar->setType(ClangUtil::GetQualType(field_clang_type)); + ivar->setAccessControl(ConvertAccessTypeToObjCIvarAccessControl(access)); + if (bit_width) + ivar->setBitWidth(bit_width); + ivar->setSynthesize(is_synthesized); + field = ivar; if (field) { class_interface_decl->addDecl(field); @@ -7089,15 +7110,11 @@ clang::VarDecl *TypeSystemClang::AddVariableToRecordType( if (!name.empty()) ident = &ast->getASTContext().Idents.get(name); - var_decl = clang::VarDecl::Create( - ast->getASTContext(), // ASTContext & - record_decl, // DeclContext * - clang::SourceLocation(), // clang::SourceLocation StartLoc - clang::SourceLocation(), // clang::SourceLocation IdLoc - ident, // clang::IdentifierInfo * - ClangUtil::GetQualType(var_type), // Variable clang::QualType - nullptr, // TypeSourceInfo * - clang::SC_Static); // StorageClass + var_decl = clang::VarDecl::CreateDeserialized(ast->getASTContext(), 0); + var_decl->setDeclContext(record_decl); + var_decl->setDeclName(ident); + var_decl->setType(ClangUtil::GetQualType(var_type)); + var_decl->setStorageClass(clang::SC_Static); if (!var_decl) return nullptr; @@ -7153,29 +7170,34 @@ clang::CXXMethodDecl *TypeSystemClang::AddMethodToCXXRecordType( return nullptr; // skip everything artificial const clang::ExplicitSpecifier explicit_spec( - nullptr /*expr*/, is_explicit - ? clang::ExplicitSpecKind::ResolvedTrue - : clang::ExplicitSpecKind::ResolvedFalse); + nullptr /*expr*/, is_explicit ? clang::ExplicitSpecKind::ResolvedTrue + : clang::ExplicitSpecKind::ResolvedFalse); + if (name.startswith("~")) { - cxx_dtor_decl = clang::CXXDestructorDecl::Create( - getASTContext(), cxx_record_decl, clang::SourceLocation(), - clang::DeclarationNameInfo( - getASTContext().DeclarationNames.getCXXDestructorName( - getASTContext().getCanonicalType(record_qual_type)), - clang::SourceLocation()), - method_qual_type, nullptr, is_inline, is_artificial, - ConstexprSpecKind::CSK_unspecified); + cxx_dtor_decl = + clang::CXXDestructorDecl::CreateDeserialized(getASTContext(), 0); + cxx_dtor_decl->setDeclContext(cxx_record_decl); + cxx_dtor_decl->setDeclName( + getASTContext().DeclarationNames.getCXXDestructorName( + getASTContext().getCanonicalType(record_qual_type))); + cxx_dtor_decl->setType(method_qual_type); + cxx_dtor_decl->setImplicit(is_artificial); + cxx_dtor_decl->setInlineSpecified(is_inline); + cxx_dtor_decl->setConstexprKind(CSK_unspecified); cxx_method_decl = cxx_dtor_decl; } else if (decl_name == cxx_record_decl->getDeclName()) { - cxx_ctor_decl = clang::CXXConstructorDecl::Create( - getASTContext(), cxx_record_decl, clang::SourceLocation(), - clang::DeclarationNameInfo( - getASTContext().DeclarationNames.getCXXConstructorName( - getASTContext().getCanonicalType(record_qual_type)), - clang::SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - explicit_spec, is_inline, is_artificial, CSK_unspecified); + cxx_ctor_decl = clang::CXXConstructorDecl::CreateDeserialized( + getASTContext(), 0, 0); + cxx_ctor_decl->setDeclContext(cxx_record_decl); + cxx_ctor_decl->setDeclName( + getASTContext().DeclarationNames.getCXXConstructorName( + getASTContext().getCanonicalType(record_qual_type))); + cxx_ctor_decl->setType(method_qual_type); + cxx_ctor_decl->setImplicit(is_artificial); + cxx_ctor_decl->setInlineSpecified(is_inline); + cxx_ctor_decl->setConstexprKind(CSK_unspecified); + cxx_ctor_decl->setNumCtorInitializers(0); + cxx_ctor_decl->setExplicitSpecifier(explicit_spec); cxx_method_decl = cxx_ctor_decl; } else { clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None; @@ -7191,36 +7213,41 @@ clang::CXXMethodDecl *TypeSystemClang::AddMethodToCXXRecordType( if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount( is_method, op_kind, num_params)) return nullptr; - cxx_method_decl = clang::CXXMethodDecl::Create( - getASTContext(), cxx_record_decl, clang::SourceLocation(), - clang::DeclarationNameInfo( - getASTContext().DeclarationNames.getCXXOperatorName(op_kind), - clang::SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - SC, is_inline, CSK_unspecified, clang::SourceLocation()); + cxx_method_decl = + clang::CXXMethodDecl::CreateDeserialized(getASTContext(), 0); + cxx_method_decl->setDeclContext(cxx_record_decl); + cxx_method_decl->setDeclName( + getASTContext().DeclarationNames.getCXXOperatorName(op_kind)); + cxx_method_decl->setType(method_qual_type); + cxx_method_decl->setStorageClass(SC); + cxx_method_decl->setInlineSpecified(is_inline); + cxx_method_decl->setConstexprKind(CSK_unspecified); } else if (num_params == 0) { // Conversion operators don't take params... - cxx_method_decl = clang::CXXConversionDecl::Create( - getASTContext(), cxx_record_decl, clang::SourceLocation(), - clang::DeclarationNameInfo( - getASTContext().DeclarationNames.getCXXConversionFunctionName( - getASTContext().getCanonicalType( - function_type->getReturnType())), - clang::SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - is_inline, explicit_spec, CSK_unspecified, clang::SourceLocation()); + auto *cxx_conversion_decl = + clang::CXXConversionDecl::CreateDeserialized(getASTContext(), 0); + cxx_conversion_decl->setDeclContext(cxx_record_decl); + cxx_conversion_decl->setDeclName( + getASTContext().DeclarationNames.getCXXConversionFunctionName( + getASTContext().getCanonicalType( + function_type->getReturnType()))); + cxx_conversion_decl->setType(method_qual_type); + cxx_conversion_decl->setInlineSpecified(is_inline); + cxx_conversion_decl->setExplicitSpecifier(explicit_spec); + cxx_conversion_decl->setConstexprKind(CSK_unspecified); + cxx_method_decl = cxx_conversion_decl; } } if (cxx_method_decl == nullptr) { - cxx_method_decl = clang::CXXMethodDecl::Create( - getASTContext(), cxx_record_decl, clang::SourceLocation(), - clang::DeclarationNameInfo(decl_name, clang::SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - SC, is_inline, CSK_unspecified, clang::SourceLocation()); + cxx_method_decl = + clang::CXXMethodDecl::CreateDeserialized(getASTContext(), 0); + cxx_method_decl->setDeclContext(cxx_record_decl); + cxx_method_decl->setDeclName(decl_name); + cxx_method_decl->setType(method_qual_type); + cxx_method_decl->setInlineSpecified(is_inline); + cxx_method_decl->setStorageClass(SC); + cxx_method_decl->setConstexprKind(CSK_unspecified); } } @@ -7389,15 +7416,14 @@ bool TypeSystemClang::AddObjCClassProperty( prop_type_source = clang_ast.getTrivialTypeSourceInfo( ClangUtil::GetQualType(property_clang_type)); - clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create( - clang_ast, class_interface_decl, - clang::SourceLocation(), // Source Location - &clang_ast.Idents.get(property_name), - clang::SourceLocation(), // Source Location for AT - clang::SourceLocation(), // Source location for ( - ivar_decl ? ivar_decl->getType() - : ClangUtil::GetQualType(property_clang_type), - prop_type_source); + clang::ObjCPropertyDecl *property_decl = + clang::ObjCPropertyDecl::CreateDeserialized(clang_ast, 0); + property_decl->setDeclContext(class_interface_decl); + property_decl->setDeclName(&clang_ast.Idents.get(property_name)); + property_decl->setType(ivar_decl + ? ivar_decl->getType() + : ClangUtil::GetQualType(property_clang_type), + prop_type_source); if (!property_decl) return false; @@ -7477,12 +7503,18 @@ bool TypeSystemClang::AddObjCClassProperty( clang::ObjCMethodDecl::None; const bool HasRelatedResultType = false; - getter = clang::ObjCMethodDecl::Create( - clang_ast, clang::SourceLocation(), clang::SourceLocation(), getter_sel, - ClangUtil::GetQualType(property_clang_type_to_access), nullptr, - class_interface_decl, isInstance, isVariadic, isPropertyAccessor, - isSynthesizedAccessorStub, isImplicitlyDeclared, isDefined, impControl, - HasRelatedResultType); + getter = clang::ObjCMethodDecl::CreateDeserialized(clang_ast, 0); + getter->setDeclName(getter_sel); + getter->setReturnType(ClangUtil::GetQualType(property_clang_type_to_access)); + getter->setDeclContext(class_interface_decl); + getter->setInstanceMethod(isInstance); + getter->setVariadic(isVariadic); + getter->setPropertyAccessor(isPropertyAccessor); + getter->setSynthesizedAccessorStub(isSynthesizedAccessorStub); + getter->setImplicit(isImplicitlyDeclared); + getter->setDefined(isDefined); + getter->setDeclImplementation(impControl); + getter->setRelatedResultType(HasRelatedResultType); if (getter) { if (metadata) @@ -7512,11 +7544,18 @@ bool TypeSystemClang::AddObjCClassProperty( clang::ObjCMethodDecl::None; const bool HasRelatedResultType = false; - setter = clang::ObjCMethodDecl::Create( - clang_ast, clang::SourceLocation(), clang::SourceLocation(), setter_sel, - result_type, nullptr, class_interface_decl, isInstance, isVariadic, - isPropertyAccessor, isSynthesizedAccessorStub, isImplicitlyDeclared, - isDefined, impControl, HasRelatedResultType); + setter = clang::ObjCMethodDecl::CreateDeserialized(clang_ast, 0); + setter->setDeclName(setter_sel); + setter->setReturnType(result_type); + setter->setDeclContext(class_interface_decl); + setter->setInstanceMethod(isInstance); + setter->setVariadic(isVariadic); + setter->setPropertyAccessor(isPropertyAccessor); + setter->setSynthesizedAccessorStub(isSynthesizedAccessorStub); + setter->setImplicit(isImplicitlyDeclared); + setter->setDefined(isDefined); + setter->setDeclImplementation(impControl); + setter->setRelatedResultType(HasRelatedResultType); if (setter) { if (metadata) @@ -7632,15 +7671,19 @@ clang::ObjCMethodDecl *TypeSystemClang::AddMethodToObjCObjectType( return nullptr; // some debug information is corrupt. We are not going to // deal with it. - clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create( - ast, - clang::SourceLocation(), // beginLoc, - clang::SourceLocation(), // endLoc, - method_selector, method_function_prototype->getReturnType(), - nullptr, // TypeSourceInfo *ResultTInfo, - lldb_ast->GetDeclContextForType(ClangUtil::GetQualType(type)), isInstance, - isVariadic, isPropertyAccessor, isSynthesizedAccessorStub, - isImplicitlyDeclared, isDefined, impControl, HasRelatedResultType); + auto *objc_method_decl = clang::ObjCMethodDecl::CreateDeserialized(ast, 0); + objc_method_decl->setDeclName(method_selector); + objc_method_decl->setReturnType(method_function_prototype->getReturnType()); + objc_method_decl->setDeclContext( + lldb_ast->GetDeclContextForType(ClangUtil::GetQualType(type))); + objc_method_decl->setInstanceMethod(isInstance); + objc_method_decl->setVariadic(isVariadic); + objc_method_decl->setPropertyAccessor(isPropertyAccessor); + objc_method_decl->setSynthesizedAccessorStub(isSynthesizedAccessorStub); + objc_method_decl->setImplicit(isImplicitlyDeclared); + objc_method_decl->setDefined(isDefined); + objc_method_decl->setDeclImplementation(impControl); + objc_method_decl->setRelatedResultType(HasRelatedResultType); if (objc_method_decl == nullptr) return nullptr; @@ -7864,10 +7907,13 @@ clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType( if (!enutype) return nullptr; - clang::EnumConstantDecl *enumerator_decl = clang::EnumConstantDecl::Create( - getASTContext(), enutype->getDecl(), clang::SourceLocation(), - name ? &getASTContext().Idents.get(name) : nullptr, // Identifier - clang::QualType(enutype, 0), nullptr, value); + clang::EnumConstantDecl *enumerator_decl = + clang::EnumConstantDecl::CreateDeserialized(getASTContext(), 0); + enumerator_decl->setDeclContext(enutype->getDecl()); + if (name && name[0]) + enumerator_decl->setDeclName(&getASTContext().Idents.get(name)); + enumerator_decl->setType(clang::QualType(enutype, 0)); + enumerator_decl->setInitVal(value); if (!enumerator_decl) return nullptr; diff --git a/lldb/source/Target/Platform.cpp b/lldb/source/Target/Platform.cpp index eaa71b9cbbd0ac..3069a363736f94 100644 --- a/lldb/source/Target/Platform.cpp +++ b/lldb/source/Target/Platform.cpp @@ -1865,6 +1865,12 @@ size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target, } } break; + case llvm::Triple::avr: { + static const uint8_t g_hex_opcode[] = {0x98, 0x95}; + trap_opcode = g_hex_opcode; + trap_opcode_size = sizeof(g_hex_opcode); + } break; + case llvm::Triple::mips: case llvm::Triple::mips64: { static const uint8_t g_hex_opcode[] = {0x00, 0x00, 0x00, 0x0d}; diff --git a/lldb/test/API/functionalities/reproducers/attach/TestReproducerAttach.py b/lldb/test/API/functionalities/reproducers/attach/TestReproducerAttach.py index e9a570b50976b6..968268d6838bdb 100644 --- a/lldb/test/API/functionalities/reproducers/attach/TestReproducerAttach.py +++ b/lldb/test/API/functionalities/reproducers/attach/TestReproducerAttach.py @@ -15,7 +15,6 @@ class ReproducerAttachTestCase(TestBase): mydir = TestBase.compute_mydir(__file__) NO_DEBUG_INFO_TESTCASE = True - @skipIfLinux # Reproducer received unexpected packet. @skipIfFreeBSD @skipIfNetBSD @skipIfWindows diff --git a/lldb/test/API/lang/objc/modules-non-objc-target/Makefile b/lldb/test/API/lang/objc/modules-non-objc-target/Makefile new file mode 100644 index 00000000000000..10495940055b63 --- /dev/null +++ b/lldb/test/API/lang/objc/modules-non-objc-target/Makefile @@ -0,0 +1,3 @@ +C_SOURCES := main.c + +include Makefile.rules diff --git a/lldb/test/API/lang/objc/modules-non-objc-target/TestObjCModulesNonObjCTarget.py b/lldb/test/API/lang/objc/modules-non-objc-target/TestObjCModulesNonObjCTarget.py new file mode 100644 index 00000000000000..18283f6d2b330a --- /dev/null +++ b/lldb/test/API/lang/objc/modules-non-objc-target/TestObjCModulesNonObjCTarget.py @@ -0,0 +1,26 @@ +""" +Tests that importing ObjC modules in a non-ObjC target doesn't crash LLDB. +""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + +class TestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipUnlessDarwin + def test(self): + self.build() + lldbutil.run_to_source_breakpoint(self,"// break here", lldb.SBFileSpec("main.c")) + + # Import foundation to get some ObjC types. + self.expect("expr --lang objc -- @import Foundation") + # Do something with NSString (which requires special handling when + # preparing to run in the target). The expression most likely can't + # be prepared to run in the target but it should at least not crash LLDB. + self.expect('expr --lang objc -- [NSString stringWithFormat:@"%d", 1];', + error=True, + substrs=["error: The expression could not be prepared to run in the target"]) diff --git a/lldb/test/API/lang/objc/modules-non-objc-target/main.c b/lldb/test/API/lang/objc/modules-non-objc-target/main.c new file mode 100644 index 00000000000000..ba45ee316cd42b --- /dev/null +++ b/lldb/test/API/lang/objc/modules-non-objc-target/main.c @@ -0,0 +1,3 @@ +int main() { + return 0; // break here +} diff --git a/lldb/tools/debugserver/resources/lldb-debugserver-Info.plist b/lldb/tools/debugserver/resources/lldb-debugserver-Info.plist index 343325c2765cbd..ddaf0644f2cf2f 100644 --- a/lldb/tools/debugserver/resources/lldb-debugserver-Info.plist +++ b/lldb/tools/debugserver/resources/lldb-debugserver-Info.plist @@ -12,10 +12,5 @@ debugserver CFBundleVersion 2 - SecTaskAccess - - allowed - debug - diff --git a/llvm/docs/CommandGuide/llvm-objdump.rst b/llvm/docs/CommandGuide/llvm-objdump.rst index bb330a0174e34b..2730374d581038 100644 --- a/llvm/docs/CommandGuide/llvm-objdump.rst +++ b/llvm/docs/CommandGuide/llvm-objdump.rst @@ -119,17 +119,6 @@ OPTIONS Demangle symbol names in the output. -.. option:: --debug-vars= - - Print the locations (in registers or memory) of source-level variables - alongside disassembly. ``format`` may be ``unicode`` or ``ascii``, defaulting - to ``unicode`` if omitted. - -.. option:: --debug-vars-indent= - - Distance to indent the source-level variable display, relative to the start - of the disassembly. Defaults to 40 characters. - .. option:: -j, --section= Perform commands on the specified sections only. For Mach-O use diff --git a/llvm/docs/CompileCudaWithLLVM.rst b/llvm/docs/CompileCudaWithLLVM.rst index b4479771f803a9..d85cac77982de2 100644 --- a/llvm/docs/CompileCudaWithLLVM.rst +++ b/llvm/docs/CompileCudaWithLLVM.rst @@ -22,21 +22,22 @@ Compiling CUDA Code Prerequisites ------------- -CUDA is supported since llvm 3.9. Current release of clang (7.0.0) supports CUDA -7.0 through 9.2. If you need support for CUDA 10, you will need to use clang -built from r342924 or newer. +CUDA is supported since llvm 3.9. Clang currently supports CUDA 7.0 through +10.1. If clang detects a newer CUDA version, it will issue a warning and will +attempt to use detected CUDA SDK it as if it were CUDA-10.1. -Before you build CUDA code, you'll need to have installed the appropriate driver -for your nvidia GPU and the CUDA SDK. See `NVIDIA's CUDA installation guide +Before you build CUDA code, you'll need to have installed the CUDA SDK. See +`NVIDIA's CUDA installation guide `_ for -details. Note that clang `does not support +details. Note that clang `maynot support `_ the CUDA toolkit as installed by -many Linux package managers; you probably need to install CUDA in a single -directory from NVIDIA's package. +some Linux package managers. Clang does attempt to deal with specific details of +CUDA installation on a handful of common Linux distributions, but in general the +most reliable way to make it work is to install CUDA in a single directory from +NVIDIA's `.run` package and specify its location via `--cuda-path=...` argument. CUDA compilation is supported on Linux. Compilation on MacOS and Windows may or -may not work and currently have no maintainers. Compilation with CUDA-9.x is -`currently broken on Windows `_. +may not work and currently have no maintainers. Invoking clang -------------- diff --git a/llvm/docs/LoopTerminology.rst b/llvm/docs/LoopTerminology.rst index 207195ef79e2c7..ef0593419a461d 100644 --- a/llvm/docs/LoopTerminology.rst +++ b/llvm/docs/LoopTerminology.rst @@ -170,4 +170,226 @@ TBD "More Canonical" Loops ====================== -TBD +.. _loop-terminology-loop-rotate: + +Rotated Loops +------------- + +Loops are rotated by the LoopRotate (:ref:`loop-rotate `) +pass, which converts loops into do/while style loops and is +implemented in +`LoopRotation.h `_. Example: + +.. code-block:: C + + void test(int n) { + for (int i = 0; i < n; i += 1) + // Loop body + } + +is transformed to: + +.. code-block:: C + + void test(int n) { + int i = 0; + do { + // Loop body + i += 1; + } while (i < n); + } + +**Warning**: This transformation is valid only if the compiler +can prove that the loop body will be executed at least once. Otherwise, +it has to insert a guard which will test it at runtime. In the example +above, that would be: + +.. code-block:: C + + void test(int n) { + int i = 0; + if (n > 0) { + do { + // Loop body + i += 1; + } while (i < n); + } + } + +It's important to understand the effect of loop rotation +at the LLVM IR level. We follow with the previous examples +in LLVM IR while also providing a graphical representation +of the control-flow graphs (CFG). You can get the same graphical +results by utilizing the :ref:`view-cfg ` pass. + +The initial **for** loop could be translated to: + +.. code-block:: none + + define void @test(i32 %n) { + entry: + br label %for.header + + for.header: + %i = phi i32 [ 0, %entry ], [ %i.next, %latch ] + %cond = icmp slt i32 %i, %n + br i1 %cond, label %body, label %exit + + body: + ; Loop body + br label %latch + + latch: + %i.next = add nsw i32 %i, 1 + br label %for.header + + exit: + ret void + } + +.. image:: ./loop-terminology-initial-loop.png + :width: 400 px + +Before we explain how LoopRotate will actually +transform this loop, here's how we could convert +it (by hand) to a do-while style loop. + +.. code-block:: none + + define void @test(i32 %n) { + entry: + br label %body + + body: + %i = phi i32 [ 0, %entry ], [ %i.next, %latch ] + ; Loop body + br label %latch + + latch: + %i.next = add nsw i32 %i, 1 + %cond = icmp slt i32 %i.next, %n + br i1 %cond, label %body, label %exit + + exit: + ret void + } + +.. image:: ./loop-terminology-rotated-loop.png + :width: 400 px + +Note two things: + +* The condition check was moved to the "bottom" of the loop, i.e. + the latch. This is something that LoopRotate does by copying the header + of the loop to the latch. +* The compiler in this case can't deduce that the loop will + definitely execute at least once so the above transformation + is not valid. As mentioned above, a guard has to be inserted, + which is something that LoopRotate will do. + +This is how LoopRotate transforms this loop: + +.. code-block:: none + + define void @test(i32 %n) { + entry: + %guard_cond = icmp slt i32 0, %n + br i1 %guard_cond, label %loop.preheader, label %exit + + loop.preheader: + br label %body + + body: + %i2 = phi i32 [ 0, %loop.preheader ], [ %i.next, %latch ] + br label %latch + + latch: + %i.next = add nsw i32 %i2, 1 + %cond = icmp slt i32 %i.next, %n + br i1 %cond, label %body, label %loop.exit + + loop.exit: + br label %exit + + exit: + ret void + } + +.. image:: ./loop-terminology-guarded-loop.png + :width: 500 px + +The result is a little bit more complicated than we may expect +because LoopRotate ensures that the loop is in +:ref:`Loop Simplify Form ` +after rotation. +In this case, it inserted the %loop.preheader basic block so +that the loop has a preheader and it introduced the %loop.exit +basic block so that the loop has dedicated exits +(otherwise, %exit would be jumped from both %latch and %entry, +but %entry is not contained in the loop). +Note that a loop has to be in Loop Simplify Form beforehand +too for LoopRotate to be applied successfully. + +The main advantage of this form is that it allows hoisting +invariant instructions, especially loads, into the preheader. +That could be done in non-rotated loops as well but with +some disadvantages. Let's illustrate them with an example: + +.. code-block:: C + + for (int i = 0; i < n; ++i) { + auto v = *p; + use(v); + } + +We assume that loading from p is invariant and use(v) is some +statement that uses v. +If we wanted to execute the load only once we could move it +"out" of the loop body, resulting in this: + +.. code-block:: C + + auto v = *p; + for (int i = 0; i < n; ++i) { + use(v); + } + +However, now, in the case that n <= 0, in the initial form, +the loop body would never execute, and so, the load would +never execute. This is a problem mainly for semantic reasons. +Consider the case in which n <= 0 and loading from p is invalid. +In the initial program there would be no error. However, with this +transformation we would introduce one, effectively breaking +the initial semantics. + +To avoid both of these problems, we can insert a guard: + +.. code-block:: C + + if (n > 0) { // loop guard + auto v = *p; + for (int i = 0; i < n; ++i) { + use(v); + } + } + +This is certainly better but it could be improved slightly. Notice +that the check for whether n is bigger than 0 is executed twice (and +n does not change in between). Once when we check the guard condition +and once in the first execution of the loop. To avoid that, we could +do an unconditional first execution and insert the loop condition +in the end. This effectively means transforming the loop into a do-while loop: + +.. code-block:: C + + if (0 < n) { + auto v = *p; + do { + use(v); + ++i; + } while (i < n); + } + +Note that LoopRotate does not generally do such +hoisting. Rather, it is an enabling transformation for other +passes like Loop-Invariant Code Motion (:ref:`-licm `). diff --git a/llvm/docs/Passes.rst b/llvm/docs/Passes.rst index a13f1e6694cad1..39451a915ee4af 100644 --- a/llvm/docs/Passes.rst +++ b/llvm/docs/Passes.rst @@ -798,10 +798,14 @@ accomplished by creating a new value to hold the initial value of the array access for the first iteration, and then creating a new GEP instruction in the loop to increment the value by the appropriate amount. +.. _passes-loop-rotate: + ``-loop-rotate``: Rotate Loops ------------------------------ -A simple loop rotation transformation. +A simple loop rotation transformation. A summary of it can be found in +:ref:`Loop Terminology for Rotated Loops `. + .. _passes-loop-simplify: @@ -1194,6 +1198,8 @@ performing optimizing transformations. Note that this does not provide full security verification (like Java), but instead just tries to ensure that code is well-formed. +.. _passes-view-cfg: + ``-view-cfg``: View CFG of function ----------------------------------- diff --git a/llvm/docs/loop-terminology-guarded-loop.png b/llvm/docs/loop-terminology-guarded-loop.png new file mode 100644 index 00000000000000..d235b1421189ab Binary files /dev/null and b/llvm/docs/loop-terminology-guarded-loop.png differ diff --git a/llvm/docs/loop-terminology-initial-loop.png b/llvm/docs/loop-terminology-initial-loop.png new file mode 100644 index 00000000000000..ad8fc109b65195 Binary files /dev/null and b/llvm/docs/loop-terminology-initial-loop.png differ diff --git a/llvm/docs/loop-terminology-rotated-loop.png b/llvm/docs/loop-terminology-rotated-loop.png new file mode 100644 index 00000000000000..b048ff702684a7 Binary files /dev/null and b/llvm/docs/loop-terminology-rotated-loop.png differ diff --git a/llvm/include/llvm-c/DebugInfo.h b/llvm/include/llvm-c/DebugInfo.h index 61702253f69b80..cdf5f5a0cca865 100644 --- a/llvm/include/llvm-c/DebugInfo.h +++ b/llvm/include/llvm-c/DebugInfo.h @@ -296,7 +296,7 @@ LLVMDIBuilderCreateModule(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentScope, const char *Name, size_t NameLen, const char *ConfigMacros, size_t ConfigMacrosLen, const char *IncludePath, size_t IncludePathLen, - const char *APINotestFile, size_t APINotestFileLen); + const char *APINotesFile, size_t APINotesFileLen); /** * Creates a new descriptor for a namespace with the specified parent scope. diff --git a/llvm/include/llvm/Analysis/StackSafetyAnalysis.h b/llvm/include/llvm/Analysis/StackSafetyAnalysis.h index f9d8b08ac1425c..c797d498b5dd8f 100644 --- a/llvm/include/llvm/Analysis/StackSafetyAnalysis.h +++ b/llvm/include/llvm/Analysis/StackSafetyAnalysis.h @@ -33,6 +33,8 @@ class StackSafetyInfo { StackSafetyInfo &operator=(StackSafetyInfo &&); ~StackSafetyInfo(); + FunctionInfo *getInfo() const { return Info.get(); } + // TODO: Add useful for client methods. void print(raw_ostream &O) const; }; @@ -96,17 +98,26 @@ class StackSafetyGlobalPrinterPass PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); }; +class StackSafetyGlobalAnnotatorPass + : public PassInfoMixin { + +public: + explicit StackSafetyGlobalAnnotatorPass() {} + PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); +}; + /// This pass performs the global (interprocedural) stack safety analysis /// (legacy pass manager). class StackSafetyGlobalInfoWrapperPass : public ModulePass { - StackSafetyGlobalInfo SSI; + StackSafetyGlobalInfo SSGI; + bool SetMetadata; public: static char ID; - StackSafetyGlobalInfoWrapperPass(); + StackSafetyGlobalInfoWrapperPass(bool SetMetadata = false); - const StackSafetyGlobalInfo &getResult() const { return SSI; } + const StackSafetyGlobalInfo &getResult() const { return SSGI; } void print(raw_ostream &O, const Module *M) const override; void getAnalysisUsage(AnalysisUsage &AU) const override; @@ -114,6 +125,8 @@ class StackSafetyGlobalInfoWrapperPass : public ModulePass { bool runOnModule(Module &M) override; }; +ModulePass *createStackSafetyGlobalInfoWrapperPass(bool SetMetadata); + } // end namespace llvm #endif // LLVM_ANALYSIS_STACKSAFETYANALYSIS_H diff --git a/llvm/include/llvm/Analysis/TargetTransformInfo.h b/llvm/include/llvm/Analysis/TargetTransformInfo.h index 1387b90307f7fe..ca6892b14ef3b2 100644 --- a/llvm/include/llvm/Analysis/TargetTransformInfo.h +++ b/llvm/include/llvm/Analysis/TargetTransformInfo.h @@ -1069,6 +1069,7 @@ class TargetTransformInfo { /// \returns The type to use in a loop expansion of a memcpy call. Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length, + unsigned SrcAddrSpace, unsigned DestAddrSpace, unsigned SrcAlign, unsigned DestAlign) const; /// \param[out] OpsOut The operand types to copy RemainingBytes of memory. @@ -1080,6 +1081,8 @@ class TargetTransformInfo { void getMemcpyLoopResidualLoweringType(SmallVectorImpl &OpsOut, LLVMContext &Context, unsigned RemainingBytes, + unsigned SrcAddrSpace, + unsigned DestAddrSpace, unsigned SrcAlign, unsigned DestAlign) const; @@ -1382,11 +1385,15 @@ class TargetTransformInfo::Concept { virtual Value *getOrCreateResultFromMemIntrinsic(IntrinsicInst *Inst, Type *ExpectedType) = 0; virtual Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length, + unsigned SrcAddrSpace, + unsigned DestAddrSpace, unsigned SrcAlign, unsigned DestAlign) const = 0; virtual void getMemcpyLoopResidualLoweringType( SmallVectorImpl &OpsOut, LLVMContext &Context, - unsigned RemainingBytes, unsigned SrcAlign, unsigned DestAlign) const = 0; + unsigned RemainingBytes, + unsigned SrcAddrSpace, unsigned DestAddrSpace, + unsigned SrcAlign, unsigned DestAlign) const = 0; virtual bool areInlineCompatible(const Function *Caller, const Function *Callee) const = 0; virtual bool @@ -1830,16 +1837,22 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { return Impl.getOrCreateResultFromMemIntrinsic(Inst, ExpectedType); } Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length, + unsigned SrcAddrSpace, unsigned DestAddrSpace, unsigned SrcAlign, unsigned DestAlign) const override { - return Impl.getMemcpyLoopLoweringType(Context, Length, SrcAlign, DestAlign); + return Impl.getMemcpyLoopLoweringType(Context, Length, + SrcAddrSpace, DestAddrSpace, + SrcAlign, DestAlign); } void getMemcpyLoopResidualLoweringType(SmallVectorImpl &OpsOut, LLVMContext &Context, unsigned RemainingBytes, + unsigned SrcAddrSpace, + unsigned DestAddrSpace, unsigned SrcAlign, unsigned DestAlign) const override { Impl.getMemcpyLoopResidualLoweringType(OpsOut, Context, RemainingBytes, + SrcAddrSpace, DestAddrSpace, SrcAlign, DestAlign); } bool areInlineCompatible(const Function *Caller, diff --git a/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h b/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h index d825a0796c5d3c..2acb88a6a83d13 100644 --- a/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h +++ b/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h @@ -543,6 +543,7 @@ class TargetTransformInfoImplBase { } Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length, + unsigned SrcAddrSpace, unsigned DestAddrSpace, unsigned SrcAlign, unsigned DestAlign) const { return Type::getInt8Ty(Context); } @@ -550,6 +551,8 @@ class TargetTransformInfoImplBase { void getMemcpyLoopResidualLoweringType(SmallVectorImpl &OpsOut, LLVMContext &Context, unsigned RemainingBytes, + unsigned SrcAddrSpace, + unsigned DestAddrSpace, unsigned SrcAlign, unsigned DestAlign) const { for (unsigned i = 0; i != RemainingBytes; ++i) diff --git a/llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h b/llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h index 6f357189025186..08d12a57adff0e 100644 --- a/llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h +++ b/llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h @@ -275,6 +275,7 @@ class LegalizerHelper { LegalizeResult lowerFMinNumMaxNum(MachineInstr &MI); LegalizeResult lowerFMad(MachineInstr &MI); LegalizeResult lowerIntrinsicRound(MachineInstr &MI); + LegalizeResult lowerFFloor(MachineInstr &MI); LegalizeResult lowerUnmergeValues(MachineInstr &MI); LegalizeResult lowerShuffleVector(MachineInstr &MI); LegalizeResult lowerDynStackAlloc(MachineInstr &MI); diff --git a/llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h b/llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h index da7258b60f2f55..59c2aa898d4fd6 100644 --- a/llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h +++ b/llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h @@ -1446,6 +1446,11 @@ class MachineIRBuilder { return buildInstr(TargetOpcode::G_CTTZ_ZERO_UNDEF, {Dst}, {Src0}); } + /// Build and insert \p Dst = G_BSWAP \p Src0 + MachineInstrBuilder buildBSwap(const DstOp &Dst, const SrcOp &Src0) { + return buildInstr(TargetOpcode::G_BSWAP, {Dst}, {Src0}); + } + /// Build and insert \p Res = G_FADD \p Op0, \p Op1 MachineInstrBuilder buildFAdd(const DstOp &Dst, const SrcOp &Src0, const SrcOp &Src1, diff --git a/llvm/include/llvm/CodeGen/MachineBasicBlock.h b/llvm/include/llvm/CodeGen/MachineBasicBlock.h index 8f2f4bb34a332b..cd33a371490896 100644 --- a/llvm/include/llvm/CodeGen/MachineBasicBlock.h +++ b/llvm/include/llvm/CodeGen/MachineBasicBlock.h @@ -46,6 +46,19 @@ class raw_ostream; class TargetRegisterClass; class TargetRegisterInfo; +enum MachineBasicBlockSection : unsigned { + /// This is also the order of sections in a function. Basic blocks that are + /// part of the original function section (entry block) come first, followed + /// by exception handling basic blocks, cold basic blocks and finally basic + // blocks that need unique sections. + MBBS_Entry, + MBBS_Exception, + MBBS_Cold, + MBBS_Unique, + /// None implies no sections for any basic block, the default. + MBBS_None, +}; + template <> struct ilist_traits { private: friend class MachineBasicBlock; // Set by the owning MachineBasicBlock. @@ -130,6 +143,9 @@ class MachineBasicBlock /// Indicate that this basic block is the entry block of a cleanup funclet. bool IsCleanupFuncletEntry = false; + /// Stores the Section type of the basic block with basic block sections. + MachineBasicBlockSection SectionType = MBBS_None; + /// Default target of the callbr of a basic block. bool InlineAsmBrDefaultTarget = false; @@ -140,6 +156,9 @@ class MachineBasicBlock /// is only computed once and is cached. mutable MCSymbol *CachedMCSymbol = nullptr; + /// Used during basic block sections to mark the end of a basic block. + MCSymbol *EndMCSymbol = nullptr; + // Intrusive list support MachineBasicBlock() = default; @@ -415,6 +434,18 @@ class MachineBasicBlock /// Indicates if this is the entry block of a cleanup funclet. void setIsCleanupFuncletEntry(bool V = true) { IsCleanupFuncletEntry = V; } + /// Returns true if this block begins any section. + bool isBeginSection() const; + + /// Returns true if this block ends any section. + bool isEndSection() const; + + /// Returns the type of section this basic block belongs to. + MachineBasicBlockSection getSectionType() const { return SectionType; } + + /// Indicate that the basic block belongs to a Section Type. + void setSectionType(MachineBasicBlockSection V) { SectionType = V; } + /// Returns true if this is the indirect dest of an INLINEASM_BR. bool isInlineAsmBrIndirectTarget(const MachineBasicBlock *Tgt) const { return InlineAsmBrIndirectTargets.count(Tgt); @@ -453,6 +484,12 @@ class MachineBasicBlock void moveBefore(MachineBasicBlock *NewAfter); void moveAfter(MachineBasicBlock *NewBefore); + /// Returns true if this and MBB belong to the same section. + bool sameSection(const MachineBasicBlock *MBB) const; + + /// Returns the basic block that ends the section which contains this one. + const MachineBasicBlock *getSectionEndMBB() const; + /// Update the terminator instructions in block to account for changes to the /// layout. If the block previously used a fallthrough, it may now need a /// branch, and if it previously used branching it may now be able to use a @@ -839,6 +876,12 @@ class MachineBasicBlock /// Return the MCSymbol for this basic block. MCSymbol *getSymbol() const; + /// Sets the MCSymbol corresponding to the end of this basic block. + void setEndMCSymbol(MCSymbol *Sym) { EndMCSymbol = Sym; } + + /// Returns the MCSymbol corresponding to the end of this basic block. + MCSymbol *getEndMCSymbol() const { return EndMCSymbol; } + Optional getIrrLoopHeaderWeight() const { return IrrLoopHeaderWeight; } diff --git a/llvm/include/llvm/CodeGen/MachineFunction.h b/llvm/include/llvm/CodeGen/MachineFunction.h index 33cefea76ab2e1..7b767ff7c7a53f 100644 --- a/llvm/include/llvm/CodeGen/MachineFunction.h +++ b/llvm/include/llvm/CodeGen/MachineFunction.h @@ -37,6 +37,7 @@ #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Recycler.h" +#include "llvm/Target/TargetOptions.h" #include #include #include @@ -64,6 +65,7 @@ class MachineRegisterInfo; class MCContext; class MCInstrDesc; class MCSymbol; +class MCSection; class Pass; class PseudoSourceValueManager; class raw_ostream; @@ -244,6 +246,9 @@ class MachineFunction { // Keep track of jump tables for switch instructions MachineJumpTableInfo *JumpTableInfo; + // Keep track of the function section. + MCSection *Section = nullptr; + // Keeps track of Wasm exception handling related data. This will be null for // functions that aren't using a wasm EH personality. WasmEHFuncInfo *WasmEHInfo = nullptr; @@ -257,6 +262,12 @@ class MachineFunction { // numbered and this vector keeps track of the mapping from ID's to MBB's. std::vector MBBNumbering; + // Unary encoding of basic block symbols is used to reduce size of ".strtab". + // Basic block number 'i' gets a prefix of length 'i'. The ith character also + // denotes the type of basic block number 'i'. Return blocks are marked with + // 'r', landing pads with 'l' and regular blocks with 'a'. + std::vector BBSectionsSymbolPrefix; + // Pool-allocate MachineFunction-lifetime and IR objects. BumpPtrAllocator Allocator; @@ -332,6 +343,14 @@ class MachineFunction { bool HasEHScopes = false; bool HasEHFunclets = false; + /// Section Type for basic blocks, only relevant with basic block sections. + BasicBlockSection BBSectionsType = BasicBlockSection::None; + + /// With Basic Block Sections, this stores the bb ranges of cold and + /// exception sections. + std::pair ColdSectionRange = {-1, -1}; + std::pair ExceptionSectionRange = {-1, -1}; + /// List of C++ TypeInfo used. std::vector TypeInfos; @@ -453,6 +472,12 @@ class MachineFunction { MachineModuleInfo &getMMI() const { return MMI; } MCContext &getContext() const { return Ctx; } + /// Returns the Section this function belongs to. + MCSection *getSection() const { return Section; } + + /// Indicates the Section this function belongs to. + void setSection(MCSection *S) { Section = S; } + PseudoSourceValueManager &getPSVManager() const { return *PSVManager; } /// Return the DataLayout attached to the Module associated to this MF. @@ -467,6 +492,35 @@ class MachineFunction { /// getFunctionNumber - Return a unique ID for the current function. unsigned getFunctionNumber() const { return FunctionNumber; } + /// Returns true if this function has basic block sections enabled. + bool hasBBSections() const { + return (BBSectionsType == BasicBlockSection::All || + BBSectionsType == BasicBlockSection::List); + } + + /// Returns true if basic block labels are to be generated for this function. + bool hasBBLabels() const { + return BBSectionsType == BasicBlockSection::Labels; + } + + void setBBSectionsType(BasicBlockSection V) { BBSectionsType = V; } + + void setSectionRange(); + + /// Returns true if this basic block number starts a cold or exception + /// section. + bool isSectionStartMBB(int N) const { + return (N == ColdSectionRange.first || N == ExceptionSectionRange.first); + } + + /// Returns true if this basic block ends a cold or exception section. + bool isSectionEndMBB(int N) const { + return (N == ColdSectionRange.second || N == ExceptionSectionRange.second); + } + + /// Creates basic block Labels for this function. + void createBBLabels(); + /// getTarget - Return the target machine this machine code is compiled with const LLVMTargetMachine &getTarget() const { return Target; } @@ -1014,6 +1068,11 @@ class MachineFunction { /// of the instruction stream. void copyCallSiteInfo(const MachineInstr *Old, const MachineInstr *New); + + const std::vector &getBBSectionsSymbolPrefix() const { + return BBSectionsSymbolPrefix; + } + /// Move the call site info from \p Old to \New call site info. This function /// is used when we are replacing one call instruction with another one to /// the same callee. diff --git a/llvm/include/llvm/CodeGen/Passes.h b/llvm/include/llvm/CodeGen/Passes.h index 72c7e8b1b6bb76..997f36eb6aede7 100644 --- a/llvm/include/llvm/CodeGen/Passes.h +++ b/llvm/include/llvm/CodeGen/Passes.h @@ -22,6 +22,7 @@ namespace llvm { class FunctionPass; class MachineFunction; class MachineFunctionPass; +class MemoryBuffer; class ModulePass; class Pass; class TargetMachine; @@ -42,6 +43,12 @@ namespace llvm { /// the entry block. FunctionPass *createUnreachableBlockEliminationPass(); + /// createBBSectionsPrepare Pass - This pass assigns sections to machine basic + /// blocks and is enabled with -fbasicblock-sections. + /// Buf is a memory buffer that contains the list of functions and basic + /// block ids to selectively enable basic block sections. + MachineFunctionPass *createBBSectionsPreparePass(const MemoryBuffer *Buf); + /// MachineFunctionPrinter pass - This pass prints out the machine function to /// the given stream as a debugging tool. MachineFunctionPass * diff --git a/llvm/include/llvm/CodeGen/StackProtector.h b/llvm/include/llvm/CodeGen/StackProtector.h index d2ab79cb235e87..f6513e8d4ea0cb 100644 --- a/llvm/include/llvm/CodeGen/StackProtector.h +++ b/llvm/include/llvm/CodeGen/StackProtector.h @@ -95,7 +95,7 @@ class StackProtector : public FunctionPass { bool InStruct = false) const; /// Check whether a stack allocation has its address taken. - bool HasAddressTaken(const Instruction *AI); + bool HasAddressTaken(const Instruction *AI, uint64_t AllocSize); /// RequiresStackProtector - Check whether or not this function needs a /// stack protector based upon the stack protector level. diff --git a/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h b/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h index 790e16ffa9eb9a..2a1123e27dada6 100644 --- a/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h +++ b/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h @@ -65,6 +65,15 @@ class TargetLoweringObjectFileELF : public TargetLoweringObjectFile { MCSection *getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override; + MCSection * + getSectionForMachineBasicBlock(const Function &F, + const MachineBasicBlock &MBB, + const TargetMachine &TM) const override; + + MCSection *getNamedSectionForMachineBasicBlock( + const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM, + const char *Suffix) const override; + bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override; diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h index 702e4e08181cd2..c4dc53337c07c9 100644 --- a/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h +++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h @@ -122,10 +122,6 @@ class DWARFExpression { return Op; } - iterator skipBytes(uint64_t Add) { - return iterator(Expr, Op.EndOffset + Add); - } - // Comparison operators are provided out of line. friend bool operator==(const iterator &, const iterator &); }; @@ -141,12 +137,6 @@ class DWARFExpression { void print(raw_ostream &OS, const MCRegisterInfo *RegInfo, DWARFUnit *U, bool IsEH = false) const; - /// Print the expression in a format intended to be compact and useful to a - /// user, but not perfectly unambiguous, or capable of representing every - /// valid DWARF expression. Returns true if the expression was sucessfully - /// printed. - bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo); - bool verify(DWARFUnit *U); private: diff --git a/llvm/include/llvm/IR/IntrinsicsAArch64.td b/llvm/include/llvm/IR/IntrinsicsAArch64.td index 3a205de4e368ea..a220934c5923e4 100644 --- a/llvm/include/llvm/IR/IntrinsicsAArch64.td +++ b/llvm/include/llvm/IR/IntrinsicsAArch64.td @@ -1263,6 +1263,27 @@ class AdvSIMD_ScatterStore_VS_Intrinsic ], [IntrWriteMem, IntrArgMemOnly]>; + +class SVE_gather_prf_scalar_base_vector_offset_scaled + : Intrinsic<[], + [ + LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, // Predicate + llvm_ptr_ty, // Base address + llvm_anyvector_ty, // Offsets + llvm_i32_ty // Prfop + ], + [IntrInaccessibleMemOrArgMemOnly, NoCapture<1>, ImmArg<3>]>; + +class SVE_gather_prf_vector_base_scalar_offset + : Intrinsic<[], + [ + LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>, // Predicate + llvm_anyvector_ty, // Base addresses + llvm_i64_ty, // Scalar offset + llvm_i32_ty // Prfop + ], + [IntrInaccessibleMemOrArgMemOnly, ImmArg<3>]>; + // // Loads // @@ -1279,13 +1300,39 @@ def int_aarch64_sve_ldff1 : AdvSIMD_1Vec_PredFaultingLoad_Intrinsic; def int_aarch64_sve_stnt1 : AdvSIMD_1Vec_PredStore_Intrinsic; // -// Prefetch +// Prefetches // def int_aarch64_sve_prf : Intrinsic<[], [llvm_anyvector_ty, llvm_ptr_ty, llvm_i32_ty], [IntrArgMemOnly, ImmArg<2>]>; +// Scalar + 32-bit scaled offset vector, zero extend, packed and +// unpacked. +def int_aarch64_sve_gather_prfb_scaled_uxtw : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfh_scaled_uxtw : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfw_scaled_uxtw : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfd_scaled_uxtw : SVE_gather_prf_scalar_base_vector_offset_scaled; + +// Scalar + 32-bit scaled offset vector, sign extend, packed and +// unpacked. +def int_aarch64_sve_gather_prfb_scaled_sxtw : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfw_scaled_sxtw : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfh_scaled_sxtw : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfd_scaled_sxtw : SVE_gather_prf_scalar_base_vector_offset_scaled; + +// Scalar + 64-bit scaled offset vector. +def int_aarch64_sve_gather_prfb_scaled : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfh_scaled : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfw_scaled : SVE_gather_prf_scalar_base_vector_offset_scaled; +def int_aarch64_sve_gather_prfd_scaled : SVE_gather_prf_scalar_base_vector_offset_scaled; + +// Vector + scalar. +def int_aarch64_sve_gather_prfb : SVE_gather_prf_vector_base_scalar_offset; +def int_aarch64_sve_gather_prfh : SVE_gather_prf_vector_base_scalar_offset; +def int_aarch64_sve_gather_prfw : SVE_gather_prf_vector_base_scalar_offset; +def int_aarch64_sve_gather_prfd : SVE_gather_prf_vector_base_scalar_offset; + // // Scalar to vector operations // diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h index 0499422e1b4b75..b3bbf5ee26e61d 100644 --- a/llvm/include/llvm/InitializePasses.h +++ b/llvm/include/llvm/InitializePasses.h @@ -77,6 +77,7 @@ void initializeAssumptionCacheTrackerPass(PassRegistry&); void initializeAtomicExpandPass(PassRegistry&); void initializeAttributorLegacyPassPass(PassRegistry&); void initializeAttributorCGSCCLegacyPassPass(PassRegistry &); +void initializeBBSectionsPreparePass(PassRegistry &); void initializeBDCELegacyPassPass(PassRegistry&); void initializeBarrierNoopPass(PassRegistry&); void initializeBasicAAWrapperPassPass(PassRegistry&); diff --git a/llvm/include/llvm/ObjectYAML/ELFYAML.h b/llvm/include/llvm/ObjectYAML/ELFYAML.h index 60bb2375901bd1..44f5d7cd069eda 100644 --- a/llvm/include/llvm/ObjectYAML/ELFYAML.h +++ b/llvm/include/llvm/ObjectYAML/ELFYAML.h @@ -65,6 +65,7 @@ LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1) LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA) LLVM_YAML_STRONG_TYPEDEF(StringRef, YAMLFlowString) +LLVM_YAML_STRONG_TYPEDEF(int64_t, YAMLIntUInt) // For now, hardcode 64 bits everywhere that 32 or 64 would be needed // since 64-bit can hold 32-bit values too. @@ -439,7 +440,7 @@ struct Group : Section { struct Relocation { llvm::yaml::Hex64 Offset; - int64_t Addend; + YAMLIntUInt Addend; ELF_REL Type; Optional Symbol; }; @@ -542,6 +543,14 @@ LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName) namespace llvm { namespace yaml { +template <> struct ScalarTraits { + static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx, + raw_ostream &Out); + static StringRef input(StringRef Scalar, void *Ctx, + ELFYAML::YAMLIntUInt &Val); + static QuotingType mustQuote(StringRef) { return QuotingType::None; } +}; + template <> struct ScalarEnumerationTraits { static void enumeration(IO &IO, ELFYAML::ELF_ET &Value); diff --git a/llvm/include/llvm/Support/FormattedStream.h b/llvm/include/llvm/Support/FormattedStream.h index 88e00647473e99..b49c8d86531dbc 100644 --- a/llvm/include/llvm/Support/FormattedStream.h +++ b/llvm/include/llvm/Support/FormattedStream.h @@ -105,17 +105,11 @@ class formatted_raw_ostream : public raw_ostream { /// \param NewCol - The column to move to. formatted_raw_ostream &PadToColumn(unsigned NewCol); - unsigned getColumn() { - // Calculate current position, taking buffer contents into account. - ComputePosition(getBufferStart(), GetNumBytesInBuffer()); - return Position.first; - } + /// getColumn - Return the column number + unsigned getColumn() { return Position.first; } - unsigned getLine() { - // Calculate current position, taking buffer contents into account. - ComputePosition(getBufferStart(), GetNumBytesInBuffer()); - return Position.second; - } + /// getLine - Return the line number + unsigned getLine() { return Position.second; } raw_ostream &resetColor() override { TheStream->resetColor(); diff --git a/llvm/include/llvm/Target/TargetLoweringObjectFile.h b/llvm/include/llvm/Target/TargetLoweringObjectFile.h index a13b09682a3a6c..2a5ac9a4de9a03 100644 --- a/llvm/include/llvm/Target/TargetLoweringObjectFile.h +++ b/llvm/include/llvm/Target/TargetLoweringObjectFile.h @@ -24,6 +24,7 @@ namespace llvm { class GlobalValue; +class MachineBasicBlock; class MachineModuleInfo; class Mangler; class MCContext; @@ -90,6 +91,15 @@ class TargetLoweringObjectFile : public MCObjectFileInfo { const Constant *C, unsigned &Align) const; + virtual MCSection * + getSectionForMachineBasicBlock(const Function &F, + const MachineBasicBlock &MBB, + const TargetMachine &TM) const; + + virtual MCSection *getNamedSectionForMachineBasicBlock( + const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM, + const char *Suffix) const; + /// Classify the specified global variable into a set of target independent /// categories embodied in SectionKind. static SectionKind getKindForGlobal(const GlobalObject *GO, diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp index bc9ae5ebffb01d..1e4d7f71178513 100644 --- a/llvm/lib/Analysis/InstructionSimplify.cpp +++ b/llvm/lib/Analysis/InstructionSimplify.cpp @@ -4081,13 +4081,16 @@ static Value *SimplifyGEPInst(Type *SrcTy, ArrayRef Ops, if (isa(Ops[0])) return UndefValue::get(GEPTy); + bool IsScalableVec = + SrcTy->isVectorTy() ? SrcTy->getVectorIsScalable() : false; + if (Ops.size() == 2) { // getelementptr P, 0 -> P. if (match(Ops[1], m_Zero()) && Ops[0]->getType() == GEPTy) return Ops[0]; Type *Ty = SrcTy; - if (Ty->isSized()) { + if (!IsScalableVec && Ty->isSized()) { Value *P; uint64_t C; uint64_t TyAllocSize = Q.DL.getTypeAllocSize(Ty); @@ -4135,7 +4138,7 @@ static Value *SimplifyGEPInst(Type *SrcTy, ArrayRef Ops, } } - if (Q.DL.getTypeAllocSize(LastType) == 1 && + if (!IsScalableVec && Q.DL.getTypeAllocSize(LastType) == 1 && all_of(Ops.slice(1).drop_back(1), [](Value *Idx) { return match(Idx, m_Zero()); })) { unsigned IdxWidth = @@ -5358,9 +5361,6 @@ Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) { if (Value *Ret = simplifyIntrinsic(Call, Q)) return Ret; - if (Value *ReturnedArg = Call->getReturnedArgOperand()) - return ReturnedArg; - if (!canConstantFoldCallTo(Call, F)) return nullptr; diff --git a/llvm/lib/Analysis/StackSafetyAnalysis.cpp b/llvm/lib/Analysis/StackSafetyAnalysis.cpp index 33a326e4a86fc6..3af1cec9d0182b 100644 --- a/llvm/lib/Analysis/StackSafetyAnalysis.cpp +++ b/llvm/lib/Analysis/StackSafetyAnalysis.cpp @@ -99,11 +99,11 @@ raw_ostream &operator<<(raw_ostream &OS, const UseInfo &U) { } struct AllocaInfo { - const AllocaInst *AI = nullptr; + AllocaInst *AI = nullptr; uint64_t Size = 0; UseInfo Use; - AllocaInfo(unsigned PointerSize, const AllocaInst *AI, uint64_t Size) + AllocaInfo(unsigned PointerSize, AllocaInst *AI, uint64_t Size) : AI(AI), Size(Size), Use(PointerSize) {} StringRef getName() const { return AI->getName(); } @@ -205,7 +205,7 @@ StackSafetyInfo::FunctionInfo::FunctionInfo(const GlobalAlias *A) : GV(A) { namespace { class StackSafetyLocalAnalysis { - const Function &F; + Function &F; const DataLayout &DL; ScalarEvolution &SE; unsigned PointerSize = 0; @@ -227,7 +227,7 @@ class StackSafetyLocalAnalysis { } public: - StackSafetyLocalAnalysis(const Function &F, ScalarEvolution &SE) + StackSafetyLocalAnalysis(Function &F, ScalarEvolution &SE) : F(F), DL(F.getParent()->getDataLayout()), SE(SE), PointerSize(DL.getPointerSizeInBits()), UnknownRange(PointerSize, true) {} @@ -653,17 +653,47 @@ PreservedAnalyses StackSafetyGlobalPrinterPass::run(Module &M, return PreservedAnalyses::all(); } +static bool SetStackSafetyMetadata(Module &M, + const StackSafetyGlobalInfo &SSGI) { + bool Changed = false; + unsigned Width = M.getDataLayout().getPointerSizeInBits(); + for (auto &F : M.functions()) { + if (F.isDeclaration() || F.hasOptNone()) + continue; + auto Iter = SSGI.find(&F); + if (Iter == SSGI.end()) + continue; + StackSafetyInfo::FunctionInfo *Summary = Iter->second.getInfo(); + for (auto &AS : Summary->Allocas) { + ConstantRange AllocaRange{APInt(Width, 0), APInt(Width, AS.Size)}; + if (AllocaRange.contains(AS.Use.Range)) { + AS.AI->setMetadata(M.getMDKindID("stack-safe"), + MDNode::get(M.getContext(), None)); + Changed = true; + } + } + } + return Changed; +} + +PreservedAnalyses +StackSafetyGlobalAnnotatorPass::run(Module &M, ModuleAnalysisManager &AM) { + auto &SSGI = AM.getResult(M); + (void)SetStackSafetyMetadata(M, SSGI); + return PreservedAnalyses::all(); +} + char StackSafetyGlobalInfoWrapperPass::ID = 0; -StackSafetyGlobalInfoWrapperPass::StackSafetyGlobalInfoWrapperPass() - : ModulePass(ID) { +StackSafetyGlobalInfoWrapperPass::StackSafetyGlobalInfoWrapperPass(bool SetMetadata) + : ModulePass(ID), SetMetadata(SetMetadata) { initializeStackSafetyGlobalInfoWrapperPassPass( *PassRegistry::getPassRegistry()); } void StackSafetyGlobalInfoWrapperPass::print(raw_ostream &O, const Module *M) const { - ::print(SSI, O, *M); + ::print(SSGI, O, *M); } void StackSafetyGlobalInfoWrapperPass::getAnalysisUsage( @@ -676,8 +706,12 @@ bool StackSafetyGlobalInfoWrapperPass::runOnModule(Module &M) { M, [this](Function &F) -> const StackSafetyInfo & { return getAnalysis(F).getResult(); }); - SSI = SSDFA.run(); - return false; + SSGI = SSDFA.run(); + return SetMetadata ? SetStackSafetyMetadata(M, SSGI) : false; +} + +ModulePass *llvm::createStackSafetyGlobalInfoWrapperPass(bool SetMetadata) { + return new StackSafetyGlobalInfoWrapperPass(SetMetadata); } static const char LocalPassArg[] = "stack-safety-local"; diff --git a/llvm/lib/Analysis/TargetTransformInfo.cpp b/llvm/lib/Analysis/TargetTransformInfo.cpp index a1b30fc8f12b1b..89b1783a9a0078 100644 --- a/llvm/lib/Analysis/TargetTransformInfo.cpp +++ b/llvm/lib/Analysis/TargetTransformInfo.cpp @@ -776,16 +776,23 @@ Value *TargetTransformInfo::getOrCreateResultFromMemIntrinsic( Type *TargetTransformInfo::getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length, + unsigned SrcAddrSpace, + unsigned DestAddrSpace, unsigned SrcAlign, unsigned DestAlign) const { - return TTIImpl->getMemcpyLoopLoweringType(Context, Length, SrcAlign, + return TTIImpl->getMemcpyLoopLoweringType(Context, Length, SrcAddrSpace, + DestAddrSpace, SrcAlign, DestAlign); } void TargetTransformInfo::getMemcpyLoopResidualLoweringType( SmallVectorImpl &OpsOut, LLVMContext &Context, - unsigned RemainingBytes, unsigned SrcAlign, unsigned DestAlign) const { + unsigned RemainingBytes, + unsigned SrcAddrSpace, + unsigned DestAddrSpace, + unsigned SrcAlign, unsigned DestAlign) const { TTIImpl->getMemcpyLoopResidualLoweringType(OpsOut, Context, RemainingBytes, + SrcAddrSpace, DestAddrSpace, SrcAlign, DestAlign); } diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index 31b53d726556af..7d0050ff8eaacb 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -682,7 +682,9 @@ void AsmPrinter::emitFunctionHeader() { emitConstantPool(); // Print the 'header' of function. - OutStreamer->SwitchSection(getObjFileLowering().SectionForGlobal(&F, TM)); + MF->setSection(getObjFileLowering().SectionForGlobal(&F, TM)); + OutStreamer->SwitchSection(MF->getSection()); + emitVisibility(CurrentFnSym, F.getVisibility()); if (MAI->needsFunctionDescriptors() && @@ -1095,6 +1097,15 @@ void AsmPrinter::emitFunctionBody() { // Print out code for the function. bool HasAnyRealCode = false; int NumInstsInFunction = 0; + bool emitBBSections = MF->hasBBSections(); + MachineBasicBlock *EndOfRegularSectionMBB = nullptr; + if (emitBBSections) { + EndOfRegularSectionMBB = + const_cast(MF->front().getSectionEndMBB()); + assert(EndOfRegularSectionMBB->isEndSection() && + "The MBB at the end of the regular section must end a section"); + } + for (auto &MBB : *MF) { // Print a label for the basic block. emitBasicBlockStart(MBB); @@ -1174,7 +1185,18 @@ void AsmPrinter::emitFunctionBody() { } } } - + if (&MBB != EndOfRegularSectionMBB && + (MF->hasBBLabels() || MBB.isEndSection())) { + // Emit size directive for the size of this basic block. Create a symbol + // for the end of the basic block. + MCSymbol *CurrentBBEnd = OutContext.createTempSymbol(); + const MCExpr *SizeExp = MCBinaryExpr::createSub( + MCSymbolRefExpr::create(CurrentBBEnd, OutContext), + MCSymbolRefExpr::create(MBB.getSymbol(), OutContext), OutContext); + OutStreamer->emitLabel(CurrentBBEnd); + MBB.setEndMCSymbol(CurrentBBEnd); + OutStreamer->emitELFSize(MBB.getSymbol(), SizeExp); + } emitBasicBlockEnd(MBB); } @@ -1208,6 +1230,10 @@ void AsmPrinter::emitFunctionBody() { } } + // Switch to the original section if basic block sections was used. + if (emitBBSections) + OutStreamer->SwitchSection(MF->getSection()); + const Function &F = MF->getFunction(); for (const auto &BB : F) { if (!BB.hasAddressTaken()) @@ -1223,7 +1249,7 @@ void AsmPrinter::emitFunctionBody() { emitFunctionBodyEnd(); if (needFuncLabelsForEHOrDebugInfo(*MF, MMI) || - MAI->hasDotTypeDotSizeDirective()) { + MAI->hasDotTypeDotSizeDirective() || emitBBSections) { // Create a symbol for the end of function. CurrentFnEnd = createTempSymbol("func_end"); OutStreamer->emitLabel(CurrentFnEnd); @@ -1246,6 +1272,9 @@ void AsmPrinter::emitFunctionBody() { HI.Handler->markFunctionEnd(); } + if (emitBBSections) + EndOfRegularSectionMBB->setEndMCSymbol(CurrentFnEnd); + // Print out jump tables referenced by the function. emitJumpTableInfo(); @@ -2973,10 +3002,11 @@ static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB, PrintChildLoopComment(OS, Loop, AP.getFunctionNumber()); } -/// EmitBasicBlockStart - This method prints the label for the specified +/// emitBasicBlockStart - This method prints the label for the specified /// MachineBasicBlock, an alignment (if present) and a comment describing /// it if appropriate. void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) { + bool BBSections = MF->hasBBSections(); // End the previous funclet and start a new one. if (MBB.isEHFuncletEntry()) { for (const HandlerInfo &HI : Handlers) { @@ -2986,9 +3016,11 @@ void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) { } // Emit an alignment directive for this block, if needed. - const Align Alignment = MBB.getAlignment(); - if (Alignment != Align(1)) - emitAlignment(Alignment); + if (MBB.pred_empty() || !BBSections) { + const Align Alignment = MBB.getAlignment(); + if (Alignment != Align(1)) + emitAlignment(Alignment); + } // If the block has its address taken, emit any labels that were used to // reference the block. It is possible that there is more than one label @@ -3020,18 +3052,37 @@ void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) { emitBasicBlockLoopComments(MBB, MLI, *this); } - // Print the main label for the block. + bool emitBBLabels = BBSections || MF->hasBBLabels(); if (MBB.pred_empty() || - (isBlockOnlyReachableByFallthrough(&MBB) && !MBB.isEHFuncletEntry() && - !MBB.hasLabelMustBeEmitted())) { + (!emitBBLabels && isBlockOnlyReachableByFallthrough(&MBB) && + !MBB.isEHFuncletEntry() && !MBB.hasLabelMustBeEmitted())) { if (isVerbose()) { // NOTE: Want this comment at start of line, don't emit with AddComment. OutStreamer->emitRawComment(" %bb." + Twine(MBB.getNumber()) + ":", false); } } else { - if (isVerbose() && MBB.hasLabelMustBeEmitted()) + if (isVerbose() && MBB.hasLabelMustBeEmitted()) { OutStreamer->AddComment("Label of block must be emitted"); + } + // With -fbasicblock-sections, a basic block can start a new section. + if (MBB.getSectionType() == MachineBasicBlockSection::MBBS_Exception) { + // Create the exception section for this function. + OutStreamer->SwitchSection( + getObjFileLowering().getNamedSectionForMachineBasicBlock( + MF->getFunction(), MBB, TM, ".eh")); + } else if (MBB.getSectionType() == MachineBasicBlockSection::MBBS_Cold) { + // Create the cold section here. + OutStreamer->SwitchSection( + getObjFileLowering().getNamedSectionForMachineBasicBlock( + MF->getFunction(), MBB, TM, ".unlikely")); + } else if (MBB.isBeginSection() && MBB.isEndSection()) { + OutStreamer->SwitchSection( + getObjFileLowering().getSectionForMachineBasicBlock(MF->getFunction(), + MBB, TM)); + } else if (BBSections) { + OutStreamer->SwitchSection(MF->getSection()); + } OutStreamer->emitLabel(MBB.getSymbol()); } } @@ -3064,6 +3115,10 @@ void AsmPrinter::emitVisibility(MCSymbol *Sym, unsigned Visibility, /// the predecessor and this block is a fall-through. bool AsmPrinter:: isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const { + // With BasicBlock Sections, no block is a fall through. + if (MBB->isBeginSection()) + return false; + // If this is a landing pad, it isn't a fall through. If it has no preds, // then nothing falls through to it. if (MBB->isEHPad() || MBB->pred_empty()) diff --git a/llvm/lib/CodeGen/BBSectionsPrepare.cpp b/llvm/lib/CodeGen/BBSectionsPrepare.cpp new file mode 100644 index 00000000000000..6e81801abf06d4 --- /dev/null +++ b/llvm/lib/CodeGen/BBSectionsPrepare.cpp @@ -0,0 +1,315 @@ +//===-- BBSectionsPrepare.cpp ---=========---------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// BBSectionsPrepare implementation. +// +// The purpose of this pass is to assign sections to basic blocks when +// -fbasicblock-sections= option is used. Exception landing pad blocks are +// specially handled by grouping them in a single section. Further, with +// profile information only the subset of basic blocks with profiles are placed +// in a separate section and the rest are grouped in a cold section. +// +// Basic Block Sections +// ==================== +// +// With option, -fbasicblock-sections=, each basic block could be placed in a +// unique ELF text section in the object file along with a symbol labelling the +// basic block. The linker can then order the basic block sections in any +// arbitrary sequence which when done correctly can encapsulate block layout, +// function layout and function splitting optimizations. However, there are a +// couple of challenges to be addressed for this to be feasible: +// +// 1. The compiler must not allow any implicit fall-through between any two +// adjacent basic blocks as they could be reordered at link time to be +// non-adjacent. In other words, the compiler must make a fall-through +// between adjacent basic blocks explicit by retaining the direct jump +// instruction that jumps to the next basic block. +// +// 2. All inter-basic block branch targets would now need to be resolved by the +// linker as they cannot be calculated during compile time. This is done +// using static relocations. Further, the compiler tries to use short branch +// instructions on some ISAs for small branch offsets. This is not possible +// with basic block sections as the offset is not determined at compile time, +// and long branch instructions have to be used everywhere. +// +// 3. Each additional section bloats object file sizes by tens of bytes. The +// number of basic blocks can be potentially very large compared to the size +// of functions and can bloat object sizes significantly. Option +// fbasicblock-sections= also takes a file path which can be used to specify +// a subset of basic blocks that needs unique sections to keep the bloats +// small. +// +// 4. Debug Information (DebugInfo) and Call Frame Information (CFI) emission +// needs special handling with basic block sections. DebugInfo needs to be +// emitted with more relocations as basic block sections can break a +// function into potentially several disjoint pieces, and CFI needs to be +// emitted per basic block. This also bloats the object file and binary +// sizes. +// +// Basic Block Labels +// ================== +// +// With -fbasicblock-sections=labels, or when a basic block is placed in a +// unique section, it is labelled with a symbol. This allows easy mapping of +// virtual addresses from PMU profiles back to the corresponding basic blocks. +// Since the number of basic blocks is large, the labeling bloats the symbol +// table sizes and the string table sizes significantly. While the binary size +// does increase, it does not affect performance as the symbol table is not +// loaded in memory during run-time. The string table size bloat is kept very +// minimal using a unary naming scheme that uses string suffix compression. The +// basic blocks for function foo are named "a.BB.foo", "aa.BB.foo", ... This +// turns out to be very good for string table sizes and the bloat in the string +// table size for a very large binary is ~8 %. The naming also allows using +// the --symbol-ordering-file option in LLD to arbitrarily reorder the +// sections. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/SmallSet.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionPass.h" +#include "llvm/CodeGen/MachineModuleInfo.h" +#include "llvm/CodeGen/Passes.h" +#include "llvm/CodeGen/TargetInstrInfo.h" +#include "llvm/InitializePasses.h" +#include "llvm/Support/LineIterator.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Target/TargetMachine.h" + +#include + +using llvm::SmallSet; +using llvm::StringMap; +using llvm::StringRef; +using namespace llvm; + +namespace { + +class BBSectionsPrepare : public MachineFunctionPass { +public: + static char ID; + StringMap> BBSectionsList; + const MemoryBuffer *MBuf = nullptr; + + BBSectionsPrepare() : MachineFunctionPass(ID) { + initializeBBSectionsPreparePass(*PassRegistry::getPassRegistry()); + } + + BBSectionsPrepare(const MemoryBuffer *Buf) + : MachineFunctionPass(ID), MBuf(Buf) { + initializeBBSectionsPreparePass(*PassRegistry::getPassRegistry()); + }; + + StringRef getPassName() const override { + return "Basic Block Sections Analysis"; + } + + void getAnalysisUsage(AnalysisUsage &AU) const override; + + /// Read profiles of basic blocks if available here. + bool doInitialization(Module &M) override; + + /// Identify basic blocks that need separate sections and prepare to emit them + /// accordingly. + bool runOnMachineFunction(MachineFunction &MF) override; +}; + +} // end anonymous namespace + +char BBSectionsPrepare::ID = 0; +INITIALIZE_PASS(BBSectionsPrepare, "bbsections-prepare", + "Determine if a basic block needs a special section", false, + false) + +// This inserts an unconditional branch at the end of MBB to the next basic +// block S if and only if the control-flow implicitly falls through from MBB to +// S and S and MBB belong to different sections. This is necessary with basic +// block sections as MBB and S could be potentially reordered. +static void insertUnconditionalFallthroughBranch(MachineBasicBlock &MBB) { + MachineBasicBlock *Fallthrough = MBB.getFallThrough(); + + if (Fallthrough == nullptr) + return; + + // If this basic block and the Fallthrough basic block are in the same + // section then do not insert the jump. + if (MBB.sameSection(Fallthrough)) + return; + + const TargetInstrInfo *TII = MBB.getParent()->getSubtarget().getInstrInfo(); + SmallVector Cond; + MachineBasicBlock *TBB = nullptr, *FBB = nullptr; + + // If a branch to the fall through block already exists, return. + if (!TII->analyzeBranch(MBB, TBB, FBB, Cond) && + (TBB == Fallthrough || FBB == Fallthrough)) { + return; + } + + Cond.clear(); + DebugLoc DL = MBB.findBranchDebugLoc(); + TII->insertBranch(MBB, Fallthrough, nullptr, Cond, DL); +} + +/// This function sorts basic blocks according to the sections in which they are +/// emitted. Basic block sections automatically turn on function sections so +/// the entry block is in the function section. The other sections that are +/// created are: +/// 1) Exception section - basic blocks that are landing pads +/// 2) Cold section - basic blocks that will not have unique sections. +/// 3) Unique section - one per basic block that is emitted in a unique section. +static bool assignSectionsAndSortBasicBlocks( + MachineFunction &MF, + const StringMap> &BBSectionsList) { + SmallSet S = BBSectionsList.lookup(MF.getName()); + + bool HasHotEHPads = false; + + for (auto &MBB : MF) { + // Entry basic block cannot start another section because the function + // starts one already. + if (MBB.getNumber() == MF.front().getNumber()) { + MBB.setSectionType(MachineBasicBlockSection::MBBS_Entry); + continue; + } + // Check if this BB is a cold basic block. With the list option, all cold + // basic blocks can be clustered in a single cold section. + // All Exception landing pads must be in a single section. If all the + // landing pads are cold, it can be kept in the cold section. Otherwise, we + // create a separate exception section. + bool isColdBB = ((MF.getTarget().getBBSectionsType() == + llvm::BasicBlockSection::List) && + !S.empty() && !S.count(MBB.getNumber())); + if (isColdBB) { + MBB.setSectionType(MachineBasicBlockSection::MBBS_Cold); + } else if (MBB.isEHPad()) { + // We handle non-cold basic eh blocks later. + HasHotEHPads = true; + } else { + // Place this MBB in a unique section. A unique section begins and ends + // that section by definition. + MBB.setSectionType(MachineBasicBlockSection::MBBS_Unique); + } + } + + // If some EH Pads are not cold then we move all EH Pads to the exception + // section as we require that all EH Pads be in a single section. + if (HasHotEHPads) { + std::for_each(MF.begin(), MF.end(), [&](MachineBasicBlock &MBB) { + if (MBB.isEHPad()) + MBB.setSectionType(MachineBasicBlockSection::MBBS_Exception); + }); + } + + for (auto &MBB : MF) { + // With -fbasicblock-sections, fall through blocks must be made + // explicitly reachable. Do this after sections is set as + // unnecessary fallthroughs can be avoided. + insertUnconditionalFallthroughBranch(MBB); + } + + MF.sort(([&](MachineBasicBlock &X, MachineBasicBlock &Y) { + unsigned TypeX = X.getSectionType(); + unsigned TypeY = Y.getSectionType(); + + return (TypeX != TypeY) ? TypeX < TypeY : X.getNumber() < Y.getNumber(); + })); + + MF.setSectionRange(); + return true; +} + +bool BBSectionsPrepare::runOnMachineFunction(MachineFunction &MF) { + auto BBSectionsType = MF.getTarget().getBBSectionsType(); + assert(BBSectionsType != BasicBlockSection::None && + "BB Sections not enabled!"); + + // Renumber blocks before sorting them for basic block sections. This is + // useful during sorting, basic blocks in the same section will retain the + // default order. This renumbering should also be done for basic block + // labels to match the profiles with the correct blocks. + MF.RenumberBlocks(); + + if (BBSectionsType == BasicBlockSection::Labels) { + MF.setBBSectionsType(BBSectionsType); + MF.createBBLabels(); + return true; + } + + if (BBSectionsType == BasicBlockSection::List && + BBSectionsList.find(MF.getName()) == BBSectionsList.end()) + return true; + + MF.setBBSectionsType(BBSectionsType); + MF.createBBLabels(); + assignSectionsAndSortBasicBlocks(MF, BBSectionsList); + + return true; +} + +// Basic Block Sections can be enabled for a subset of machine basic blocks. +// This is done by passing a file containing names of functions for which basic +// block sections are desired. Additionally, machine basic block ids of the +// functions can also be specified for a finer granularity. +// A file with basic block sections for all of function main and two blocks for +// function foo looks like this: +// ---------------------------- +// list.txt: +// !main +// !foo +// !!2 +// !!4 +static bool getBBSectionsList(const MemoryBuffer *MBuf, + StringMap> &bbMap) { + if (!MBuf) + return false; + + line_iterator LineIt(*MBuf, /*SkipBlanks=*/true, /*CommentMarker=*/'#'); + + StringMap>::iterator fi = bbMap.end(); + + for (; !LineIt.is_at_eof(); ++LineIt) { + StringRef s(*LineIt); + if (s[0] == '@') + continue; + // Check for the leading "!" + if (!s.consume_front("!") || s.empty()) + break; + // Check for second "!" which encodes basic block ids. + if (s.consume_front("!")) { + if (fi != bbMap.end()) + fi->second.insert(std::stoi(s.str())); + else + return false; + } else { + // Start a new function. + auto R = bbMap.try_emplace(s.split('/').first); + fi = R.first; + assert(R.second); + } + } + return true; +} + +bool BBSectionsPrepare::doInitialization(Module &M) { + if (MBuf) + getBBSectionsList(MBuf, BBSectionsList); + return true; +} + +void BBSectionsPrepare::getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + AU.addRequired(); +} + +MachineFunctionPass * +llvm::createBBSectionsPreparePass(const MemoryBuffer *Buf) { + return new BBSectionsPrepare(Buf); +} diff --git a/llvm/lib/CodeGen/CMakeLists.txt b/llvm/lib/CodeGen/CMakeLists.txt index 0a299da0f40307..0d3ecc1d106d93 100644 --- a/llvm/lib/CodeGen/CMakeLists.txt +++ b/llvm/lib/CodeGen/CMakeLists.txt @@ -8,6 +8,7 @@ add_llvm_component_library(LLVMCodeGen BranchRelaxation.cpp BreakFalseDeps.cpp BuiltinGCs.cpp + BBSectionsPrepare.cpp CalcSpillWeights.cpp CallingConvLower.cpp CFGuardLongjmp.cpp diff --git a/llvm/lib/CodeGen/CodeGen.cpp b/llvm/lib/CodeGen/CodeGen.cpp index c74ba71d617084..eefb328c9c607b 100644 --- a/llvm/lib/CodeGen/CodeGen.cpp +++ b/llvm/lib/CodeGen/CodeGen.cpp @@ -20,6 +20,7 @@ using namespace llvm; /// initializeCodeGen - Initialize all passes linked into the CodeGen library. void llvm::initializeCodeGen(PassRegistry &Registry) { initializeAtomicExpandPass(Registry); + initializeBBSectionsPreparePass(Registry); initializeBranchFolderPassPass(Registry); initializeBranchRelaxationPass(Registry); initializeCFGuardLongjmpPass(Registry); diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp index fd55ef2936b0aa..1cccd6fade4efb 100644 --- a/llvm/lib/CodeGen/CodeGenPrepare.cpp +++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp @@ -6140,7 +6140,7 @@ bool CodeGenPrepare::optimizeSelectInst(SelectInst *SI) { // select.end: // %sel = phi i32 [ %c, %select.true ], [ %d, %select.false ] // - // %cmp should be freezed, otherwise it may introduce undefined behavior. + // %cmp should be frozen, otherwise it may introduce undefined behavior. // In addition, we may sink instructions that produce %c or %d from // the entry block into the destination(s) of the new branch. // If the true or false blocks do not contain a sunken instruction, that diff --git a/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp b/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp index d0a51ed03f000e..d7cbdbc3c90462 100644 --- a/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp +++ b/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp @@ -2194,6 +2194,8 @@ LegalizerHelper::lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty) { } case TargetOpcode::G_FMAD: return lowerFMad(MI); + case TargetOpcode::G_FFLOOR: + return lowerFFloor(MI); case TargetOpcode::G_INTRINSIC_ROUND: return lowerIntrinsicRound(MI); case TargetOpcode::G_ATOMIC_CMPXCHG_WITH_SUCCESS: { @@ -4646,6 +4648,39 @@ LegalizerHelper::LegalizeResult LegalizerHelper::lowerFMad(MachineInstr &MI) { LegalizerHelper::LegalizeResult LegalizerHelper::lowerIntrinsicRound(MachineInstr &MI) { + Register DstReg = MI.getOperand(0).getReg(); + Register X = MI.getOperand(1).getReg(); + const unsigned Flags = MI.getFlags(); + const LLT Ty = MRI.getType(DstReg); + const LLT CondTy = Ty.changeElementSize(1); + + // round(x) => + // t = trunc(x); + // d = fabs(x - t); + // o = copysign(1.0f, x); + // return t + (d >= 0.5 ? o : 0.0); + + auto T = MIRBuilder.buildIntrinsicTrunc(Ty, X, Flags); + + auto Diff = MIRBuilder.buildFSub(Ty, X, T, Flags); + auto AbsDiff = MIRBuilder.buildFAbs(Ty, Diff, Flags); + auto Zero = MIRBuilder.buildFConstant(Ty, 0.0); + auto One = MIRBuilder.buildFConstant(Ty, 1.0); + auto Half = MIRBuilder.buildFConstant(Ty, 0.5); + auto SignOne = MIRBuilder.buildFCopysign(Ty, One, X); + + auto Cmp = MIRBuilder.buildFCmp(CmpInst::FCMP_OGE, CondTy, AbsDiff, Half, + Flags); + auto Sel = MIRBuilder.buildSelect(Ty, Cmp, SignOne, Zero, Flags); + + MIRBuilder.buildFAdd(DstReg, T, Sel, Flags); + + MI.eraseFromParent(); + return Legalized; +} + +LegalizerHelper::LegalizeResult +LegalizerHelper::lowerFFloor(MachineInstr &MI) { Register DstReg = MI.getOperand(0).getReg(); Register SrcReg = MI.getOperand(1).getReg(); unsigned Flags = MI.getFlags(); @@ -4656,8 +4691,8 @@ LegalizerHelper::lowerIntrinsicRound(MachineInstr &MI) { // if (src < 0.0 && src != result) // result += -1.0. - auto Zero = MIRBuilder.buildFConstant(Ty, 0.0); auto Trunc = MIRBuilder.buildIntrinsicTrunc(Ty, SrcReg, Flags); + auto Zero = MIRBuilder.buildFConstant(Ty, 0.0); auto Lt0 = MIRBuilder.buildFCmp(CmpInst::FCMP_OLT, CondTy, SrcReg, Zero, Flags); @@ -4666,7 +4701,7 @@ LegalizerHelper::lowerIntrinsicRound(MachineInstr &MI) { auto And = MIRBuilder.buildAnd(CondTy, Lt0, NeTrunc); auto AddVal = MIRBuilder.buildSITOFP(Ty, And); - MIRBuilder.buildFAdd(DstReg, Trunc, AddVal); + MIRBuilder.buildFAdd(DstReg, Trunc, AddVal, Flags); MI.eraseFromParent(); return Legalized; } @@ -4837,35 +4872,47 @@ LegalizerHelper::LegalizeResult LegalizerHelper::lowerInsert(MachineInstr &MI) { LLT DstTy = MRI.getType(Src); LLT InsertTy = MRI.getType(InsertSrc); - if (InsertTy.isScalar() && - (DstTy.isScalar() || - (DstTy.isVector() && DstTy.getElementType() == InsertTy))) { - LLT IntDstTy = DstTy; - if (!DstTy.isScalar()) { - IntDstTy = LLT::scalar(DstTy.getSizeInBits()); - Src = MIRBuilder.buildBitcast(IntDstTy, Src).getReg(0); - } + if (InsertTy.isVector() || + (DstTy.isVector() && DstTy.getElementType() != InsertTy)) + return UnableToLegalize; - Register ExtInsSrc = MIRBuilder.buildZExt(IntDstTy, InsertSrc).getReg(0); - if (Offset != 0) { - auto ShiftAmt = MIRBuilder.buildConstant(IntDstTy, Offset); - ExtInsSrc = MIRBuilder.buildShl(IntDstTy, ExtInsSrc, ShiftAmt).getReg(0); - } + const DataLayout &DL = MIRBuilder.getDataLayout(); + if ((DstTy.isPointer() && + DL.isNonIntegralAddressSpace(DstTy.getAddressSpace())) || + (InsertTy.isPointer() && + DL.isNonIntegralAddressSpace(InsertTy.getAddressSpace()))) { + LLVM_DEBUG(dbgs() << "Not casting non-integral address space integer\n"); + return UnableToLegalize; + } - APInt MaskVal = APInt::getBitsSetWithWrap(DstTy.getSizeInBits(), - Offset + InsertTy.getSizeInBits(), - Offset); + LLT IntDstTy = DstTy; - auto Mask = MIRBuilder.buildConstant(IntDstTy, MaskVal); - auto MaskedSrc = MIRBuilder.buildAnd(IntDstTy, Src, Mask); - auto Or = MIRBuilder.buildOr(IntDstTy, MaskedSrc, ExtInsSrc); + if (!DstTy.isScalar()) { + IntDstTy = LLT::scalar(DstTy.getSizeInBits()); + Src = MIRBuilder.buildCast(IntDstTy, Src).getReg(0); + } - MIRBuilder.buildBitcast(Dst, Or); - MI.eraseFromParent(); - return Legalized; + if (!InsertTy.isScalar()) { + const LLT IntInsertTy = LLT::scalar(InsertTy.getSizeInBits()); + InsertSrc = MIRBuilder.buildPtrToInt(IntInsertTy, InsertSrc).getReg(0); } - return UnableToLegalize; + Register ExtInsSrc = MIRBuilder.buildZExt(IntDstTy, InsertSrc).getReg(0); + if (Offset != 0) { + auto ShiftAmt = MIRBuilder.buildConstant(IntDstTy, Offset); + ExtInsSrc = MIRBuilder.buildShl(IntDstTy, ExtInsSrc, ShiftAmt).getReg(0); + } + + APInt MaskVal = APInt::getBitsSetWithWrap( + DstTy.getSizeInBits(), Offset + InsertTy.getSizeInBits(), Offset); + + auto Mask = MIRBuilder.buildConstant(IntDstTy, MaskVal); + auto MaskedSrc = MIRBuilder.buildAnd(IntDstTy, Src, Mask); + auto Or = MIRBuilder.buildOr(IntDstTy, MaskedSrc, ExtInsSrc); + + MIRBuilder.buildCast(Dst, Or); + MI.eraseFromParent(); + return Legalized; } LegalizerHelper::LegalizeResult @@ -4909,7 +4956,7 @@ LegalizerHelper::lowerBswap(MachineInstr &MI) { Register Dst = MI.getOperand(0).getReg(); Register Src = MI.getOperand(1).getReg(); const LLT Ty = MRI.getType(Src); - unsigned SizeInBytes = Ty.getSizeInBytes(); + unsigned SizeInBytes = (Ty.getScalarSizeInBits() + 7) / 8; unsigned BaseShiftAmt = (SizeInBytes - 1) * 8; // Swap most and least significant byte, set remaining bytes in Res to zero. diff --git a/llvm/lib/CodeGen/MIRParser/MILexer.cpp b/llvm/lib/CodeGen/MIRParser/MILexer.cpp index 827f53aa54f68f..36a027c987e1f6 100644 --- a/llvm/lib/CodeGen/MIRParser/MILexer.cpp +++ b/llvm/lib/CodeGen/MIRParser/MILexer.cpp @@ -268,6 +268,7 @@ static MIToken::TokenKind getIdentifierKind(StringRef Identifier) { .Case("pre-instr-symbol", MIToken::kw_pre_instr_symbol) .Case("post-instr-symbol", MIToken::kw_post_instr_symbol) .Case("heap-alloc-marker", MIToken::kw_heap_alloc_marker) + .Case("bbsections", MIToken::kw_bbsections) .Case("unknown-size", MIToken::kw_unknown_size) .Default(MIToken::Identifier); } diff --git a/llvm/lib/CodeGen/MIRParser/MILexer.h b/llvm/lib/CodeGen/MIRParser/MILexer.h index aaffe4a4c91bba..e76f6a7e21a394 100644 --- a/llvm/lib/CodeGen/MIRParser/MILexer.h +++ b/llvm/lib/CodeGen/MIRParser/MILexer.h @@ -122,6 +122,7 @@ struct MIToken { kw_pre_instr_symbol, kw_post_instr_symbol, kw_heap_alloc_marker, + kw_bbsections, kw_unknown_size, // Named metadata keywords diff --git a/llvm/lib/CodeGen/MIRParser/MIParser.cpp b/llvm/lib/CodeGen/MIRParser/MIParser.cpp index c20c1552377dcc..93af409ec85524 100644 --- a/llvm/lib/CodeGen/MIRParser/MIParser.cpp +++ b/llvm/lib/CodeGen/MIRParser/MIParser.cpp @@ -495,6 +495,7 @@ class MIParser { bool parseOffset(int64_t &Offset); bool parseAlignment(unsigned &Alignment); bool parseAddrspace(unsigned &Addrspace); + bool parseMBBS(MachineBasicBlockSection &T); bool parseOperandsOffset(MachineOperand &Op); bool parseIRValue(const Value *&V); bool parseMemoryOperandFlag(MachineMemOperand::Flags &Flags); @@ -619,6 +620,25 @@ bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) { return true; } +// Parse Machine Basic Block Section Type. +bool MIParser::parseMBBS(MachineBasicBlockSection &T) { + assert(Token.is(MIToken::kw_bbsections)); + lex(); + const StringRef &S = Token.stringValue(); + if (S == "Entry") + T = MBBS_Entry; + else if (S == "Exception") + T = MBBS_Exception; + else if (S == "Cold") + T = MBBS_Cold; + else if (S == "Unique") + T = MBBS_Unique; + else + return error("Unknown Section Type"); + lex(); + return false; +} + bool MIParser::parseBasicBlockDefinition( DenseMap &MBBSlots) { assert(Token.is(MIToken::MachineBasicBlockLabel)); @@ -630,6 +650,7 @@ bool MIParser::parseBasicBlockDefinition( lex(); bool HasAddressTaken = false; bool IsLandingPad = false; + MachineBasicBlockSection SectionType = MBBS_None; unsigned Alignment = 0; BasicBlock *BB = nullptr; if (consumeIfPresent(MIToken::lparen)) { @@ -654,6 +675,10 @@ bool MIParser::parseBasicBlockDefinition( return true; lex(); break; + case MIToken::kw_bbsections: + if (parseMBBS(SectionType)) + return true; + break; default: break; } @@ -683,6 +708,10 @@ bool MIParser::parseBasicBlockDefinition( if (HasAddressTaken) MBB->setHasAddressTaken(); MBB->setIsEHPad(IsLandingPad); + if (SectionType != MBBS_None) { + MBB->setSectionType(SectionType); + MF.setBBSectionsType(BasicBlockSection::List); + } return false; } diff --git a/llvm/lib/CodeGen/MIRParser/MIRParser.cpp b/llvm/lib/CodeGen/MIRParser/MIRParser.cpp index f955bdc6186a7c..199d077ac66ee1 100644 --- a/llvm/lib/CodeGen/MIRParser/MIRParser.cpp +++ b/llvm/lib/CodeGen/MIRParser/MIRParser.cpp @@ -438,6 +438,14 @@ MIRParserImpl::initializeMachineFunction(const yaml::MachineFunction &YamlMF, diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange)); return true; } + // Check Basic Block Section Flags. + if (MF.getTarget().getBBSectionsType() == BasicBlockSection::Labels) { + MF.createBBLabels(); + MF.setBBSectionsType(BasicBlockSection::Labels); + } else if (MF.hasBBSections()) { + MF.setSectionRange(); + MF.createBBLabels(); + } PFS.SM = &SM; // Initialize the frame information after creating all the MBBs so that the diff --git a/llvm/lib/CodeGen/MIRPrinter.cpp b/llvm/lib/CodeGen/MIRPrinter.cpp index ece4f96325ca01..1fb557e4dfcd0c 100644 --- a/llvm/lib/CodeGen/MIRPrinter.cpp +++ b/llvm/lib/CodeGen/MIRPrinter.cpp @@ -635,6 +635,27 @@ void MIPrinter::print(const MachineBasicBlock &MBB) { OS << "align " << MBB.getAlignment().value(); HasAttributes = true; } + if (MBB.getSectionType() != MBBS_None) { + OS << (HasAttributes ? ", " : " ("); + OS << "bbsections "; + switch (MBB.getSectionType()) { + case MBBS_Entry: + OS << "Entry"; + break; + case MBBS_Exception: + OS << "Exception"; + break; + case MBBS_Cold: + OS << "Cold"; + break; + case MBBS_Unique: + OS << "Unique"; + break; + default: + llvm_unreachable("No such section type"); + } + HasAttributes = true; + } if (HasAttributes) OS << ")"; OS << ":\n"; diff --git a/llvm/lib/CodeGen/MachineBasicBlock.cpp b/llvm/lib/CodeGen/MachineBasicBlock.cpp index c2f459e313ccd7..b273da862fa3a5 100644 --- a/llvm/lib/CodeGen/MachineBasicBlock.cpp +++ b/llvm/lib/CodeGen/MachineBasicBlock.cpp @@ -61,12 +61,31 @@ MCSymbol *MachineBasicBlock::getSymbol() const { const MachineFunction *MF = getParent(); MCContext &Ctx = MF->getContext(); auto Prefix = Ctx.getAsmInfo()->getPrivateLabelPrefix(); + + bool BasicBlockSymbols = MF->hasBBSections() || MF->hasBBLabels(); + auto Delimiter = BasicBlockSymbols ? "." : "_"; assert(getNumber() >= 0 && "cannot get label for unreachable MBB"); - CachedMCSymbol = Ctx.getOrCreateSymbol(Twine(Prefix) + "BB" + - Twine(MF->getFunctionNumber()) + - "_" + Twine(getNumber())); - } + // With Basic Block Sections, we emit a symbol for every basic block. To + // keep the size of strtab small, we choose a unary encoding which can + // compress the symbol names significantly. The basic blocks for function + // foo are named a.BB.foo, aa.BB.foo, and so on. + if (BasicBlockSymbols) { + auto Iter = MF->getBBSectionsSymbolPrefix().begin(); + if (getNumber() < 0 || + getNumber() >= (int)MF->getBBSectionsSymbolPrefix().size()) + report_fatal_error("Unreachable MBB: " + Twine(getNumber())); + std::string Prefix(Iter + 1, Iter + getNumber() + 1); + std::reverse(Prefix.begin(), Prefix.end()); + CachedMCSymbol = + Ctx.getOrCreateSymbol(Prefix + Twine(Delimiter) + "BB" + + Twine(Delimiter) + Twine(MF->getName())); + } else { + CachedMCSymbol = Ctx.getOrCreateSymbol( + Twine(Prefix) + "BB" + Twine(MF->getFunctionNumber()) + + Twine(Delimiter) + Twine(getNumber())); + } + } return CachedMCSymbol; } @@ -529,6 +548,48 @@ void MachineBasicBlock::moveAfter(MachineBasicBlock *NewBefore) { getParent()->splice(++NewBefore->getIterator(), getIterator()); } +// Returns true if this basic block and the Other are in the same section. +bool MachineBasicBlock::sameSection(const MachineBasicBlock *Other) const { + if (this == Other) + return true; + + if (this->getSectionType() != Other->getSectionType()) + return false; + + // If either is in a unique section, return false. + if (this->getSectionType() == llvm::MachineBasicBlockSection::MBBS_Unique || + Other->getSectionType() == llvm::MachineBasicBlockSection::MBBS_Unique) + return false; + + return true; +} + +const MachineBasicBlock *MachineBasicBlock::getSectionEndMBB() const { + if (this->isEndSection()) + return this; + auto I = std::next(this->getIterator()); + const MachineFunction *MF = getParent(); + while (I != MF->end()) { + const MachineBasicBlock &MBB = *I; + if (MBB.isEndSection()) + return &MBB; + I = std::next(I); + } + llvm_unreachable("No End Basic Block for this section."); +} + +// Returns true if this block begins any section. +bool MachineBasicBlock::isBeginSection() const { + return (SectionType == MBBS_Entry || SectionType == MBBS_Unique || + getParent()->isSectionStartMBB(getNumber())); +} + +// Returns true if this block begins any section. +bool MachineBasicBlock::isEndSection() const { + return (SectionType == MBBS_Entry || SectionType == MBBS_Unique || + getParent()->isSectionEndMBB(getNumber())); +} + void MachineBasicBlock::updateTerminator() { const TargetInstrInfo *TII = getParent()->getSubtarget().getInstrInfo(); // A block with no successors has no concerns with fall-through edges. diff --git a/llvm/lib/CodeGen/MachineFunction.cpp b/llvm/lib/CodeGen/MachineFunction.cpp index b00907f63d4ea9..76a1bd9f75afb8 100644 --- a/llvm/lib/CodeGen/MachineFunction.cpp +++ b/llvm/lib/CodeGen/MachineFunction.cpp @@ -33,6 +33,7 @@ #include "llvm/CodeGen/MachineRegisterInfo.h" #include "llvm/CodeGen/PseudoSourceValue.h" #include "llvm/CodeGen/TargetFrameLowering.h" +#include "llvm/CodeGen/TargetInstrInfo.h" #include "llvm/CodeGen/TargetLowering.h" #include "llvm/CodeGen/TargetRegisterInfo.h" #include "llvm/CodeGen/TargetSubtargetInfo.h" @@ -71,6 +72,7 @@ #include #include #include +#include #include #include @@ -339,6 +341,59 @@ void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) { MBBNumbering.resize(BlockNo); } +/// This sets the section ranges of cold or exception section with basic block +/// sections. +void MachineFunction::setSectionRange() { + // Compute the Section Range of cold and exception basic blocks. Find the + // first and last block of each range. + auto SectionRange = + ([&](llvm::MachineBasicBlockSection S) -> std::pair { + auto MBBP = + std::find_if(begin(), end(), [&](MachineBasicBlock &MBB) -> bool { + return MBB.getSectionType() == S; + }); + if (MBBP == end()) + return std::make_pair(-1, -1); + + auto MBBQ = + std::find_if(rbegin(), rend(), [&](MachineBasicBlock &MBB) -> bool { + return MBB.getSectionType() == S; + }); + assert(MBBQ != rend() && "Section end not found!"); + return std::make_pair(MBBP->getNumber(), MBBQ->getNumber()); + }); + + ExceptionSectionRange = SectionRange(MBBS_Exception); + ColdSectionRange = SectionRange(llvm::MBBS_Cold); +} + +/// This is used with -fbasicblock-sections or -fbasicblock-labels option. +/// A unary encoding of basic block labels is done to keep ".strtab" sizes +/// small. +void MachineFunction::createBBLabels() { + const TargetInstrInfo *TII = getSubtarget().getInstrInfo(); + this->BBSectionsSymbolPrefix.resize(getNumBlockIDs(), 'a'); + for (auto MBBI = begin(), E = end(); MBBI != E; ++MBBI) { + assert( + (MBBI->getNumber() >= 0 && MBBI->getNumber() < (int)getNumBlockIDs()) && + "BasicBlock number was out of range!"); + // 'a' - Normal block. + // 'r' - Return block. + // 'l' - Landing Pad. + // 'L' - Return and landing pad. + bool isEHPad = MBBI->isEHPad(); + bool isRetBlock = MBBI->isReturnBlock() && !TII->isTailCall(MBBI->back()); + char type = 'a'; + if (isEHPad && isRetBlock) + type = 'L'; + else if (isEHPad) + type = 'l'; + else if (isRetBlock) + type = 'r'; + BBSectionsSymbolPrefix[MBBI->getNumber()] = type; + } +} + /// Allocate a new MachineInstr. Use this instead of `new MachineInstr'. MachineInstr *MachineFunction::CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL, diff --git a/llvm/lib/CodeGen/StackProtector.cpp b/llvm/lib/CodeGen/StackProtector.cpp index 4e2189884bb19f..a343791807e64c 100644 --- a/llvm/lib/CodeGen/StackProtector.cpp +++ b/llvm/lib/CodeGen/StackProtector.cpp @@ -18,6 +18,7 @@ #include "llvm/ADT/Statistic.h" #include "llvm/Analysis/BranchProbabilityInfo.h" #include "llvm/Analysis/EHPersonalities.h" +#include "llvm/Analysis/MemoryLocation.h" #include "llvm/Analysis/OptimizationRemarkEmitter.h" #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/TargetLowering.h" @@ -161,9 +162,16 @@ bool StackProtector::ContainsProtectableArray(Type *Ty, bool &IsLarge, return NeedsProtector; } -bool StackProtector::HasAddressTaken(const Instruction *AI) { +bool StackProtector::HasAddressTaken(const Instruction *AI, + uint64_t AllocSize) { + const DataLayout &DL = M->getDataLayout(); for (const User *U : AI->users()) { const auto *I = cast(U); + // If this instruction accesses memory make sure it doesn't access beyond + // the bounds of the allocated object. + Optional MemLoc = MemoryLocation::getOrNone(I); + if (MemLoc.hasValue() && MemLoc->Size.getValue() > AllocSize) + return true; switch (I->getOpcode()) { case Instruction::Store: if (AI == cast(I)->getValueOperand()) @@ -189,11 +197,26 @@ bool StackProtector::HasAddressTaken(const Instruction *AI) { } case Instruction::Invoke: return true; + case Instruction::GetElementPtr: { + // If the GEP offset is out-of-bounds, or is non-constant and so has to be + // assumed to be potentially out-of-bounds, then any memory access that + // would use it could also be out-of-bounds meaning stack protection is + // required. + const GetElementPtrInst *GEP = cast(I); + unsigned TypeSize = DL.getIndexTypeSizeInBits(I->getType()); + APInt Offset(TypeSize, 0); + APInt MaxOffset(TypeSize, AllocSize); + if (!GEP->accumulateConstantOffset(DL, Offset) || Offset.ugt(MaxOffset)) + return true; + // Adjust AllocSize to be the space remaining after this offset. + if (HasAddressTaken(I, AllocSize - Offset.getLimitedValue())) + return true; + break; + } case Instruction::BitCast: - case Instruction::GetElementPtr: case Instruction::Select: case Instruction::AddrSpaceCast: - if (HasAddressTaken(I)) + if (HasAddressTaken(I, AllocSize)) return true; break; case Instruction::PHI: { @@ -201,7 +224,7 @@ bool StackProtector::HasAddressTaken(const Instruction *AI) { // they are only visited once. const auto *PN = cast(I); if (VisitedPHIs.insert(PN).second) - if (HasAddressTaken(PN)) + if (HasAddressTaken(PN, AllocSize)) return true; break; } @@ -330,7 +353,8 @@ bool StackProtector::RequiresStackProtector() { continue; } - if (Strong && HasAddressTaken(AI)) { + if (Strong && HasAddressTaken(AI, M->getDataLayout().getTypeAllocSize( + AI->getAllocatedType()))) { ++NumAddrTaken; Layout.insert(std::make_pair(AI, MachineFrameInfo::SSPLK_AddrOf)); ORE.emit([&]() { @@ -342,6 +366,9 @@ bool StackProtector::RequiresStackProtector() { }); NeedsProtector = true; } + // Clear any PHIs that we visited, to make sure we examine all uses of + // any subsequent allocas that we look at. + VisitedPHIs.clear(); } } } diff --git a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp index 2ce285c85672c1..8f1c342202d6d4 100644 --- a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp +++ b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp @@ -21,6 +21,8 @@ #include "llvm/BinaryFormat/Dwarf.h" #include "llvm/BinaryFormat/ELF.h" #include "llvm/BinaryFormat/MachO.h" +#include "llvm/CodeGen/MachineBasicBlock.h" +#include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/MachineModuleInfoImpls.h" #include "llvm/IR/Comdat.h" @@ -52,8 +54,8 @@ #include "llvm/ProfileData/InstrProf.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CodeGen.h" -#include "llvm/Support/Format.h" #include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/Format.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Target/TargetMachine.h" #include @@ -762,6 +764,56 @@ MCSection *TargetLoweringObjectFileELF::getSectionForConstant( return DataRelROSection; } +/// Returns a unique section for the given machine basic block. +MCSection *TargetLoweringObjectFileELF::getSectionForMachineBasicBlock( + const Function &F, const MachineBasicBlock &MBB, + const TargetMachine &TM) const { + SmallString<128> Name; + Name = (static_cast(MBB.getParent()->getSection())) + ->getSectionName(); + if (TM.getUniqueBBSectionNames()) { + Name += "."; + Name += MBB.getSymbol()->getName(); + } + unsigned UniqueID = NextUniqueID++; + unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_EXECINSTR; + std::string GroupName = ""; + if (F.hasComdat()) { + Flags |= ELF::SHF_GROUP; + GroupName = F.getComdat()->getName().str(); + } + return getContext().getELFSection(Name, ELF::SHT_PROGBITS, Flags, + 0 /* Entry Size */, GroupName, UniqueID, + nullptr); +} + +MCSection *TargetLoweringObjectFileELF::getNamedSectionForMachineBasicBlock( + const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM, + const char *Suffix) const { + SmallString<128> Name; + Name = (static_cast(MBB.getParent()->getSection())) + ->getSectionName(); + + // If unique section names is off, explicity add the function name to the + // section name to make sure named sections for functions are unique + // across the module. + if (!TM.getUniqueSectionNames()) { + Name += "."; + Name += MBB.getParent()->getName(); + } + + Name += Suffix; + + unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_EXECINSTR; + std::string GroupName = ""; + if (F.hasComdat()) { + Flags |= ELF::SHF_GROUP; + GroupName = F.getComdat()->getName().str(); + } + return getContext().getELFSection(Name, ELF::SHT_PROGBITS, Flags, + 0 /* Entry Size */, GroupName); +} + static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray, bool IsCtor, unsigned Priority, const MCSymbol *KeySym) { diff --git a/llvm/lib/CodeGen/TargetPassConfig.cpp b/llvm/lib/CodeGen/TargetPassConfig.cpp index 4485d5ee4f9511..a351efc6659d5f 100644 --- a/llvm/lib/CodeGen/TargetPassConfig.cpp +++ b/llvm/lib/CodeGen/TargetPassConfig.cpp @@ -983,6 +983,9 @@ void TargetPassConfig::addMachinePasses() { addPass(createMachineOutlinerPass(RunOnAllFunctions)); } + if (TM->getBBSectionsType() != llvm::BasicBlockSection::None) + addPass(llvm::createBBSectionsPreparePass(TM->getBBSectionsFuncListBuf())); + // Add passes that directly emit MI after all other MI passes. addPreEmitPass2(); diff --git a/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp b/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp index 8a8d98d728aaa8..0a658034b67b8a 100644 --- a/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp +++ b/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp @@ -351,126 +351,4 @@ bool DWARFExpression::verify(DWARFUnit *U) { return true; } -/// A user-facing string representation of a DWARF expression. This might be an -/// Address expression, in which case it will be implicitly dereferenced, or a -/// Value expression. -struct PrintedExpr { - enum ExprKind { - Address, - Value, - }; - ExprKind Kind; - SmallString<16> String; - - PrintedExpr(ExprKind K = Address) : Kind(K) {} -}; - -static bool printCompactDWARFExpr(raw_ostream &OS, DWARFExpression::iterator I, - const DWARFExpression::iterator E, - const MCRegisterInfo &MRI) { - SmallVector Stack; - - while (I != E) { - DWARFExpression::Operation &Op = *I; - uint8_t Opcode = Op.getCode(); - switch (Opcode) { - case dwarf::DW_OP_regx: { - // DW_OP_regx: A register, with the register num given as an operand. - // Printed as the plain register name. - uint64_t DwarfRegNum = Op.getRawOperand(0); - Optional LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false); - if (!LLVMRegNum) { - OS << ""; - return false; - } - raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String); - S << MRI.getName(*LLVMRegNum); - break; - } - case dwarf::DW_OP_bregx: { - int DwarfRegNum = Op.getRawOperand(0); - int64_t Offset = Op.getRawOperand(1); - Optional LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false); - if (!LLVMRegNum) { - OS << ""; - return false; - } - raw_svector_ostream S(Stack.emplace_back().String); - S << MRI.getName(*LLVMRegNum); - if (Offset) - S << format("%+" PRId64, Offset); - break; - } - case dwarf::DW_OP_entry_value: - case dwarf::DW_OP_GNU_entry_value: { - // DW_OP_entry_value contains a sub-expression which must be rendered - // separately. - uint64_t SubExprLength = Op.getRawOperand(0); - DWARFExpression::iterator SubExprEnd = I.skipBytes(SubExprLength); - ++I; - raw_svector_ostream S(Stack.emplace_back().String); - S << "entry("; - printCompactDWARFExpr(S, I, SubExprEnd, MRI); - S << ")"; - I = SubExprEnd; - continue; - } - case dwarf::DW_OP_stack_value: { - // The top stack entry should be treated as the actual value of tne - // variable, rather than the address of the variable in memory. - assert(!Stack.empty()); - Stack.back().Kind = PrintedExpr::Value; - break; - } - default: - if (Opcode >= dwarf::DW_OP_reg0 && Opcode <= dwarf::DW_OP_reg31) { - // DW_OP_reg: A register, with the register num implied by the - // opcode. Printed as the plain register name. - uint64_t DwarfRegNum = Opcode - dwarf::DW_OP_reg0; - Optional LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false); - if (!LLVMRegNum) { - OS << ""; - return false; - } - raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String); - S << MRI.getName(*LLVMRegNum); - } else if (Opcode >= dwarf::DW_OP_breg0 && - Opcode <= dwarf::DW_OP_breg31) { - int DwarfRegNum = Opcode - dwarf::DW_OP_breg0; - int64_t Offset = Op.getRawOperand(0); - Optional LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false); - if (!LLVMRegNum) { - OS << ""; - return false; - } - raw_svector_ostream S(Stack.emplace_back().String); - S << MRI.getName(*LLVMRegNum); - if (Offset) - S << format("%+" PRId64, Offset); - } else { - // If we hit an unknown operand, we don't know its effect on the stack, - // so bail out on the whole expression. - OS << ""; - return false; - } - break; - } - ++I; - } - - assert(Stack.size() == 1 && "expected one value on stack"); - - if (Stack.front().Kind == PrintedExpr::Address) - OS << "[" << Stack.front().String << "]"; - else - OS << Stack.front().String; - - return true; -} - -bool DWARFExpression::printCompact(raw_ostream &OS, const MCRegisterInfo &MRI) { - return printCompactDWARFExpr(OS, begin(), end(), MRI); -} - } // namespace llvm diff --git a/llvm/lib/ObjectYAML/ELFYAML.cpp b/llvm/lib/ObjectYAML/ELFYAML.cpp index d567153af4c229..e9977b4899eeb2 100644 --- a/llvm/lib/ObjectYAML/ELFYAML.cpp +++ b/llvm/lib/ObjectYAML/ELFYAML.cpp @@ -982,6 +982,38 @@ struct NormalizedOther { } // end anonymous namespace +void ScalarTraits::output(const ELFYAML::YAMLIntUInt &Val, + void *Ctx, raw_ostream &Out) { + Out << Val; +} + +StringRef ScalarTraits::input(StringRef Scalar, void *Ctx, + ELFYAML::YAMLIntUInt &Val) { + const bool Is64 = static_cast(Ctx)->Header.Class == + ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64); + StringRef ErrMsg = "invalid number"; + // We do not accept negative hex numbers because their meaning is ambiguous. + // For example, would -0xfffffffff mean 1 or INT32_MIN? + if (Scalar.empty() || Scalar.startswith("-0x")) + return ErrMsg; + + if (Scalar.startswith("-")) { + const int64_t MinVal = Is64 ? INT64_MIN : INT32_MIN; + long long Int; + if (getAsSignedInteger(Scalar, /*Radix=*/0, Int) || (Int < MinVal)) + return ErrMsg; + Val = Int; + return ""; + } + + const uint64_t MaxVal = Is64 ? UINT64_MAX : UINT32_MAX; + unsigned long long UInt; + if (getAsUnsignedInteger(Scalar, /*Radix=*/0, UInt) || (UInt > MaxVal)) + return ErrMsg; + Val = UInt; + return ""; +} + void MappingTraits::mapping(IO &IO, ELFYAML::Symbol &Symbol) { IO.mapOptional("Name", Symbol.Name, StringRef()); IO.mapOptional("StName", Symbol.StName); @@ -1582,7 +1614,7 @@ void MappingTraits::mapping(IO &IO, } else IO.mapRequired("Type", Rel.Type); - IO.mapOptional("Addend", Rel.Addend, (int64_t)0); + IO.mapOptional("Addend", Rel.Addend, (ELFYAML::YAMLIntUInt)0); } void MappingTraits::mapping(IO &IO, ELFYAML::Object &Object) { diff --git a/llvm/lib/Passes/PassRegistry.def b/llvm/lib/Passes/PassRegistry.def index 056e8833ab83e4..56af6d3bd7c218 100644 --- a/llvm/lib/Passes/PassRegistry.def +++ b/llvm/lib/Passes/PassRegistry.def @@ -92,6 +92,7 @@ MODULE_PASS("tsan-module", ThreadSanitizerPass()) MODULE_PASS("kasan-module", ModuleAddressSanitizerPass(/*CompileKernel=*/true, false, true, false)) MODULE_PASS("sancov-module", ModuleSanitizerCoveragePass()) MODULE_PASS("poison-checking", PoisonCheckingPass()) +MODULE_PASS("stack-safety-annotator", StackSafetyGlobalAnnotatorPass()) #undef MODULE_PASS #ifndef CGSCC_ANALYSIS diff --git a/llvm/lib/Support/FormattedStream.cpp b/llvm/lib/Support/FormattedStream.cpp index f30a9678029f76..4eb747038bb9ee 100644 --- a/llvm/lib/Support/FormattedStream.cpp +++ b/llvm/lib/Support/FormattedStream.cpp @@ -11,9 +11,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Support/FormattedStream.h" -#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/Debug.h" -#include "llvm/Support/Locale.h" #include "llvm/Support/raw_ostream.h" #include @@ -21,32 +19,15 @@ using namespace llvm; /// UpdatePosition - Examine the given char sequence and figure out which /// column we end up in after output, and how many line breaks are contained. -/// This assumes that the input string is well-formed UTF-8, and takes into -/// account unicode characters which render as multiple columns wide. -static void UpdatePosition(std::pair &Position, - const char *Ptr, size_t Size) { +/// +static void UpdatePosition(std::pair &Position, const char *Ptr, size_t Size) { unsigned &Column = Position.first; unsigned &Line = Position.second; // Keep track of the current column and line by scanning the string for - // special characters. - unsigned NumBytes; - for (const char *End = Ptr + Size; Ptr < End; Ptr += NumBytes) { - NumBytes = getNumBytesForUTF8(*Ptr); - - // The string should never end part way through a multi-byte sequence. - assert((Ptr + NumBytes) <= End && "Malformed multi-byte sequence"); - - int Width = sys::locale::columnWidth(StringRef(Ptr, NumBytes)); - // columnWidth returns -1 for non-printing characters. - if (Width != -1) - Column += Width; - - // If this is the final byte of a multi-byte sequence, it can't be any of - // the special whitespace characters below. - if (NumBytes > 1) - continue; - + // special characters + for (const char *End = Ptr + Size; Ptr != End; ++Ptr) { + ++Column; switch (*Ptr) { case '\n': Line += 1; diff --git a/llvm/lib/Support/raw_ostream.cpp b/llvm/lib/Support/raw_ostream.cpp index 13b0203ac953ed..7e9428e5dbc924 100644 --- a/llvm/lib/Support/raw_ostream.cpp +++ b/llvm/lib/Support/raw_ostream.cpp @@ -792,7 +792,7 @@ size_t raw_fd_ostream::preferred_buffer_size() const { // If this is a terminal, don't use buffering. Line buffering // would be a more traditional thing to do, but it's not worth // the complexity. - if (S_ISCHR(statbuf.st_mode) && isatty(FD)) + if (S_ISCHR(statbuf.st_mode) && is_displayed()) return 0; // Return the preferred block size. return statbuf.st_blksize; diff --git a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp index 23df49790b5e1c..3611090b9e09a2 100644 --- a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp +++ b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp @@ -12646,6 +12646,41 @@ static SDValue getScaledOffsetForBitWidth(SelectionDAG &DAG, SDValue Offset, return DAG.getNode(ISD::SHL, DL, MVT::nxv2i64, Offset, SplatShift); } +/// Check if the value of \p OffsetInBytes can be used as an immediate for +/// the gather load/prefetch and scatter store instructions with vector base and +/// immediate offset addressing mode: +/// +/// [.[S|D]{, #}] +/// +/// where = sizeof() * k, for k = 0, 1, ..., 31. + +inline static bool isValidImmForSVEVecImmAddrMode(unsigned OffsetInBytes, + unsigned ScalarSizeInBytes) { + // The immediate is not a multiple of the scalar size. + if (OffsetInBytes % ScalarSizeInBytes) + return false; + + // The immediate is out of range. + if (OffsetInBytes / ScalarSizeInBytes > 31) + return false; + + return true; +} + +/// Check if the value of \p Offset represents a valid immediate for the SVE +/// gather load/prefetch and scatter store instructiona with vector base and +/// immediate offset addressing mode: +/// +/// [.[S|D]{, #}] +/// +/// where = sizeof() * k, for k = 0, 1, ..., 31. +static bool isValidImmForSVEVecImmAddrMode(SDValue Offset, + unsigned ScalarSizeInBytes) { + ConstantSDNode *OffsetConst = dyn_cast(Offset.getNode()); + return OffsetConst && isValidImmForSVEVecImmAddrMode( + OffsetConst->getZExtValue(), ScalarSizeInBytes); +} + static SDValue performScatterStoreCombine(SDNode *N, SelectionDAG &DAG, unsigned Opcode, bool OnlyPackedOffsets = true) { @@ -12697,13 +12732,8 @@ static SDValue performScatterStoreCombine(SDNode *N, SelectionDAG &DAG, // immediates outside that range and non-immediate scalar offsets use SST1 or // SST1_UXTW instead. if (Opcode == AArch64ISD::SST1_IMM) { - uint64_t MaxIndex = 31; - uint64_t SrcElSize = SrcElVT.getStoreSize().getKnownMinSize(); - - ConstantSDNode *OffsetConst = dyn_cast(Offset.getNode()); - if (nullptr == OffsetConst || - OffsetConst->getZExtValue() > MaxIndex * SrcElSize || - OffsetConst->getZExtValue() % SrcElSize) { + if (!isValidImmForSVEVecImmAddrMode(Offset, + SrcVT.getScalarSizeInBits() / 8)) { if (MVT::nxv4i32 == Base.getValueType().getSimpleVT().SimpleTy) Opcode = AArch64ISD::SST1_UXTW; else @@ -12763,7 +12793,6 @@ static SDValue performGatherLoadCombine(SDNode *N, SelectionDAG &DAG, "Gather loads are only possible for SVE vectors"); SDLoc DL(N); - MVT RetElVT = RetVT.getVectorElementType().getSimpleVT(); // Make sure that the loaded data will fit into an SVE register if (RetVT.getSizeInBits().getKnownMinSize() > AArch64::SVEBitsPerBlock) @@ -12780,8 +12809,8 @@ static SDValue performGatherLoadCombine(SDNode *N, SelectionDAG &DAG, // applies to non-temporal gathers because there's no instruction that takes // indicies. if (Opcode == AArch64ISD::GLDNT1_INDEX) { - Offset = - getScaledOffsetForBitWidth(DAG, Offset, DL, RetElVT.getSizeInBits()); + Offset = getScaledOffsetForBitWidth(DAG, Offset, DL, + RetVT.getScalarSizeInBits()); Opcode = AArch64ISD::GLDNT1; } @@ -12800,13 +12829,8 @@ static SDValue performGatherLoadCombine(SDNode *N, SelectionDAG &DAG, // immediates outside that range and non-immediate scalar offsets use GLD1 or // GLD1_UXTW instead. if (Opcode == AArch64ISD::GLD1_IMM || Opcode == AArch64ISD::GLDFF1_IMM) { - uint64_t MaxIndex = 31; - uint64_t RetElSize = RetElVT.getStoreSize().getKnownMinSize(); - - ConstantSDNode *OffsetConst = dyn_cast(Offset.getNode()); - if (nullptr == OffsetConst || - OffsetConst->getZExtValue() > MaxIndex * RetElSize || - OffsetConst->getZExtValue() % RetElSize) { + if (!isValidImmForSVEVecImmAddrMode(Offset, + RetVT.getScalarSizeInBits() / 8)) { if (MVT::nxv4i32 == Base.getValueType().getSimpleVT().SimpleTy) Opcode = (Opcode == AArch64ISD::GLD1_IMM) ? AArch64ISD::GLD1_UXTW : AArch64ISD::GLDFF1_UXTW; @@ -12950,6 +12974,51 @@ performSignExtendInRegCombine(SDNode *N, TargetLowering::DAGCombinerInfo &DCI, return SDValue(N, 0); } +/// Legalize the gather prefetch (scalar + vector addressing mode) when the +/// offset vector is an unpacked 32-bit scalable vector. The other cases (Offset +/// != nxv2i32) do not need legalization. +static SDValue legalizeSVEGatherPrefetchOffsVec(SDNode *N, SelectionDAG &DAG) { + const unsigned OffsetPos = 4; + SDValue Offset = N->getOperand(OffsetPos); + + // Not an unpacked vector, bail out. + if (Offset.getValueType().getSimpleVT().SimpleTy != MVT::nxv2i32) + return SDValue(); + + // Extend the unpacked offset vector to 64-bit lanes. + SDLoc DL(N); + Offset = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::nxv2i64, Offset); + SmallVector Ops(N->op_begin(), N->op_end()); + // Replace the offset operand with the 64-bit one. + Ops[OffsetPos] = Offset; + + return DAG.getNode(N->getOpcode(), DL, DAG.getVTList(MVT::Other), Ops); +} + +/// Combines a node carrying the intrinsic `aarch64_sve_gather_prf` into a +/// node that uses `aarch64_sve_gather_prf_scaled_uxtw` when the scalar +/// offset passed to `aarch64_sve_gather_prf` is not a valid immediate for +/// the sve gather prefetch instruction with vector plus immediate addressing +/// mode. +static SDValue combineSVEPrefetchVecBaseImmOff(SDNode *N, SelectionDAG &DAG, + unsigned NewIID, + unsigned ScalarSizeInBytes) { + const unsigned ImmPos = 4, OffsetPos = 3; + // No need to combine the node if the immediate is valid... + if (isValidImmForSVEVecImmAddrMode(N->getOperand(ImmPos), ScalarSizeInBytes)) + return SDValue(); + + // ...otherwise swap the offset base with the offset... + SmallVector Ops(N->op_begin(), N->op_end()); + std::swap(Ops[ImmPos], Ops[OffsetPos]); + // ...and remap the intrinsic `aarch64_sve_gather_prf` to + // `aarch64_sve_gather_prf_scaled_uxtw`. + SDLoc DL(N); + Ops[1] = DAG.getConstant(NewIID, DL, MVT::i64); + + return DAG.getNode(N->getOpcode(), DL, DAG.getVTList(MVT::Other), Ops); +} + SDValue AArch64TargetLowering::PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const { SelectionDAG &DAG = DCI.DAG; @@ -13014,6 +13083,31 @@ SDValue AArch64TargetLowering::PerformDAGCombine(SDNode *N, case ISD::INTRINSIC_VOID: case ISD::INTRINSIC_W_CHAIN: switch (cast(N->getOperand(1))->getZExtValue()) { + case Intrinsic::aarch64_sve_gather_prfb: + return combineSVEPrefetchVecBaseImmOff( + N, DAG, Intrinsic::aarch64_sve_gather_prfb_scaled_uxtw, + 1 /*=ScalarSizeInBytes*/); + case Intrinsic::aarch64_sve_gather_prfh: + return combineSVEPrefetchVecBaseImmOff( + N, DAG, Intrinsic::aarch64_sve_gather_prfh_scaled_uxtw, + 2 /*=ScalarSizeInBytes*/); + case Intrinsic::aarch64_sve_gather_prfw: + return combineSVEPrefetchVecBaseImmOff( + N, DAG, Intrinsic::aarch64_sve_gather_prfw_scaled_uxtw, + 4 /*=ScalarSizeInBytes*/); + case Intrinsic::aarch64_sve_gather_prfd: + return combineSVEPrefetchVecBaseImmOff( + N, DAG, Intrinsic::aarch64_sve_gather_prfd_scaled_uxtw, + 8 /*=ScalarSizeInBytes*/); + case Intrinsic::aarch64_sve_gather_prfb_scaled_uxtw: + case Intrinsic::aarch64_sve_gather_prfb_scaled_sxtw: + case Intrinsic::aarch64_sve_gather_prfh_scaled_uxtw: + case Intrinsic::aarch64_sve_gather_prfh_scaled_sxtw: + case Intrinsic::aarch64_sve_gather_prfw_scaled_uxtw: + case Intrinsic::aarch64_sve_gather_prfw_scaled_sxtw: + case Intrinsic::aarch64_sve_gather_prfd_scaled_uxtw: + case Intrinsic::aarch64_sve_gather_prfd_scaled_sxtw: + return legalizeSVEGatherPrefetchOffsVec(N, DAG); case Intrinsic::aarch64_neon_ld2: case Intrinsic::aarch64_neon_ld3: case Intrinsic::aarch64_neon_ld4: diff --git a/llvm/lib/Target/AArch64/AArch64SVEInstrInfo.td b/llvm/lib/Target/AArch64/AArch64SVEInstrInfo.td index 833aee041aa513..a83e23832ba177 100644 --- a/llvm/lib/Target/AArch64/AArch64SVEInstrInfo.td +++ b/llvm/lib/Target/AArch64/AArch64SVEInstrInfo.td @@ -880,37 +880,37 @@ multiclass sve_prefetch; - defm PRFH_S : sve_mem_32b_prfm_sv_scaled<0b01, "prfh", ZPR32ExtSXTW16, ZPR32ExtUXTW16>; - defm PRFW_S : sve_mem_32b_prfm_sv_scaled<0b10, "prfw", ZPR32ExtSXTW32, ZPR32ExtUXTW32>; - defm PRFD_S : sve_mem_32b_prfm_sv_scaled<0b11, "prfd", ZPR32ExtSXTW64, ZPR32ExtUXTW64>; + defm PRFB_S : sve_mem_32b_prfm_sv_scaled<0b00, "prfb", ZPR32ExtSXTW8Only, ZPR32ExtUXTW8Only, int_aarch64_sve_gather_prfb_scaled_sxtw, int_aarch64_sve_gather_prfb_scaled_uxtw>; + defm PRFH_S : sve_mem_32b_prfm_sv_scaled<0b01, "prfh", ZPR32ExtSXTW16, ZPR32ExtUXTW16, int_aarch64_sve_gather_prfh_scaled_sxtw, int_aarch64_sve_gather_prfh_scaled_uxtw>; + defm PRFW_S : sve_mem_32b_prfm_sv_scaled<0b10, "prfw", ZPR32ExtSXTW32, ZPR32ExtUXTW32, int_aarch64_sve_gather_prfw_scaled_sxtw, int_aarch64_sve_gather_prfw_scaled_uxtw>; + defm PRFD_S : sve_mem_32b_prfm_sv_scaled<0b11, "prfd", ZPR32ExtSXTW64, ZPR32ExtUXTW64, int_aarch64_sve_gather_prfd_scaled_sxtw, int_aarch64_sve_gather_prfd_scaled_uxtw>; // Gather prefetch using unpacked, scaled 32-bit offsets, e.g. // prfh pldl1keep, p0, [x0, z0.d, uxtw #1] - defm PRFB_D : sve_mem_64b_prfm_sv_ext_scaled<0b00, "prfb", ZPR64ExtSXTW8Only, ZPR64ExtUXTW8Only>; - defm PRFH_D : sve_mem_64b_prfm_sv_ext_scaled<0b01, "prfh", ZPR64ExtSXTW16, ZPR64ExtUXTW16>; - defm PRFW_D : sve_mem_64b_prfm_sv_ext_scaled<0b10, "prfw", ZPR64ExtSXTW32, ZPR64ExtUXTW32>; - defm PRFD_D : sve_mem_64b_prfm_sv_ext_scaled<0b11, "prfd", ZPR64ExtSXTW64, ZPR64ExtUXTW64>; + defm PRFB_D : sve_mem_64b_prfm_sv_ext_scaled<0b00, "prfb", ZPR64ExtSXTW8Only, ZPR64ExtUXTW8Only, int_aarch64_sve_gather_prfb_scaled_sxtw, int_aarch64_sve_gather_prfb_scaled_uxtw>; + defm PRFH_D : sve_mem_64b_prfm_sv_ext_scaled<0b01, "prfh", ZPR64ExtSXTW16, ZPR64ExtUXTW16, int_aarch64_sve_gather_prfh_scaled_sxtw, int_aarch64_sve_gather_prfh_scaled_uxtw>; + defm PRFW_D : sve_mem_64b_prfm_sv_ext_scaled<0b10, "prfw", ZPR64ExtSXTW32, ZPR64ExtUXTW32, int_aarch64_sve_gather_prfw_scaled_sxtw, int_aarch64_sve_gather_prfw_scaled_uxtw>; + defm PRFD_D : sve_mem_64b_prfm_sv_ext_scaled<0b11, "prfd", ZPR64ExtSXTW64, ZPR64ExtUXTW64, int_aarch64_sve_gather_prfd_scaled_sxtw, int_aarch64_sve_gather_prfd_scaled_uxtw>; // Gather prefetch using scaled 64-bit offsets, e.g. // prfh pldl1keep, p0, [x0, z0.d, lsl #1] - defm PRFB_D_SCALED : sve_mem_64b_prfm_sv_lsl_scaled<0b00, "prfb", ZPR64ExtLSL8>; - defm PRFH_D_SCALED : sve_mem_64b_prfm_sv_lsl_scaled<0b01, "prfh", ZPR64ExtLSL16>; - defm PRFW_D_SCALED : sve_mem_64b_prfm_sv_lsl_scaled<0b10, "prfw", ZPR64ExtLSL32>; - defm PRFD_D_SCALED : sve_mem_64b_prfm_sv_lsl_scaled<0b11, "prfd", ZPR64ExtLSL64>; + defm PRFB_D_SCALED : sve_mem_64b_prfm_sv_lsl_scaled<0b00, "prfb", ZPR64ExtLSL8, int_aarch64_sve_gather_prfb_scaled>; + defm PRFH_D_SCALED : sve_mem_64b_prfm_sv_lsl_scaled<0b01, "prfh", ZPR64ExtLSL16, int_aarch64_sve_gather_prfh_scaled>; + defm PRFW_D_SCALED : sve_mem_64b_prfm_sv_lsl_scaled<0b10, "prfw", ZPR64ExtLSL32, int_aarch64_sve_gather_prfw_scaled>; + defm PRFD_D_SCALED : sve_mem_64b_prfm_sv_lsl_scaled<0b11, "prfd", ZPR64ExtLSL64, int_aarch64_sve_gather_prfd_scaled>; // Gather prefetch using 32/64-bit pointers with offset, e.g. // prfh pldl1keep, p0, [z0.s, #16] // prfh pldl1keep, p0, [z0.d, #16] - defm PRFB_S_PZI : sve_mem_32b_prfm_vi<0b00, "prfb", imm0_31>; - defm PRFH_S_PZI : sve_mem_32b_prfm_vi<0b01, "prfh", uimm5s2>; - defm PRFW_S_PZI : sve_mem_32b_prfm_vi<0b10, "prfw", uimm5s4>; - defm PRFD_S_PZI : sve_mem_32b_prfm_vi<0b11, "prfd", uimm5s8>; - - defm PRFB_D_PZI : sve_mem_64b_prfm_vi<0b00, "prfb", imm0_31>; - defm PRFH_D_PZI : sve_mem_64b_prfm_vi<0b01, "prfh", uimm5s2>; - defm PRFW_D_PZI : sve_mem_64b_prfm_vi<0b10, "prfw", uimm5s4>; - defm PRFD_D_PZI : sve_mem_64b_prfm_vi<0b11, "prfd", uimm5s8>; + defm PRFB_S_PZI : sve_mem_32b_prfm_vi<0b00, "prfb", imm0_31, int_aarch64_sve_gather_prfb>; + defm PRFH_S_PZI : sve_mem_32b_prfm_vi<0b01, "prfh", uimm5s2, int_aarch64_sve_gather_prfh>; + defm PRFW_S_PZI : sve_mem_32b_prfm_vi<0b10, "prfw", uimm5s4, int_aarch64_sve_gather_prfw>; + defm PRFD_S_PZI : sve_mem_32b_prfm_vi<0b11, "prfd", uimm5s8, int_aarch64_sve_gather_prfd>; + + defm PRFB_D_PZI : sve_mem_64b_prfm_vi<0b00, "prfb", imm0_31, int_aarch64_sve_gather_prfb>; + defm PRFH_D_PZI : sve_mem_64b_prfm_vi<0b01, "prfh", uimm5s2, int_aarch64_sve_gather_prfh>; + defm PRFW_D_PZI : sve_mem_64b_prfm_vi<0b10, "prfw", uimm5s4, int_aarch64_sve_gather_prfw>; + defm PRFD_D_PZI : sve_mem_64b_prfm_vi<0b11, "prfd", uimm5s8, int_aarch64_sve_gather_prfd>; defm ADR_SXTW_ZZZ_D : sve_int_bin_cons_misc_0_a_sxtw<0b00, "adr">; defm ADR_UXTW_ZZZ_D : sve_int_bin_cons_misc_0_a_uxtw<0b01, "adr">; diff --git a/llvm/lib/Target/AArch64/AArch64StackTagging.cpp b/llvm/lib/Target/AArch64/AArch64StackTagging.cpp index 975502818fcd29..8169c49285d1d0 100644 --- a/llvm/lib/Target/AArch64/AArch64StackTagging.cpp +++ b/llvm/lib/Target/AArch64/AArch64StackTagging.cpp @@ -400,7 +400,9 @@ bool AArch64StackTagging::isInterestingAlloca(const AllocaInst &AI) { // dynamic alloca instrumentation for them as well. !AI.isUsedWithInAlloca() && // swifterror allocas are register promoted by ISel - !AI.isSwiftError(); + !AI.isSwiftError() && + // safe allocas are not interesting + !AI.getMetadata("stack-safe"); return IsInteresting; } diff --git a/llvm/lib/Target/AArch64/SVEInstrFormats.td b/llvm/lib/Target/AArch64/SVEInstrFormats.td index 6a9d3acff8fb2a..3937d6390c4da1 100644 --- a/llvm/lib/Target/AArch64/SVEInstrFormats.td +++ b/llvm/lib/Target/AArch64/SVEInstrFormats.td @@ -6455,9 +6455,17 @@ class sve_mem_32b_prfm_sv msz, bit xs, string asm, multiclass sve_mem_32b_prfm_sv_scaled msz, string asm, RegisterOperand sxtw_opnd, - RegisterOperand uxtw_opnd> { + RegisterOperand uxtw_opnd, + PatFrag op_sxtw, + PatFrag op_uxtw> { def _UXTW_SCALED : sve_mem_32b_prfm_sv; def _SXTW_SCALED : sve_mem_32b_prfm_sv; + + def : Pat<(op_uxtw (nxv4i1 PPR3bAny:$Pg), (i64 GPR64sp:$Rn), (nxv4i32 uxtw_opnd:$Zm), (i32 sve_prfop:$prfop)), + (!cast(NAME # _UXTW_SCALED) sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, uxtw_opnd:$Zm)>; + + def : Pat<(op_sxtw (nxv4i1 PPR3bAny:$Pg), (i64 GPR64sp:$Rn), (nxv4i32 sxtw_opnd:$Zm), (i32 sve_prfop:$prfop)), + (!cast(NAME # _SXTW_SCALED) sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, sxtw_opnd:$Zm)>; } class sve_mem_32b_prfm_vi msz, string asm, Operand imm_ty> @@ -6480,11 +6488,14 @@ class sve_mem_32b_prfm_vi msz, string asm, Operand imm_ty> let Inst{3-0} = prfop; } -multiclass sve_mem_32b_prfm_vi msz, string asm, Operand imm_ty> { +multiclass sve_mem_32b_prfm_vi msz, string asm, Operand imm_ty, SDPatternOperator op> { def NAME : sve_mem_32b_prfm_vi; def : InstAlias(NAME) sve_prfop:$prfop, PPR3bAny:$Pg, ZPR32:$Zn, 0), 1>; + + def : Pat<(op (nxv4i1 PPR_3b:$Pg), (nxv4i32 ZPR32:$Zn), (i64 imm_ty:$imm), (i32 sve_prfop:$prfop)), + (!cast(NAME) sve_prfop:$prfop, PPR_3b:$Pg, ZPR32:$Zn, imm_ty:$imm)>; } class sve_mem_z_fill @@ -6798,14 +6809,27 @@ class sve_mem_64b_prfm_sv msz, bit xs, bit lsl, string asm, multiclass sve_mem_64b_prfm_sv_ext_scaled msz, string asm, RegisterOperand sxtw_opnd, - RegisterOperand uxtw_opnd> { + RegisterOperand uxtw_opnd, + PatFrag op_sxtw, + PatFrag op_uxtw> { def _UXTW_SCALED : sve_mem_64b_prfm_sv; def _SXTW_SCALED : sve_mem_64b_prfm_sv; + + def : Pat<(op_uxtw (nxv2i1 PPR3bAny:$Pg), (i64 GPR64sp:$Rn), (nxv2i64 uxtw_opnd:$Zm), (i32 sve_prfop:$prfop)), + (!cast(NAME # _UXTW_SCALED) sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, uxtw_opnd:$Zm)>; + + def : Pat<(op_sxtw (nxv2i1 PPR3bAny:$Pg), (i64 GPR64sp:$Rn), (nxv2i64 sxtw_opnd:$Zm), (i32 sve_prfop:$prfop)), + (!cast(NAME # _SXTW_SCALED) sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, sxtw_opnd:$Zm)>; + } multiclass sve_mem_64b_prfm_sv_lsl_scaled msz, string asm, - RegisterOperand zprext> { + RegisterOperand zprext, PatFrag frag> { def NAME : sve_mem_64b_prfm_sv; + + def : Pat<(frag (nxv2i1 PPR3bAny:$Pg), (i64 GPR64sp:$Rn), (nxv2i64 zprext:$Zm), (i32 sve_prfop:$prfop)), + (!cast(NAME) sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm)>; + } @@ -6831,11 +6855,14 @@ class sve_mem_64b_prfm_vi msz, string asm, Operand imm_ty> let hasSideEffects = 1; } -multiclass sve_mem_64b_prfm_vi msz, string asm, Operand imm_ty> { +multiclass sve_mem_64b_prfm_vi msz, string asm, Operand imm_ty, SDPatternOperator op> { def NAME : sve_mem_64b_prfm_vi; def : InstAlias(NAME) sve_prfop:$prfop, PPR3bAny:$Pg, ZPR64:$Zn, 0), 1>; + + def : Pat<(op (nxv2i1 PPR_3b:$Pg), (nxv2i64 ZPR32:$Zn), (i64 imm_ty:$imm), (i32 sve_prfop:$prfop)), + (!cast(NAME) sve_prfop:$prfop, PPR_3b:$Pg, ZPR32:$Zn, imm_ty:$imm)>; } //===----------------------------------------------------------------------===// diff --git a/llvm/lib/Target/AMDGPU/AMDGPUCallLowering.cpp b/llvm/lib/Target/AMDGPU/AMDGPUCallLowering.cpp index 7d30178b57ed56..e7e5e132ecbd31 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUCallLowering.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUCallLowering.cpp @@ -572,8 +572,20 @@ static void packSplitRegsToOrigType(MachineIRBuilder &B, ArrayRef Regs, LLT LLTy, LLT PartLLT) { + MachineRegisterInfo &MRI = *B.getMRI(); + if (!LLTy.isVector() && !PartLLT.isVector()) { - B.buildMerge(OrigRegs[0], Regs); + assert(OrigRegs.size() == 1); + LLT OrigTy = MRI.getType(OrigRegs[0]); + + unsigned SrcSize = PartLLT.getSizeInBits() * Regs.size(); + if (SrcSize == OrigTy.getSizeInBits()) + B.buildMerge(OrigRegs[0], Regs); + else { + auto Widened = B.buildMerge(LLT::scalar(SrcSize), Regs); + B.buildTrunc(OrigRegs[0], Widened); + } + return; } @@ -584,8 +596,6 @@ static void packSplitRegsToOrigType(MachineIRBuilder &B, return; } - MachineRegisterInfo &MRI = *B.getMRI(); - assert(LLTy.isVector() && !PartLLT.isVector()); LLT DstEltTy = LLTy.getElementType(); diff --git a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp index 3a92f0bac240db..d0c6e13b290cd5 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp @@ -2238,8 +2238,7 @@ SDValue AMDGPUTargetLowering::LowerFNEARBYINT(SDValue Op, SelectionDAG &DAG) con // Don't handle v2f16. The extra instructions to scalarize and repack around the // compare and vselect end up producing worse code than scalarizing the whole // operation. -SDValue AMDGPUTargetLowering::LowerFROUND_LegalFTRUNC(SDValue Op, - SelectionDAG &DAG) const { +SDValue AMDGPUTargetLowering::LowerFROUND(SDValue Op, SelectionDAG &DAG) const { SDLoc SL(Op); SDValue X = Op.getOperand(0); EVT VT = Op.getValueType(); @@ -2268,75 +2267,6 @@ SDValue AMDGPUTargetLowering::LowerFROUND_LegalFTRUNC(SDValue Op, return DAG.getNode(ISD::FADD, SL, VT, T, Sel); } -SDValue AMDGPUTargetLowering::LowerFROUND64(SDValue Op, SelectionDAG &DAG) const { - SDLoc SL(Op); - SDValue X = Op.getOperand(0); - - SDValue L = DAG.getNode(ISD::BITCAST, SL, MVT::i64, X); - - const SDValue Zero = DAG.getConstant(0, SL, MVT::i32); - const SDValue One = DAG.getConstant(1, SL, MVT::i32); - const SDValue NegOne = DAG.getConstant(-1, SL, MVT::i32); - const SDValue FiftyOne = DAG.getConstant(51, SL, MVT::i32); - EVT SetCCVT = - getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), MVT::i32); - - SDValue BC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, X); - - SDValue Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, BC, One); - - SDValue Exp = extractF64Exponent(Hi, SL, DAG); - - const SDValue Mask = DAG.getConstant(INT64_C(0x000fffffffffffff), SL, - MVT::i64); - - SDValue M = DAG.getNode(ISD::SRA, SL, MVT::i64, Mask, Exp); - SDValue D = DAG.getNode(ISD::SRA, SL, MVT::i64, - DAG.getConstant(INT64_C(0x0008000000000000), SL, - MVT::i64), - Exp); - - SDValue Tmp0 = DAG.getNode(ISD::AND, SL, MVT::i64, L, M); - SDValue Tmp1 = DAG.getSetCC(SL, SetCCVT, - DAG.getConstant(0, SL, MVT::i64), Tmp0, - ISD::SETNE); - - SDValue Tmp2 = DAG.getNode(ISD::SELECT, SL, MVT::i64, Tmp1, - D, DAG.getConstant(0, SL, MVT::i64)); - SDValue K = DAG.getNode(ISD::ADD, SL, MVT::i64, L, Tmp2); - - K = DAG.getNode(ISD::AND, SL, MVT::i64, K, DAG.getNOT(SL, M, MVT::i64)); - K = DAG.getNode(ISD::BITCAST, SL, MVT::f64, K); - - SDValue ExpLt0 = DAG.getSetCC(SL, SetCCVT, Exp, Zero, ISD::SETLT); - SDValue ExpGt51 = DAG.getSetCC(SL, SetCCVT, Exp, FiftyOne, ISD::SETGT); - SDValue ExpEqNegOne = DAG.getSetCC(SL, SetCCVT, NegOne, Exp, ISD::SETEQ); - - SDValue Mag = DAG.getNode(ISD::SELECT, SL, MVT::f64, - ExpEqNegOne, - DAG.getConstantFP(1.0, SL, MVT::f64), - DAG.getConstantFP(0.0, SL, MVT::f64)); - - SDValue S = DAG.getNode(ISD::FCOPYSIGN, SL, MVT::f64, Mag, X); - - K = DAG.getNode(ISD::SELECT, SL, MVT::f64, ExpLt0, S, K); - K = DAG.getNode(ISD::SELECT, SL, MVT::f64, ExpGt51, X, K); - - return K; -} - -SDValue AMDGPUTargetLowering::LowerFROUND(SDValue Op, SelectionDAG &DAG) const { - EVT VT = Op.getValueType(); - - if (isOperationLegal(ISD::FTRUNC, VT)) - return LowerFROUND_LegalFTRUNC(Op, DAG); - - if (VT == MVT::f64) - return LowerFROUND64(Op, DAG); - - llvm_unreachable("unhandled type"); -} - SDValue AMDGPUTargetLowering::LowerFFLOOR(SDValue Op, SelectionDAG &DAG) const { SDLoc SL(Op); SDValue Src = Op.getOperand(0); diff --git a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.h b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.h index fc35b1f3ad54e3..83bc433dba8116 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.h +++ b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.h @@ -52,8 +52,6 @@ class AMDGPUTargetLowering : public TargetLowering { SDValue LowerFRINT(SDValue Op, SelectionDAG &DAG) const; SDValue LowerFNEARBYINT(SDValue Op, SelectionDAG &DAG) const; - SDValue LowerFROUND_LegalFTRUNC(SDValue Op, SelectionDAG &DAG) const; - SDValue LowerFROUND64(SDValue Op, SelectionDAG &DAG) const; SDValue LowerFROUND(SDValue Op, SelectionDAG &DAG) const; SDValue LowerFFLOOR(SDValue Op, SelectionDAG &DAG) const; SDValue LowerFLOG(SDValue Op, SelectionDAG &DAG, diff --git a/llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp index 7b2bf85a9a8572..ffa3198e636b84 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp @@ -217,6 +217,7 @@ AMDGPULegalizerInfo::AMDGPULegalizerInfo(const GCNSubtarget &ST_, const LLT S64 = LLT::scalar(64); const LLT S128 = LLT::scalar(128); const LLT S256 = LLT::scalar(256); + const LLT S512 = LLT::scalar(512); const LLT S1024 = LLT::scalar(1024); const LLT V2S16 = LLT::vector(2, 16); @@ -1205,10 +1206,10 @@ AMDGPULegalizerInfo::AMDGPULegalizerInfo(const GCNSubtarget &ST_, unsigned LitTyIdx = Op == G_MERGE_VALUES ? 1 : 0; auto notValidElt = [=](const LegalityQuery &Query, unsigned TypeIdx) { - const LLT &Ty = Query.Types[TypeIdx]; + const LLT Ty = Query.Types[TypeIdx]; if (Ty.isVector()) { const LLT &EltTy = Ty.getElementType(); - if (EltTy.getSizeInBits() < 8 || EltTy.getSizeInBits() > 64) + if (EltTy.getSizeInBits() < 8 || EltTy.getSizeInBits() > 512) return true; if (!isPowerOf2_32(EltTy.getSizeInBits())) return true; @@ -1230,14 +1231,14 @@ AMDGPULegalizerInfo::AMDGPULegalizerInfo(const GCNSubtarget &ST_, // Clamp the little scalar to s8-s256 and make it a power of 2. It's not // worth considering the multiples of 64 since 2*192 and 2*384 are not // valid. - .clampScalar(LitTyIdx, S32, S256) + .clampScalar(LitTyIdx, S32, S512) .widenScalarToNextPow2(LitTyIdx, /*Min*/ 32) // Break up vectors with weird elements into scalars .fewerElementsIf( - [=](const LegalityQuery &Query) { return notValidElt(Query, 0); }, + [=](const LegalityQuery &Query) { return notValidElt(Query, LitTyIdx); }, scalarize(0)) .fewerElementsIf( - [=](const LegalityQuery &Query) { return notValidElt(Query, 1); }, + [=](const LegalityQuery &Query) { return notValidElt(Query, BigTyIdx); }, scalarize(1)) .clampScalar(BigTyIdx, S32, S1024); diff --git a/llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp b/llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp index 123391e79d53e1..0d92aafa3bd980 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp @@ -220,7 +220,7 @@ unsigned AMDGPURegisterBankInfo::copyCost(const RegisterBank &Dst, unsigned Size) const { // TODO: Should there be a UniformVGPRRegBank which can use readfirstlane? if (Dst.getID() == AMDGPU::SGPRRegBankID && - isVectorRegisterBank(Src)) { + (isVectorRegisterBank(Src) || Src.getID() == AMDGPU::VCCRegBankID)) { return std::numeric_limits::max(); } @@ -238,9 +238,6 @@ unsigned AMDGPURegisterBankInfo::copyCost(const RegisterBank &Dst, Src.getID() == AMDGPU::VCCRegBankID)) return std::numeric_limits::max(); - if (Src.getID() == AMDGPU::VCCRegBankID) - return std::numeric_limits::max(); - // There is no direct copy between AGPRs. if (Dst.getID() == AMDGPU::AGPRRegBankID && Src.getID() == AMDGPU::AGPRRegBankID) @@ -2252,10 +2249,13 @@ void AMDGPURegisterBankInfo::applyMappingImpl( return; } case AMDGPU::G_SEXT: - case AMDGPU::G_ZEXT: { + case AMDGPU::G_ZEXT: + case AMDGPU::G_ANYEXT: { Register SrcReg = MI.getOperand(1).getReg(); LLT SrcTy = MRI.getType(SrcReg); - bool Signed = Opc == AMDGPU::G_SEXT; + const bool Signed = Opc == AMDGPU::G_SEXT; + + assert(empty(OpdMapper.getVRegs(1))); MachineIRBuilder B(MI); const RegisterBank *SrcBank = @@ -2282,9 +2282,12 @@ void AMDGPURegisterBankInfo::applyMappingImpl( auto ShiftAmt = B.buildConstant(S32, 31); MRI.setRegBank(ShiftAmt.getReg(0), *SrcBank); B.buildAShr(DefRegs[1], DefRegs[0], ShiftAmt); - } else { + } else if (Opc == AMDGPU::G_ZEXT) { B.buildZExtOrTrunc(DefRegs[0], SrcReg); B.buildConstant(DefRegs[1], 0); + } else { + B.buildAnyExtOrTrunc(DefRegs[0], SrcReg); + B.buildUndef(DefRegs[1]); } MRI.setRegBank(DstReg, *SrcBank); @@ -2295,6 +2298,9 @@ void AMDGPURegisterBankInfo::applyMappingImpl( if (SrcTy != LLT::scalar(1)) return; + // It is not legal to have a legalization artifact with a VCC source. Rather + // than introducing a copy, insert the selcet we would have to select the + // copy to. if (SrcBank == &AMDGPU::VCCRegBank) { SmallVector DefRegs(OpdMapper.getVRegs(0)); @@ -2329,24 +2335,7 @@ void AMDGPURegisterBankInfo::applyMappingImpl( return; } - // Fixup the case with an s1 src that isn't a condition register. Use shifts - // instead of introducing a compare to avoid an unnecessary condition - // register (and since there's no scalar 16-bit compares). - auto Ext = B.buildAnyExt(DstTy, SrcReg); - auto ShiftAmt = B.buildConstant(LLT::scalar(32), DstTy.getSizeInBits() - 1); - auto Shl = B.buildShl(DstTy, Ext, ShiftAmt); - - if (MI.getOpcode() == AMDGPU::G_SEXT) - B.buildAShr(DstReg, Shl, ShiftAmt); - else - B.buildLShr(DstReg, Shl, ShiftAmt); - - MRI.setRegBank(DstReg, *SrcBank); - MRI.setRegBank(Ext.getReg(0), *SrcBank); - MRI.setRegBank(ShiftAmt.getReg(0), *SrcBank); - MRI.setRegBank(Shl.getReg(0), *SrcBank); - MI.eraseFromParent(); - return; + break; } case AMDGPU::G_BUILD_VECTOR: case AMDGPU::G_BUILD_VECTOR_TRUNC: { @@ -3423,17 +3412,11 @@ AMDGPURegisterBankInfo::getInstrMapping(const MachineInstr &MI) const { break; } - // TODO: Should anyext be split into 32-bit part as well? - if (MI.getOpcode() == AMDGPU::G_ANYEXT) { - OpdsMapping[0] = AMDGPU::getValueMapping(DstBank, DstSize); - OpdsMapping[1] = AMDGPU::getValueMapping(SrcBank->getID(), SrcSize); - } else { - // Scalar extend can use 64-bit BFE, but VGPRs require extending to - // 32-bits, and then to 64. - OpdsMapping[0] = AMDGPU::getValueMappingSGPR64Only(DstBank, DstSize); - OpdsMapping[1] = AMDGPU::getValueMappingSGPR64Only(SrcBank->getID(), - SrcSize); - } + // Scalar extend can use 64-bit BFE, but VGPRs require extending to + // 32-bits, and then to 64. + OpdsMapping[0] = AMDGPU::getValueMappingSGPR64Only(DstBank, DstSize); + OpdsMapping[1] = AMDGPU::getValueMappingSGPR64Only(SrcBank->getID(), + SrcSize); break; } case AMDGPU::G_FCMP: { diff --git a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp index 8ac965d614bacc..22e7f8a7b97ed6 100644 --- a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp +++ b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp @@ -7592,15 +7592,6 @@ SDValue PPCTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const { !Op.getOperand(2).getValueType().isFloatingPoint()) return Op; - bool HasNoInfs = DAG.getTarget().Options.NoInfsFPMath; - bool HasNoNaNs = DAG.getTarget().Options.NoNaNsFPMath; - // We might be able to do better than this under some circumstances, but in - // general, fsel-based lowering of select is a finite-math-only optimization. - // For more information, see section F.3 of the 2.06 ISA specification. - // With ISA 3.0, we have xsmaxcdp/xsmincdp which are OK to emit even in the - // presence of infinities. - if (!Subtarget.hasP9Vector() && (!HasNoInfs || !HasNoNaNs)) - return Op; ISD::CondCode CC = cast(Op.getOperand(4))->get(); EVT ResVT = Op.getValueType(); @@ -7609,13 +7600,12 @@ SDValue PPCTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const { SDValue TV = Op.getOperand(2), FV = Op.getOperand(3); SDLoc dl(Op); + // We have xsmaxcdp/xsmincdp which are OK to emit even in the + // presence of infinities. if (Subtarget.hasP9Vector() && LHS == TV && RHS == FV) { switch (CC) { default: - // Not a min/max but with finite math, we may still be able to use fsel. - if (HasNoInfs && HasNoNaNs) - break; - return Op; + break; case ISD::SETOGT: case ISD::SETGT: return DAG.getNode(PPCISD::XSMAXCDP, dl, Op.getValueType(), LHS, RHS); @@ -7623,7 +7613,14 @@ SDValue PPCTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const { case ISD::SETLT: return DAG.getNode(PPCISD::XSMINCDP, dl, Op.getValueType(), LHS, RHS); } - } else if (!HasNoInfs || !HasNoNaNs) + } + + // We might be able to do better than this under some circumstances, but in + // general, fsel-based lowering of select is a finite-math-only optimization. + // For more information, see section F.3 of the 2.06 ISA specification. + // With ISA 3.0 + if (!DAG.getTarget().Options.NoInfsFPMath || + !DAG.getTarget().Options.NoNaNsFPMath) return Op; // TODO: Propagate flags from the select rather than global settings. diff --git a/llvm/lib/Target/PowerPC/PPCMacroFusion.cpp b/llvm/lib/Target/PowerPC/PPCMacroFusion.cpp index bde3f5918a2395..815dfd1402f47d 100644 --- a/llvm/lib/Target/PowerPC/PPCMacroFusion.cpp +++ b/llvm/lib/Target/PowerPC/PPCMacroFusion.cpp @@ -113,7 +113,7 @@ static bool checkOpConstraints(FusionFeature::FusionKind Kd, if (!SI.isImm()) return true; int64_t Imm = SI.getImm(); - if (((Imm & 0xFFF0) != 0) || ((Imm & 0xFFF0) != 0xFFF0)) + if (((Imm & 0xFFF0) != 0) && ((Imm & 0xFFF0) != 0xFFF0)) return false; // If si = 1111111111110000 and the msb of the d/ds field of the load equals diff --git a/llvm/lib/Target/TargetLoweringObjectFile.cpp b/llvm/lib/Target/TargetLoweringObjectFile.cpp index cfdb67537f0e23..9f464c0201eb64 100644 --- a/llvm/lib/Target/TargetLoweringObjectFile.cpp +++ b/llvm/lib/Target/TargetLoweringObjectFile.cpp @@ -149,6 +149,10 @@ SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalObject *GO, if (isa(GO)) return SectionKind::getText(); + // Basic blocks are classified as text sections. + if (isa(GO)) + return SectionKind::getText(); + // Global variables require more detailed analysis. const auto *GVar = cast(GO); @@ -302,6 +306,18 @@ MCSection *TargetLoweringObjectFile::getSectionForConstant( return DataSection; } +MCSection *TargetLoweringObjectFile::getSectionForMachineBasicBlock( + const Function &F, const MachineBasicBlock &MBB, + const TargetMachine &TM) const { + return nullptr; +} + +MCSection *TargetLoweringObjectFile::getNamedSectionForMachineBasicBlock( + const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM, + const char *Suffix) const { + return nullptr; +} + /// getTTypeGlobalReference - Return an MCExpr to use for a /// reference to the specified global variable from exception /// handling information. diff --git a/llvm/lib/Target/VE/CMakeLists.txt b/llvm/lib/Target/VE/CMakeLists.txt index 5b32fd50e5834e..89c946d87e1985 100644 --- a/llvm/lib/Target/VE/CMakeLists.txt +++ b/llvm/lib/Target/VE/CMakeLists.txt @@ -21,6 +21,5 @@ add_llvm_target(VECodeGen VETargetMachine.cpp ) -add_subdirectory(InstPrinter) add_subdirectory(TargetInfo) add_subdirectory(MCTargetDesc) diff --git a/llvm/lib/Target/VE/InstPrinter/CMakeLists.txt b/llvm/lib/Target/VE/InstPrinter/CMakeLists.txt deleted file mode 100644 index 7ddeebb9a7df6f..00000000000000 --- a/llvm/lib/Target/VE/InstPrinter/CMakeLists.txt +++ /dev/null @@ -1,3 +0,0 @@ -add_llvm_component_library(LLVMVEAsmPrinter - VEInstPrinter.cpp - ) diff --git a/llvm/lib/Target/VE/InstPrinter/LLVMBuild.txt b/llvm/lib/Target/VE/InstPrinter/LLVMBuild.txt deleted file mode 100644 index 8cfaea7634e655..00000000000000 --- a/llvm/lib/Target/VE/InstPrinter/LLVMBuild.txt +++ /dev/null @@ -1,22 +0,0 @@ -;===- ./lib/Target/VE/InstPrinter/LLVMBuild.txt ----------------*- Conf -*--===; -; -; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -; See https://llvm.org/LICENSE.txt for license information. -; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -; -;===------------------------------------------------------------------------===; -; -; This is an LLVMBuild description file for the components in this subdirectory. -; -; For more information on the LLVMBuild system, please see: -; -; http://llvm.org/docs/LLVMBuild.html -; -;===------------------------------------------------------------------------===; - -[component_0] -type = Library -name = VEAsmPrinter -parent = VE -required_libraries = MC Support -add_to_library_groups = VE diff --git a/llvm/lib/Target/VE/LLVMBuild.txt b/llvm/lib/Target/VE/LLVMBuild.txt index 4e1a5ed898ca23..eb74a9a387b025 100644 --- a/llvm/lib/Target/VE/LLVMBuild.txt +++ b/llvm/lib/Target/VE/LLVMBuild.txt @@ -15,7 +15,7 @@ ;===------------------------------------------------------------------------===; [common] -subdirectories = InstPrinter MCTargetDesc TargetInfo +subdirectories = MCTargetDesc TargetInfo [component_0] type = TargetGroup @@ -29,6 +29,5 @@ type = Library name = VECodeGen parent = VE required_libraries = Analysis AsmPrinter CodeGen Core - MC SelectionDAG VEAsmPrinter - VEDesc VEInfo Support Target + MC SelectionDAG VEDesc VEInfo Support Target add_to_library_groups = VE diff --git a/llvm/lib/Target/VE/MCTargetDesc/CMakeLists.txt b/llvm/lib/Target/VE/MCTargetDesc/CMakeLists.txt index 5ef74c18461cbf..9bca0ceeb69bfb 100644 --- a/llvm/lib/Target/VE/MCTargetDesc/CMakeLists.txt +++ b/llvm/lib/Target/VE/MCTargetDesc/CMakeLists.txt @@ -1,4 +1,5 @@ add_llvm_component_library(LLVMVEDesc + VEInstPrinter.cpp VEMCAsmInfo.cpp VEMCExpr.cpp VEMCTargetDesc.cpp diff --git a/llvm/lib/Target/VE/MCTargetDesc/LLVMBuild.txt b/llvm/lib/Target/VE/MCTargetDesc/LLVMBuild.txt index 3fddd5268bee60..e585042e60bbab 100644 --- a/llvm/lib/Target/VE/MCTargetDesc/LLVMBuild.txt +++ b/llvm/lib/Target/VE/MCTargetDesc/LLVMBuild.txt @@ -18,5 +18,5 @@ type = Library name = VEDesc parent = VE -required_libraries = MC VEAsmPrinter VEInfo Support +required_libraries = MC VEInfo Support add_to_library_groups = VE diff --git a/llvm/lib/Target/VE/InstPrinter/VEInstPrinter.cpp b/llvm/lib/Target/VE/MCTargetDesc/VEInstPrinter.cpp similarity index 100% rename from llvm/lib/Target/VE/InstPrinter/VEInstPrinter.cpp rename to llvm/lib/Target/VE/MCTargetDesc/VEInstPrinter.cpp diff --git a/llvm/lib/Target/VE/InstPrinter/VEInstPrinter.h b/llvm/lib/Target/VE/MCTargetDesc/VEInstPrinter.h similarity index 100% rename from llvm/lib/Target/VE/InstPrinter/VEInstPrinter.h rename to llvm/lib/Target/VE/MCTargetDesc/VEInstPrinter.h diff --git a/llvm/lib/Target/VE/MCTargetDesc/VEMCTargetDesc.cpp b/llvm/lib/Target/VE/MCTargetDesc/VEMCTargetDesc.cpp index b228617058a6a9..3cd09299fc70f4 100644 --- a/llvm/lib/Target/VE/MCTargetDesc/VEMCTargetDesc.cpp +++ b/llvm/lib/Target/VE/MCTargetDesc/VEMCTargetDesc.cpp @@ -11,7 +11,7 @@ //===----------------------------------------------------------------------===// #include "VEMCTargetDesc.h" -#include "InstPrinter/VEInstPrinter.h" +#include "VEInstPrinter.h" #include "VEMCAsmInfo.h" #include "VETargetStreamer.h" #include "llvm/MC/MCInstrInfo.h" diff --git a/llvm/lib/Target/VE/MCTargetDesc/VETargetStreamer.cpp b/llvm/lib/Target/VE/MCTargetDesc/VETargetStreamer.cpp index dfe94bbaaa4bf1..29f5afb67ac149 100644 --- a/llvm/lib/Target/VE/MCTargetDesc/VETargetStreamer.cpp +++ b/llvm/lib/Target/VE/MCTargetDesc/VETargetStreamer.cpp @@ -11,7 +11,7 @@ //===----------------------------------------------------------------------===// #include "VETargetStreamer.h" -#include "InstPrinter/VEInstPrinter.h" +#include "VEInstPrinter.h" #include "llvm/Support/FormattedStream.h" using namespace llvm; diff --git a/llvm/lib/Target/VE/VEAsmPrinter.cpp b/llvm/lib/Target/VE/VEAsmPrinter.cpp index 99bbe441608d3e..19a01f4f074982 100644 --- a/llvm/lib/Target/VE/VEAsmPrinter.cpp +++ b/llvm/lib/Target/VE/VEAsmPrinter.cpp @@ -11,7 +11,7 @@ // //===----------------------------------------------------------------------===// -#include "InstPrinter/VEInstPrinter.h" +#include "MCTargetDesc/VEInstPrinter.h" #include "MCTargetDesc/VEMCExpr.h" #include "MCTargetDesc/VETargetStreamer.h" #include "VE.h" diff --git a/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp b/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp index 141fcf89555fc1..e3d8b7715f5a43 100644 --- a/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp +++ b/llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp @@ -138,6 +138,7 @@ class X86AsmBackend : public MCAsmBackend { bool needAlignInst(const MCInst &Inst) const; MCInst PrevInst; MCBoundaryAlignFragment *PendingBoundaryAlign = nullptr; + std::pair PrevInstPosition; public: X86AsmBackend(const Target &T, const MCSubtargetInfo &STI) @@ -491,6 +492,52 @@ static bool hasInterruptDelaySlot(const MCInst &Inst) { return false; } +/// Check if the instruction to be emitted is right after any data. +static bool +isRightAfterData(MCFragment *CurrentFragment, + const std::pair &PrevInstPosition) { + MCFragment *F = CurrentFragment; + // Empty data fragments may be created to prevent further data being + // added into the previous fragment, we need to skip them since they + // have no contents. + for (; isa_and_nonnull(F); F = F->getPrevNode()) + if (cast(F)->getContents().size() != 0) + break; + + // Since data is always emitted into a DataFragment, our check strategy is + // simple here. + // - If the fragment is a DataFragment + // - If it's not the fragment where the previous instruction is, + // returns true. + // - If it's the fragment holding the previous instruction but its + // size changed since the the previous instruction was emitted into + // it, returns true. + // - Otherwise returns false. + // - If the fragment is not a DataFragment, returns false. + if (auto *DF = dyn_cast_or_null(F)) + return DF != PrevInstPosition.first || + DF->getContents().size() != PrevInstPosition.second; + + return false; +} + +/// \returns the fragment size if it has instructions, otherwise returns 0. +static size_t getSizeForInstFragment(const MCFragment *F) { + if (!F || !F->hasInstructions()) + return 0; + // MCEncodedFragmentWithContents being templated makes this tricky. + switch (F->getKind()) { + default: + llvm_unreachable("Unknown fragment with instructions!"); + case MCFragment::FT_Data: + return cast(*F).getContents().size(); + case MCFragment::FT_Relaxable: + return cast(*F).getContents().size(); + case MCFragment::FT_CompactEncodedInst: + return cast(*F).getContents().size(); + } +} + /// Check if the instruction operand needs to be aligned. Padding is disabled /// before intruction which may be rewritten by linker(e.g. TLSCALL). bool X86AsmBackend::needAlignInst(const MCInst &Inst) const { @@ -527,6 +574,11 @@ void X86AsmBackend::emitInstructionBegin(MCObjectStreamer &OS, // semantic. return; + if (isRightAfterData(OS.getCurrentFragment(), PrevInstPosition)) + // If this instruction follows any data, there is no clear + // instruction boundary, inserting a nop would change semantic. + return; + if (!isMacroFused(PrevInst, Inst)) // Macro fusion doesn't happen indeed, clear the pending. PendingBoundaryAlign = nullptr; @@ -569,19 +621,21 @@ void X86AsmBackend::emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst) return; PrevInst = Inst; + MCFragment *CF = OS.getCurrentFragment(); + PrevInstPosition = std::make_pair(CF, getSizeForInstFragment(CF)); if (!needAlignInst(Inst) || !PendingBoundaryAlign) return; // Tie the aligned instructions into a a pending BoundaryAlign. - PendingBoundaryAlign->setLastFragment(OS.getCurrentFragment()); + PendingBoundaryAlign->setLastFragment(CF); PendingBoundaryAlign = nullptr; // We need to ensure that further data isn't added to the current // DataFragment, so that we can get the size of instructions later in // MCAssembler::relaxBoundaryAlign. The easiest way is to insert a new empty // DataFragment. - if (isa_and_nonnull(OS.getCurrentFragment())) + if (isa_and_nonnull(CF)) OS.insert(new MCDataFragment()); // Update the maximum alignment on the current section if necessary. diff --git a/llvm/lib/Target/X86/X86FastISel.cpp b/llvm/lib/Target/X86/X86FastISel.cpp index 027e2c2d45afba..c25785b9000dd7 100644 --- a/llvm/lib/Target/X86/X86FastISel.cpp +++ b/llvm/lib/Target/X86/X86FastISel.cpp @@ -3289,7 +3289,8 @@ bool X86FastISel::fastLowerCall(CallLoweringInfo &CLI) { ResultReg = fastEmit_ri(VT, VT, ISD::AND, ResultReg, hasTrivialKill(PrevVal), 1); } else { - if (!isTypeLegal(Val->getType(), VT)) + if (!isTypeLegal(Val->getType(), VT) || + (VT.isVector() && VT.getVectorElementType() == MVT::i1)) return false; ResultReg = getRegForValue(Val); } diff --git a/llvm/lib/Target/X86/X86ISelLowering.cpp b/llvm/lib/Target/X86/X86ISelLowering.cpp index 339e3c37ee2560..8e8a7cce9fb18f 100644 --- a/llvm/lib/Target/X86/X86ISelLowering.cpp +++ b/llvm/lib/Target/X86/X86ISelLowering.cpp @@ -20964,9 +20964,12 @@ static SDValue getSETCC(X86::CondCode Cond, SDValue EFLAGS, const SDLoc &dl, } /// Helper for matching OR(EXTRACTELT(X,0),OR(EXTRACTELT(X,1),...)) -/// style scalarized (associative) reduction patterns. +/// style scalarized (associative) reduction patterns. Partial reductions +/// are supported when the pointer SrcMask is non-null. +/// TODO - move this to SelectionDAG? static bool matchScalarReduction(SDValue Op, ISD::NodeType BinOp, - SmallVectorImpl &SrcOps) { + SmallVectorImpl &SrcOps, + SmallVectorImpl *SrcMask = nullptr) { SmallVector Opnds; DenseMap SrcOpMap; EVT VT = MVT::Other; @@ -21018,12 +21021,18 @@ static bool matchScalarReduction(SDValue Op, ISD::NodeType BinOp, M->second.setBit(CIdx); } - // Quit if not all elements are used. - for (DenseMap::const_iterator I = SrcOpMap.begin(), - E = SrcOpMap.end(); - I != E; ++I) { - if (!I->second.isAllOnesValue()) - return false; + if (SrcMask) { + // Collect the source partial masks. + for (SDValue &SrcOp : SrcOps) + SrcMask->push_back(SrcOpMap[SrcOp]); + } else { + // Quit if not all elements are used. + for (DenseMap::const_iterator I = SrcOpMap.begin(), + E = SrcOpMap.end(); + I != E; ++I) { + if (!I->second.isAllOnesValue()) + return false; + } } return true; @@ -41210,7 +41219,8 @@ static SDValue combineAnd(SDNode *N, SelectionDAG &DAG, // TODO: Support multiple SrcOps. if (VT == MVT::i1) { SmallVector SrcOps; - if (matchScalarReduction(SDValue(N, 0), ISD::AND, SrcOps) && + SmallVector SrcPartials; + if (matchScalarReduction(SDValue(N, 0), ISD::AND, SrcOps, &SrcPartials) && SrcOps.size() == 1) { SDLoc dl(N); const TargetLowering &TLI = DAG.getTargetLoweringInfo(); @@ -41220,9 +41230,11 @@ static SDValue combineAnd(SDNode *N, SelectionDAG &DAG, if (!Mask && TLI.isTypeLegal(SrcOps[0].getValueType())) Mask = DAG.getBitcast(MaskVT, SrcOps[0]); if (Mask) { - APInt AllBits = APInt::getAllOnesValue(NumElts); - return DAG.getSetCC(dl, MVT::i1, Mask, - DAG.getConstant(AllBits, dl, MaskVT), ISD::SETEQ); + assert(SrcPartials[0].getBitWidth() == NumElts && + "Unexpected partial reduction mask"); + SDValue PartialBits = DAG.getConstant(SrcPartials[0], dl, MaskVT); + Mask = DAG.getNode(ISD::AND, dl, MaskVT, Mask, PartialBits); + return DAG.getSetCC(dl, MVT::i1, Mask, PartialBits, ISD::SETEQ); } } } @@ -41685,7 +41697,8 @@ static SDValue combineOr(SDNode *N, SelectionDAG &DAG, // TODO: Support multiple SrcOps. if (VT == MVT::i1) { SmallVector SrcOps; - if (matchScalarReduction(SDValue(N, 0), ISD::OR, SrcOps) && + SmallVector SrcPartials; + if (matchScalarReduction(SDValue(N, 0), ISD::OR, SrcOps, &SrcPartials) && SrcOps.size() == 1) { SDLoc dl(N); const TargetLowering &TLI = DAG.getTargetLoweringInfo(); @@ -41695,9 +41708,12 @@ static SDValue combineOr(SDNode *N, SelectionDAG &DAG, if (!Mask && TLI.isTypeLegal(SrcOps[0].getValueType())) Mask = DAG.getBitcast(MaskVT, SrcOps[0]); if (Mask) { - APInt AllBits = APInt::getNullValue(NumElts); - return DAG.getSetCC(dl, MVT::i1, Mask, - DAG.getConstant(AllBits, dl, MaskVT), ISD::SETNE); + assert(SrcPartials[0].getBitWidth() == NumElts && + "Unexpected partial reduction mask"); + SDValue ZeroBits = DAG.getConstant(0, dl, MaskVT); + SDValue PartialBits = DAG.getConstant(SrcPartials[0], dl, MaskVT); + Mask = DAG.getNode(ISD::AND, dl, MaskVT, Mask, PartialBits); + return DAG.getSetCC(dl, MVT::i1, Mask, ZeroBits, ISD::SETNE); } } } diff --git a/llvm/lib/Target/X86/X86InstrAVX512.td b/llvm/lib/Target/X86/X86InstrAVX512.td index 8ed20cdabf7ac9..b23050ef61aca5 100644 --- a/llvm/lib/Target/X86/X86InstrAVX512.td +++ b/llvm/lib/Target/X86/X86InstrAVX512.td @@ -12235,6 +12235,7 @@ multiclass avx512_binop_all2 opc, string OpcodeStr, } } +let ExeDomain = SSEPackedSingle in defm VCVTNE2PS2BF16 : avx512_binop_all2<0x72, "vcvtne2ps2bf16", SchedWriteCvtPD2PS, //FIXME: Shoulod be SchedWriteCvtPS2BF avx512vl_f32_info, avx512vl_i16_info, @@ -12243,6 +12244,7 @@ defm VCVTNE2PS2BF16 : avx512_binop_all2<0x72, "vcvtne2ps2bf16", // Truncate Float to BFloat16 multiclass avx512_cvtps2bf16 opc, string OpcodeStr, X86SchedWriteWidths sched> { + let ExeDomain = SSEPackedSingle in { let Predicates = [HasBF16], Uses = [], mayRaiseFPException = 0 in { defm Z : avx512_vcvt_fp, EVEX_V512; @@ -12256,20 +12258,21 @@ multiclass avx512_cvtps2bf16 opc, string OpcodeStr, X86cvtneps2bf16, X86cvtneps2bf16, sched.YMM, "{1to8}", "{y}">, EVEX_V256; } + } // Predicates = [HasBF16, HasVLX] + } // ExeDomain = SSEPackedSingle - def : InstAlias(NAME # "Z128rr") VR128X:$dst, - VR128X:$src), 0>; - def : InstAlias(NAME # "Z128rm") VR128X:$dst, - f128mem:$src), 0, "intel">; - def : InstAlias(NAME # "Z256rr") VR128X:$dst, - VR256X:$src), 0>; - def : InstAlias(NAME # "Z256rm") VR128X:$dst, - f256mem:$src), 0, "intel">; - } + def : InstAlias(NAME # "Z128rr") VR128X:$dst, + VR128X:$src), 0>; + def : InstAlias(NAME # "Z128rm") VR128X:$dst, + f128mem:$src), 0, "intel">; + def : InstAlias(NAME # "Z256rr") VR128X:$dst, + VR256X:$src), 0>; + def : InstAlias(NAME # "Z256rm") VR128X:$dst, + f256mem:$src), 0, "intel">; } defm VCVTNEPS2BF16 : avx512_cvtps2bf16<0x72, "vcvtneps2bf16", @@ -12352,6 +12355,7 @@ multiclass avx512_dpbf16ps_sizes opc, string OpcodeStr, SDNode OpNode, } } +let ExeDomain = SSEPackedSingle in defm VDPBF16PS : avx512_dpbf16ps_sizes<0x52, "vdpbf16ps", X86dpbf16ps, SchedWriteFMA, avx512vl_f32_info, avx512vl_i32_info, HasBF16>, T8XS, EVEX_CD8<32, CD8VF>; diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp index 494626519c0645..c8811f1d4e700f 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp @@ -1806,6 +1806,18 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) { IntrinsicInst *II = dyn_cast(&CI); if (!II) return visitCallBase(CI); + // For atomic unordered mem intrinsics if len is not a positive or + // not a multiple of element size then behavior is undefined. + if (auto *AMI = dyn_cast(II)) + if (ConstantInt *NumBytes = dyn_cast(AMI->getLength())) + if (NumBytes->getSExtValue() < 0 || + (NumBytes->getZExtValue() % AMI->getElementSizeInBytes() != 0)) { + CreateNonTerminatorUnreachable(AMI); + assert(AMI->getType()->isVoidTy() && + "non void atomic unordered mem intrinsic"); + return eraseInstFromFunction(*AMI); + } + // Intrinsics cannot occur in an invoke or a callbr, so handle them here // instead of in visitCallBase. if (auto *MI = dyn_cast(II)) { diff --git a/llvm/lib/Transforms/Scalar/SCCP.cpp b/llvm/lib/Transforms/Scalar/SCCP.cpp index dcdc3483a9088c..e1a2ec2b93f089 100644 --- a/llvm/lib/Transforms/Scalar/SCCP.cpp +++ b/llvm/lib/Transforms/Scalar/SCCP.cpp @@ -352,7 +352,7 @@ class SCCPSolver : public InstVisitor { // pushToWorkList - Helper for markConstant/markOverdefined void pushToWorkList(LatticeVal &IV, Value *V) { - if (isOverdefined(IV)) + if (IV.isOverdefined()) return OverdefinedInstWorkList.push_back(V); InstWorkList.push_back(V); } @@ -361,7 +361,7 @@ class SCCPSolver : public InstVisitor { // prints a debug message with the updated value. void pushToWorkListMsg(LatticeVal &IV, Value *V) { LLVM_DEBUG(dbgs() << "updated " << IV << ": " << *V << '\n'); - if (isOverdefined(IV)) + if (IV.isOverdefined()) return OverdefinedInstWorkList.push_back(V); InstWorkList.push_back(V); } @@ -779,7 +779,7 @@ void SCCPSolver::visitReturnInst(ReturnInst &I) { // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would // discover a concrete value later. if (isOverdefined(ValueState[&I])) - return; + return (void)markOverdefined(&I); Function *F = I.getParent()->getParent(); Value *ResultOp = I.getOperand(0); @@ -820,7 +820,7 @@ void SCCPSolver::visitCastInst(CastInst &I) { // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would // discover a concrete value later. if (isOverdefined(ValueState[&I])) - return; + return (void)markOverdefined(&I); LatticeVal OpSt = getValueState(I.getOperand(0)); if (Constant *OpC = getConstant(OpSt)) { @@ -838,7 +838,7 @@ void SCCPSolver::visitExtractValueInst(ExtractValueInst &EVI) { // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would // discover a concrete value later. if (isOverdefined(ValueState[&EVI])) - return; + return (void)markOverdefined(&EVI); // If this returns a struct, mark all elements over defined, we don't track // structs in structs. @@ -868,7 +868,7 @@ void SCCPSolver::visitInsertValueInst(InsertValueInst &IVI) { // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would // discover a concrete value later. if (isOverdefined(ValueState[&IVI])) - return; + return (void)markOverdefined(&IVI); // If this has more than one index, we can't handle it, drive all results to // undef. @@ -906,8 +906,8 @@ void SCCPSolver::visitSelectInst(SelectInst &I) { // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would // discover a concrete value later. - if (isOverdefined(ValueState[&I])) - return; + if (ValueState[&I].isOverdefined()) + return (void)markOverdefined(&I); LatticeVal CondValue = getValueState(I.getCondition()); if (CondValue.isUnknownOrUndef()) @@ -944,7 +944,8 @@ void SCCPSolver::visitUnaryOperator(Instruction &I) { LatticeVal &IV = ValueState[&I]; // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would // discover a concrete value later. - if (isOverdefined(IV)) return; + if (isOverdefined(IV)) + return (void)markOverdefined(&I); if (isConstant(V0State)) { Constant *C = ConstantExpr::get(I.getOpcode(), getConstant(V0State)); @@ -968,10 +969,8 @@ void SCCPSolver::visitBinaryOperator(Instruction &I) { LatticeVal V2State = getValueState(I.getOperand(1)); LatticeVal &IV = ValueState[&I]; - if (isOverdefined(IV)) { - markOverdefined(&I); - return; - } + if (isOverdefined(IV)) + return (void)markOverdefined(&I); if (isConstant(V1State) && isConstant(V2State)) { Constant *C = ConstantExpr::get(I.getOpcode(), getConstant(V1State), @@ -1032,10 +1031,8 @@ void SCCPSolver::visitBinaryOperator(Instruction &I) { void SCCPSolver::visitCmpInst(CmpInst &I) { // Do not cache this lookup, getValueState calls later in the function might // invalidate the reference. - if (isOverdefined(ValueState[&I])) { - markOverdefined(&I); - return; - } + if (isOverdefined(ValueState[&I])) + return (void)markOverdefined(&I); Value *Op1 = I.getOperand(0); Value *Op2 = I.getOperand(1); @@ -1066,7 +1063,8 @@ void SCCPSolver::visitCmpInst(CmpInst &I) { // Handle getelementptr instructions. If all operands are constants then we // can turn this into a getelementptr ConstantExpr. void SCCPSolver::visitGetElementPtrInst(GetElementPtrInst &I) { - if (isOverdefined(ValueState[&I])) return; + if (isOverdefined(ValueState[&I])) + return (void)markOverdefined(&I); SmallVector Operands; Operands.reserve(I.getNumOperands()); @@ -1107,7 +1105,7 @@ void SCCPSolver::visitStoreInst(StoreInst &SI) { // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would // discover a concrete value later. if (isOverdefined(ValueState[&SI])) - return; + return (void)markOverdefined(&SI); GlobalVariable *GV = cast(SI.getOperand(1)); DenseMap::iterator I = TrackedGlobals.find(GV); @@ -1130,7 +1128,7 @@ void SCCPSolver::visitLoadInst(LoadInst &I) { // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would // discover a concrete value later. if (isOverdefined(ValueState[&I])) - return; + return (void)markOverdefined(&I); LatticeVal PtrVal = getValueState(I.getOperand(0)); if (PtrVal.isUnknownOrUndef()) @@ -1267,7 +1265,7 @@ void SCCPSolver::visitCallSite(CallSite CS) { } if (isOverdefined(getValueState(I))) - return; + return (void)markOverdefined(I); // If we can constant fold this, mark the result of the call as a // constant. @@ -1365,7 +1363,7 @@ void SCCPSolver::Solve() { // since all of its users will have already been marked as overdefined. // Update all of the users of this instruction's value. // - if (I->getType()->isStructTy() || !isOverdefined(getValueState(I))) + if (I->getType()->isStructTy() || !getValueState(I).isOverdefined()) markUsersAsChanged(I); } diff --git a/llvm/lib/Transforms/Utils/LoopRotationUtils.cpp b/llvm/lib/Transforms/Utils/LoopRotationUtils.cpp index 39be3d3831f00e..8804bba975b6a1 100644 --- a/llvm/lib/Transforms/Utils/LoopRotationUtils.cpp +++ b/llvm/lib/Transforms/Utils/LoopRotationUtils.cpp @@ -314,8 +314,14 @@ bool LoopRotate::rotateLoop(Loop *L, bool SimplifiedLatch) { L->dump()); return Rotated; } - if (Metrics.NumInsts > MaxHeaderSize) + if (Metrics.NumInsts > MaxHeaderSize) { + LLVM_DEBUG(dbgs() << "LoopRotation: NOT rotating - contains " + << Metrics.NumInsts + << " instructions, which is more than the threshold (" + << MaxHeaderSize << " instructions): "; + L->dump()); return Rotated; + } } // Now, this loop is suitable for rotation. diff --git a/llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp b/llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp index 0cc085dc366c66..0bb2746eed2d08 100644 --- a/llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp +++ b/llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp @@ -14,17 +14,9 @@ using namespace llvm; -static unsigned getLoopOperandSizeInBytes(Type *Type) { - if (VectorType *VTy = dyn_cast(Type)) { - return VTy->getBitWidth() / 8; - } - - return Type->getPrimitiveSizeInBits() / 8; -} - void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr, Value *DstAddr, ConstantInt *CopyLen, - unsigned SrcAlign, unsigned DestAlign, + unsigned SrcAlign, unsigned DstAlign, bool SrcIsVolatile, bool DstIsVolatile, const TargetTransformInfo &TTI) { // No need to expand zero length copies. @@ -35,17 +27,18 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr, BasicBlock *PostLoopBB = nullptr; Function *ParentFunc = PreLoopBB->getParent(); LLVMContext &Ctx = PreLoopBB->getContext(); + const DataLayout &DL = ParentFunc->getParent()->getDataLayout(); + + unsigned SrcAS = cast(SrcAddr->getType())->getAddressSpace(); + unsigned DstAS = cast(DstAddr->getType())->getAddressSpace(); Type *TypeOfCopyLen = CopyLen->getType(); - Type *LoopOpType = - TTI.getMemcpyLoopLoweringType(Ctx, CopyLen, SrcAlign, DestAlign); + Type *LoopOpType = TTI.getMemcpyLoopLoweringType(Ctx, CopyLen, SrcAS, DstAS, + SrcAlign, DstAlign); - unsigned LoopOpSize = getLoopOperandSizeInBytes(LoopOpType); + unsigned LoopOpSize = DL.getTypeStoreSize(LoopOpType); uint64_t LoopEndCount = CopyLen->getZExtValue() / LoopOpSize; - unsigned SrcAS = cast(SrcAddr->getType())->getAddressSpace(); - unsigned DstAS = cast(DstAddr->getType())->getAddressSpace(); - if (LoopEndCount != 0) { // Split PostLoopBB = PreLoopBB->splitBasicBlock(InsertBefore, "memcpy-split"); @@ -66,16 +59,20 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr, DstAddr = PLBuilder.CreateBitCast(DstAddr, DstOpType); } + Align PartDstAlign(MinAlign(DstAlign, LoopOpSize)); + Align PartSrcAlign(MinAlign(SrcAlign, LoopOpSize)); + IRBuilder<> LoopBuilder(LoopBB); PHINode *LoopIndex = LoopBuilder.CreatePHI(TypeOfCopyLen, 2, "loop-index"); LoopIndex->addIncoming(ConstantInt::get(TypeOfCopyLen, 0U), PreLoopBB); // Loop Body Value *SrcGEP = LoopBuilder.CreateInBoundsGEP(LoopOpType, SrcAddr, LoopIndex); - Value *Load = LoopBuilder.CreateLoad(LoopOpType, SrcGEP, SrcIsVolatile); + Value *Load = LoopBuilder.CreateAlignedLoad(LoopOpType, SrcGEP, + PartSrcAlign, SrcIsVolatile); Value *DstGEP = LoopBuilder.CreateInBoundsGEP(LoopOpType, DstAddr, LoopIndex); - LoopBuilder.CreateStore(Load, DstGEP, DstIsVolatile); + LoopBuilder.CreateAlignedStore(Load, DstGEP, PartDstAlign, DstIsVolatile); Value *NewIndex = LoopBuilder.CreateAdd(LoopIndex, ConstantInt::get(TypeOfCopyLen, 1U)); @@ -93,17 +90,16 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr, IRBuilder<> RBuilder(PostLoopBB ? PostLoopBB->getFirstNonPHI() : InsertBefore); - // Update the alignment based on the copy size used in the loop body. - SrcAlign = std::min(SrcAlign, LoopOpSize); - DestAlign = std::min(DestAlign, LoopOpSize); - SmallVector RemainingOps; TTI.getMemcpyLoopResidualLoweringType(RemainingOps, Ctx, RemainingBytes, - SrcAlign, DestAlign); + SrcAS, DstAS, SrcAlign, DstAlign); for (auto OpTy : RemainingOps) { + Align PartSrcAlign(MinAlign(SrcAlign, BytesCopied)); + Align PartDstAlign(MinAlign(DstAlign, BytesCopied)); + // Calaculate the new index - unsigned OperandSize = getLoopOperandSizeInBytes(OpTy); + unsigned OperandSize = DL.getTypeStoreSize(OpTy); uint64_t GepIndex = BytesCopied / OperandSize; assert(GepIndex * OperandSize == BytesCopied && "Division should have no Remainder!"); @@ -114,7 +110,8 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr, : RBuilder.CreateBitCast(SrcAddr, SrcPtrType); Value *SrcGEP = RBuilder.CreateInBoundsGEP( OpTy, CastedSrc, ConstantInt::get(TypeOfCopyLen, GepIndex)); - Value *Load = RBuilder.CreateLoad(OpTy, SrcGEP, SrcIsVolatile); + Value *Load = + RBuilder.CreateAlignedLoad(OpTy, SrcGEP, PartSrcAlign, SrcIsVolatile); // Cast destination to operand type and store. PointerType *DstPtrType = PointerType::get(OpTy, DstAS); @@ -123,7 +120,7 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr, : RBuilder.CreateBitCast(DstAddr, DstPtrType); Value *DstGEP = RBuilder.CreateInBoundsGEP( OpTy, CastedDst, ConstantInt::get(TypeOfCopyLen, GepIndex)); - RBuilder.CreateStore(Load, DstGEP, DstIsVolatile); + RBuilder.CreateAlignedStore(Load, DstGEP, PartDstAlign, DstIsVolatile); BytesCopied += OperandSize; } @@ -135,7 +132,7 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr, void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore, Value *SrcAddr, Value *DstAddr, Value *CopyLen, unsigned SrcAlign, - unsigned DestAlign, bool SrcIsVolatile, + unsigned DstAlign, bool SrcIsVolatile, bool DstIsVolatile, const TargetTransformInfo &TTI) { BasicBlock *PreLoopBB = InsertBefore->getParent(); @@ -143,16 +140,17 @@ void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore, PreLoopBB->splitBasicBlock(InsertBefore, "post-loop-memcpy-expansion"); Function *ParentFunc = PreLoopBB->getParent(); + const DataLayout &DL = ParentFunc->getParent()->getDataLayout(); LLVMContext &Ctx = PreLoopBB->getContext(); + unsigned SrcAS = cast(SrcAddr->getType())->getAddressSpace(); + unsigned DstAS = cast(DstAddr->getType())->getAddressSpace(); - Type *LoopOpType = - TTI.getMemcpyLoopLoweringType(Ctx, CopyLen, SrcAlign, DestAlign); - unsigned LoopOpSize = getLoopOperandSizeInBytes(LoopOpType); + Type *LoopOpType = TTI.getMemcpyLoopLoweringType(Ctx, CopyLen, SrcAS, DstAS, + SrcAlign, DstAlign); + unsigned LoopOpSize = DL.getTypeStoreSize(LoopOpType); IRBuilder<> PLBuilder(PreLoopBB->getTerminator()); - unsigned SrcAS = cast(SrcAddr->getType())->getAddressSpace(); - unsigned DstAS = cast(DstAddr->getType())->getAddressSpace(); PointerType *SrcOpType = PointerType::get(LoopOpType, SrcAS); PointerType *DstOpType = PointerType::get(LoopOpType, DstAS); if (SrcAddr->getType() != SrcOpType) { @@ -177,13 +175,17 @@ void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore, BasicBlock::Create(Ctx, "loop-memcpy-expansion", ParentFunc, PostLoopBB); IRBuilder<> LoopBuilder(LoopBB); + Align PartSrcAlign(MinAlign(SrcAlign, LoopOpSize)); + Align PartDstAlign(MinAlign(DstAlign, LoopOpSize)); + PHINode *LoopIndex = LoopBuilder.CreatePHI(CopyLenType, 2, "loop-index"); LoopIndex->addIncoming(ConstantInt::get(CopyLenType, 0U), PreLoopBB); Value *SrcGEP = LoopBuilder.CreateInBoundsGEP(LoopOpType, SrcAddr, LoopIndex); - Value *Load = LoopBuilder.CreateLoad(LoopOpType, SrcGEP, SrcIsVolatile); + Value *Load = LoopBuilder.CreateAlignedLoad(LoopOpType, SrcGEP, PartSrcAlign, + SrcIsVolatile); Value *DstGEP = LoopBuilder.CreateInBoundsGEP(LoopOpType, DstAddr, LoopIndex); - LoopBuilder.CreateStore(Load, DstGEP, DstIsVolatile); + LoopBuilder.CreateAlignedStore(Load, DstGEP, PartDstAlign, DstIsVolatile); Value *NewIndex = LoopBuilder.CreateAdd(LoopIndex, ConstantInt::get(CopyLenType, 1U)); @@ -234,10 +236,11 @@ void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore, Value *FullOffset = ResBuilder.CreateAdd(RuntimeBytesCopied, ResidualIndex); Value *SrcGEP = ResBuilder.CreateInBoundsGEP(Int8Type, SrcAsInt8, FullOffset); - Value *Load = ResBuilder.CreateLoad(Int8Type, SrcGEP, SrcIsVolatile); + Value *Load = ResBuilder.CreateAlignedLoad(Int8Type, SrcGEP, PartSrcAlign, + SrcIsVolatile); Value *DstGEP = ResBuilder.CreateInBoundsGEP(Int8Type, DstAsInt8, FullOffset); - ResBuilder.CreateStore(Load, DstGEP, DstIsVolatile); + ResBuilder.CreateAlignedStore(Load, DstGEP, PartDstAlign, DstIsVolatile); Value *ResNewIndex = ResBuilder.CreateAdd(ResidualIndex, ConstantInt::get(CopyLenType, 1U)); @@ -284,13 +287,14 @@ void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore, // } // return dst; // } -static void createMemMoveLoop(Instruction *InsertBefore, - Value *SrcAddr, Value *DstAddr, Value *CopyLen, - unsigned SrcAlign, unsigned DestAlign, - bool SrcIsVolatile, bool DstIsVolatile) { +static void createMemMoveLoop(Instruction *InsertBefore, Value *SrcAddr, + Value *DstAddr, Value *CopyLen, unsigned SrcAlign, + unsigned DstAlign, bool SrcIsVolatile, + bool DstIsVolatile) { Type *TypeOfCopyLen = CopyLen->getType(); BasicBlock *OrigBB = InsertBefore->getParent(); Function *F = OrigBB->getParent(); + const DataLayout &DL = F->getParent()->getDataLayout(); Type *EltTy = cast(SrcAddr->getType())->getElementType(); @@ -318,6 +322,10 @@ static void createMemMoveLoop(Instruction *InsertBefore, BasicBlock *ExitBB = InsertBefore->getParent(); ExitBB->setName("memmove_done"); + unsigned PartSize = DL.getTypeStoreSize(EltTy); + Align PartSrcAlign(MinAlign(SrcAlign, PartSize)); + Align PartDstAlign(MinAlign(DstAlign, PartSize)); + // Initial comparison of n == 0 that lets us skip the loops altogether. Shared // between both backwards and forward copy clauses. ICmpInst *CompareN = @@ -331,11 +339,12 @@ static void createMemMoveLoop(Instruction *InsertBefore, PHINode *LoopPhi = LoopBuilder.CreatePHI(TypeOfCopyLen, 0); Value *IndexPtr = LoopBuilder.CreateSub( LoopPhi, ConstantInt::get(TypeOfCopyLen, 1), "index_ptr"); - Value *Element = LoopBuilder.CreateLoad( + Value *Element = LoopBuilder.CreateAlignedLoad( EltTy, LoopBuilder.CreateInBoundsGEP(EltTy, SrcAddr, IndexPtr), - "element"); - LoopBuilder.CreateStore( - Element, LoopBuilder.CreateInBoundsGEP(EltTy, DstAddr, IndexPtr)); + PartSrcAlign, "element"); + LoopBuilder.CreateAlignedStore( + Element, LoopBuilder.CreateInBoundsGEP(EltTy, DstAddr, IndexPtr), + PartDstAlign); LoopBuilder.CreateCondBr( LoopBuilder.CreateICmpEQ(IndexPtr, ConstantInt::get(TypeOfCopyLen, 0)), ExitBB, LoopBB); @@ -349,11 +358,11 @@ static void createMemMoveLoop(Instruction *InsertBefore, BasicBlock::Create(F->getContext(), "copy_forward_loop", F, ExitBB); IRBuilder<> FwdLoopBuilder(FwdLoopBB); PHINode *FwdCopyPhi = FwdLoopBuilder.CreatePHI(TypeOfCopyLen, 0, "index_ptr"); - Value *FwdElement = FwdLoopBuilder.CreateLoad( - EltTy, FwdLoopBuilder.CreateInBoundsGEP(EltTy, SrcAddr, FwdCopyPhi), - "element"); - FwdLoopBuilder.CreateStore( - FwdElement, FwdLoopBuilder.CreateInBoundsGEP(EltTy, DstAddr, FwdCopyPhi)); + Value *SrcGEP = FwdLoopBuilder.CreateInBoundsGEP(EltTy, SrcAddr, FwdCopyPhi); + Value *FwdElement = + FwdLoopBuilder.CreateAlignedLoad(EltTy, SrcGEP, PartSrcAlign, "element"); + Value *DstGEP = FwdLoopBuilder.CreateInBoundsGEP(EltTy, DstAddr, FwdCopyPhi); + FwdLoopBuilder.CreateAlignedStore(FwdElement, DstGEP, PartDstAlign); Value *FwdIndexPtr = FwdLoopBuilder.CreateAdd( FwdCopyPhi, ConstantInt::get(TypeOfCopyLen, 1), "index_increment"); FwdLoopBuilder.CreateCondBr(FwdLoopBuilder.CreateICmpEQ(FwdIndexPtr, CopyLen), @@ -365,12 +374,13 @@ static void createMemMoveLoop(Instruction *InsertBefore, ElseTerm->eraseFromParent(); } -static void createMemSetLoop(Instruction *InsertBefore, - Value *DstAddr, Value *CopyLen, Value *SetValue, - unsigned Align, bool IsVolatile) { +static void createMemSetLoop(Instruction *InsertBefore, Value *DstAddr, + Value *CopyLen, Value *SetValue, unsigned DstAlign, + bool IsVolatile) { Type *TypeOfCopyLen = CopyLen->getType(); BasicBlock *OrigBB = InsertBefore->getParent(); Function *F = OrigBB->getParent(); + const DataLayout &DL = F->getParent()->getDataLayout(); BasicBlock *NewBB = OrigBB->splitBasicBlock(InsertBefore, "split"); BasicBlock *LoopBB @@ -388,14 +398,17 @@ static void createMemSetLoop(Instruction *InsertBefore, LoopBB); OrigBB->getTerminator()->eraseFromParent(); + unsigned PartSize = DL.getTypeStoreSize(SetValue->getType()); + Align PartAlign(MinAlign(DstAlign, PartSize)); + IRBuilder<> LoopBuilder(LoopBB); PHINode *LoopIndex = LoopBuilder.CreatePHI(TypeOfCopyLen, 0); LoopIndex->addIncoming(ConstantInt::get(TypeOfCopyLen, 0), OrigBB); - LoopBuilder.CreateStore( + LoopBuilder.CreateAlignedStore( SetValue, LoopBuilder.CreateInBoundsGEP(SetValue->getType(), DstAddr, LoopIndex), - IsVolatile); + PartAlign, IsVolatile); Value *NewIndex = LoopBuilder.CreateAdd(LoopIndex, ConstantInt::get(TypeOfCopyLen, 1)); diff --git a/llvm/test/Analysis/StackSafetyAnalysis/ipa-attr.ll b/llvm/test/Analysis/StackSafetyAnalysis/ipa-attr.ll new file mode 100644 index 00000000000000..0b2dbff53f0061 --- /dev/null +++ b/llvm/test/Analysis/StackSafetyAnalysis/ipa-attr.ll @@ -0,0 +1,34 @@ +; RUN: llvm-as %s -o %t0.bc +; RUN: llvm-as %S/Inputs/ipa.ll -o %t1.bc +; RUN: llvm-link -disable-lazy-loading %t0.bc %t1.bc -o %t.combined.bc +; RUN: opt -S -passes="stack-safety-annotator" %t.combined.bc -o - 2>&1 | FileCheck %s + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +declare void @Write1(i8* %p) +declare void @Write8(i8* %p) + +; Basic out-of-bounds. +define void @f1() { +; CHECK-LABEL: define void @f1() { +; CHECK: alloca i32, align 4{{$}} +entry: + %x = alloca i32, align 4 + %x1 = bitcast i32* %x to i8* + call void @Write8(i8* %x1) + ret void +} + +; Basic in-bounds. +define void @f2() { +; CHECK-LABEL: define void @f2() { +; CHECK: alloca i32, align 4, !stack-safe ![[A:[0-9]+]]{{$}} +entry: + %x = alloca i32, align 4 + %x1 = bitcast i32* %x to i8* + call void @Write1(i8* %x1) + ret void +} + +; CHECK: ![[A]] = !{} diff --git a/llvm/test/Analysis/ValueTracking/known-nonnull-at.ll b/llvm/test/Analysis/ValueTracking/known-nonnull-at.ll index 06f4811837818f..9df8c28551329b 100644 --- a/llvm/test/Analysis/ValueTracking/known-nonnull-at.ll +++ b/llvm/test/Analysis/ValueTracking/known-nonnull-at.ll @@ -117,7 +117,7 @@ define i1 @nonnullReturnTest(i8* nonnull %x) { define i1 @unknownReturnTest(i8* %x) { ; CHECK-LABEL: @unknownReturnTest( ; CHECK-NEXT: [[X2:%.*]] = call i8* @returningPtr(i8* [[X:%.*]]) -; CHECK-NEXT: [[NULL_CHECK:%.*]] = icmp eq i8* [[X]], null +; CHECK-NEXT: [[NULL_CHECK:%.*]] = icmp eq i8* [[X2]], null ; CHECK-NEXT: ret i1 [[NULL_CHECK]] ; %x2 = call i8* @returningPtr(i8* %x) diff --git a/llvm/test/CodeGen/AArch64/stack-tagging.ll b/llvm/test/CodeGen/AArch64/stack-tagging.ll index 244a0a1edbb25b..feaa5de24c5240 100644 --- a/llvm/test/CodeGen/AArch64/stack-tagging.ll +++ b/llvm/test/CodeGen/AArch64/stack-tagging.ll @@ -33,6 +33,7 @@ entry: %x1 = alloca i32, align 4 %x2 = alloca i8, align 4 %x3 = alloca i32, i32 11, align 4 + %x4 = alloca i32, align 4, !stack-safe !0 call void @use32(i32* %x1) call void @use8(i8* %x2) call void @use32(i32* %x3) @@ -49,6 +50,9 @@ entry: ; CHECK: alloca { [11 x i32], [4 x i8] }, align 16 ; CHECK: call { [11 x i32], [4 x i8] }* @llvm.aarch64.tagp.{{.*}}({ [11 x i32], [4 x i8] }* {{.*}}, i64 2) ; CHECK: call void @llvm.aarch64.settag(i8* {{.*}}, i64 48) +; CHECK: alloca i32, align 4 +; CHECK-NOT: @llvm.aarch64.tagp +; CHECK-NOT: @llvm.aarch64.settag ; CHECK: call void @use32( ; CHECK: call void @use8( @@ -185,3 +189,5 @@ another_bb: ; CHECK: call void @llvm.aarch64.settag( ; CHECK: call void @llvm.aarch64.settag( ; CHECK: ret void + +!0 = !{} \ No newline at end of file diff --git a/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-scaled-offset.ll b/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-scaled-offset.ll new file mode 100644 index 00000000000000..78251707a0105b --- /dev/null +++ b/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-scaled-offset.ll @@ -0,0 +1,200 @@ +; RUN: llc -mtriple=aarch64--linux-gnu -mattr=+sve --asm-verbose=false < %s | FileCheck %s + +; PRFB , , [, .S, ] -> 32-bit scaled offset +define void @llvm_aarch64_sve_gather_prfb_scaled_uxtw_nx4vi32( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_scaled_uxtw_nx4vi32: +; CHECK-NEXT: prfb pldl1strm, p0, [x0, z0.s, uxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.scaled.uxtw.nx4vi32( %Pg, i8* %base, %offset, i32 1) + ret void + } + +define void @llvm_aarch64_sve_gather_prfb_scaled_sxtw_nx4vi32( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_scaled_sxtw_nx4vi32: +; CHECK-NEXT: prfb pldl1strm, p0, [x0, z0.s, sxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.scaled.sxtw.nx4vi32( %Pg, i8* %base, %offset, i32 1) + ret void + } + +; PRFB , , [, .D, ] -> 32-bit unpacked scaled offset + +define void @llvm_aarch64_sve_gather_prfb_scaled_uxtw_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_scaled_uxtw_nx2vi64: +; CHECK-NEXT: prfb pldl1strm, p0, [x0, z0.d, uxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.scaled.uxtw.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +define void @llvm_aarch64_sve_gather_prfb_scaled_sxtw_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_scaled_sxtw_nx2vi64: +; CHECK-NEXT: prfb pldl1strm, p0, [x0, z0.d, sxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.scaled.sxtw.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } +; PRFB , , [, .D] -> 64-bit scaled offset +define void @llvm_aarch64_sve_gather_prfb_scaled_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_scaled_nx2vi64: +; CHECK-NEXT: prfb pldl1strm, p0, [x0, z0.d] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.scaled.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; PRFH , , [, .S, ] -> 32-bit scaled offset +define void @llvm_aarch64_sve_gather_prfh_scaled_uxtw_nx4vi32( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_scaled_uxtw_nx4vi32: +; CHECK-NEXT: prfh pldl1strm, p0, [x0, z0.s, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.scaled.uxtw.nx4vi32( %Pg, i8* %base, %offset, i32 1) + ret void + } + +define void @llvm_aarch64_sve_gather_prfh_scaled_sxtw_nx4vi32( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_scaled_sxtw_nx4vi32: +; CHECK-NEXT: prfh pldl1strm, p0, [x0, z0.s, sxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.scaled.sxtw.nx4vi32( %Pg, i8* %base, %offset, i32 1) + ret void + } + +; PRFH , , [, .D, #1] -> 32-bit unpacked scaled offset +define void @llvm_aarch64_sve_gather_prfh_scaled_uxtw_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_scaled_uxtw_nx2vi64: +; CHECK-NEXT: prfh pldl1strm, p0, [x0, z0.d, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.scaled.uxtw.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +define void @llvm_aarch64_sve_gather_prfh_scaled_sxtw_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_scaled_sxtw_nx2vi64: +; CHECK-NEXT: prfh pldl1strm, p0, [x0, z0.d, sxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.scaled.sxtw.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +; PRFH , , [, .D] -> 64-bit scaled offset +define void @llvm_aarch64_sve_gather_prfh_scaled_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_scaled_nx2vi64: +; CHECK-NEXT: prfh pldl1strm, p0, [x0, z0.d, lsl #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.scaled.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; PRFW , , [, .S, ] -> 32-bit scaled offset +define void @llvm_aarch64_sve_gather_prfw_scaled_uxtw_nx4vi32( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_scaled_uxtw_nx4vi32: +; CHECK-NEXT: prfw pldl1strm, p0, [x0, z0.s, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.scaled.uxtw.nx4vi32( %Pg, i8* %base, %offset, i32 1) + ret void + } + +define void @llvm_aarch64_sve_gather_prfw_scaled_sxtw_nx4vi32( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_scaled_sxtw_nx4vi32: +; CHECK-NEXT: prfw pldl1strm, p0, [x0, z0.s, sxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.scaled.sxtw.nx4vi32( %Pg, i8* %base, %offset, i32 1) + ret void + } + +; PRFW , , [, .D, #2] -> 32-bit unpacked scaled offset +define void @llvm_aarch64_sve_gather_prfw_scaled_uxtw_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_scaled_uxtw_nx2vi64: +; CHECK-NEXT: prfw pldl1strm, p0, [x0, z0.d, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.scaled.uxtw.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +define void @llvm_aarch64_sve_gather_prfw_scaled_sxtw_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_scaled_sxtw_nx2vi64: +; CHECK-NEXT: prfw pldl1strm, p0, [x0, z0.d, sxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.scaled.sxtw.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +; PRFW , , [, .D] -> 64-bit scaled offset +define void @llvm_aarch64_sve_gather_prfw_scaled_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_scaled_nx2vi64: +; CHECK-NEXT: prfw pldl1strm, p0, [x0, z0.d, lsl #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.scaled.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; PRFD , , [, .S, ] -> 32-bit scaled offset +define void @llvm_aarch64_sve_gather_prfd_scaled_uxtw_nx4vi32( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_scaled_uxtw_nx4vi32: +; CHECK-NEXT: prfd pldl1strm, p0, [x0, z0.s, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.scaled.uxtw.nx4vi32( %Pg, i8* %base, %offset, i32 1) + ret void + } + +define void @llvm_aarch64_sve_gather_prfd_scaled_sxtw_nx4vi32( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_scaled_sxtw_nx4vi32: +; CHECK-NEXT: prfd pldl1strm, p0, [x0, z0.s, sxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.scaled.sxtw.nx4vi32( %Pg, i8* %base, %offset, i32 1) + ret void + } + +; PRFD , , [, .D, #3] -> 32-bit unpacked scaled offset +define void @llvm_aarch64_sve_gather_prfd_scaled_uxtw_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_scaled_uxtw_nx2vi64: +; CHECK-NEXT: prfd pldl1strm, p0, [x0, z0.d, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.scaled.uxtw.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +define void @llvm_aarch64_sve_gather_prfd_scaled_sxtw_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_scaled_sxtw_nx2vi64: +; CHECK-NEXT: prfd pldl1strm, p0, [x0, z0.d, sxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.scaled.sxtw.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +; PRFD , , [, .D] -> 64-bit scaled offset +define void @llvm_aarch64_sve_gather_prfd_scaled_nx2vi64( %Pg, i8* %base, %offset) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_scaled_nx2vi64: +; CHECK-NEXT: prfd pldl1strm, p0, [x0, z0.d, lsl #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.scaled.nx2vi64( %Pg, i8* %base, %offset, i32 1) + ret void + } + +declare void @llvm.aarch64.sve.gather.prfb.scaled.uxtw.nx4vi32( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfb.scaled.sxtw.nx4vi32( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfb.scaled.uxtw.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfb.scaled.sxtw.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfb.scaled.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.scaled.uxtw.nx4vi32( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.scaled.sxtw.nx4vi32( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.scaled.uxtw.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.scaled.sxtw.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.scaled.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.scaled.uxtw.nx4vi32( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.scaled.sxtw.nx4vi32( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.scaled.uxtw.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.scaled.sxtw.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.scaled.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.scaled.uxtw.nx4vi32( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.scaled.sxtw.nx4vi32( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.scaled.uxtw.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.scaled.sxtw.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.scaled.nx2vi64( %Pg, i8* %base, %offset, i32 %prfop) diff --git a/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-vect-base-imm-offset.ll b/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-vect-base-imm-offset.ll new file mode 100644 index 00000000000000..481302ce597209 --- /dev/null +++ b/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-vect-base-imm-offset.ll @@ -0,0 +1,82 @@ +; RUN: llc -mtriple=aarch64--linux-gnu -mattr=+sve --asm-verbose=false < %s | FileCheck %s + +; PRFB , , [.S{, #}] -> 32-bit element +define void @llvm_aarch64_sve_gather_prfb_nx4vi32( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_nx4vi32: +; CHECK-NEXT: prfb pldl1strm, p0, [z0.s, #7] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.nx4vi32( %Pg, %bases, i64 7, i32 1) + ret void +} + +; PRFB , , [.D{, #}] -> 64-bit element +define void @llvm_aarch64_sve_gather_prfb_nx2vi64( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_nx2vi64: +; CHECK-NEXT: prfb pldl1strm, p0, [z0.d, #7] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.nx2vi64( %Pg, %bases, i64 7, i32 1) + ret void +} + +; PRFH , , [.S{, #}] -> 32-bit element +define void @llvm_aarch64_sve_gather_prfh_nx4vi32( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx4vi32: +; CHECK-NEXT: prfh pldl1strm, p0, [z0.s, #6] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx4vi32( %Pg, %bases, i64 6, i32 1) + ret void +} + +; PRFH , , [.D{, #}] -> 64-bit element +define void @llvm_aarch64_sve_gather_prfh_nx2vi64( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx2vi64: +; CHECK-NEXT: prfh pldl1strm, p0, [z0.d, #6] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx2vi64( %Pg, %bases, i64 6, i32 1) + ret void +} + +; PRFW , , [.S{, #}] -> 32-bit element +define void @llvm_aarch64_sve_gather_prfw_nx4vi32( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx4vi32: +; CHECK-NEXT: prfw pldl1strm, p0, [z0.s, #12] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx4vi32( %Pg, %bases, i64 12, i32 1) + ret void +} + +; PRFW , , [.D{, #}] -> 64-bit element +define void @llvm_aarch64_sve_gather_prfw_nx2vi64( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx2vi64: +; CHECK-NEXT: prfw pldl1strm, p0, [z0.d, #12] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx2vi64( %Pg, %bases, i64 12, i32 1) + ret void +} + +; PRFD , , [.S{, #}] -> 32-bit element +define void @llvm_aarch64_sve_gather_prfd_nx4vi32( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx4vi32: +; CHECK-NEXT: prfd pldl1strm, p0, [z0.s, #16] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx4vi32( %Pg, %bases, i64 16, i32 1) + ret void +} + +; PRFD , , [.D{, #}] -> 64-bit element +define void @llvm_aarch64_sve_gather_prfd_nx2vi64( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx2vi64: +; CHECK-NEXT: prfd pldl1strm, p0, [z0.d, #16] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx2vi64( %Pg, %bases, i64 16, i32 1) + ret void +} + +declare void @llvm.aarch64.sve.gather.prfb.nx4vi32( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfb.nx2vi64( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.nx4vi32( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.nx2vi64( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.nx4vi32( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.nx2vi64( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.nx4vi32( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.nx2vi64( %Pg, %bases, i64 %imm, i32 %prfop) diff --git a/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-vect-base-invalid-imm-offset.ll b/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-vect-base-invalid-imm-offset.ll new file mode 100644 index 00000000000000..4b0b42eb73b98e --- /dev/null +++ b/llvm/test/CodeGen/AArch64/sve-intrinsics-gather-prefetches-vect-base-invalid-imm-offset.ll @@ -0,0 +1,286 @@ +; RUN: llc -mtriple=aarch64--linux-gnu -mattr=+sve --asm-verbose=false < %s | FileCheck %s + +; PRFB , , [.S{, #}] -> 32-bit element, imm = 0, 1, ..., 31 +define void @llvm_aarch64_sve_gather_prfb_nx4vi32_runtime_offset( %bases, i64 %imm, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_nx4vi32_runtime_offset: +; CHECK-NEXT: prfb pldl1strm, p0, [x0, z0.s, uxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.nx4vi32( %Pg, %bases, i64 %imm, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfb_nx4vi32_invalid_immediate_offset_upper_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_nx4vi32_invalid_immediate_offset_upper_bound: +; CHECK-NEXT: mov w[[N:[0-9]+]], #32 +; CHECK-NEXT: prfb pldl1strm, p0, [x[[N]], z0.s, uxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.nx4vi32( %Pg, %bases, i64 32, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfb_nx4vi32_invalid_immediate_offset_lower_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_nx4vi32_invalid_immediate_offset_lower_bound: +; CHECK-NEXT: mov x[[N:[0-9]+]], #-1 +; CHECK-NEXT: prfb pldl1strm, p0, [x[[N:[0-9]+]], z0.s, uxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.nx4vi32( %Pg, %bases, i64 -1, i32 1) + ret void +} + +; PRFB , , [.D{, #}] -> 64-bit element, imm = 0, 1, ..., 31 +define void @llvm_aarch64_sve_gather_prfb_nx2vi64_runtime_offset( %bases, i64 %imm, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_nx2vi64_runtime_offset: +; CHECK-NEXT: prfb pldl1strm, p0, [x0, z0.d, uxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.nx2vi64( %Pg, %bases, i64 %imm, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfb_nx2vi64_invalid_immediate_offset_upper_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_nx2vi64_invalid_immediate_offset_upper_bound: +; CHECK-NEXT: mov w[[N:[0-9]+]], #32 +; CHECK-NEXT: prfb pldl1strm, p0, [x[[N]], z0.d, uxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.nx2vi64( %Pg, %bases, i64 32, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfb_nx2vi64_invalid_immediate_offset_lower_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfb_nx2vi64_invalid_immediate_offset_lower_bound: +; CHECK-NEXT: mov x[[N:[0-9]+]], #-1 +; CHECK-NEXT: prfb pldl1strm, p0, [x[[N:[0-9]+]], z0.d, uxtw] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfb.nx2vi64( %Pg, %bases, i64 -1, i32 1) + ret void +} + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; PRFH , , [.S{, #}] -> 32-bit element, imm = 0, 2, ..., 62 +define void @llvm_aarch64_sve_gather_prfh_nx4vi32_runtime_offset( %bases, i64 %imm, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx4vi32_runtime_offset: +; CHECK-NEXT: prfh pldl1strm, p0, [x0, z0.s, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx4vi32( %Pg, %bases, i64 %imm, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfh_nx4vi32_invalid_immediate_offset_upper_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx4vi32_invalid_immediate_offset_upper_bound: +; CHECK-NEXT: mov w[[N:[0-9]+]], #63 +; CHECK-NEXT: prfh pldl1strm, p0, [x[[N]], z0.s, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx4vi32( %Pg, %bases, i64 63, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfh_nx4vi32_invalid_immediate_offset_lower_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx4vi32_invalid_immediate_offset_lower_bound: +; CHECK-NEXT: mov x[[N:[0-9]+]], #-1 +; CHECK-NEXT: prfh pldl1strm, p0, [x[[N:[0-9]+]], z0.s, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx4vi32( %Pg, %bases, i64 -1, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfh_nx4vi32_invalid_immediate_offset_inbound_not_multiple_of_2( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx4vi32_invalid_immediate_offset_inbound_not_multiple_of_2: +; CHECK-NEXT: mov w[[N:[0-9]+]], #33 +; CHECK-NEXT: prfh pldl1strm, p0, [x[[N:[0-9]+]], z0.s, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx4vi32( %Pg, %bases, i64 33, i32 1) + ret void +} + +; PRFH , , [.D{, #}] -> 64-bit element, imm = 0, 2, ..., 62 +define void @llvm_aarch64_sve_gather_prfh_nx2vi64_runtime_offset( %bases, i64 %imm, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx2vi64_runtime_offset: +; CHECK-NEXT: prfh pldl1strm, p0, [x0, z0.d, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx2vi64( %Pg, %bases, i64 %imm, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfh_nx2vi64_invalid_immediate_offset_upper_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx2vi64_invalid_immediate_offset_upper_bound: +; CHECK-NEXT: mov w[[N:[0-9]+]], #63 +; CHECK-NEXT: prfh pldl1strm, p0, [x[[N]], z0.d, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx2vi64( %Pg, %bases, i64 63, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfh_nx2vi64_invalid_immediate_offset_lower_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx2vi64_invalid_immediate_offset_lower_bound: +; CHECK-NEXT: mov x[[N:[0-9]+]], #-1 +; CHECK-NEXT: prfh pldl1strm, p0, [x[[N:[0-9]+]], z0.d, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx2vi64( %Pg, %bases, i64 -1, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfh_nx2vi64_invalid_immediate_offset_inbound_not_multiple_of_2( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfh_nx2vi64_invalid_immediate_offset_inbound_not_multiple_of_2: +; CHECK-NEXT: mov w[[N:[0-9]+]], #33 +; CHECK-NEXT: prfh pldl1strm, p0, [x[[N:[0-9]+]], z0.d, uxtw #1] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfh.nx2vi64( %Pg, %bases, i64 33, i32 1) + ret void +} + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; PRFW , , [.S{, #}] -> 32-bit element, imm = 0, 4, ..., 124 +define void @llvm_aarch64_sve_gather_prfw_nx4vi32_runtime_offset( %bases, i64 %imm, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx4vi32_runtime_offset: +; CHECK-NEXT: prfw pldl1strm, p0, [x0, z0.s, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx4vi32( %Pg, %bases, i64 %imm, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfw_nx4vi32_invalid_immediate_offset_upper_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx4vi32_invalid_immediate_offset_upper_bound: +; CHECK-NEXT: mov w[[N:[0-9]+]], #125 +; CHECK-NEXT: prfw pldl1strm, p0, [x[[N]], z0.s, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx4vi32( %Pg, %bases, i64 125, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfw_nx4vi32_invalid_immediate_offset_lower_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx4vi32_invalid_immediate_offset_lower_bound: +; CHECK-NEXT: mov x[[N:[0-9]+]], #-1 +; CHECK-NEXT: prfw pldl1strm, p0, [x[[N:[0-9]+]], z0.s, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx4vi32( %Pg, %bases, i64 -1, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfw_nx4vi32_invalid_immediate_offset_inbound_not_multiple_of_4( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx4vi32_invalid_immediate_offset_inbound_not_multiple_of_4: +; CHECK-NEXT: mov w[[N:[0-9]+]], #33 +; CHECK-NEXT: prfw pldl1strm, p0, [x[[N:[0-9]+]], z0.s, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx4vi32( %Pg, %bases, i64 33, i32 1) + ret void +} + +; PRFW , , [.D{, #}] -> 64-bit element, imm = 0, 4, ..., 124 +define void @llvm_aarch64_sve_gather_prfw_nx2vi64_runtime_offset( %bases, i64 %imm, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx2vi64_runtime_offset: +; CHECK-NEXT: prfw pldl1strm, p0, [x0, z0.d, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx2vi64( %Pg, %bases, i64 %imm, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfw_nx2vi64_invalid_immediate_offset_upper_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx2vi64_invalid_immediate_offset_upper_bound: +; CHECK-NEXT: mov w[[N:[0-9]+]], #125 +; CHECK-NEXT: prfw pldl1strm, p0, [x[[N]], z0.d, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx2vi64( %Pg, %bases, i64 125, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfw_nx2vi64_invalid_immediate_offset_lower_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx2vi64_invalid_immediate_offset_lower_bound: +; CHECK-NEXT: mov x[[N:[0-9]+]], #-1 +; CHECK-NEXT: prfw pldl1strm, p0, [x[[N:[0-9]+]], z0.d, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx2vi64( %Pg, %bases, i64 -1, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfw_nx2vi64_invalid_immediate_offset_inbound_not_multiple_of_4( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfw_nx2vi64_invalid_immediate_offset_inbound_not_multiple_of_4: +; CHECK-NEXT: mov w[[N:[0-9]+]], #33 +; CHECK-NEXT: prfw pldl1strm, p0, [x[[N:[0-9]+]], z0.d, uxtw #2] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfw.nx2vi64( %Pg, %bases, i64 33, i32 1) + ret void +} + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; PRFD , , [.S{, #}] -> 32-bit element, imm = 0, 8, ..., 248 +define void @llvm_aarch64_sve_gather_prfd_nx4vi32_runtime_offset( %bases, i64 %imm, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx4vi32_runtime_offset: +; CHECK-NEXT: prfd pldl1strm, p0, [x0, z0.s, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx4vi32( %Pg, %bases, i64 %imm, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfd_nx4vi32_invalid_immediate_offset_upper_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx4vi32_invalid_immediate_offset_upper_bound: +; CHECK-NEXT: mov w[[N:[0-9]+]], #125 +; CHECK-NEXT: prfd pldl1strm, p0, [x[[N]], z0.s, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx4vi32( %Pg, %bases, i64 125, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfd_nx4vi32_invalid_immediate_offset_lower_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx4vi32_invalid_immediate_offset_lower_bound: +; CHECK-NEXT: mov x[[N:[0-9]+]], #-1 +; CHECK-NEXT: prfd pldl1strm, p0, [x[[N:[0-9]+]], z0.s, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx4vi32( %Pg, %bases, i64 -1, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfd_nx4vi32_invalid_immediate_offset_inbound_not_multiple_of_8( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx4vi32_invalid_immediate_offset_inbound_not_multiple_of_8: +; CHECK-NEXT: mov w[[N:[0-9]+]], #33 +; CHECK-NEXT: prfd pldl1strm, p0, [x[[N:[0-9]+]], z0.s, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx4vi32( %Pg, %bases, i64 33, i32 1) + ret void +} + +; PRFD , , [.D{, #}] -> 64-bit element, imm = 0, 4, ..., 248 +define void @llvm_aarch64_sve_gather_prfd_nx2vi64_runtime_offset( %bases, i64 %imm, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx2vi64_runtime_offset: +; CHECK-NEXT: prfd pldl1strm, p0, [x0, z0.d, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx2vi64( %Pg, %bases, i64 %imm, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfd_nx2vi64_invalid_immediate_offset_upper_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx2vi64_invalid_immediate_offset_upper_bound: +; CHECK-NEXT: mov w[[N:[0-9]+]], #125 +; CHECK-NEXT: prfd pldl1strm, p0, [x[[N]], z0.d, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx2vi64( %Pg, %bases, i64 125, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfd_nx2vi64_invalid_immediate_offset_lower_bound( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx2vi64_invalid_immediate_offset_lower_bound: +; CHECK-NEXT: mov x[[N:[0-9]+]], #-1 +; CHECK-NEXT: prfd pldl1strm, p0, [x[[N:[0-9]+]], z0.d, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx2vi64( %Pg, %bases, i64 -1, i32 1) + ret void +} + +define void @llvm_aarch64_sve_gather_prfd_nx2vi64_invalid_immediate_offset_inbound_not_multiple_of_8( %bases, %Pg) nounwind { +; CHECK-LABEL: llvm_aarch64_sve_gather_prfd_nx2vi64_invalid_immediate_offset_inbound_not_multiple_of_8: +; CHECK-NEXT: mov w[[N:[0-9]+]], #33 +; CHECK-NEXT: prfd pldl1strm, p0, [x[[N:[0-9]+]], z0.d, uxtw #3] +; CHECK-NEXT: ret + call void @llvm.aarch64.sve.gather.prfd.nx2vi64( %Pg, %bases, i64 33, i32 1) + ret void +} + +declare void @llvm.aarch64.sve.gather.prfb.nx4vi32( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfb.nx2vi64( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.nx4vi32( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfh.nx2vi64( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.nx4vi32( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfw.nx2vi64( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.nx4vi32( %Pg, %bases, i64 %imm, i32 %prfop) +declare void @llvm.aarch64.sve.gather.prfd.nx2vi64( %Pg, %bases, i64 %imm, i32 %prfop) diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/inst-select-merge-values.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/inst-select-merge-values.mir index f0bcd376fe4e9f..207814ccd8c86b 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/inst-select-merge-values.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/inst-select-merge-values.mir @@ -589,3 +589,27 @@ body: | %4:sgpr(s1024) = G_MERGE_VALUES %0, %1, %2, %3 S_ENDPGM 0, implicit %4 ... + +--- + +name: test_merge_values_s_s1024_s_s512 +legalized: true +regBankSelected: true +tracksRegLiveness: true + +body: | + bb.0: + liveins: $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15, $sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + + ; GCN-LABEL: name: test_merge_values_s_s1024_s_s512 + ; GCN: liveins: $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15, $sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + ; GCN: [[COPY:%[0-9]+]]:sreg_512 = COPY $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15 + ; GCN: [[COPY1:%[0-9]+]]:sreg_512 = COPY $sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + ; GCN: [[REG_SEQUENCE:%[0-9]+]]:sreg_1024 = REG_SEQUENCE [[COPY]], %subreg.sub0_sub1_sub2_sub3_sub4_sub5_sub6_sub7_sub8_sub9_sub10_sub11_sub12_sub13_sub14_sub15, [[COPY1]], %subreg.sub16_sub17_sub18_sub19_sub20_sub21_sub22_sub23_sub24_sub25_sub26_sub27_sub28_sub29_sub30_sub31 + ; GCN: $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15_sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 = COPY [[REG_SEQUENCE]] + %0:sgpr(s512) = COPY $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15 + %1:sgpr(s512) = COPY $sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + %2:sgpr(s1024) = G_MERGE_VALUES %0, %1 + $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15_sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 = COPY %2 + +... diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/inst-select-unmerge-values.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/inst-select-unmerge-values.mir index 30270d22b1af66..f96dd5129e0231 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/inst-select-unmerge-values.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/inst-select-unmerge-values.mir @@ -257,3 +257,32 @@ body: | %1:sgpr(s256), %2:sgpr(s256), %3:sgpr(s256), %4:sgpr(s256) = G_UNMERGE_VALUES %0 S_ENDPGM 0, implicit %1, implicit %2, implicit %3, implicit %4 ... + +--- + +name: test_unmerge_values_s_s512_s_s1024 +legalized: true +regBankSelected: true +tracksRegLiveness: true + +body: | + bb.0: + liveins: $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15_sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + + ; CHECK-LABEL: name: test_unmerge_s512_s1024 + ; CHECK: [[COPY:%[0-9]+]]:_(s1024) = COPY $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15_sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + ; CHECK: [[UV:%[0-9]+]]:_(s512), [[UV1:%[0-9]+]]:_(s512) = G_UNMERGE_VALUES [[COPY]](s1024) + ; CHECK: $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15 = COPY [[UV]](s512) + ; CHECK: $sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 = COPY [[UV1]](s512) + ; GCN-LABEL: name: test_unmerge_values_s_s512_s_s1024 + ; GCN: liveins: $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15_sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + ; GCN: [[COPY:%[0-9]+]]:sreg_1024 = COPY $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15_sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + ; GCN: [[COPY1:%[0-9]+]]:sreg_512 = COPY [[COPY]].sub0_sub1_sub2_sub3_sub4_sub5_sub6_sub7_sub8_sub9_sub10_sub11_sub12_sub13_sub14_sub15 + ; GCN: [[COPY2:%[0-9]+]]:sreg_512 = COPY [[COPY]].sub16_sub17_sub18_sub19_sub20_sub21_sub22_sub23_sub24_sub25_sub26_sub27_sub28_sub29_sub30_sub31 + ; GCN: $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15 = COPY [[COPY1]] + ; GCN: $sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 = COPY [[COPY2]] + %0:sgpr(s1024) = COPY $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15_sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 + %1:sgpr(s512), %2:sgpr(s512) = G_UNMERGE_VALUES %0 + $sgpr0_sgpr1_sgpr2_sgpr3_sgpr4_sgpr5_sgpr6_sgpr7_sgpr8_sgpr9_sgpr10_sgpr11_sgpr12_sgpr13_sgpr14_sgpr15 = COPY %1 + $sgpr16_sgpr17_sgpr18_sgpr19_sgpr20_sgpr21_sgpr22_sgpr23_sgpr24_sgpr25_sgpr26_sgpr27_sgpr28_sgpr29_sgpr30_sgpr31 = COPY %2 +... diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-function-args.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-function-args.ll index b058c6fe502b2a..fdf98d2acb5821 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-function-args.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/irtranslator-function-args.ll @@ -229,6 +229,67 @@ define void @void_func_p3i8(i8 addrspace(3)* %arg0) #0 { ret void } +define void @void_func_i48(i48 %arg0) #0 { + ; CHECK-LABEL: name: void_func_i48 + ; CHECK: bb.1 (%ir-block.0): + ; CHECK: liveins: $vgpr0, $vgpr1, $sgpr30_sgpr31 + ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 + ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 + ; CHECK: [[COPY2:%[0-9]+]]:sgpr_64 = COPY $sgpr30_sgpr31 + ; CHECK: [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[COPY]](s32), [[COPY1]](s32) + ; CHECK: [[TRUNC:%[0-9]+]]:_(s48) = G_TRUNC [[MV]](s64) + ; CHECK: [[DEF:%[0-9]+]]:_(p1) = G_IMPLICIT_DEF + ; CHECK: G_STORE [[TRUNC]](s48), [[DEF]](p1) :: (store 6 into `i48 addrspace(1)* undef`, align 8, addrspace 1) + ; CHECK: [[COPY3:%[0-9]+]]:ccr_sgpr_64 = COPY [[COPY2]] + ; CHECK: S_SETPC_B64_return [[COPY3]] + store i48 %arg0, i48 addrspace(1)* undef + ret void +} + +define void @void_func_i48_zeroext(i48 zeroext %arg0) #0 { + ; CHECK-LABEL: name: void_func_i48_zeroext + ; CHECK: bb.1 (%ir-block.0): + ; CHECK: liveins: $vgpr0, $vgpr1, $sgpr30_sgpr31 + ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 + ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 + ; CHECK: [[COPY2:%[0-9]+]]:sgpr_64 = COPY $sgpr30_sgpr31 + ; CHECK: [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[COPY]](s32), [[COPY1]](s32) + ; CHECK: [[TRUNC:%[0-9]+]]:_(s48) = G_TRUNC [[MV]](s64) + ; CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 12 + ; CHECK: [[DEF:%[0-9]+]]:_(p1) = G_IMPLICIT_DEF + ; CHECK: [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[TRUNC]](s48) + ; CHECK: [[ADD:%[0-9]+]]:_(s64) = G_ADD [[ZEXT]], [[C]] + ; CHECK: G_STORE [[ADD]](s64), [[DEF]](p1) :: (store 8 into `i64 addrspace(1)* undef`, addrspace 1) + ; CHECK: [[COPY3:%[0-9]+]]:ccr_sgpr_64 = COPY [[COPY2]] + ; CHECK: S_SETPC_B64_return [[COPY3]] + %ext = zext i48 %arg0 to i64 + %add = add i64 %ext, 12 + store i64 %add, i64 addrspace(1)* undef + ret void +} + +define void @void_func_i48_signext(i48 signext %arg0) #0 { + ; CHECK-LABEL: name: void_func_i48_signext + ; CHECK: bb.1 (%ir-block.0): + ; CHECK: liveins: $vgpr0, $vgpr1, $sgpr30_sgpr31 + ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 + ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 + ; CHECK: [[COPY2:%[0-9]+]]:sgpr_64 = COPY $sgpr30_sgpr31 + ; CHECK: [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[COPY]](s32), [[COPY1]](s32) + ; CHECK: [[TRUNC:%[0-9]+]]:_(s48) = G_TRUNC [[MV]](s64) + ; CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 12 + ; CHECK: [[DEF:%[0-9]+]]:_(p1) = G_IMPLICIT_DEF + ; CHECK: [[SEXT:%[0-9]+]]:_(s64) = G_SEXT [[TRUNC]](s48) + ; CHECK: [[ADD:%[0-9]+]]:_(s64) = G_ADD [[SEXT]], [[C]] + ; CHECK: G_STORE [[ADD]](s64), [[DEF]](p1) :: (store 8 into `i64 addrspace(1)* undef`, addrspace 1) + ; CHECK: [[COPY3:%[0-9]+]]:ccr_sgpr_64 = COPY [[COPY2]] + ; CHECK: S_SETPC_B64_return [[COPY3]] + %ext = sext i48 %arg0 to i64 + %add = add i64 %ext, 12 + store i64 %add, i64 addrspace(1)* undef + ret void +} + define void @void_func_i64(i64 %arg0) #0 { ; CHECK-LABEL: name: void_func_i64 ; CHECK: bb.1 (%ir-block.0): @@ -245,6 +306,87 @@ define void @void_func_i64(i64 %arg0) #0 { ret void } +define void @void_func_i95(i95 %arg0) #0 { + ; CHECK-LABEL: name: void_func_i95 + ; CHECK: bb.1 (%ir-block.0): + ; CHECK: liveins: $vgpr0, $vgpr1, $vgpr2, $sgpr30_sgpr31 + ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 + ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 + ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2 + ; CHECK: [[COPY3:%[0-9]+]]:sgpr_64 = COPY $sgpr30_sgpr31 + ; CHECK: [[MV:%[0-9]+]]:_(s96) = G_MERGE_VALUES [[COPY]](s32), [[COPY1]](s32), [[COPY2]](s32) + ; CHECK: [[TRUNC:%[0-9]+]]:_(s95) = G_TRUNC [[MV]](s96) + ; CHECK: [[DEF:%[0-9]+]]:_(p1) = G_IMPLICIT_DEF + ; CHECK: G_STORE [[TRUNC]](s95), [[DEF]](p1) :: (store 12 into `i95 addrspace(1)* undef`, align 8, addrspace 1) + ; CHECK: [[COPY4:%[0-9]+]]:ccr_sgpr_64 = COPY [[COPY3]] + ; CHECK: S_SETPC_B64_return [[COPY4]] + store i95 %arg0, i95 addrspace(1)* undef + ret void +} + +define void @void_func_i95_zeroext(i95 zeroext %arg0) #0 { + ; CHECK-LABEL: name: void_func_i95_zeroext + ; CHECK: bb.1 (%ir-block.0): + ; CHECK: liveins: $vgpr0, $vgpr1, $vgpr2, $sgpr30_sgpr31 + ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 + ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 + ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2 + ; CHECK: [[COPY3:%[0-9]+]]:sgpr_64 = COPY $sgpr30_sgpr31 + ; CHECK: [[MV:%[0-9]+]]:_(s96) = G_MERGE_VALUES [[COPY]](s32), [[COPY1]](s32), [[COPY2]](s32) + ; CHECK: [[TRUNC:%[0-9]+]]:_(s95) = G_TRUNC [[MV]](s96) + ; CHECK: [[C:%[0-9]+]]:_(s96) = G_CONSTANT i96 12 + ; CHECK: [[DEF:%[0-9]+]]:_(p1) = G_IMPLICIT_DEF + ; CHECK: [[ZEXT:%[0-9]+]]:_(s96) = G_ZEXT [[TRUNC]](s95) + ; CHECK: [[ADD:%[0-9]+]]:_(s96) = G_ADD [[ZEXT]], [[C]] + ; CHECK: G_STORE [[ADD]](s96), [[DEF]](p1) :: (store 12 into `i96 addrspace(1)* undef`, align 8, addrspace 1) + ; CHECK: [[COPY4:%[0-9]+]]:ccr_sgpr_64 = COPY [[COPY3]] + ; CHECK: S_SETPC_B64_return [[COPY4]] + %ext = zext i95 %arg0 to i96 + %add = add i96 %ext, 12 + store i96 %add, i96 addrspace(1)* undef + ret void +} + +define void @void_func_i95_signext(i95 signext %arg0) #0 { + ; CHECK-LABEL: name: void_func_i95_signext + ; CHECK: bb.1 (%ir-block.0): + ; CHECK: liveins: $vgpr0, $vgpr1, $vgpr2, $sgpr30_sgpr31 + ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 + ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 + ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2 + ; CHECK: [[COPY3:%[0-9]+]]:sgpr_64 = COPY $sgpr30_sgpr31 + ; CHECK: [[MV:%[0-9]+]]:_(s96) = G_MERGE_VALUES [[COPY]](s32), [[COPY1]](s32), [[COPY2]](s32) + ; CHECK: [[TRUNC:%[0-9]+]]:_(s95) = G_TRUNC [[MV]](s96) + ; CHECK: [[C:%[0-9]+]]:_(s96) = G_CONSTANT i96 12 + ; CHECK: [[DEF:%[0-9]+]]:_(p1) = G_IMPLICIT_DEF + ; CHECK: [[SEXT:%[0-9]+]]:_(s96) = G_SEXT [[TRUNC]](s95) + ; CHECK: [[ADD:%[0-9]+]]:_(s96) = G_ADD [[SEXT]], [[C]] + ; CHECK: G_STORE [[ADD]](s96), [[DEF]](p1) :: (store 12 into `i96 addrspace(1)* undef`, align 8, addrspace 1) + ; CHECK: [[COPY4:%[0-9]+]]:ccr_sgpr_64 = COPY [[COPY3]] + ; CHECK: S_SETPC_B64_return [[COPY4]] + %ext = sext i95 %arg0 to i96 + %add = add i96 %ext, 12 + store i96 %add, i96 addrspace(1)* undef + ret void +} + +define void @void_func_i96(i96 %arg0) #0 { + ; CHECK-LABEL: name: void_func_i96 + ; CHECK: bb.1 (%ir-block.0): + ; CHECK: liveins: $vgpr0, $vgpr1, $vgpr2, $sgpr30_sgpr31 + ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 + ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 + ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2 + ; CHECK: [[COPY3:%[0-9]+]]:sgpr_64 = COPY $sgpr30_sgpr31 + ; CHECK: [[MV:%[0-9]+]]:_(s96) = G_MERGE_VALUES [[COPY]](s32), [[COPY1]](s32), [[COPY2]](s32) + ; CHECK: [[DEF:%[0-9]+]]:_(p1) = G_IMPLICIT_DEF + ; CHECK: G_STORE [[MV]](s96), [[DEF]](p1) :: (store 12 into `i96 addrspace(1)* undef`, align 8, addrspace 1) + ; CHECK: [[COPY4:%[0-9]+]]:ccr_sgpr_64 = COPY [[COPY3]] + ; CHECK: S_SETPC_B64_return [[COPY4]] + store i96 %arg0, i96 addrspace(1)* undef + ret void +} + define void @void_func_p0i8(i8* %arg0) #0 { ; CHECK-LABEL: name: void_func_p0i8 ; CHECK: bb.1 (%ir-block.0): diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-insert.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-insert.mir index 459b6beae18e49..37971d389fe4ea 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-insert.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-insert.mir @@ -1295,8 +1295,8 @@ body: | ; CHECK: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 -65536 ; CHECK: [[AND1:%[0-9]+]]:_(s32) = G_AND [[COPY1]], [[C1]] ; CHECK: [[OR:%[0-9]+]]:_(s32) = G_OR [[AND1]], [[AND]] - ; CHECK: [[BITCAST:%[0-9]+]]:_(s32) = G_BITCAST [[OR]](s32) - ; CHECK: $vgpr0 = COPY [[BITCAST]](s32) + ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[OR]](s32) + ; CHECK: $vgpr0 = COPY [[COPY3]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s32) = COPY $vgpr1 %2:_(s16) = G_TRUNC %1 @@ -1321,8 +1321,8 @@ body: | ; CHECK: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 -131071 ; CHECK: [[AND1:%[0-9]+]]:_(s32) = G_AND [[COPY1]], [[C2]] ; CHECK: [[OR:%[0-9]+]]:_(s32) = G_OR [[AND1]], [[SHL]] - ; CHECK: [[BITCAST:%[0-9]+]]:_(s32) = G_BITCAST [[OR]](s32) - ; CHECK: $vgpr0 = COPY [[BITCAST]](s32) + ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[OR]](s32) + ; CHECK: $vgpr0 = COPY [[COPY3]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s32) = COPY $vgpr1 %2:_(s16) = G_TRUNC %1 @@ -1347,8 +1347,8 @@ body: | ; CHECK: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 -16776961 ; CHECK: [[AND1:%[0-9]+]]:_(s32) = G_AND [[COPY1]], [[C2]] ; CHECK: [[OR:%[0-9]+]]:_(s32) = G_OR [[AND1]], [[SHL]] - ; CHECK: [[BITCAST:%[0-9]+]]:_(s32) = G_BITCAST [[OR]](s32) - ; CHECK: $vgpr0 = COPY [[BITCAST]](s32) + ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[OR]](s32) + ; CHECK: $vgpr0 = COPY [[COPY3]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s32) = COPY $vgpr1 %2:_(s16) = G_TRUNC %1 @@ -1372,8 +1372,8 @@ body: | ; CHECK: [[SHL:%[0-9]+]]:_(s32) = G_SHL [[AND]], [[C1]](s32) ; CHECK: [[AND1:%[0-9]+]]:_(s32) = G_AND [[COPY1]], [[C]] ; CHECK: [[OR:%[0-9]+]]:_(s32) = G_OR [[AND1]], [[SHL]] - ; CHECK: [[BITCAST:%[0-9]+]]:_(s32) = G_BITCAST [[OR]](s32) - ; CHECK: $vgpr0 = COPY [[BITCAST]](s32) + ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[OR]](s32) + ; CHECK: $vgpr0 = COPY [[COPY3]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s32) = COPY $vgpr1 %2:_(s16) = G_TRUNC %1 diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-intrinsic-round.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-intrinsic-round.mir index 1677838d4439a4..406cbf2c350478 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-intrinsic-round.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-intrinsic-round.mir @@ -11,35 +11,41 @@ body: | ; GFX6-LABEL: name: test_intrinsic_round_s32 ; GFX6: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 - ; GFX6: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[COPY]] - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[COPY]](s32), [[C]] - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[COPY]](s32), [[INTRINSIC_TRUNC]] - ; GFX6: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX6: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] + ; GFX6: [[FSUB:%[0-9]+]]:_(s32) = G_FSUB [[COPY]], [[INTRINSIC_TRUNC]] + ; GFX6: [[FABS:%[0-9]+]]:_(s32) = G_FABS [[FSUB]] + ; GFX6: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX6: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX6: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX6: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX6: $vgpr0 = COPY [[FADD]](s32) ; GFX8-LABEL: name: test_intrinsic_round_s32 ; GFX8: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 - ; GFX8: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[COPY]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[COPY]](s32), [[C]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[COPY]](s32), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] + ; GFX8: [[FSUB:%[0-9]+]]:_(s32) = G_FSUB [[COPY]], [[INTRINSIC_TRUNC]] + ; GFX8: [[FABS:%[0-9]+]]:_(s32) = G_FABS [[FSUB]] + ; GFX8: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX8: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX8: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX8: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] ; GFX8: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX8: $vgpr0 = COPY [[FADD]](s32) ; GFX9-LABEL: name: test_intrinsic_round_s32 ; GFX9: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 - ; GFX9: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[COPY]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[COPY]](s32), [[C]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[COPY]](s32), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] + ; GFX9: [[FSUB:%[0-9]+]]:_(s32) = G_FSUB [[COPY]], [[INTRINSIC_TRUNC]] + ; GFX9: [[FABS:%[0-9]+]]:_(s32) = G_FABS [[FSUB]] + ; GFX9: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX9: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX9: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX9: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] ; GFX9: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX9: $vgpr0 = COPY [[FADD]](s32) %0:_(s32) = COPY $vgpr0 @@ -55,36 +61,42 @@ body: | ; GFX6-LABEL: name: test_intrinsic_round_s32_flags ; GFX6: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 - ; GFX6: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = nsz G_INTRINSIC_TRUNC [[COPY]] - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(olt), [[COPY]](s32), [[C]] - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(one), [[COPY]](s32), [[INTRINSIC_TRUNC]] - ; GFX6: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX6: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX6: [[FSUB:%[0-9]+]]:_(s32) = nsz G_FSUB [[COPY]], [[INTRINSIC_TRUNC]] + ; GFX6: [[FABS:%[0-9]+]]:_(s32) = nsz G_FABS [[FSUB]] + ; GFX6: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX6: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX6: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX6: [[SELECT:%[0-9]+]]:_(s32) = nsz G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX6: [[FADD:%[0-9]+]]:_(s32) = nsz G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX6: $vgpr0 = COPY [[FADD]](s32) ; GFX8-LABEL: name: test_intrinsic_round_s32_flags ; GFX8: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 - ; GFX8: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = nsz G_INTRINSIC_TRUNC [[COPY]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(olt), [[COPY]](s32), [[C]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(one), [[COPY]](s32), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX8: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX8: [[FSUB:%[0-9]+]]:_(s32) = nsz G_FSUB [[COPY]], [[INTRINSIC_TRUNC]] + ; GFX8: [[FABS:%[0-9]+]]:_(s32) = nsz G_FABS [[FSUB]] + ; GFX8: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX8: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX8: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX8: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s32) = nsz G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX8: [[FADD:%[0-9]+]]:_(s32) = nsz G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX8: $vgpr0 = COPY [[FADD]](s32) ; GFX9-LABEL: name: test_intrinsic_round_s32_flags ; GFX9: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 - ; GFX9: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = nsz G_INTRINSIC_TRUNC [[COPY]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(olt), [[COPY]](s32), [[C]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(one), [[COPY]](s32), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX9: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX9: [[FSUB:%[0-9]+]]:_(s32) = nsz G_FSUB [[COPY]], [[INTRINSIC_TRUNC]] + ; GFX9: [[FABS:%[0-9]+]]:_(s32) = nsz G_FABS [[FSUB]] + ; GFX9: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX9: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX9: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX9: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = nsz G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s32) = nsz G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX9: [[FADD:%[0-9]+]]:_(s32) = nsz G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX9: $vgpr0 = COPY [[FADD]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s32) = nsz G_INTRINSIC_ROUND %0 @@ -99,57 +111,66 @@ body: | ; GFX6-LABEL: name: test_intrinsic_round_s64 ; GFX6: [[COPY:%[0-9]+]]:_(s64) = COPY $vgpr0_vgpr1 - ; GFX6: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 ; GFX6: [[UV:%[0-9]+]]:_(s32), [[UV1:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[COPY]](s64) - ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 20 - ; GFX6: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 11 - ; GFX6: [[INT:%[0-9]+]]:_(s32) = G_INTRINSIC intrinsic(@llvm.amdgcn.ubfe), [[C1]](s32), [[C2]](s32) - ; GFX6: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 1023 - ; GFX6: [[SUB:%[0-9]+]]:_(s32) = G_SUB [[INT]], [[C3]] - ; GFX6: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 -2147483648 - ; GFX6: [[AND:%[0-9]+]]:_(s32) = G_AND [[UV1]], [[C4]] - ; GFX6: [[C5:%[0-9]+]]:_(s64) = G_CONSTANT i64 4503599627370495 - ; GFX6: [[C6:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 - ; GFX6: [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[C6]](s32), [[AND]](s32) - ; GFX6: [[ASHR:%[0-9]+]]:_(s64) = G_ASHR [[C5]], [[SUB]](s32) - ; GFX6: [[C7:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1 - ; GFX6: [[XOR:%[0-9]+]]:_(s64) = G_XOR [[ASHR]], [[C7]] + ; GFX6: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 20 + ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 11 + ; GFX6: [[INT:%[0-9]+]]:_(s32) = G_INTRINSIC intrinsic(@llvm.amdgcn.ubfe), [[C]](s32), [[C1]](s32) + ; GFX6: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1023 + ; GFX6: [[SUB:%[0-9]+]]:_(s32) = G_SUB [[INT]], [[C2]] + ; GFX6: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 -2147483648 + ; GFX6: [[AND:%[0-9]+]]:_(s32) = G_AND [[UV1]], [[C3]] + ; GFX6: [[C4:%[0-9]+]]:_(s64) = G_CONSTANT i64 4503599627370495 + ; GFX6: [[C5:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 + ; GFX6: [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[C5]](s32), [[AND]](s32) + ; GFX6: [[ASHR:%[0-9]+]]:_(s64) = G_ASHR [[C4]], [[SUB]](s32) + ; GFX6: [[C6:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1 + ; GFX6: [[XOR:%[0-9]+]]:_(s64) = G_XOR [[ASHR]], [[C6]] ; GFX6: [[AND1:%[0-9]+]]:_(s64) = G_AND [[COPY]], [[XOR]] - ; GFX6: [[C8:%[0-9]+]]:_(s32) = G_CONSTANT i32 51 - ; GFX6: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[SUB]](s32), [[C6]] - ; GFX6: [[ICMP1:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[SUB]](s32), [[C8]] + ; GFX6: [[C7:%[0-9]+]]:_(s32) = G_CONSTANT i32 51 + ; GFX6: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[SUB]](s32), [[C5]] + ; GFX6: [[ICMP1:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[SUB]](s32), [[C7]] ; GFX6: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[ICMP]](s1), [[MV]], [[AND1]] ; GFX6: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[ICMP1]](s1), [[COPY]], [[SELECT]] ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[COPY]] - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[COPY]](s64), [[C]] - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[COPY]](s64), [[INTRINSIC_TRUNC]] - ; GFX6: [[AND2:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C9:%[0-9]+]]:_(s64) = G_FCONSTANT double -1.000000e+00 - ; GFX6: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[AND2]](s1), [[C9]], [[C]] - ; GFX6: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT1]] - ; GFX6: $vgpr0_vgpr1 = COPY [[FADD]](s64) + ; GFX6: [[FNEG:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX6: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[COPY]], [[FNEG]] + ; GFX6: [[FABS:%[0-9]+]]:_(s64) = G_FABS [[FADD]] + ; GFX6: [[C8:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 + ; GFX6: [[C9:%[0-9]+]]:_(s64) = G_FCONSTANT double 5.000000e-01 + ; GFX6: [[C10:%[0-9]+]]:_(s64) = G_CONSTANT i64 4607182418800017408 + ; GFX6: [[COPY1:%[0-9]+]]:_(s64) = COPY [[C10]](s64) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s64), [[C9]] + ; GFX6: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C8]] + ; GFX6: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT1]] + ; GFX6: $vgpr0_vgpr1 = COPY [[FADD1]](s64) ; GFX8-LABEL: name: test_intrinsic_round_s64 ; GFX8: [[COPY:%[0-9]+]]:_(s64) = COPY $vgpr0_vgpr1 - ; GFX8: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[COPY]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[COPY]](s64), [[C]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[COPY]](s64), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double -1.000000e+00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX8: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] - ; GFX8: $vgpr0_vgpr1 = COPY [[FADD]](s64) + ; GFX8: [[FNEG:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX8: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[COPY]], [[FNEG]] + ; GFX8: [[FABS:%[0-9]+]]:_(s64) = G_FABS [[FADD]] + ; GFX8: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 + ; GFX8: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double 5.000000e-01 + ; GFX8: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 4607182418800017408 + ; GFX8: [[COPY1:%[0-9]+]]:_(s64) = COPY [[C2]](s64) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s64), [[C1]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX8: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX8: $vgpr0_vgpr1 = COPY [[FADD1]](s64) ; GFX9-LABEL: name: test_intrinsic_round_s64 ; GFX9: [[COPY:%[0-9]+]]:_(s64) = COPY $vgpr0_vgpr1 - ; GFX9: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[COPY]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[COPY]](s64), [[C]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[COPY]](s64), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double -1.000000e+00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX9: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] - ; GFX9: $vgpr0_vgpr1 = COPY [[FADD]](s64) + ; GFX9: [[FNEG:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX9: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[COPY]], [[FNEG]] + ; GFX9: [[FABS:%[0-9]+]]:_(s64) = G_FABS [[FADD]] + ; GFX9: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 + ; GFX9: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double 5.000000e-01 + ; GFX9: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 4607182418800017408 + ; GFX9: [[COPY1:%[0-9]+]]:_(s64) = COPY [[C2]](s64) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s64), [[C1]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX9: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX9: $vgpr0_vgpr1 = COPY [[FADD1]](s64) %0:_(s64) = COPY $vgpr0_vgpr1 %1:_(s64) = G_INTRINSIC_ROUND %0 $vgpr0_vgpr1 = COPY %1 @@ -164,57 +185,66 @@ body: | ; GFX6-LABEL: name: test_intrinsic_round_v2s32 ; GFX6: [[COPY:%[0-9]+]]:_(<2 x s32>) = COPY $vgpr0_vgpr1 ; GFX6: [[UV:%[0-9]+]]:_(s32), [[UV1:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[COPY]](<2 x s32>) - ; GFX6: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[UV]] - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV]](s32), [[C]] - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV]](s32), [[INTRINSIC_TRUNC]] - ; GFX6: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX6: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] + ; GFX6: [[FSUB:%[0-9]+]]:_(s32) = G_FSUB [[UV]], [[INTRINSIC_TRUNC]] + ; GFX6: [[FABS:%[0-9]+]]:_(s32) = G_FABS [[FSUB]] + ; GFX6: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX6: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX6: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX6: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX6: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[UV1]] - ; GFX6: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV1]](s32), [[C]] - ; GFX6: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV1]](s32), [[INTRINSIC_TRUNC1]] - ; GFX6: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX6: [[SELECT1:%[0-9]+]]:_(s32) = G_SELECT [[AND1]](s1), [[C1]], [[C]] + ; GFX6: [[FSUB1:%[0-9]+]]:_(s32) = G_FSUB [[UV1]], [[INTRINSIC_TRUNC1]] + ; GFX6: [[FABS1:%[0-9]+]]:_(s32) = G_FABS [[FSUB1]] + ; GFX6: [[COPY2:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s32), [[C1]] + ; GFX6: [[SELECT1:%[0-9]+]]:_(s32) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C]] ; GFX6: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] ; GFX6: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[FADD]](s32), [[FADD1]](s32) ; GFX6: $vgpr0_vgpr1 = COPY [[BUILD_VECTOR]](<2 x s32>) ; GFX8-LABEL: name: test_intrinsic_round_v2s32 ; GFX8: [[COPY:%[0-9]+]]:_(<2 x s32>) = COPY $vgpr0_vgpr1 ; GFX8: [[UV:%[0-9]+]]:_(s32), [[UV1:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[COPY]](<2 x s32>) - ; GFX8: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[UV]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV]](s32), [[C]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV]](s32), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] + ; GFX8: [[FSUB:%[0-9]+]]:_(s32) = G_FSUB [[UV]], [[INTRINSIC_TRUNC]] + ; GFX8: [[FABS:%[0-9]+]]:_(s32) = G_FABS [[FSUB]] + ; GFX8: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX8: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX8: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX8: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] ; GFX8: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX8: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[UV1]] - ; GFX8: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV1]](s32), [[C]] - ; GFX8: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV1]](s32), [[INTRINSIC_TRUNC1]] - ; GFX8: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX8: [[SELECT1:%[0-9]+]]:_(s32) = G_SELECT [[AND1]](s1), [[C1]], [[C]] + ; GFX8: [[FSUB1:%[0-9]+]]:_(s32) = G_FSUB [[UV1]], [[INTRINSIC_TRUNC1]] + ; GFX8: [[FABS1:%[0-9]+]]:_(s32) = G_FABS [[FSUB1]] + ; GFX8: [[COPY2:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s32), [[C1]] + ; GFX8: [[SELECT1:%[0-9]+]]:_(s32) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C]] ; GFX8: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] ; GFX8: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[FADD]](s32), [[FADD1]](s32) ; GFX8: $vgpr0_vgpr1 = COPY [[BUILD_VECTOR]](<2 x s32>) ; GFX9-LABEL: name: test_intrinsic_round_v2s32 ; GFX9: [[COPY:%[0-9]+]]:_(<2 x s32>) = COPY $vgpr0_vgpr1 ; GFX9: [[UV:%[0-9]+]]:_(s32), [[UV1:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[COPY]](<2 x s32>) - ; GFX9: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[UV]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV]](s32), [[C]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV]](s32), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float -1.000000e+00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[AND]](s1), [[C1]], [[C]] + ; GFX9: [[FSUB:%[0-9]+]]:_(s32) = G_FSUB [[UV]], [[INTRINSIC_TRUNC]] + ; GFX9: [[FABS:%[0-9]+]]:_(s32) = G_FABS [[FSUB]] + ; GFX9: [[C:%[0-9]+]]:_(s32) = G_FCONSTANT float 0.000000e+00 + ; GFX9: [[C1:%[0-9]+]]:_(s32) = G_FCONSTANT float 5.000000e-01 + ; GFX9: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1065353216 + ; GFX9: [[COPY1:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s32), [[C1]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] ; GFX9: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX9: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[UV1]] - ; GFX9: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV1]](s32), [[C]] - ; GFX9: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV1]](s32), [[INTRINSIC_TRUNC1]] - ; GFX9: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX9: [[SELECT1:%[0-9]+]]:_(s32) = G_SELECT [[AND1]](s1), [[C1]], [[C]] + ; GFX9: [[FSUB1:%[0-9]+]]:_(s32) = G_FSUB [[UV1]], [[INTRINSIC_TRUNC1]] + ; GFX9: [[FABS1:%[0-9]+]]:_(s32) = G_FABS [[FSUB1]] + ; GFX9: [[COPY2:%[0-9]+]]:_(s32) = COPY [[C2]](s32) + ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s32), [[C1]] + ; GFX9: [[SELECT1:%[0-9]+]]:_(s32) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C]] ; GFX9: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] ; GFX9: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[FADD]](s32), [[FADD1]](s32) ; GFX9: $vgpr0_vgpr1 = COPY [[BUILD_VECTOR]](<2 x s32>) @@ -232,91 +262,106 @@ body: | ; GFX6-LABEL: name: test_intrinsic_round_v2s64 ; GFX6: [[COPY:%[0-9]+]]:_(<2 x s64>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3 ; GFX6: [[UV:%[0-9]+]]:_(s64), [[UV1:%[0-9]+]]:_(s64) = G_UNMERGE_VALUES [[COPY]](<2 x s64>) - ; GFX6: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 ; GFX6: [[UV2:%[0-9]+]]:_(s32), [[UV3:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[UV]](s64) - ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 20 - ; GFX6: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 11 - ; GFX6: [[INT:%[0-9]+]]:_(s32) = G_INTRINSIC intrinsic(@llvm.amdgcn.ubfe), [[C1]](s32), [[C2]](s32) - ; GFX6: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 1023 - ; GFX6: [[SUB:%[0-9]+]]:_(s32) = G_SUB [[INT]], [[C3]] - ; GFX6: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 -2147483648 - ; GFX6: [[AND:%[0-9]+]]:_(s32) = G_AND [[UV3]], [[C4]] - ; GFX6: [[C5:%[0-9]+]]:_(s64) = G_CONSTANT i64 4503599627370495 - ; GFX6: [[C6:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 - ; GFX6: [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[C6]](s32), [[AND]](s32) - ; GFX6: [[ASHR:%[0-9]+]]:_(s64) = G_ASHR [[C5]], [[SUB]](s32) - ; GFX6: [[C7:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1 - ; GFX6: [[XOR:%[0-9]+]]:_(s64) = G_XOR [[ASHR]], [[C7]] + ; GFX6: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 20 + ; GFX6: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 11 + ; GFX6: [[INT:%[0-9]+]]:_(s32) = G_INTRINSIC intrinsic(@llvm.amdgcn.ubfe), [[C]](s32), [[C1]](s32) + ; GFX6: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 1023 + ; GFX6: [[SUB:%[0-9]+]]:_(s32) = G_SUB [[INT]], [[C2]] + ; GFX6: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 -2147483648 + ; GFX6: [[AND:%[0-9]+]]:_(s32) = G_AND [[UV3]], [[C3]] + ; GFX6: [[C4:%[0-9]+]]:_(s64) = G_CONSTANT i64 4503599627370495 + ; GFX6: [[C5:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 + ; GFX6: [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[C5]](s32), [[AND]](s32) + ; GFX6: [[ASHR:%[0-9]+]]:_(s64) = G_ASHR [[C4]], [[SUB]](s32) + ; GFX6: [[C6:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1 + ; GFX6: [[XOR:%[0-9]+]]:_(s64) = G_XOR [[ASHR]], [[C6]] ; GFX6: [[AND1:%[0-9]+]]:_(s64) = G_AND [[UV]], [[XOR]] - ; GFX6: [[C8:%[0-9]+]]:_(s32) = G_CONSTANT i32 51 - ; GFX6: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[SUB]](s32), [[C6]] - ; GFX6: [[ICMP1:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[SUB]](s32), [[C8]] + ; GFX6: [[C7:%[0-9]+]]:_(s32) = G_CONSTANT i32 51 + ; GFX6: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[SUB]](s32), [[C5]] + ; GFX6: [[ICMP1:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[SUB]](s32), [[C7]] ; GFX6: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[ICMP]](s1), [[MV]], [[AND1]] ; GFX6: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[ICMP1]](s1), [[UV]], [[SELECT]] ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[UV]] - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV]](s64), [[C]] - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV]](s64), [[INTRINSIC_TRUNC]] - ; GFX6: [[AND2:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C9:%[0-9]+]]:_(s64) = G_FCONSTANT double -1.000000e+00 - ; GFX6: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[AND2]](s1), [[C9]], [[C]] - ; GFX6: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT1]] + ; GFX6: [[FNEG:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX6: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[UV]], [[FNEG]] + ; GFX6: [[FABS:%[0-9]+]]:_(s64) = G_FABS [[FADD]] + ; GFX6: [[C8:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 + ; GFX6: [[C9:%[0-9]+]]:_(s64) = G_FCONSTANT double 5.000000e-01 + ; GFX6: [[C10:%[0-9]+]]:_(s64) = G_CONSTANT i64 4607182418800017408 + ; GFX6: [[COPY1:%[0-9]+]]:_(s64) = COPY [[C10]](s64) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s64), [[C9]] + ; GFX6: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C8]] + ; GFX6: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT1]] ; GFX6: [[UV4:%[0-9]+]]:_(s32), [[UV5:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[UV1]](s64) - ; GFX6: [[INT1:%[0-9]+]]:_(s32) = G_INTRINSIC intrinsic(@llvm.amdgcn.ubfe), [[C1]](s32), [[C2]](s32) - ; GFX6: [[SUB1:%[0-9]+]]:_(s32) = G_SUB [[INT1]], [[C3]] - ; GFX6: [[AND3:%[0-9]+]]:_(s32) = G_AND [[UV5]], [[C4]] - ; GFX6: [[MV1:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[C6]](s32), [[AND3]](s32) - ; GFX6: [[ASHR1:%[0-9]+]]:_(s64) = G_ASHR [[C5]], [[SUB1]](s32) - ; GFX6: [[XOR1:%[0-9]+]]:_(s64) = G_XOR [[ASHR1]], [[C7]] - ; GFX6: [[AND4:%[0-9]+]]:_(s64) = G_AND [[UV1]], [[XOR1]] - ; GFX6: [[ICMP2:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[SUB1]](s32), [[C6]] - ; GFX6: [[ICMP3:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[SUB1]](s32), [[C8]] - ; GFX6: [[SELECT2:%[0-9]+]]:_(s64) = G_SELECT [[ICMP2]](s1), [[MV1]], [[AND4]] + ; GFX6: [[INT1:%[0-9]+]]:_(s32) = G_INTRINSIC intrinsic(@llvm.amdgcn.ubfe), [[C]](s32), [[C1]](s32) + ; GFX6: [[SUB1:%[0-9]+]]:_(s32) = G_SUB [[INT1]], [[C2]] + ; GFX6: [[AND2:%[0-9]+]]:_(s32) = G_AND [[UV5]], [[C3]] + ; GFX6: [[MV1:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[C5]](s32), [[AND2]](s32) + ; GFX6: [[ASHR1:%[0-9]+]]:_(s64) = G_ASHR [[C4]], [[SUB1]](s32) + ; GFX6: [[XOR1:%[0-9]+]]:_(s64) = G_XOR [[ASHR1]], [[C6]] + ; GFX6: [[AND3:%[0-9]+]]:_(s64) = G_AND [[UV1]], [[XOR1]] + ; GFX6: [[ICMP2:%[0-9]+]]:_(s1) = G_ICMP intpred(slt), [[SUB1]](s32), [[C5]] + ; GFX6: [[ICMP3:%[0-9]+]]:_(s1) = G_ICMP intpred(sgt), [[SUB1]](s32), [[C7]] + ; GFX6: [[SELECT2:%[0-9]+]]:_(s64) = G_SELECT [[ICMP2]](s1), [[MV1]], [[AND3]] ; GFX6: [[SELECT3:%[0-9]+]]:_(s64) = G_SELECT [[ICMP3]](s1), [[UV1]], [[SELECT2]] ; GFX6: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[UV1]] - ; GFX6: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV1]](s64), [[C]] - ; GFX6: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV1]](s64), [[INTRINSIC_TRUNC1]] - ; GFX6: [[AND5:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX6: [[SELECT3:%[0-9]+]]:_(s64) = G_SELECT [[AND5]](s1), [[C9]], [[C]] - ; GFX6: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT3]] - ; GFX6: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[FADD]](s64), [[FADD1]](s64) + ; GFX6: [[FNEG1:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX6: [[FADD2:%[0-9]+]]:_(s64) = G_FADD [[UV1]], [[FNEG1]] + ; GFX6: [[FABS1:%[0-9]+]]:_(s64) = G_FABS [[FADD2]] + ; GFX6: [[COPY2:%[0-9]+]]:_(s64) = COPY [[C10]](s64) + ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s64), [[C9]] + ; GFX6: [[SELECT3:%[0-9]+]]:_(s64) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C8]] + ; GFX6: [[FADD3:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT3]] + ; GFX6: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[FADD1]](s64), [[FADD3]](s64) ; GFX6: $vgpr0_vgpr1_vgpr2_vgpr3 = COPY [[BUILD_VECTOR]](<2 x s64>) ; GFX8-LABEL: name: test_intrinsic_round_v2s64 ; GFX8: [[COPY:%[0-9]+]]:_(<2 x s64>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3 ; GFX8: [[UV:%[0-9]+]]:_(s64), [[UV1:%[0-9]+]]:_(s64) = G_UNMERGE_VALUES [[COPY]](<2 x s64>) - ; GFX8: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[UV]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV]](s64), [[C]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV]](s64), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double -1.000000e+00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX8: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX8: [[FNEG:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX8: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[UV]], [[FNEG]] + ; GFX8: [[FABS:%[0-9]+]]:_(s64) = G_FABS [[FADD]] + ; GFX8: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 + ; GFX8: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double 5.000000e-01 + ; GFX8: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 4607182418800017408 + ; GFX8: [[COPY1:%[0-9]+]]:_(s64) = COPY [[C2]](s64) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s64), [[C1]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX8: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX8: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[UV1]] - ; GFX8: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV1]](s64), [[C]] - ; GFX8: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV1]](s64), [[INTRINSIC_TRUNC1]] - ; GFX8: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX8: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[AND1]](s1), [[C1]], [[C]] - ; GFX8: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] - ; GFX8: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[FADD]](s64), [[FADD1]](s64) + ; GFX8: [[FNEG1:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX8: [[FADD2:%[0-9]+]]:_(s64) = G_FADD [[UV1]], [[FNEG1]] + ; GFX8: [[FABS1:%[0-9]+]]:_(s64) = G_FABS [[FADD2]] + ; GFX8: [[COPY2:%[0-9]+]]:_(s64) = COPY [[C2]](s64) + ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s64), [[C1]] + ; GFX8: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C]] + ; GFX8: [[FADD3:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] + ; GFX8: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[FADD1]](s64), [[FADD3]](s64) ; GFX8: $vgpr0_vgpr1_vgpr2_vgpr3 = COPY [[BUILD_VECTOR]](<2 x s64>) ; GFX9-LABEL: name: test_intrinsic_round_v2s64 ; GFX9: [[COPY:%[0-9]+]]:_(<2 x s64>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3 ; GFX9: [[UV:%[0-9]+]]:_(s64), [[UV1:%[0-9]+]]:_(s64) = G_UNMERGE_VALUES [[COPY]](<2 x s64>) - ; GFX9: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[UV]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV]](s64), [[C]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV]](s64), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double -1.000000e+00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX9: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX9: [[FNEG:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX9: [[FADD:%[0-9]+]]:_(s64) = G_FADD [[UV]], [[FNEG]] + ; GFX9: [[FABS:%[0-9]+]]:_(s64) = G_FABS [[FADD]] + ; GFX9: [[C:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 + ; GFX9: [[C1:%[0-9]+]]:_(s64) = G_FCONSTANT double 5.000000e-01 + ; GFX9: [[C2:%[0-9]+]]:_(s64) = G_CONSTANT i64 4607182418800017408 + ; GFX9: [[COPY1:%[0-9]+]]:_(s64) = COPY [[C2]](s64) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s64), [[C1]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s64) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX9: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX9: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s64) = G_INTRINSIC_TRUNC [[UV1]] - ; GFX9: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[UV1]](s64), [[C]] - ; GFX9: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[UV1]](s64), [[INTRINSIC_TRUNC1]] - ; GFX9: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX9: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[AND1]](s1), [[C1]], [[C]] - ; GFX9: [[FADD1:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] - ; GFX9: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[FADD]](s64), [[FADD1]](s64) + ; GFX9: [[FNEG1:%[0-9]+]]:_(s64) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX9: [[FADD2:%[0-9]+]]:_(s64) = G_FADD [[UV1]], [[FNEG1]] + ; GFX9: [[FABS1:%[0-9]+]]:_(s64) = G_FABS [[FADD2]] + ; GFX9: [[COPY2:%[0-9]+]]:_(s64) = COPY [[C2]](s64) + ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s64), [[C1]] + ; GFX9: [[SELECT1:%[0-9]+]]:_(s64) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C]] + ; GFX9: [[FADD3:%[0-9]+]]:_(s64) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] + ; GFX9: [[BUILD_VECTOR:%[0-9]+]]:_(<2 x s64>) = G_BUILD_VECTOR [[FADD1]](s64), [[FADD3]](s64) ; GFX9: $vgpr0_vgpr1_vgpr2_vgpr3 = COPY [[BUILD_VECTOR]](<2 x s64>) %0:_(<2 x s64>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3 %1:_(<2 x s64>) = G_INTRINSIC_ROUND %0 @@ -332,50 +377,60 @@ body: | ; GFX6-LABEL: name: test_intrinsic_round_s16 ; GFX6: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 ; GFX6: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s32) - ; GFX6: [[C:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX6: [[FPEXT:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT]] ; GFX6: [[FPTRUNC:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC]](s32) + ; GFX6: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC]] ; GFX6: [[FPEXT1:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) - ; GFX6: [[FPEXT2:%[0-9]+]]:_(s32) = G_FPEXT [[C]](s16) - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT1]](s32), [[FPEXT2]] - ; GFX6: [[FPEXT3:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) - ; GFX6: [[FPEXT4:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC]](s16) - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT3]](s32), [[FPEXT4]] - ; GFX6: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX6: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C1]], [[C]] + ; GFX6: [[FPEXT2:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG]](s16) + ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[FPEXT1]], [[FPEXT2]] + ; GFX6: [[FPTRUNC1:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD]](s32) + ; GFX6: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC1]] + ; GFX6: [[C:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX6: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX6: [[C2:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX6: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C2]](s16) + ; GFX6: [[FPEXT3:%[0-9]+]]:_(s32) = G_FPEXT [[FABS]](s16) + ; GFX6: [[FPEXT4:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT3]](s32), [[FPEXT4]] + ; GFX6: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] ; GFX6: [[FPEXT5:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC]](s16) ; GFX6: [[FPEXT6:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT]](s16) - ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[FPEXT5]], [[FPEXT6]] - ; GFX6: [[FPTRUNC1:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD]](s32) - ; GFX6: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FPTRUNC1]](s16) + ; GFX6: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[FPEXT5]], [[FPEXT6]] + ; GFX6: [[FPTRUNC2:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD1]](s32) + ; GFX6: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FPTRUNC2]](s16) ; GFX6: $vgpr0 = COPY [[ANYEXT]](s32) ; GFX8-LABEL: name: test_intrinsic_round_s16 ; GFX8: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 ; GFX8: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s32) - ; GFX8: [[C:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC]](s16), [[C]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC]](s16), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX8: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] - ; GFX8: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD]](s16) + ; GFX8: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX8: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[TRUNC]], [[FNEG]] + ; GFX8: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FADD]] + ; GFX8: [[C:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX8: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX8: [[C2:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX8: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C2]](s16) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s16), [[C1]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX8: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX8: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD1]](s16) ; GFX8: $vgpr0 = COPY [[ANYEXT]](s32) ; GFX9-LABEL: name: test_intrinsic_round_s16 ; GFX9: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 ; GFX9: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s32) - ; GFX9: [[C:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC]](s16), [[C]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC]](s16), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C1]], [[C]] - ; GFX9: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] - ; GFX9: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD]](s16) + ; GFX9: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX9: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[TRUNC]], [[FNEG]] + ; GFX9: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FADD]] + ; GFX9: [[C:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX9: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX9: [[C2:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX9: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C2]](s16) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s16), [[C1]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C]] + ; GFX9: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX9: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD1]](s16) ; GFX9: $vgpr0 = COPY [[ANYEXT]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s16) = G_TRUNC %0 @@ -397,40 +452,47 @@ body: | ; GFX6: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 16 ; GFX6: [[LSHR:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST]], [[C]](s32) ; GFX6: [[TRUNC1:%[0-9]+]]:_(s16) = G_TRUNC [[LSHR]](s32) - ; GFX6: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX6: [[FPEXT:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT]] ; GFX6: [[FPTRUNC:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC]](s32) + ; GFX6: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC]] ; GFX6: [[FPEXT1:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) - ; GFX6: [[FPEXT2:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT1]](s32), [[FPEXT2]] - ; GFX6: [[FPEXT3:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) - ; GFX6: [[FPEXT4:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC]](s16) - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT3]](s32), [[FPEXT4]] - ; GFX6: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX6: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] + ; GFX6: [[FPEXT2:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG]](s16) + ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[FPEXT1]], [[FPEXT2]] + ; GFX6: [[FPTRUNC1:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD]](s32) + ; GFX6: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC1]] + ; GFX6: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX6: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX6: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX6: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT3:%[0-9]+]]:_(s32) = G_FPEXT [[FABS]](s16) + ; GFX6: [[FPEXT4:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT3]](s32), [[FPEXT4]] + ; GFX6: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] ; GFX6: [[FPEXT5:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC]](s16) ; GFX6: [[FPEXT6:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT]](s16) - ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[FPEXT5]], [[FPEXT6]] - ; GFX6: [[FPTRUNC1:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD]](s32) + ; GFX6: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[FPEXT5]], [[FPEXT6]] + ; GFX6: [[FPTRUNC2:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD1]](s32) ; GFX6: [[FPEXT7:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) ; GFX6: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT7]] - ; GFX6: [[FPTRUNC2:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC1]](s32) + ; GFX6: [[FPTRUNC3:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC1]](s32) + ; GFX6: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC3]] ; GFX6: [[FPEXT8:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) - ; GFX6: [[FPEXT9:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT8]](s32), [[FPEXT9]] - ; GFX6: [[FPEXT10:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) - ; GFX6: [[FPEXT11:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC2]](s16) - ; GFX6: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT10]](s32), [[FPEXT11]] - ; GFX6: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX6: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX6: [[FPEXT12:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC2]](s16) + ; GFX6: [[FPEXT9:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG1]](s16) + ; GFX6: [[FADD2:%[0-9]+]]:_(s32) = G_FADD [[FPEXT8]], [[FPEXT9]] + ; GFX6: [[FPTRUNC4:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD2]](s32) + ; GFX6: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC4]] + ; GFX6: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT10:%[0-9]+]]:_(s32) = G_FPEXT [[FABS1]](s16) + ; GFX6: [[FPEXT11:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT10]](s32), [[FPEXT11]] + ; GFX6: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX6: [[FPEXT12:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC3]](s16) ; GFX6: [[FPEXT13:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT1]](s16) - ; GFX6: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[FPEXT12]], [[FPEXT13]] - ; GFX6: [[FPTRUNC3:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD1]](s32) - ; GFX6: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC1]](s16) - ; GFX6: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC3]](s16) + ; GFX6: [[FADD3:%[0-9]+]]:_(s32) = G_FADD [[FPEXT12]], [[FPEXT13]] + ; GFX6: [[FPTRUNC5:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD3]](s32) + ; GFX6: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC2]](s16) + ; GFX6: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC5]](s16) ; GFX6: [[SHL:%[0-9]+]]:_(s32) = G_SHL [[ZEXT1]], [[C]](s32) ; GFX6: [[OR:%[0-9]+]]:_(s32) = G_OR [[ZEXT]], [[SHL]] ; GFX6: [[BITCAST1:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR]](s32) @@ -442,22 +504,27 @@ body: | ; GFX8: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 16 ; GFX8: [[LSHR:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST]], [[C]](s32) ; GFX8: [[TRUNC1:%[0-9]+]]:_(s16) = G_TRUNC [[LSHR]](s32) - ; GFX8: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC]](s16), [[C1]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC]](s16), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX8: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX8: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[TRUNC]], [[FNEG]] + ; GFX8: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FADD]] + ; GFX8: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX8: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX8: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX8: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s16), [[C2]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] + ; GFX8: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX8: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC1]] - ; GFX8: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC1]](s16), [[C1]] - ; GFX8: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC1]](s16), [[INTRINSIC_TRUNC1]] - ; GFX8: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX8: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] - ; GFX8: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FADD]](s16) - ; GFX8: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FADD1]](s16) + ; GFX8: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX8: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[TRUNC1]], [[FNEG1]] + ; GFX8: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FADD2]] + ; GFX8: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s16), [[C2]] + ; GFX8: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX8: [[FADD3:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] + ; GFX8: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FADD1]](s16) + ; GFX8: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FADD3]](s16) ; GFX8: [[SHL:%[0-9]+]]:_(s32) = G_SHL [[ZEXT1]], [[C]](s32) ; GFX8: [[OR:%[0-9]+]]:_(s32) = G_OR [[ZEXT]], [[SHL]] ; GFX8: [[BITCAST1:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR]](s32) @@ -469,22 +536,27 @@ body: | ; GFX9: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 16 ; GFX9: [[LSHR:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST]], [[C]](s32) ; GFX9: [[TRUNC1:%[0-9]+]]:_(s16) = G_TRUNC [[LSHR]](s32) - ; GFX9: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC]](s16), [[C1]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC]](s16), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX9: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX9: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[TRUNC]], [[FNEG]] + ; GFX9: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FADD]] + ; GFX9: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX9: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX9: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX9: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s16), [[C2]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] + ; GFX9: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX9: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC1]] - ; GFX9: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC1]](s16), [[C1]] - ; GFX9: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC1]](s16), [[INTRINSIC_TRUNC1]] - ; GFX9: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX9: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] - ; GFX9: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD]](s16) - ; GFX9: [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD1]](s16) + ; GFX9: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX9: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[TRUNC1]], [[FNEG1]] + ; GFX9: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FADD2]] + ; GFX9: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s16), [[C2]] + ; GFX9: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX9: [[FADD3:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] + ; GFX9: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD1]](s16) + ; GFX9: [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD3]](s16) ; GFX9: [[BUILD_VECTOR_TRUNC:%[0-9]+]]:_(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[ANYEXT]](s32), [[ANYEXT1]](s32) ; GFX9: $vgpr0 = COPY [[BUILD_VECTOR_TRUNC]](<2 x s16>) %0:_(<2 x s16>) = COPY $vgpr0 @@ -512,61 +584,71 @@ body: | ; GFX6: [[BITCAST1:%[0-9]+]]:_(s32) = G_BITCAST [[UV1]](<2 x s16>) ; GFX6: [[TRUNC2:%[0-9]+]]:_(s16) = G_TRUNC [[BITCAST1]](s32) ; GFX6: [[LSHR1:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST1]], [[C]](s32) - ; GFX6: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX6: [[FPEXT:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT]] ; GFX6: [[FPTRUNC:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC]](s32) + ; GFX6: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC]] ; GFX6: [[FPEXT1:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) - ; GFX6: [[FPEXT2:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT1]](s32), [[FPEXT2]] - ; GFX6: [[FPEXT3:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) - ; GFX6: [[FPEXT4:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC]](s16) - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT3]](s32), [[FPEXT4]] - ; GFX6: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX6: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] + ; GFX6: [[FPEXT2:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG]](s16) + ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[FPEXT1]], [[FPEXT2]] + ; GFX6: [[FPTRUNC1:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD]](s32) + ; GFX6: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC1]] + ; GFX6: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX6: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX6: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX6: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT3:%[0-9]+]]:_(s32) = G_FPEXT [[FABS]](s16) + ; GFX6: [[FPEXT4:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT3]](s32), [[FPEXT4]] + ; GFX6: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] ; GFX6: [[FPEXT5:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC]](s16) ; GFX6: [[FPEXT6:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT]](s16) - ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[FPEXT5]], [[FPEXT6]] - ; GFX6: [[FPTRUNC1:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD]](s32) + ; GFX6: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[FPEXT5]], [[FPEXT6]] + ; GFX6: [[FPTRUNC2:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD1]](s32) ; GFX6: [[FPEXT7:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) ; GFX6: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT7]] - ; GFX6: [[FPTRUNC2:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC1]](s32) + ; GFX6: [[FPTRUNC3:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC1]](s32) + ; GFX6: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC3]] ; GFX6: [[FPEXT8:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) - ; GFX6: [[FPEXT9:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT8]](s32), [[FPEXT9]] - ; GFX6: [[FPEXT10:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) - ; GFX6: [[FPEXT11:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC2]](s16) - ; GFX6: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT10]](s32), [[FPEXT11]] - ; GFX6: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX6: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX6: [[FPEXT12:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC2]](s16) + ; GFX6: [[FPEXT9:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG1]](s16) + ; GFX6: [[FADD2:%[0-9]+]]:_(s32) = G_FADD [[FPEXT8]], [[FPEXT9]] + ; GFX6: [[FPTRUNC4:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD2]](s32) + ; GFX6: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC4]] + ; GFX6: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT10:%[0-9]+]]:_(s32) = G_FPEXT [[FABS1]](s16) + ; GFX6: [[FPEXT11:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT10]](s32), [[FPEXT11]] + ; GFX6: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX6: [[FPEXT12:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC3]](s16) ; GFX6: [[FPEXT13:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT1]](s16) - ; GFX6: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[FPEXT12]], [[FPEXT13]] - ; GFX6: [[FPTRUNC3:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD1]](s32) + ; GFX6: [[FADD3:%[0-9]+]]:_(s32) = G_FADD [[FPEXT12]], [[FPEXT13]] + ; GFX6: [[FPTRUNC5:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD3]](s32) ; GFX6: [[FPEXT14:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC2]](s16) ; GFX6: [[INTRINSIC_TRUNC2:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT14]] - ; GFX6: [[FPTRUNC4:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC2]](s32) + ; GFX6: [[FPTRUNC6:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC2]](s32) + ; GFX6: [[FNEG2:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC6]] ; GFX6: [[FPEXT15:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC2]](s16) - ; GFX6: [[FPEXT16:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP4:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT15]](s32), [[FPEXT16]] - ; GFX6: [[FPEXT17:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC2]](s16) - ; GFX6: [[FPEXT18:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC4]](s16) - ; GFX6: [[FCMP5:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT17]](s32), [[FPEXT18]] - ; GFX6: [[AND2:%[0-9]+]]:_(s1) = G_AND [[FCMP4]], [[FCMP5]] - ; GFX6: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[AND2]](s1), [[C2]], [[C1]] - ; GFX6: [[FPEXT19:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC4]](s16) + ; GFX6: [[FPEXT16:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG2]](s16) + ; GFX6: [[FADD4:%[0-9]+]]:_(s32) = G_FADD [[FPEXT15]], [[FPEXT16]] + ; GFX6: [[FPTRUNC7:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD4]](s32) + ; GFX6: [[FABS2:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC7]] + ; GFX6: [[COPY3:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT17:%[0-9]+]]:_(s32) = G_FPEXT [[FABS2]](s16) + ; GFX6: [[FPEXT18:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT17]](s32), [[FPEXT18]] + ; GFX6: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[FCMP2]](s1), [[COPY3]], [[C1]] + ; GFX6: [[FPEXT19:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC6]](s16) ; GFX6: [[FPEXT20:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT2]](s16) - ; GFX6: [[FADD2:%[0-9]+]]:_(s32) = G_FADD [[FPEXT19]], [[FPEXT20]] - ; GFX6: [[FPTRUNC5:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD2]](s32) - ; GFX6: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC1]](s16) - ; GFX6: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC3]](s16) + ; GFX6: [[FADD5:%[0-9]+]]:_(s32) = G_FADD [[FPEXT19]], [[FPEXT20]] + ; GFX6: [[FPTRUNC8:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD5]](s32) + ; GFX6: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC2]](s16) + ; GFX6: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC5]](s16) ; GFX6: [[SHL:%[0-9]+]]:_(s32) = G_SHL [[ZEXT1]], [[C]](s32) ; GFX6: [[OR:%[0-9]+]]:_(s32) = G_OR [[ZEXT]], [[SHL]] ; GFX6: [[BITCAST2:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR]](s32) - ; GFX6: [[ZEXT2:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC5]](s16) - ; GFX6: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 - ; GFX6: [[SHL1:%[0-9]+]]:_(s32) = G_SHL [[C3]], [[C]](s32) + ; GFX6: [[ZEXT2:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC8]](s16) + ; GFX6: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 + ; GFX6: [[SHL1:%[0-9]+]]:_(s32) = G_SHL [[C4]], [[C]](s32) ; GFX6: [[OR1:%[0-9]+]]:_(s32) = G_OR [[ZEXT2]], [[SHL1]] ; GFX6: [[BITCAST3:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR1]](s32) ; GFX6: [[CONCAT_VECTORS:%[0-9]+]]:_(<4 x s16>) = G_CONCAT_VECTORS [[BITCAST2]](<2 x s16>), [[BITCAST3]](<2 x s16>) @@ -587,34 +669,41 @@ body: | ; GFX8: [[BITCAST1:%[0-9]+]]:_(s32) = G_BITCAST [[UV1]](<2 x s16>) ; GFX8: [[TRUNC2:%[0-9]+]]:_(s16) = G_TRUNC [[BITCAST1]](s32) ; GFX8: [[LSHR1:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST1]], [[C]](s32) - ; GFX8: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC]](s16), [[C1]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC]](s16), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX8: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX8: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[TRUNC]], [[FNEG]] + ; GFX8: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FADD]] + ; GFX8: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX8: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX8: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX8: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s16), [[C2]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] + ; GFX8: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX8: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC1]] - ; GFX8: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC1]](s16), [[C1]] - ; GFX8: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC1]](s16), [[INTRINSIC_TRUNC1]] - ; GFX8: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX8: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] + ; GFX8: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX8: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[TRUNC1]], [[FNEG1]] + ; GFX8: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FADD2]] + ; GFX8: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s16), [[C2]] + ; GFX8: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX8: [[FADD3:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] ; GFX8: [[INTRINSIC_TRUNC2:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC2]] - ; GFX8: [[FCMP4:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC2]](s16), [[C1]] - ; GFX8: [[FCMP5:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC2]](s16), [[INTRINSIC_TRUNC2]] - ; GFX8: [[AND2:%[0-9]+]]:_(s1) = G_AND [[FCMP4]], [[FCMP5]] - ; GFX8: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[AND2]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC2]], [[SELECT2]] - ; GFX8: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FADD]](s16) - ; GFX8: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FADD1]](s16) + ; GFX8: [[FNEG2:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC2]] + ; GFX8: [[FADD4:%[0-9]+]]:_(s16) = G_FADD [[TRUNC2]], [[FNEG2]] + ; GFX8: [[FABS2:%[0-9]+]]:_(s16) = G_FABS [[FADD4]] + ; GFX8: [[COPY3:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS2]](s16), [[C2]] + ; GFX8: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[FCMP2]](s1), [[COPY3]], [[C1]] + ; GFX8: [[FADD5:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC2]], [[SELECT2]] + ; GFX8: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FADD1]](s16) + ; GFX8: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FADD3]](s16) ; GFX8: [[SHL:%[0-9]+]]:_(s32) = G_SHL [[ZEXT1]], [[C]](s32) ; GFX8: [[OR:%[0-9]+]]:_(s32) = G_OR [[ZEXT]], [[SHL]] ; GFX8: [[BITCAST2:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR]](s32) - ; GFX8: [[ZEXT2:%[0-9]+]]:_(s32) = G_ZEXT [[FADD2]](s16) - ; GFX8: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 - ; GFX8: [[SHL1:%[0-9]+]]:_(s32) = G_SHL [[C3]], [[C]](s32) + ; GFX8: [[ZEXT2:%[0-9]+]]:_(s32) = G_ZEXT [[FADD5]](s16) + ; GFX8: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 + ; GFX8: [[SHL1:%[0-9]+]]:_(s32) = G_SHL [[C4]], [[C]](s32) ; GFX8: [[OR1:%[0-9]+]]:_(s32) = G_OR [[ZEXT2]], [[SHL1]] ; GFX8: [[BITCAST3:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR1]](s32) ; GFX8: [[CONCAT_VECTORS:%[0-9]+]]:_(<4 x s16>) = G_CONCAT_VECTORS [[BITCAST2]](<2 x s16>), [[BITCAST3]](<2 x s16>) @@ -635,30 +724,37 @@ body: | ; GFX9: [[BITCAST1:%[0-9]+]]:_(s32) = G_BITCAST [[UV1]](<2 x s16>) ; GFX9: [[TRUNC2:%[0-9]+]]:_(s16) = G_TRUNC [[BITCAST1]](s32) ; GFX9: [[LSHR1:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST1]], [[C]](s32) - ; GFX9: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC]](s16), [[C1]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC]](s16), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX9: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX9: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[TRUNC]], [[FNEG]] + ; GFX9: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FADD]] + ; GFX9: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX9: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX9: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX9: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s16), [[C2]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] + ; GFX9: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX9: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC1]] - ; GFX9: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC1]](s16), [[C1]] - ; GFX9: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC1]](s16), [[INTRINSIC_TRUNC1]] - ; GFX9: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX9: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] + ; GFX9: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX9: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[TRUNC1]], [[FNEG1]] + ; GFX9: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FADD2]] + ; GFX9: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s16), [[C2]] + ; GFX9: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX9: [[FADD3:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] ; GFX9: [[INTRINSIC_TRUNC2:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC2]] - ; GFX9: [[FCMP4:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC2]](s16), [[C1]] - ; GFX9: [[FCMP5:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC2]](s16), [[INTRINSIC_TRUNC2]] - ; GFX9: [[AND2:%[0-9]+]]:_(s1) = G_AND [[FCMP4]], [[FCMP5]] - ; GFX9: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[AND2]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC2]], [[SELECT2]] - ; GFX9: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD]](s16) - ; GFX9: [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD1]](s16) + ; GFX9: [[FNEG2:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC2]] + ; GFX9: [[FADD4:%[0-9]+]]:_(s16) = G_FADD [[TRUNC2]], [[FNEG2]] + ; GFX9: [[FABS2:%[0-9]+]]:_(s16) = G_FABS [[FADD4]] + ; GFX9: [[COPY3:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS2]](s16), [[C2]] + ; GFX9: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[FCMP2]](s1), [[COPY3]], [[C1]] + ; GFX9: [[FADD5:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC2]], [[SELECT2]] + ; GFX9: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD1]](s16) + ; GFX9: [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD3]](s16) ; GFX9: [[BUILD_VECTOR_TRUNC:%[0-9]+]]:_(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[ANYEXT]](s32), [[ANYEXT1]](s32) - ; GFX9: [[ANYEXT2:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD2]](s16) + ; GFX9: [[ANYEXT2:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD5]](s16) ; GFX9: [[DEF1:%[0-9]+]]:_(s32) = G_IMPLICIT_DEF ; GFX9: [[BUILD_VECTOR_TRUNC1:%[0-9]+]]:_(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[ANYEXT2]](s32), [[DEF1]](s32) ; GFX9: [[CONCAT_VECTORS:%[0-9]+]]:_(<4 x s16>) = G_CONCAT_VECTORS [[BUILD_VECTOR_TRUNC]](<2 x s16>), [[BUILD_VECTOR_TRUNC1]](<2 x s16>) @@ -691,75 +787,88 @@ body: | ; GFX6: [[TRUNC2:%[0-9]+]]:_(s16) = G_TRUNC [[BITCAST1]](s32) ; GFX6: [[LSHR1:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST1]], [[C]](s32) ; GFX6: [[TRUNC3:%[0-9]+]]:_(s16) = G_TRUNC [[LSHR1]](s32) - ; GFX6: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX6: [[FPEXT:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) ; GFX6: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT]] ; GFX6: [[FPTRUNC:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC]](s32) + ; GFX6: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC]] ; GFX6: [[FPEXT1:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) - ; GFX6: [[FPEXT2:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT1]](s32), [[FPEXT2]] - ; GFX6: [[FPEXT3:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC]](s16) - ; GFX6: [[FPEXT4:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC]](s16) - ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT3]](s32), [[FPEXT4]] - ; GFX6: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX6: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX6: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] + ; GFX6: [[FPEXT2:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG]](s16) + ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[FPEXT1]], [[FPEXT2]] + ; GFX6: [[FPTRUNC1:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD]](s32) + ; GFX6: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC1]] + ; GFX6: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX6: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX6: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX6: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT3:%[0-9]+]]:_(s32) = G_FPEXT [[FABS]](s16) + ; GFX6: [[FPEXT4:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT3]](s32), [[FPEXT4]] + ; GFX6: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] ; GFX6: [[FPEXT5:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC]](s16) ; GFX6: [[FPEXT6:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT]](s16) - ; GFX6: [[FADD:%[0-9]+]]:_(s32) = G_FADD [[FPEXT5]], [[FPEXT6]] - ; GFX6: [[FPTRUNC1:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD]](s32) + ; GFX6: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[FPEXT5]], [[FPEXT6]] + ; GFX6: [[FPTRUNC2:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD1]](s32) ; GFX6: [[FPEXT7:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) ; GFX6: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT7]] - ; GFX6: [[FPTRUNC2:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC1]](s32) + ; GFX6: [[FPTRUNC3:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC1]](s32) + ; GFX6: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC3]] ; GFX6: [[FPEXT8:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) - ; GFX6: [[FPEXT9:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT8]](s32), [[FPEXT9]] - ; GFX6: [[FPEXT10:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC1]](s16) - ; GFX6: [[FPEXT11:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC2]](s16) - ; GFX6: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT10]](s32), [[FPEXT11]] - ; GFX6: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX6: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX6: [[FPEXT12:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC2]](s16) + ; GFX6: [[FPEXT9:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG1]](s16) + ; GFX6: [[FADD2:%[0-9]+]]:_(s32) = G_FADD [[FPEXT8]], [[FPEXT9]] + ; GFX6: [[FPTRUNC4:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD2]](s32) + ; GFX6: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC4]] + ; GFX6: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT10:%[0-9]+]]:_(s32) = G_FPEXT [[FABS1]](s16) + ; GFX6: [[FPEXT11:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT10]](s32), [[FPEXT11]] + ; GFX6: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX6: [[FPEXT12:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC3]](s16) ; GFX6: [[FPEXT13:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT1]](s16) - ; GFX6: [[FADD1:%[0-9]+]]:_(s32) = G_FADD [[FPEXT12]], [[FPEXT13]] - ; GFX6: [[FPTRUNC3:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD1]](s32) + ; GFX6: [[FADD3:%[0-9]+]]:_(s32) = G_FADD [[FPEXT12]], [[FPEXT13]] + ; GFX6: [[FPTRUNC5:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD3]](s32) ; GFX6: [[FPEXT14:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC2]](s16) ; GFX6: [[INTRINSIC_TRUNC2:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT14]] - ; GFX6: [[FPTRUNC4:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC2]](s32) + ; GFX6: [[FPTRUNC6:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC2]](s32) + ; GFX6: [[FNEG2:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC6]] ; GFX6: [[FPEXT15:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC2]](s16) - ; GFX6: [[FPEXT16:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP4:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT15]](s32), [[FPEXT16]] - ; GFX6: [[FPEXT17:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC2]](s16) - ; GFX6: [[FPEXT18:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC4]](s16) - ; GFX6: [[FCMP5:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT17]](s32), [[FPEXT18]] - ; GFX6: [[AND2:%[0-9]+]]:_(s1) = G_AND [[FCMP4]], [[FCMP5]] - ; GFX6: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[AND2]](s1), [[C2]], [[C1]] - ; GFX6: [[FPEXT19:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC4]](s16) + ; GFX6: [[FPEXT16:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG2]](s16) + ; GFX6: [[FADD4:%[0-9]+]]:_(s32) = G_FADD [[FPEXT15]], [[FPEXT16]] + ; GFX6: [[FPTRUNC7:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD4]](s32) + ; GFX6: [[FABS2:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC7]] + ; GFX6: [[COPY3:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT17:%[0-9]+]]:_(s32) = G_FPEXT [[FABS2]](s16) + ; GFX6: [[FPEXT18:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT17]](s32), [[FPEXT18]] + ; GFX6: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[FCMP2]](s1), [[COPY3]], [[C1]] + ; GFX6: [[FPEXT19:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC6]](s16) ; GFX6: [[FPEXT20:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT2]](s16) - ; GFX6: [[FADD2:%[0-9]+]]:_(s32) = G_FADD [[FPEXT19]], [[FPEXT20]] - ; GFX6: [[FPTRUNC5:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD2]](s32) + ; GFX6: [[FADD5:%[0-9]+]]:_(s32) = G_FADD [[FPEXT19]], [[FPEXT20]] + ; GFX6: [[FPTRUNC8:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD5]](s32) ; GFX6: [[FPEXT21:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC3]](s16) ; GFX6: [[INTRINSIC_TRUNC3:%[0-9]+]]:_(s32) = G_INTRINSIC_TRUNC [[FPEXT21]] - ; GFX6: [[FPTRUNC6:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC3]](s32) + ; GFX6: [[FPTRUNC9:%[0-9]+]]:_(s16) = G_FPTRUNC [[INTRINSIC_TRUNC3]](s32) + ; GFX6: [[FNEG3:%[0-9]+]]:_(s16) = G_FNEG [[FPTRUNC9]] ; GFX6: [[FPEXT22:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC3]](s16) - ; GFX6: [[FPEXT23:%[0-9]+]]:_(s32) = G_FPEXT [[C1]](s16) - ; GFX6: [[FCMP6:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[FPEXT22]](s32), [[FPEXT23]] - ; GFX6: [[FPEXT24:%[0-9]+]]:_(s32) = G_FPEXT [[TRUNC3]](s16) - ; GFX6: [[FPEXT25:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC6]](s16) - ; GFX6: [[FCMP7:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[FPEXT24]](s32), [[FPEXT25]] - ; GFX6: [[AND3:%[0-9]+]]:_(s1) = G_AND [[FCMP6]], [[FCMP7]] - ; GFX6: [[SELECT3:%[0-9]+]]:_(s16) = G_SELECT [[AND3]](s1), [[C2]], [[C1]] - ; GFX6: [[FPEXT26:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC6]](s16) + ; GFX6: [[FPEXT23:%[0-9]+]]:_(s32) = G_FPEXT [[FNEG3]](s16) + ; GFX6: [[FADD6:%[0-9]+]]:_(s32) = G_FADD [[FPEXT22]], [[FPEXT23]] + ; GFX6: [[FPTRUNC10:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD6]](s32) + ; GFX6: [[FABS3:%[0-9]+]]:_(s16) = G_FABS [[FPTRUNC10]] + ; GFX6: [[COPY4:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX6: [[FPEXT24:%[0-9]+]]:_(s32) = G_FPEXT [[FABS3]](s16) + ; GFX6: [[FPEXT25:%[0-9]+]]:_(s32) = G_FPEXT [[C2]](s16) + ; GFX6: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FPEXT24]](s32), [[FPEXT25]] + ; GFX6: [[SELECT3:%[0-9]+]]:_(s16) = G_SELECT [[FCMP3]](s1), [[COPY4]], [[C1]] + ; GFX6: [[FPEXT26:%[0-9]+]]:_(s32) = G_FPEXT [[FPTRUNC9]](s16) ; GFX6: [[FPEXT27:%[0-9]+]]:_(s32) = G_FPEXT [[SELECT3]](s16) - ; GFX6: [[FADD3:%[0-9]+]]:_(s32) = G_FADD [[FPEXT26]], [[FPEXT27]] - ; GFX6: [[FPTRUNC7:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD3]](s32) - ; GFX6: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC1]](s16) - ; GFX6: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC3]](s16) + ; GFX6: [[FADD7:%[0-9]+]]:_(s32) = G_FADD [[FPEXT26]], [[FPEXT27]] + ; GFX6: [[FPTRUNC11:%[0-9]+]]:_(s16) = G_FPTRUNC [[FADD7]](s32) + ; GFX6: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC2]](s16) + ; GFX6: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC5]](s16) ; GFX6: [[SHL:%[0-9]+]]:_(s32) = G_SHL [[ZEXT1]], [[C]](s32) ; GFX6: [[OR:%[0-9]+]]:_(s32) = G_OR [[ZEXT]], [[SHL]] ; GFX6: [[BITCAST2:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR]](s32) - ; GFX6: [[ZEXT2:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC5]](s16) - ; GFX6: [[ZEXT3:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC7]](s16) + ; GFX6: [[ZEXT2:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC8]](s16) + ; GFX6: [[ZEXT3:%[0-9]+]]:_(s32) = G_ZEXT [[FPTRUNC11]](s16) ; GFX6: [[SHL1:%[0-9]+]]:_(s32) = G_SHL [[ZEXT3]], [[C]](s32) ; GFX6: [[OR1:%[0-9]+]]:_(s32) = G_OR [[ZEXT2]], [[SHL1]] ; GFX6: [[BITCAST3:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR1]](s32) @@ -777,39 +886,48 @@ body: | ; GFX8: [[TRUNC2:%[0-9]+]]:_(s16) = G_TRUNC [[BITCAST1]](s32) ; GFX8: [[LSHR1:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST1]], [[C]](s32) ; GFX8: [[TRUNC3:%[0-9]+]]:_(s16) = G_TRUNC [[LSHR1]](s32) - ; GFX8: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX8: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC]] - ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC]](s16), [[C1]] - ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC]](s16), [[INTRINSIC_TRUNC]] - ; GFX8: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX8: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX8: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX8: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX8: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[TRUNC]], [[FNEG]] + ; GFX8: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FADD]] + ; GFX8: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX8: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX8: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX8: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s16), [[C2]] + ; GFX8: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] + ; GFX8: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX8: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC1]] - ; GFX8: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC1]](s16), [[C1]] - ; GFX8: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC1]](s16), [[INTRINSIC_TRUNC1]] - ; GFX8: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX8: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] + ; GFX8: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX8: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[TRUNC1]], [[FNEG1]] + ; GFX8: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FADD2]] + ; GFX8: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s16), [[C2]] + ; GFX8: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX8: [[FADD3:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] ; GFX8: [[INTRINSIC_TRUNC2:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC2]] - ; GFX8: [[FCMP4:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC2]](s16), [[C1]] - ; GFX8: [[FCMP5:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC2]](s16), [[INTRINSIC_TRUNC2]] - ; GFX8: [[AND2:%[0-9]+]]:_(s1) = G_AND [[FCMP4]], [[FCMP5]] - ; GFX8: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[AND2]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC2]], [[SELECT2]] + ; GFX8: [[FNEG2:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC2]] + ; GFX8: [[FADD4:%[0-9]+]]:_(s16) = G_FADD [[TRUNC2]], [[FNEG2]] + ; GFX8: [[FABS2:%[0-9]+]]:_(s16) = G_FABS [[FADD4]] + ; GFX8: [[COPY3:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS2]](s16), [[C2]] + ; GFX8: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[FCMP2]](s1), [[COPY3]], [[C1]] + ; GFX8: [[FADD5:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC2]], [[SELECT2]] ; GFX8: [[INTRINSIC_TRUNC3:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC3]] - ; GFX8: [[FCMP6:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC3]](s16), [[C1]] - ; GFX8: [[FCMP7:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC3]](s16), [[INTRINSIC_TRUNC3]] - ; GFX8: [[AND3:%[0-9]+]]:_(s1) = G_AND [[FCMP6]], [[FCMP7]] - ; GFX8: [[SELECT3:%[0-9]+]]:_(s16) = G_SELECT [[AND3]](s1), [[C2]], [[C1]] - ; GFX8: [[FADD3:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC3]], [[SELECT3]] - ; GFX8: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FADD]](s16) - ; GFX8: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FADD1]](s16) + ; GFX8: [[FNEG3:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC3]] + ; GFX8: [[FADD6:%[0-9]+]]:_(s16) = G_FADD [[TRUNC3]], [[FNEG3]] + ; GFX8: [[FABS3:%[0-9]+]]:_(s16) = G_FABS [[FADD6]] + ; GFX8: [[COPY4:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX8: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS3]](s16), [[C2]] + ; GFX8: [[SELECT3:%[0-9]+]]:_(s16) = G_SELECT [[FCMP3]](s1), [[COPY4]], [[C1]] + ; GFX8: [[FADD7:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC3]], [[SELECT3]] + ; GFX8: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[FADD1]](s16) + ; GFX8: [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[FADD3]](s16) ; GFX8: [[SHL:%[0-9]+]]:_(s32) = G_SHL [[ZEXT1]], [[C]](s32) ; GFX8: [[OR:%[0-9]+]]:_(s32) = G_OR [[ZEXT]], [[SHL]] ; GFX8: [[BITCAST2:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR]](s32) - ; GFX8: [[ZEXT2:%[0-9]+]]:_(s32) = G_ZEXT [[FADD2]](s16) - ; GFX8: [[ZEXT3:%[0-9]+]]:_(s32) = G_ZEXT [[FADD3]](s16) + ; GFX8: [[ZEXT2:%[0-9]+]]:_(s32) = G_ZEXT [[FADD5]](s16) + ; GFX8: [[ZEXT3:%[0-9]+]]:_(s32) = G_ZEXT [[FADD7]](s16) ; GFX8: [[SHL1:%[0-9]+]]:_(s32) = G_SHL [[ZEXT3]], [[C]](s32) ; GFX8: [[OR1:%[0-9]+]]:_(s32) = G_OR [[ZEXT2]], [[SHL1]] ; GFX8: [[BITCAST3:%[0-9]+]]:_(<2 x s16>) = G_BITCAST [[OR1]](s32) @@ -827,37 +945,46 @@ body: | ; GFX9: [[TRUNC2:%[0-9]+]]:_(s16) = G_TRUNC [[BITCAST1]](s32) ; GFX9: [[LSHR1:%[0-9]+]]:_(s32) = G_LSHR [[BITCAST1]], [[C]](s32) ; GFX9: [[TRUNC3:%[0-9]+]]:_(s16) = G_TRUNC [[LSHR1]](s32) - ; GFX9: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 ; GFX9: [[INTRINSIC_TRUNC:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC]] - ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC]](s16), [[C1]] - ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC]](s16), [[INTRINSIC_TRUNC]] - ; GFX9: [[AND:%[0-9]+]]:_(s1) = G_AND [[FCMP]], [[FCMP1]] - ; GFX9: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xHBC00 - ; GFX9: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[AND]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] + ; GFX9: [[FNEG:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC]] + ; GFX9: [[FADD:%[0-9]+]]:_(s16) = G_FADD [[TRUNC]], [[FNEG]] + ; GFX9: [[FABS:%[0-9]+]]:_(s16) = G_FABS [[FADD]] + ; GFX9: [[C1:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH0000 + ; GFX9: [[C2:%[0-9]+]]:_(s16) = G_FCONSTANT half 0xH3800 + ; GFX9: [[C3:%[0-9]+]]:_(s16) = G_CONSTANT i16 15360 + ; GFX9: [[COPY1:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS]](s16), [[C2]] + ; GFX9: [[SELECT:%[0-9]+]]:_(s16) = G_SELECT [[FCMP]](s1), [[COPY1]], [[C1]] + ; GFX9: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC]], [[SELECT]] ; GFX9: [[INTRINSIC_TRUNC1:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC1]] - ; GFX9: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC1]](s16), [[C1]] - ; GFX9: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC1]](s16), [[INTRINSIC_TRUNC1]] - ; GFX9: [[AND1:%[0-9]+]]:_(s1) = G_AND [[FCMP2]], [[FCMP3]] - ; GFX9: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[AND1]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD1:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] + ; GFX9: [[FNEG1:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC1]] + ; GFX9: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[TRUNC1]], [[FNEG1]] + ; GFX9: [[FABS1:%[0-9]+]]:_(s16) = G_FABS [[FADD2]] + ; GFX9: [[COPY2:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP1:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS1]](s16), [[C2]] + ; GFX9: [[SELECT1:%[0-9]+]]:_(s16) = G_SELECT [[FCMP1]](s1), [[COPY2]], [[C1]] + ; GFX9: [[FADD3:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC1]], [[SELECT1]] ; GFX9: [[INTRINSIC_TRUNC2:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC2]] - ; GFX9: [[FCMP4:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC2]](s16), [[C1]] - ; GFX9: [[FCMP5:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC2]](s16), [[INTRINSIC_TRUNC2]] - ; GFX9: [[AND2:%[0-9]+]]:_(s1) = G_AND [[FCMP4]], [[FCMP5]] - ; GFX9: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[AND2]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD2:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC2]], [[SELECT2]] + ; GFX9: [[FNEG2:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC2]] + ; GFX9: [[FADD4:%[0-9]+]]:_(s16) = G_FADD [[TRUNC2]], [[FNEG2]] + ; GFX9: [[FABS2:%[0-9]+]]:_(s16) = G_FABS [[FADD4]] + ; GFX9: [[COPY3:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP2:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS2]](s16), [[C2]] + ; GFX9: [[SELECT2:%[0-9]+]]:_(s16) = G_SELECT [[FCMP2]](s1), [[COPY3]], [[C1]] + ; GFX9: [[FADD5:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC2]], [[SELECT2]] ; GFX9: [[INTRINSIC_TRUNC3:%[0-9]+]]:_(s16) = G_INTRINSIC_TRUNC [[TRUNC3]] - ; GFX9: [[FCMP6:%[0-9]+]]:_(s1) = G_FCMP floatpred(olt), [[TRUNC3]](s16), [[C1]] - ; GFX9: [[FCMP7:%[0-9]+]]:_(s1) = G_FCMP floatpred(one), [[TRUNC3]](s16), [[INTRINSIC_TRUNC3]] - ; GFX9: [[AND3:%[0-9]+]]:_(s1) = G_AND [[FCMP6]], [[FCMP7]] - ; GFX9: [[SELECT3:%[0-9]+]]:_(s16) = G_SELECT [[AND3]](s1), [[C2]], [[C1]] - ; GFX9: [[FADD3:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC3]], [[SELECT3]] - ; GFX9: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD]](s16) - ; GFX9: [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD1]](s16) + ; GFX9: [[FNEG3:%[0-9]+]]:_(s16) = G_FNEG [[INTRINSIC_TRUNC3]] + ; GFX9: [[FADD6:%[0-9]+]]:_(s16) = G_FADD [[TRUNC3]], [[FNEG3]] + ; GFX9: [[FABS3:%[0-9]+]]:_(s16) = G_FABS [[FADD6]] + ; GFX9: [[COPY4:%[0-9]+]]:_(s16) = COPY [[C3]](s16) + ; GFX9: [[FCMP3:%[0-9]+]]:_(s1) = G_FCMP floatpred(oge), [[FABS3]](s16), [[C2]] + ; GFX9: [[SELECT3:%[0-9]+]]:_(s16) = G_SELECT [[FCMP3]](s1), [[COPY4]], [[C1]] + ; GFX9: [[FADD7:%[0-9]+]]:_(s16) = G_FADD [[INTRINSIC_TRUNC3]], [[SELECT3]] + ; GFX9: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD1]](s16) + ; GFX9: [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD3]](s16) ; GFX9: [[BUILD_VECTOR_TRUNC:%[0-9]+]]:_(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[ANYEXT]](s32), [[ANYEXT1]](s32) - ; GFX9: [[ANYEXT2:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD2]](s16) - ; GFX9: [[ANYEXT3:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD3]](s16) + ; GFX9: [[ANYEXT2:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD5]](s16) + ; GFX9: [[ANYEXT3:%[0-9]+]]:_(s32) = G_ANYEXT [[FADD7]](s16) ; GFX9: [[BUILD_VECTOR_TRUNC1:%[0-9]+]]:_(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[ANYEXT2]](s32), [[ANYEXT3]](s32) ; GFX9: [[CONCAT_VECTORS:%[0-9]+]]:_(<4 x s16>) = G_CONCAT_VECTORS [[BUILD_VECTOR_TRUNC]](<2 x s16>), [[BUILD_VECTOR_TRUNC1]](<2 x s16>) ; GFX9: $vgpr0_vgpr1 = COPY [[CONCAT_VECTORS]](<4 x s16>) diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-merge-values.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-merge-values.mir index 6a0ce00d205fb3..8dbf083da85d15 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-merge-values.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-merge-values.mir @@ -1602,3 +1602,58 @@ body: | %7:_(s64) = G_ANYEXT %6 $vgpr0_vgpr1 = COPY %7 ... + +--- + +name: test_merge_s256_s128 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3, $vgpr4_vgpr5_vgpr6_vgpr7 + + ; CHECK-LABEL: name: test_merge_s256_s128 + ; CHECK: [[COPY:%[0-9]+]]:_(s128) = COPY $vgpr0_vgpr1_vgpr2_vgpr3 + ; CHECK: [[COPY1:%[0-9]+]]:_(s128) = COPY $vgpr4_vgpr5_vgpr6_vgpr7 + ; CHECK: [[MV:%[0-9]+]]:_(s256) = G_MERGE_VALUES [[COPY]](s128), [[COPY1]](s128) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 = COPY [[MV]](s256) + %0:_(s128) = COPY $vgpr0_vgpr1_vgpr2_vgpr3 + %1:_(s128) = COPY $vgpr4_vgpr5_vgpr6_vgpr7 + %2:_(s256) = G_MERGE_VALUES %0, %1 + $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 = COPY %2 +... + +--- + +name: test_merge_s512_s256 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3, $vgpr4_vgpr5_vgpr6_vgpr7, $vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + + ; CHECK-LABEL: name: test_merge_s512_s256 + ; CHECK: [[COPY:%[0-9]+]]:_(s256) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + ; CHECK: [[COPY1:%[0-9]+]]:_(s256) = COPY $vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + ; CHECK: [[MV:%[0-9]+]]:_(s512) = G_MERGE_VALUES [[COPY]](s256), [[COPY1]](s256) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY [[MV]](s512) + %0:_(s256) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + %1:_(s256) = COPY $vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + %2:_(s512) = G_MERGE_VALUES %0, %1 + $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY %2 +... + +--- + +name: test_merge_s1024_s512 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15, $vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + + ; CHECK-LABEL: name: test_merge_s1024_s512 + ; CHECK: [[COPY:%[0-9]+]]:_(s512) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + ; CHECK: [[COPY1:%[0-9]+]]:_(s512) = COPY $vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + ; CHECK: [[MV:%[0-9]+]]:_(s1024) = G_MERGE_VALUES [[COPY]](s512), [[COPY1]](s512) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15_vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 = COPY [[MV]](s1024) + %0:_(s512) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + %1:_(s512) = COPY $vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + %2:_(s1024) = G_MERGE_VALUES %0, %1 + $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15_vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 = COPY %2 + +... diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-unmerge-values.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-unmerge-values.mir index 3e089af9e6cb2c..561fcdf504e9d6 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-unmerge-values.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-unmerge-values.mir @@ -758,3 +758,109 @@ body: | $vgpr6 = COPY %16 $vgpr7 = COPY %17 ... + +--- + +name: test_unmerge_s128_v2s128 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + ; CHECK-LABEL: name: test_unmerge_s128_v2s128 + ; CHECK: [[COPY:%[0-9]+]]:_(<2 x s128>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + ; CHECK: [[UV:%[0-9]+]]:_(s128), [[UV1:%[0-9]+]]:_(s128) = G_UNMERGE_VALUES [[COPY]](<2 x s128>) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3 = COPY [[UV]](s128) + ; CHECK: $vgpr4_vgpr5_vgpr6_vgpr7 = COPY [[UV1]](s128) + %0:_(<2 x s128>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + %1:_(s128), %2:_(s128) = G_UNMERGE_VALUES %0 + $vgpr0_vgpr1_vgpr2_vgpr3 = COPY %1 + $vgpr4_vgpr5_vgpr6_vgpr7 = COPY %2 +... + +--- + +name: test_unmerge_s128_s256 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + ; CHECK-LABEL: name: test_unmerge_s128_s256 + ; CHECK: [[COPY:%[0-9]+]]:_(s256) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + ; CHECK: [[UV:%[0-9]+]]:_(s128), [[UV1:%[0-9]+]]:_(s128) = G_UNMERGE_VALUES [[COPY]](s256) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3 = COPY [[UV]](s128) + ; CHECK: $vgpr4_vgpr5_vgpr6_vgpr7 = COPY [[UV1]](s128) + %0:_(s256) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 + %1:_(s128), %2:_(s128) = G_UNMERGE_VALUES %0 + $vgpr0_vgpr1_vgpr2_vgpr3 = COPY %1 + $vgpr4_vgpr5_vgpr6_vgpr7 = COPY %2 +... + +--- + +name: test_unmerge_s256_s512 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + + ; CHECK-LABEL: name: test_unmerge_s256_s512 + ; CHECK: [[COPY:%[0-9]+]]:_(s512) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + ; CHECK: [[UV:%[0-9]+]]:_(s256), [[UV1:%[0-9]+]]:_(s256) = G_UNMERGE_VALUES [[COPY]](s512) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 = COPY [[UV]](s256) + ; CHECK: $vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY [[UV1]](s256) + %0:_(s512) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + %1:_(s256), %2:_(s256) = G_UNMERGE_VALUES %0 + $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 = COPY %1 + $vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY %2 +... + +--- + +name: test_unmerge_s256_v2s256 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + + ; CHECK-LABEL: name: test_unmerge_s256_v2s256 + ; CHECK: [[COPY:%[0-9]+]]:_(<2 x s256>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + ; CHECK: [[UV:%[0-9]+]]:_(s256), [[UV1:%[0-9]+]]:_(s256) = G_UNMERGE_VALUES [[COPY]](<2 x s256>) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 = COPY [[UV]](s256) + ; CHECK: $vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY [[UV1]](s256) + %0:_(<2 x s256>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 + %1:_(s256), %2:_(s256) = G_UNMERGE_VALUES %0 + $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7 = COPY %1 + $vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY %2 +... + +--- + +name: test_unmerge_s512_s1024 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15_vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + + ; CHECK-LABEL: name: test_unmerge_s512_s1024 + ; CHECK: [[COPY:%[0-9]+]]:_(s1024) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15_vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + ; CHECK: [[UV:%[0-9]+]]:_(s512), [[UV1:%[0-9]+]]:_(s512) = G_UNMERGE_VALUES [[COPY]](s1024) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY [[UV]](s512) + ; CHECK: $vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 = COPY [[UV1]](s512) + %0:_(s1024) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15_vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + %1:_(s512), %2:_(s512) = G_UNMERGE_VALUES %0 + $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY %1 + $vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 = COPY %2 +... + +--- + +name: test_unmerge_s512_v2s512 +body: | + bb.0: + liveins: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15_vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + + ; CHECK-LABEL: name: test_unmerge_s512_v2s512 + ; CHECK: [[COPY:%[0-9]+]]:_(<2 x s512>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15_vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + ; CHECK: [[UV:%[0-9]+]]:_(s512), [[UV1:%[0-9]+]]:_(s512) = G_UNMERGE_VALUES [[COPY]](<2 x s512>) + ; CHECK: $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY [[UV]](s512) + ; CHECK: $vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 = COPY [[UV1]](s512) + %0:_(<2 x s512>) = COPY $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15_vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 + %1:_(s512), %2:_(s512) = G_UNMERGE_VALUES %0 + $vgpr0_vgpr1_vgpr2_vgpr3_vgpr4_vgpr5_vgpr6_vgpr7_vgpr8_vgpr9_vgpr10_vgpr11_vgpr12_vgpr13_vgpr14_vgpr15 = COPY %1 + $vgpr16_vgpr17_vgpr18_vgpr19_vgpr20_vgpr21_vgpr22_vgpr23_vgpr24_vgpr25_vgpr26_vgpr27_vgpr28_vgpr29_vgpr30_vgpr31 = COPY %2 +... diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/mul.ll b/llvm/test/CodeGen/AMDGPU/GlobalISel/mul.ll index a1f73a9f67b3e0..f34c481824afdb 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/mul.ll +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/mul.ll @@ -301,11 +301,10 @@ define amdgpu_ps <3 x i32> @s_mul_i96(i96 inreg %num, i96 inreg %den) { ; GFX7-NEXT: s_mul_i32 s6, s0, s3 ; GFX7-NEXT: s_mul_i32 s5, s0, s5 ; GFX7-NEXT: s_add_i32 s0, s2, s7 -; GFX7-NEXT: s_lshl_b32 s8, s8, 31 ; GFX7-NEXT: s_add_i32 s0, s0, s5 ; GFX7-NEXT: v_cndmask_b32_e64 v1, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v2, vcc, s0, v2 -; GFX7-NEXT: s_lshr_b32 s8, s8, 31 +; GFX7-NEXT: s_and_b32 s8, s8, 1 ; GFX7-NEXT: v_add_i32_e32 v1, vcc, s8, v1 ; GFX7-NEXT: v_add_i32_e32 v2, vcc, v2, v3 ; GFX7-NEXT: v_add_i32_e32 v1, vcc, v2, v1 @@ -332,11 +331,10 @@ define amdgpu_ps <3 x i32> @s_mul_i96(i96 inreg %num, i96 inreg %den) { ; GFX8-NEXT: s_mul_i32 s6, s0, s3 ; GFX8-NEXT: s_mul_i32 s5, s0, s5 ; GFX8-NEXT: s_add_i32 s0, s2, s7 -; GFX8-NEXT: s_lshl_b32 s8, s8, 31 ; GFX8-NEXT: s_add_i32 s0, s0, s5 ; GFX8-NEXT: v_cndmask_b32_e64 v1, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v2, vcc, s0, v2 -; GFX8-NEXT: s_lshr_b32 s8, s8, 31 +; GFX8-NEXT: s_and_b32 s8, s8, 1 ; GFX8-NEXT: v_add_u32_e32 v1, vcc, s8, v1 ; GFX8-NEXT: v_add_u32_e32 v2, vcc, v2, v3 ; GFX8-NEXT: v_add_u32_e32 v1, vcc, v2, v1 @@ -351,13 +349,11 @@ define amdgpu_ps <3 x i32> @s_mul_i96(i96 inreg %num, i96 inreg %den) { ; GFX9-NEXT: s_mul_i32 s8, s0, s4 ; GFX9-NEXT: s_add_u32 s7, s7, s8 ; GFX9-NEXT: s_cselect_b32 s8, 1, 0 -; GFX9-NEXT: s_lshl_b32 s8, s8, 31 ; GFX9-NEXT: s_mul_hi_u32 s9, s0, s3 -; GFX9-NEXT: s_lshr_b32 s8, s8, 31 +; GFX9-NEXT: s_and_b32 s8, s8, 1 ; GFX9-NEXT: s_add_u32 s7, s7, s9 ; GFX9-NEXT: s_cselect_b32 s9, 1, 0 -; GFX9-NEXT: s_lshl_b32 s9, s9, 31 -; GFX9-NEXT: s_lshr_b32 s9, s9, 31 +; GFX9-NEXT: s_and_b32 s9, s9, 1 ; GFX9-NEXT: s_add_i32 s8, s8, s9 ; GFX9-NEXT: s_mul_i32 s9, s1, s4 ; GFX9-NEXT: s_mul_i32 s2, s2, s3 @@ -467,27 +463,24 @@ define amdgpu_ps <4 x i32> @s_mul_i128(i128 inreg %num, i128 inreg %den) { ; GFX7-NEXT: s_mul_i32 s10, s0, s5 ; GFX7-NEXT: s_add_u32 s9, s9, s10 ; GFX7-NEXT: s_cselect_b32 s10, 1, 0 -; GFX7-NEXT: s_lshl_b32 s10, s10, 31 ; GFX7-NEXT: v_add_i32_e32 v0, vcc, s9, v0 -; GFX7-NEXT: s_lshr_b32 s10, s10, 31 +; GFX7-NEXT: s_and_b32 s10, s10, 1 ; GFX7-NEXT: v_cndmask_b32_e64 v1, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v1, vcc, s10, v1 ; GFX7-NEXT: s_mul_i32 s9, s2, s4 ; GFX7-NEXT: s_mul_i32 s10, s1, s5 +; GFX7-NEXT: v_mov_b32_e32 v2, s1 ; GFX7-NEXT: s_add_u32 s9, s9, s10 ; GFX7-NEXT: s_cselect_b32 s10, 1, 0 -; GFX7-NEXT: v_mov_b32_e32 v2, s1 -; GFX7-NEXT: s_lshl_b32 s10, s10, 31 -; GFX7-NEXT: s_mul_i32 s11, s0, s6 -; GFX7-NEXT: s_lshr_b32 s10, s10, 31 ; GFX7-NEXT: v_mul_hi_u32 v2, v2, s4 +; GFX7-NEXT: s_mul_i32 s11, s0, s6 +; GFX7-NEXT: s_and_b32 s10, s10, 1 ; GFX7-NEXT: s_add_u32 s9, s9, s11 -; GFX7-NEXT: s_cselect_b32 s11, 1, 0 ; GFX7-NEXT: v_mov_b32_e32 v3, s5 -; GFX7-NEXT: s_lshl_b32 s11, s11, 31 +; GFX7-NEXT: s_cselect_b32 s11, 1, 0 ; GFX7-NEXT: v_mul_hi_u32 v4, s0, v3 ; GFX7-NEXT: v_add_i32_e32 v2, vcc, s9, v2 -; GFX7-NEXT: s_lshr_b32 s11, s11, 31 +; GFX7-NEXT: s_and_b32 s11, s11, 1 ; GFX7-NEXT: s_add_i32 s10, s10, s11 ; GFX7-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v5, vcc, s10, v5 @@ -528,27 +521,24 @@ define amdgpu_ps <4 x i32> @s_mul_i128(i128 inreg %num, i128 inreg %den) { ; GFX8-NEXT: s_mul_i32 s10, s0, s5 ; GFX8-NEXT: s_add_u32 s9, s9, s10 ; GFX8-NEXT: s_cselect_b32 s10, 1, 0 -; GFX8-NEXT: s_lshl_b32 s10, s10, 31 ; GFX8-NEXT: v_add_u32_e32 v0, vcc, s9, v0 -; GFX8-NEXT: s_lshr_b32 s10, s10, 31 +; GFX8-NEXT: s_and_b32 s10, s10, 1 ; GFX8-NEXT: v_cndmask_b32_e64 v1, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v1, vcc, s10, v1 ; GFX8-NEXT: s_mul_i32 s9, s2, s4 ; GFX8-NEXT: s_mul_i32 s10, s1, s5 +; GFX8-NEXT: v_mov_b32_e32 v2, s1 ; GFX8-NEXT: s_add_u32 s9, s9, s10 ; GFX8-NEXT: s_cselect_b32 s10, 1, 0 -; GFX8-NEXT: v_mov_b32_e32 v2, s1 -; GFX8-NEXT: s_lshl_b32 s10, s10, 31 -; GFX8-NEXT: s_mul_i32 s11, s0, s6 -; GFX8-NEXT: s_lshr_b32 s10, s10, 31 ; GFX8-NEXT: v_mul_hi_u32 v2, v2, s4 +; GFX8-NEXT: s_mul_i32 s11, s0, s6 +; GFX8-NEXT: s_and_b32 s10, s10, 1 ; GFX8-NEXT: s_add_u32 s9, s9, s11 -; GFX8-NEXT: s_cselect_b32 s11, 1, 0 ; GFX8-NEXT: v_mov_b32_e32 v3, s5 -; GFX8-NEXT: s_lshl_b32 s11, s11, 31 +; GFX8-NEXT: s_cselect_b32 s11, 1, 0 ; GFX8-NEXT: v_mul_hi_u32 v4, s0, v3 ; GFX8-NEXT: v_add_u32_e32 v2, vcc, s9, v2 -; GFX8-NEXT: s_lshr_b32 s11, s11, 31 +; GFX8-NEXT: s_and_b32 s11, s11, 1 ; GFX8-NEXT: s_add_i32 s10, s10, s11 ; GFX8-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v5, vcc, s10, v5 @@ -587,42 +577,35 @@ define amdgpu_ps <4 x i32> @s_mul_i128(i128 inreg %num, i128 inreg %den) { ; GFX9-NEXT: s_mul_i32 s10, s0, s5 ; GFX9-NEXT: s_add_u32 s9, s9, s10 ; GFX9-NEXT: s_cselect_b32 s10, 1, 0 -; GFX9-NEXT: s_lshl_b32 s10, s10, 31 ; GFX9-NEXT: s_mul_hi_u32 s11, s0, s4 -; GFX9-NEXT: s_lshr_b32 s10, s10, 31 +; GFX9-NEXT: s_and_b32 s10, s10, 1 ; GFX9-NEXT: s_add_u32 s9, s9, s11 ; GFX9-NEXT: s_cselect_b32 s11, 1, 0 -; GFX9-NEXT: s_lshl_b32 s11, s11, 31 -; GFX9-NEXT: s_lshr_b32 s11, s11, 31 +; GFX9-NEXT: s_and_b32 s11, s11, 1 ; GFX9-NEXT: s_add_i32 s10, s10, s11 ; GFX9-NEXT: s_mul_i32 s11, s2, s4 ; GFX9-NEXT: s_mul_i32 s12, s1, s5 ; GFX9-NEXT: s_add_u32 s11, s11, s12 ; GFX9-NEXT: s_cselect_b32 s12, 1, 0 -; GFX9-NEXT: s_lshl_b32 s12, s12, 31 ; GFX9-NEXT: s_mul_i32 s13, s0, s6 -; GFX9-NEXT: s_lshr_b32 s12, s12, 31 +; GFX9-NEXT: s_and_b32 s12, s12, 1 ; GFX9-NEXT: s_add_u32 s11, s11, s13 ; GFX9-NEXT: s_cselect_b32 s13, 1, 0 -; GFX9-NEXT: s_lshl_b32 s13, s13, 31 -; GFX9-NEXT: s_lshr_b32 s13, s13, 31 +; GFX9-NEXT: s_and_b32 s13, s13, 1 ; GFX9-NEXT: s_mul_hi_u32 s14, s1, s4 ; GFX9-NEXT: s_add_i32 s12, s12, s13 ; GFX9-NEXT: s_add_u32 s11, s11, s14 ; GFX9-NEXT: s_cselect_b32 s13, 1, 0 -; GFX9-NEXT: s_lshl_b32 s13, s13, 31 -; GFX9-NEXT: s_lshr_b32 s13, s13, 31 +; GFX9-NEXT: s_and_b32 s13, s13, 1 ; GFX9-NEXT: s_mul_hi_u32 s15, s0, s5 ; GFX9-NEXT: s_add_i32 s12, s12, s13 ; GFX9-NEXT: s_add_u32 s11, s11, s15 ; GFX9-NEXT: s_cselect_b32 s13, 1, 0 -; GFX9-NEXT: s_lshl_b32 s13, s13, 31 -; GFX9-NEXT: s_lshr_b32 s13, s13, 31 +; GFX9-NEXT: s_and_b32 s13, s13, 1 ; GFX9-NEXT: s_add_i32 s12, s12, s13 ; GFX9-NEXT: s_add_u32 s10, s11, s10 ; GFX9-NEXT: s_cselect_b32 s11, 1, 0 -; GFX9-NEXT: s_lshl_b32 s11, s11, 31 -; GFX9-NEXT: s_lshr_b32 s11, s11, 31 +; GFX9-NEXT: s_and_b32 s11, s11, 1 ; GFX9-NEXT: s_add_i32 s12, s12, s11 ; GFX9-NEXT: s_mul_i32 s11, s2, s5 ; GFX9-NEXT: s_mul_i32 s3, s3, s4 @@ -806,148 +789,134 @@ define amdgpu_ps <8 x i32> @s_mul_i256(i256 inreg %num, i256 inreg %den) { ; GFX7-NEXT: s_mul_i32 s18, s0, s9 ; GFX7-NEXT: s_add_u32 s17, s17, s18 ; GFX7-NEXT: s_cselect_b32 s18, 1, 0 -; GFX7-NEXT: s_lshl_b32 s18, s18, 31 ; GFX7-NEXT: v_add_i32_e32 v0, vcc, s17, v0 -; GFX7-NEXT: s_lshr_b32 s18, s18, 31 +; GFX7-NEXT: s_and_b32 s18, s18, 1 ; GFX7-NEXT: v_cndmask_b32_e64 v1, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v1, vcc, s18, v1 ; GFX7-NEXT: s_mul_i32 s17, s2, s8 ; GFX7-NEXT: s_mul_i32 s18, s1, s9 +; GFX7-NEXT: v_mov_b32_e32 v2, s1 ; GFX7-NEXT: s_add_u32 s17, s17, s18 ; GFX7-NEXT: s_cselect_b32 s18, 1, 0 -; GFX7-NEXT: v_mov_b32_e32 v2, s1 -; GFX7-NEXT: s_lshl_b32 s18, s18, 31 -; GFX7-NEXT: s_mul_i32 s19, s0, s10 -; GFX7-NEXT: s_lshr_b32 s18, s18, 31 ; GFX7-NEXT: v_mul_hi_u32 v2, v2, s8 +; GFX7-NEXT: s_mul_i32 s19, s0, s10 +; GFX7-NEXT: s_and_b32 s18, s18, 1 ; GFX7-NEXT: s_add_u32 s17, s17, s19 -; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 -; GFX7-NEXT: v_add_i32_e32 v2, vcc, s17, v2 ; GFX7-NEXT: v_mov_b32_e32 v3, s9 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_cselect_b32 s19, 1, 0 ; GFX7-NEXT: v_mul_hi_u32 v4, s0, v3 +; GFX7-NEXT: v_add_i32_e32 v2, vcc, s17, v2 +; GFX7-NEXT: s_and_b32 s19, s19, 1 ; GFX7-NEXT: s_add_i32 s18, s18, s19 ; GFX7-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v5, vcc, s18, v5 +; GFX7-NEXT: v_add_i32_e32 v2, vcc, v2, v4 ; GFX7-NEXT: s_mul_i32 s17, s3, s8 ; GFX7-NEXT: s_mul_i32 s18, s2, s9 +; GFX7-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc ; GFX7-NEXT: s_add_u32 s17, s17, s18 ; GFX7-NEXT: s_cselect_b32 s18, 1, 0 -; GFX7-NEXT: v_add_i32_e32 v2, vcc, v2, v4 -; GFX7-NEXT: s_lshl_b32 s18, s18, 31 -; GFX7-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc -; GFX7-NEXT: s_mul_i32 s19, s1, s10 -; GFX7-NEXT: s_lshr_b32 s18, s18, 31 -; GFX7-NEXT: s_add_u32 s17, s17, s19 ; GFX7-NEXT: v_add_i32_e32 v4, vcc, v5, v4 -; GFX7-NEXT: s_cselect_b32 s19, 1, 0 ; GFX7-NEXT: v_add_i32_e32 v1, vcc, v2, v1 +; GFX7-NEXT: s_mul_i32 s19, s1, s10 +; GFX7-NEXT: s_and_b32 s18, s18, 1 ; GFX7-NEXT: v_cndmask_b32_e64 v2, 0, 1, vcc -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 +; GFX7-NEXT: s_add_u32 s17, s17, s19 +; GFX7-NEXT: s_cselect_b32 s19, 1, 0 ; GFX7-NEXT: v_add_i32_e32 v2, vcc, v4, v2 ; GFX7-NEXT: v_mov_b32_e32 v4, s2 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 ; GFX7-NEXT: v_mul_hi_u32 v5, v4, s8 +; GFX7-NEXT: s_and_b32 s19, s19, 1 ; GFX7-NEXT: s_mul_i32 s20, s0, s11 ; GFX7-NEXT: s_add_i32 s18, s18, s19 ; GFX7-NEXT: s_add_u32 s17, s17, s20 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 +; GFX7-NEXT: v_mul_hi_u32 v3, s1, v3 ; GFX7-NEXT: v_add_i32_e32 v5, vcc, s17, v5 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_mov_b32_e32 v6, s10 ; GFX7-NEXT: s_add_i32 s18, s18, s19 ; GFX7-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v8, vcc, s18, v8 +; GFX7-NEXT: v_mul_hi_u32 v7, s0, v6 ; GFX7-NEXT: s_mul_i32 s17, s4, s8 ; GFX7-NEXT: s_mul_i32 s18, s3, s9 -; GFX7-NEXT: v_mul_hi_u32 v3, s1, v3 +; GFX7-NEXT: v_add_i32_e32 v3, vcc, v5, v3 ; GFX7-NEXT: s_add_u32 s17, s17, s18 +; GFX7-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GFX7-NEXT: s_cselect_b32 s18, 1, 0 -; GFX7-NEXT: s_lshl_b32 s18, s18, 31 -; GFX7-NEXT: v_mov_b32_e32 v6, s10 -; GFX7-NEXT: v_mul_hi_u32 v7, s0, v6 +; GFX7-NEXT: v_add_i32_e32 v5, vcc, v8, v5 ; GFX7-NEXT: s_mul_i32 s19, s2, s10 -; GFX7-NEXT: s_lshr_b32 s18, s18, 31 -; GFX7-NEXT: v_add_i32_e32 v3, vcc, v5, v3 +; GFX7-NEXT: s_and_b32 s18, s18, 1 +; GFX7-NEXT: v_add_i32_e32 v3, vcc, v3, v7 ; GFX7-NEXT: s_add_u32 s17, s17, s19 -; GFX7-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: v_add_i32_e32 v5, vcc, v8, v5 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 -; GFX7-NEXT: v_add_i32_e32 v3, vcc, v3, v7 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 ; GFX7-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc +; GFX7-NEXT: v_add_i32_e32 v5, vcc, v5, v7 +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_add_i32_e32 v2, vcc, v3, v2 ; GFX7-NEXT: s_mul_i32 s20, s1, s11 ; GFX7-NEXT: s_add_i32 s18, s18, s19 +; GFX7-NEXT: v_cndmask_b32_e64 v3, 0, 1, vcc ; GFX7-NEXT: s_add_u32 s17, s17, s20 -; GFX7-NEXT: v_add_i32_e32 v5, vcc, v5, v7 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: v_add_i32_e32 v2, vcc, v3, v2 -; GFX7-NEXT: v_cndmask_b32_e64 v3, 0, 1, vcc -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_add_i32_e32 v3, vcc, v5, v3 ; GFX7-NEXT: v_mov_b32_e32 v5, s3 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_mul_hi_u32 v7, v5, s8 ; GFX7-NEXT: s_mul_i32 s21, s0, s12 ; GFX7-NEXT: s_add_i32 s18, s18, s19 -; GFX7-NEXT: v_mul_hi_u32 v7, v5, s8 ; GFX7-NEXT: s_add_u32 s17, s17, s21 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_add_i32_e32 v7, vcc, s17, v7 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_mul_hi_u32 v4, v4, s9 ; GFX7-NEXT: s_add_i32 s18, s18, s19 ; GFX7-NEXT: v_cndmask_b32_e64 v11, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v11, vcc, s18, v11 ; GFX7-NEXT: s_mul_i32 s17, s5, s8 ; GFX7-NEXT: s_mul_i32 s18, s4, s9 ; GFX7-NEXT: s_add_u32 s17, s17, s18 -; GFX7-NEXT: s_cselect_b32 s18, 1, 0 -; GFX7-NEXT: v_mul_hi_u32 v4, v4, s9 -; GFX7-NEXT: s_lshl_b32 s18, s18, 31 -; GFX7-NEXT: s_mul_i32 s19, s3, s10 -; GFX7-NEXT: s_lshr_b32 s18, s18, 31 -; GFX7-NEXT: s_add_u32 s17, s17, s19 -; GFX7-NEXT: s_cselect_b32 s19, 1, 0 ; GFX7-NEXT: v_mul_hi_u32 v8, s1, v6 +; GFX7-NEXT: s_cselect_b32 s18, 1, 0 ; GFX7-NEXT: v_add_i32_e32 v4, vcc, v7, v4 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc ; GFX7-NEXT: v_mov_b32_e32 v9, s11 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_mul_i32 s19, s3, s10 +; GFX7-NEXT: s_and_b32 s18, s18, 1 ; GFX7-NEXT: v_add_i32_e32 v7, vcc, v11, v7 +; GFX7-NEXT: s_add_u32 s17, s17, s19 ; GFX7-NEXT: v_mul_hi_u32 v10, s0, v9 +; GFX7-NEXT: s_cselect_b32 s19, 1, 0 +; GFX7-NEXT: v_add_i32_e32 v4, vcc, v4, v8 +; GFX7-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_add_i32_e32 v7, vcc, v7, v8 ; GFX7-NEXT: s_mul_i32 s20, s2, s11 ; GFX7-NEXT: s_add_i32 s18, s18, s19 -; GFX7-NEXT: v_add_i32_e32 v4, vcc, v4, v8 +; GFX7-NEXT: v_add_i32_e32 v4, vcc, v4, v10 ; GFX7-NEXT: s_add_u32 s17, s17, s20 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 ; GFX7-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_add_i32_e32 v7, vcc, v7, v8 -; GFX7-NEXT: v_add_i32_e32 v4, vcc, v4, v10 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 -; GFX7-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_add_i32_e32 v3, vcc, v4, v3 ; GFX7-NEXT: s_mul_i32 s21, s1, s12 ; GFX7-NEXT: s_add_i32 s18, s18, s19 +; GFX7-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc ; GFX7-NEXT: s_add_u32 s17, s17, s21 -; GFX7-NEXT: v_add_i32_e32 v7, vcc, v7, v8 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: v_add_i32_e32 v3, vcc, v4, v3 -; GFX7-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_add_i32_e32 v4, vcc, v7, v4 ; GFX7-NEXT: v_mov_b32_e32 v7, s4 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_mul_hi_u32 v8, v7, s8 ; GFX7-NEXT: s_mul_i32 s22, s0, s13 ; GFX7-NEXT: s_add_i32 s18, s18, s19 -; GFX7-NEXT: v_mul_hi_u32 v8, v7, s8 ; GFX7-NEXT: s_add_u32 s17, s17, s22 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_add_i32_e32 v8, vcc, s17, v8 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_mul_hi_u32 v10, v5, s9 ; GFX7-NEXT: s_add_i32 s18, s18, s19 ; GFX7-NEXT: v_cndmask_b32_e64 v14, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v14, vcc, s18, v14 @@ -955,61 +924,54 @@ define amdgpu_ps <8 x i32> @s_mul_i256(i256 inreg %num, i256 inreg %den) { ; GFX7-NEXT: s_mul_i32 s18, s5, s9 ; GFX7-NEXT: s_add_u32 s17, s17, s18 ; GFX7-NEXT: s_cselect_b32 s18, 1, 0 -; GFX7-NEXT: s_lshl_b32 s18, s18, 31 -; GFX7-NEXT: s_mul_i32 s19, s4, s10 -; GFX7-NEXT: s_lshr_b32 s18, s18, 31 -; GFX7-NEXT: v_mul_hi_u32 v10, v5, s9 -; GFX7-NEXT: s_add_u32 s17, s17, s19 -; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 ; GFX7-NEXT: v_mul_hi_u32 v6, s2, v6 ; GFX7-NEXT: v_add_i32_e32 v8, vcc, v8, v10 -; GFX7-NEXT: s_mul_i32 s20, s3, s11 -; GFX7-NEXT: s_add_i32 s18, s18, s19 +; GFX7-NEXT: s_mul_i32 s19, s4, s10 +; GFX7-NEXT: s_and_b32 s18, s18, 1 ; GFX7-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc -; GFX7-NEXT: s_add_u32 s17, s17, s20 +; GFX7-NEXT: s_add_u32 s17, s17, s19 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 ; GFX7-NEXT: v_add_i32_e32 v10, vcc, v14, v10 ; GFX7-NEXT: v_mul_hi_u32 v11, s1, v9 ; GFX7-NEXT: v_add_i32_e32 v6, vcc, v8, v6 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 +; GFX7-NEXT: s_and_b32 s19, s19, 1 ; GFX7-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc ; GFX7-NEXT: v_mov_b32_e32 v12, s12 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_mul_i32 s20, s3, s11 +; GFX7-NEXT: s_add_i32 s18, s18, s19 ; GFX7-NEXT: v_add_i32_e32 v8, vcc, v10, v8 +; GFX7-NEXT: s_add_u32 s17, s17, s20 ; GFX7-NEXT: v_mul_hi_u32 v13, s0, v12 +; GFX7-NEXT: s_cselect_b32 s19, 1, 0 +; GFX7-NEXT: v_add_i32_e32 v6, vcc, v6, v11 +; GFX7-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_add_i32_e32 v8, vcc, v8, v10 ; GFX7-NEXT: s_mul_i32 s21, s2, s12 ; GFX7-NEXT: s_add_i32 s18, s18, s19 -; GFX7-NEXT: v_add_i32_e32 v6, vcc, v6, v11 +; GFX7-NEXT: v_add_i32_e32 v6, vcc, v6, v13 ; GFX7-NEXT: s_add_u32 s17, s17, s21 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 ; GFX7-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_add_i32_e32 v8, vcc, v8, v10 -; GFX7-NEXT: v_add_i32_e32 v6, vcc, v6, v13 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 -; GFX7-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc +; GFX7-NEXT: s_and_b32 s19, s19, 1 +; GFX7-NEXT: v_add_i32_e32 v4, vcc, v6, v4 ; GFX7-NEXT: s_mul_i32 s22, s1, s13 ; GFX7-NEXT: s_add_i32 s18, s18, s19 -; GFX7-NEXT: v_add_i32_e32 v8, vcc, v8, v10 +; GFX7-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc ; GFX7-NEXT: s_add_u32 s17, s17, s22 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: v_add_i32_e32 v4, vcc, v6, v4 -; GFX7-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_add_i32_e32 v6, vcc, v8, v6 ; GFX7-NEXT: v_mov_b32_e32 v8, s5 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 ; GFX7-NEXT: v_mul_hi_u32 v10, v8, s8 +; GFX7-NEXT: s_and_b32 s19, s19, 1 ; GFX7-NEXT: s_mul_i32 s23, s0, s14 ; GFX7-NEXT: s_add_i32 s18, s18, s19 ; GFX7-NEXT: s_add_u32 s17, s17, s23 ; GFX7-NEXT: s_cselect_b32 s19, 1, 0 -; GFX7-NEXT: s_lshl_b32 s19, s19, 31 ; GFX7-NEXT: v_mul_hi_u32 v11, v7, s9 ; GFX7-NEXT: v_add_i32_e32 v10, vcc, s17, v10 -; GFX7-NEXT: s_lshr_b32 s19, s19, 31 +; GFX7-NEXT: s_and_b32 s19, s19, 1 ; GFX7-NEXT: s_add_i32 s18, s18, s19 ; GFX7-NEXT: v_cndmask_b32_e64 v17, 0, 1, vcc ; GFX7-NEXT: v_add_i32_e32 v17, vcc, s18, v17 @@ -1087,148 +1049,134 @@ define amdgpu_ps <8 x i32> @s_mul_i256(i256 inreg %num, i256 inreg %den) { ; GFX8-NEXT: s_mul_i32 s18, s0, s9 ; GFX8-NEXT: s_add_u32 s17, s17, s18 ; GFX8-NEXT: s_cselect_b32 s18, 1, 0 -; GFX8-NEXT: s_lshl_b32 s18, s18, 31 ; GFX8-NEXT: v_add_u32_e32 v0, vcc, s17, v0 -; GFX8-NEXT: s_lshr_b32 s18, s18, 31 +; GFX8-NEXT: s_and_b32 s18, s18, 1 ; GFX8-NEXT: v_cndmask_b32_e64 v1, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v1, vcc, s18, v1 ; GFX8-NEXT: s_mul_i32 s17, s2, s8 ; GFX8-NEXT: s_mul_i32 s18, s1, s9 +; GFX8-NEXT: v_mov_b32_e32 v2, s1 ; GFX8-NEXT: s_add_u32 s17, s17, s18 ; GFX8-NEXT: s_cselect_b32 s18, 1, 0 -; GFX8-NEXT: v_mov_b32_e32 v2, s1 -; GFX8-NEXT: s_lshl_b32 s18, s18, 31 -; GFX8-NEXT: s_mul_i32 s19, s0, s10 -; GFX8-NEXT: s_lshr_b32 s18, s18, 31 ; GFX8-NEXT: v_mul_hi_u32 v2, v2, s8 +; GFX8-NEXT: s_mul_i32 s19, s0, s10 +; GFX8-NEXT: s_and_b32 s18, s18, 1 ; GFX8-NEXT: s_add_u32 s17, s17, s19 -; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 -; GFX8-NEXT: v_add_u32_e32 v2, vcc, s17, v2 ; GFX8-NEXT: v_mov_b32_e32 v3, s9 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_cselect_b32 s19, 1, 0 ; GFX8-NEXT: v_mul_hi_u32 v4, s0, v3 +; GFX8-NEXT: v_add_u32_e32 v2, vcc, s17, v2 +; GFX8-NEXT: s_and_b32 s19, s19, 1 ; GFX8-NEXT: s_add_i32 s18, s18, s19 ; GFX8-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v5, vcc, s18, v5 +; GFX8-NEXT: v_add_u32_e32 v2, vcc, v2, v4 ; GFX8-NEXT: s_mul_i32 s17, s3, s8 ; GFX8-NEXT: s_mul_i32 s18, s2, s9 +; GFX8-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc ; GFX8-NEXT: s_add_u32 s17, s17, s18 ; GFX8-NEXT: s_cselect_b32 s18, 1, 0 -; GFX8-NEXT: v_add_u32_e32 v2, vcc, v2, v4 -; GFX8-NEXT: s_lshl_b32 s18, s18, 31 -; GFX8-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc -; GFX8-NEXT: s_mul_i32 s19, s1, s10 -; GFX8-NEXT: s_lshr_b32 s18, s18, 31 -; GFX8-NEXT: s_add_u32 s17, s17, s19 ; GFX8-NEXT: v_add_u32_e32 v4, vcc, v5, v4 -; GFX8-NEXT: s_cselect_b32 s19, 1, 0 ; GFX8-NEXT: v_add_u32_e32 v1, vcc, v2, v1 +; GFX8-NEXT: s_mul_i32 s19, s1, s10 +; GFX8-NEXT: s_and_b32 s18, s18, 1 ; GFX8-NEXT: v_cndmask_b32_e64 v2, 0, 1, vcc -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 +; GFX8-NEXT: s_add_u32 s17, s17, s19 +; GFX8-NEXT: s_cselect_b32 s19, 1, 0 ; GFX8-NEXT: v_add_u32_e32 v2, vcc, v4, v2 ; GFX8-NEXT: v_mov_b32_e32 v4, s2 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 ; GFX8-NEXT: v_mul_hi_u32 v5, v4, s8 +; GFX8-NEXT: s_and_b32 s19, s19, 1 ; GFX8-NEXT: s_mul_i32 s20, s0, s11 ; GFX8-NEXT: s_add_i32 s18, s18, s19 ; GFX8-NEXT: s_add_u32 s17, s17, s20 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 +; GFX8-NEXT: v_mul_hi_u32 v3, s1, v3 ; GFX8-NEXT: v_add_u32_e32 v5, vcc, s17, v5 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_mov_b32_e32 v6, s10 ; GFX8-NEXT: s_add_i32 s18, s18, s19 ; GFX8-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v8, vcc, s18, v8 +; GFX8-NEXT: v_mul_hi_u32 v7, s0, v6 ; GFX8-NEXT: s_mul_i32 s17, s4, s8 ; GFX8-NEXT: s_mul_i32 s18, s3, s9 -; GFX8-NEXT: v_mul_hi_u32 v3, s1, v3 +; GFX8-NEXT: v_add_u32_e32 v3, vcc, v5, v3 ; GFX8-NEXT: s_add_u32 s17, s17, s18 +; GFX8-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GFX8-NEXT: s_cselect_b32 s18, 1, 0 -; GFX8-NEXT: s_lshl_b32 s18, s18, 31 -; GFX8-NEXT: v_mov_b32_e32 v6, s10 -; GFX8-NEXT: v_mul_hi_u32 v7, s0, v6 +; GFX8-NEXT: v_add_u32_e32 v5, vcc, v8, v5 ; GFX8-NEXT: s_mul_i32 s19, s2, s10 -; GFX8-NEXT: s_lshr_b32 s18, s18, 31 -; GFX8-NEXT: v_add_u32_e32 v3, vcc, v5, v3 +; GFX8-NEXT: s_and_b32 s18, s18, 1 +; GFX8-NEXT: v_add_u32_e32 v3, vcc, v3, v7 ; GFX8-NEXT: s_add_u32 s17, s17, s19 -; GFX8-NEXT: v_cndmask_b32_e64 v5, 0, 1, vcc ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: v_add_u32_e32 v5, vcc, v8, v5 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 -; GFX8-NEXT: v_add_u32_e32 v3, vcc, v3, v7 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 ; GFX8-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc +; GFX8-NEXT: v_add_u32_e32 v5, vcc, v5, v7 +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_add_u32_e32 v2, vcc, v3, v2 ; GFX8-NEXT: s_mul_i32 s20, s1, s11 ; GFX8-NEXT: s_add_i32 s18, s18, s19 +; GFX8-NEXT: v_cndmask_b32_e64 v3, 0, 1, vcc ; GFX8-NEXT: s_add_u32 s17, s17, s20 -; GFX8-NEXT: v_add_u32_e32 v5, vcc, v5, v7 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: v_add_u32_e32 v2, vcc, v3, v2 -; GFX8-NEXT: v_cndmask_b32_e64 v3, 0, 1, vcc -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_add_u32_e32 v3, vcc, v5, v3 ; GFX8-NEXT: v_mov_b32_e32 v5, s3 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_mul_hi_u32 v7, v5, s8 ; GFX8-NEXT: s_mul_i32 s21, s0, s12 ; GFX8-NEXT: s_add_i32 s18, s18, s19 -; GFX8-NEXT: v_mul_hi_u32 v7, v5, s8 ; GFX8-NEXT: s_add_u32 s17, s17, s21 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_add_u32_e32 v7, vcc, s17, v7 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_mul_hi_u32 v4, v4, s9 ; GFX8-NEXT: s_add_i32 s18, s18, s19 ; GFX8-NEXT: v_cndmask_b32_e64 v11, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v11, vcc, s18, v11 ; GFX8-NEXT: s_mul_i32 s17, s5, s8 ; GFX8-NEXT: s_mul_i32 s18, s4, s9 ; GFX8-NEXT: s_add_u32 s17, s17, s18 -; GFX8-NEXT: s_cselect_b32 s18, 1, 0 -; GFX8-NEXT: v_mul_hi_u32 v4, v4, s9 -; GFX8-NEXT: s_lshl_b32 s18, s18, 31 -; GFX8-NEXT: s_mul_i32 s19, s3, s10 -; GFX8-NEXT: s_lshr_b32 s18, s18, 31 -; GFX8-NEXT: s_add_u32 s17, s17, s19 -; GFX8-NEXT: s_cselect_b32 s19, 1, 0 ; GFX8-NEXT: v_mul_hi_u32 v8, s1, v6 +; GFX8-NEXT: s_cselect_b32 s18, 1, 0 ; GFX8-NEXT: v_add_u32_e32 v4, vcc, v7, v4 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_cndmask_b32_e64 v7, 0, 1, vcc ; GFX8-NEXT: v_mov_b32_e32 v9, s11 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_mul_i32 s19, s3, s10 +; GFX8-NEXT: s_and_b32 s18, s18, 1 ; GFX8-NEXT: v_add_u32_e32 v7, vcc, v11, v7 +; GFX8-NEXT: s_add_u32 s17, s17, s19 ; GFX8-NEXT: v_mul_hi_u32 v10, s0, v9 +; GFX8-NEXT: s_cselect_b32 s19, 1, 0 +; GFX8-NEXT: v_add_u32_e32 v4, vcc, v4, v8 +; GFX8-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_add_u32_e32 v7, vcc, v7, v8 ; GFX8-NEXT: s_mul_i32 s20, s2, s11 ; GFX8-NEXT: s_add_i32 s18, s18, s19 -; GFX8-NEXT: v_add_u32_e32 v4, vcc, v4, v8 +; GFX8-NEXT: v_add_u32_e32 v4, vcc, v4, v10 ; GFX8-NEXT: s_add_u32 s17, s17, s20 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 ; GFX8-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_add_u32_e32 v7, vcc, v7, v8 -; GFX8-NEXT: v_add_u32_e32 v4, vcc, v4, v10 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 -; GFX8-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_add_u32_e32 v3, vcc, v4, v3 ; GFX8-NEXT: s_mul_i32 s21, s1, s12 ; GFX8-NEXT: s_add_i32 s18, s18, s19 +; GFX8-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc ; GFX8-NEXT: s_add_u32 s17, s17, s21 -; GFX8-NEXT: v_add_u32_e32 v7, vcc, v7, v8 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: v_add_u32_e32 v3, vcc, v4, v3 -; GFX8-NEXT: v_cndmask_b32_e64 v4, 0, 1, vcc -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_add_u32_e32 v4, vcc, v7, v4 ; GFX8-NEXT: v_mov_b32_e32 v7, s4 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_mul_hi_u32 v8, v7, s8 ; GFX8-NEXT: s_mul_i32 s22, s0, s13 ; GFX8-NEXT: s_add_i32 s18, s18, s19 -; GFX8-NEXT: v_mul_hi_u32 v8, v7, s8 ; GFX8-NEXT: s_add_u32 s17, s17, s22 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_add_u32_e32 v8, vcc, s17, v8 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_mul_hi_u32 v10, v5, s9 ; GFX8-NEXT: s_add_i32 s18, s18, s19 ; GFX8-NEXT: v_cndmask_b32_e64 v14, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v14, vcc, s18, v14 @@ -1236,61 +1184,54 @@ define amdgpu_ps <8 x i32> @s_mul_i256(i256 inreg %num, i256 inreg %den) { ; GFX8-NEXT: s_mul_i32 s18, s5, s9 ; GFX8-NEXT: s_add_u32 s17, s17, s18 ; GFX8-NEXT: s_cselect_b32 s18, 1, 0 -; GFX8-NEXT: s_lshl_b32 s18, s18, 31 -; GFX8-NEXT: s_mul_i32 s19, s4, s10 -; GFX8-NEXT: s_lshr_b32 s18, s18, 31 -; GFX8-NEXT: v_mul_hi_u32 v10, v5, s9 -; GFX8-NEXT: s_add_u32 s17, s17, s19 -; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 ; GFX8-NEXT: v_mul_hi_u32 v6, s2, v6 ; GFX8-NEXT: v_add_u32_e32 v8, vcc, v8, v10 -; GFX8-NEXT: s_mul_i32 s20, s3, s11 -; GFX8-NEXT: s_add_i32 s18, s18, s19 +; GFX8-NEXT: s_mul_i32 s19, s4, s10 +; GFX8-NEXT: s_and_b32 s18, s18, 1 ; GFX8-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc -; GFX8-NEXT: s_add_u32 s17, s17, s20 +; GFX8-NEXT: s_add_u32 s17, s17, s19 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 ; GFX8-NEXT: v_add_u32_e32 v10, vcc, v14, v10 ; GFX8-NEXT: v_mul_hi_u32 v11, s1, v9 ; GFX8-NEXT: v_add_u32_e32 v6, vcc, v8, v6 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 +; GFX8-NEXT: s_and_b32 s19, s19, 1 ; GFX8-NEXT: v_cndmask_b32_e64 v8, 0, 1, vcc ; GFX8-NEXT: v_mov_b32_e32 v12, s12 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_mul_i32 s20, s3, s11 +; GFX8-NEXT: s_add_i32 s18, s18, s19 ; GFX8-NEXT: v_add_u32_e32 v8, vcc, v10, v8 +; GFX8-NEXT: s_add_u32 s17, s17, s20 ; GFX8-NEXT: v_mul_hi_u32 v13, s0, v12 +; GFX8-NEXT: s_cselect_b32 s19, 1, 0 +; GFX8-NEXT: v_add_u32_e32 v6, vcc, v6, v11 +; GFX8-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_add_u32_e32 v8, vcc, v8, v10 ; GFX8-NEXT: s_mul_i32 s21, s2, s12 ; GFX8-NEXT: s_add_i32 s18, s18, s19 -; GFX8-NEXT: v_add_u32_e32 v6, vcc, v6, v11 +; GFX8-NEXT: v_add_u32_e32 v6, vcc, v6, v13 ; GFX8-NEXT: s_add_u32 s17, s17, s21 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 ; GFX8-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_add_u32_e32 v8, vcc, v8, v10 -; GFX8-NEXT: v_add_u32_e32 v6, vcc, v6, v13 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 -; GFX8-NEXT: v_cndmask_b32_e64 v10, 0, 1, vcc +; GFX8-NEXT: s_and_b32 s19, s19, 1 +; GFX8-NEXT: v_add_u32_e32 v4, vcc, v6, v4 ; GFX8-NEXT: s_mul_i32 s22, s1, s13 ; GFX8-NEXT: s_add_i32 s18, s18, s19 -; GFX8-NEXT: v_add_u32_e32 v8, vcc, v8, v10 +; GFX8-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc ; GFX8-NEXT: s_add_u32 s17, s17, s22 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: v_add_u32_e32 v4, vcc, v6, v4 -; GFX8-NEXT: v_cndmask_b32_e64 v6, 0, 1, vcc -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_add_u32_e32 v6, vcc, v8, v6 ; GFX8-NEXT: v_mov_b32_e32 v8, s5 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 ; GFX8-NEXT: v_mul_hi_u32 v10, v8, s8 +; GFX8-NEXT: s_and_b32 s19, s19, 1 ; GFX8-NEXT: s_mul_i32 s23, s0, s14 ; GFX8-NEXT: s_add_i32 s18, s18, s19 ; GFX8-NEXT: s_add_u32 s17, s17, s23 ; GFX8-NEXT: s_cselect_b32 s19, 1, 0 -; GFX8-NEXT: s_lshl_b32 s19, s19, 31 ; GFX8-NEXT: v_mul_hi_u32 v11, v7, s9 ; GFX8-NEXT: v_add_u32_e32 v10, vcc, s17, v10 -; GFX8-NEXT: s_lshr_b32 s19, s19, 31 +; GFX8-NEXT: s_and_b32 s19, s19, 1 ; GFX8-NEXT: s_add_i32 s18, s18, s19 ; GFX8-NEXT: v_cndmask_b32_e64 v17, 0, 1, vcc ; GFX8-NEXT: v_add_u32_e32 v17, vcc, s18, v17 @@ -1362,282 +1303,235 @@ define amdgpu_ps <8 x i32> @s_mul_i256(i256 inreg %num, i256 inreg %den) { ; ; GFX9-LABEL: s_mul_i256: ; GFX9: ; %bb.0: -; GFX9-NEXT: s_mul_i32 s16, s1, s8 +; GFX9-NEXT: s_mul_i32 s17, s1, s8 ; GFX9-NEXT: s_mul_i32 s18, s0, s9 -; GFX9-NEXT: s_add_u32 s16, s16, s18 +; GFX9-NEXT: s_add_u32 s17, s17, s18 ; GFX9-NEXT: s_cselect_b32 s18, 1, 0 -; GFX9-NEXT: s_lshl_b32 s18, s18, 31 ; GFX9-NEXT: s_mul_hi_u32 s19, s0, s8 -; GFX9-NEXT: s_lshr_b32 s18, s18, 31 -; GFX9-NEXT: s_add_u32 s16, s16, s19 +; GFX9-NEXT: s_and_b32 s18, s18, 1 +; GFX9-NEXT: s_add_u32 s17, s17, s19 ; GFX9-NEXT: s_cselect_b32 s19, 1, 0 -; GFX9-NEXT: s_lshl_b32 s19, s19, 31 -; GFX9-NEXT: s_lshr_b32 s19, s19, 31 +; GFX9-NEXT: s_and_b32 s19, s19, 1 ; GFX9-NEXT: s_add_i32 s18, s18, s19 ; GFX9-NEXT: s_mul_i32 s19, s2, s8 ; GFX9-NEXT: s_mul_i32 s20, s1, s9 ; GFX9-NEXT: s_add_u32 s19, s19, s20 ; GFX9-NEXT: s_cselect_b32 s20, 1, 0 -; GFX9-NEXT: s_lshl_b32 s20, s20, 31 ; GFX9-NEXT: s_mul_i32 s21, s0, s10 -; GFX9-NEXT: s_lshr_b32 s20, s20, 31 +; GFX9-NEXT: s_and_b32 s20, s20, 1 ; GFX9-NEXT: s_add_u32 s19, s19, s21 ; GFX9-NEXT: s_cselect_b32 s21, 1, 0 -; GFX9-NEXT: s_lshl_b32 s21, s21, 31 -; GFX9-NEXT: s_lshr_b32 s21, s21, 31 +; GFX9-NEXT: s_and_b32 s21, s21, 1 ; GFX9-NEXT: s_mul_hi_u32 s22, s1, s8 ; GFX9-NEXT: s_add_i32 s20, s20, s21 ; GFX9-NEXT: s_add_u32 s19, s19, s22 ; GFX9-NEXT: s_cselect_b32 s21, 1, 0 -; GFX9-NEXT: s_lshl_b32 s21, s21, 31 -; GFX9-NEXT: s_lshr_b32 s21, s21, 31 +; GFX9-NEXT: s_and_b32 s21, s21, 1 ; GFX9-NEXT: s_mul_hi_u32 s23, s0, s9 ; GFX9-NEXT: s_add_i32 s20, s20, s21 ; GFX9-NEXT: s_add_u32 s19, s19, s23 ; GFX9-NEXT: s_cselect_b32 s21, 1, 0 -; GFX9-NEXT: s_lshl_b32 s21, s21, 31 -; GFX9-NEXT: s_lshr_b32 s21, s21, 31 +; GFX9-NEXT: s_and_b32 s21, s21, 1 ; GFX9-NEXT: s_add_i32 s20, s20, s21 ; GFX9-NEXT: s_add_u32 s18, s19, s18 ; GFX9-NEXT: s_cselect_b32 s19, 1, 0 -; GFX9-NEXT: s_lshl_b32 s19, s19, 31 -; GFX9-NEXT: s_lshr_b32 s19, s19, 31 +; GFX9-NEXT: s_and_b32 s19, s19, 1 ; GFX9-NEXT: s_add_i32 s20, s20, s19 ; GFX9-NEXT: s_mul_i32 s19, s3, s8 ; GFX9-NEXT: s_mul_i32 s21, s2, s9 ; GFX9-NEXT: s_add_u32 s19, s19, s21 ; GFX9-NEXT: s_cselect_b32 s21, 1, 0 -; GFX9-NEXT: s_lshl_b32 s21, s21, 31 ; GFX9-NEXT: s_mul_i32 s22, s1, s10 -; GFX9-NEXT: s_lshr_b32 s21, s21, 31 +; GFX9-NEXT: s_and_b32 s21, s21, 1 ; GFX9-NEXT: s_add_u32 s19, s19, s22 ; GFX9-NEXT: s_cselect_b32 s22, 1, 0 -; GFX9-NEXT: s_lshl_b32 s22, s22, 31 -; GFX9-NEXT: s_lshr_b32 s22, s22, 31 +; GFX9-NEXT: s_and_b32 s22, s22, 1 ; GFX9-NEXT: s_mul_i32 s23, s0, s11 ; GFX9-NEXT: s_add_i32 s21, s21, s22 ; GFX9-NEXT: s_add_u32 s19, s19, s23 ; GFX9-NEXT: s_cselect_b32 s22, 1, 0 -; GFX9-NEXT: s_lshl_b32 s22, s22, 31 -; GFX9-NEXT: s_lshr_b32 s22, s22, 31 +; GFX9-NEXT: s_and_b32 s22, s22, 1 ; GFX9-NEXT: s_mul_hi_u32 s24, s2, s8 ; GFX9-NEXT: s_add_i32 s21, s21, s22 ; GFX9-NEXT: s_add_u32 s19, s19, s24 ; GFX9-NEXT: s_cselect_b32 s22, 1, 0 -; GFX9-NEXT: s_lshl_b32 s22, s22, 31 -; GFX9-NEXT: s_lshr_b32 s22, s22, 31 +; GFX9-NEXT: s_and_b32 s22, s22, 1 ; GFX9-NEXT: s_mul_hi_u32 s25, s1, s9 ; GFX9-NEXT: s_add_i32 s21, s21, s22 ; GFX9-NEXT: s_add_u32 s19, s19, s25 ; GFX9-NEXT: s_cselect_b32 s22, 1, 0 -; GFX9-NEXT: s_lshl_b32 s22, s22, 31 -; GFX9-NEXT: s_lshr_b32 s22, s22, 31 +; GFX9-NEXT: s_and_b32 s22, s22, 1 ; GFX9-NEXT: s_mul_hi_u32 s26, s0, s10 ; GFX9-NEXT: s_add_i32 s21, s21, s22 ; GFX9-NEXT: s_add_u32 s19, s19, s26 ; GFX9-NEXT: s_cselect_b32 s22, 1, 0 -; GFX9-NEXT: s_lshl_b32 s22, s22, 31 -; GFX9-NEXT: s_lshr_b32 s22, s22, 31 +; GFX9-NEXT: s_and_b32 s22, s22, 1 ; GFX9-NEXT: s_add_i32 s21, s21, s22 ; GFX9-NEXT: s_add_u32 s19, s19, s20 ; GFX9-NEXT: s_cselect_b32 s20, 1, 0 -; GFX9-NEXT: s_lshl_b32 s20, s20, 31 -; GFX9-NEXT: s_lshr_b32 s20, s20, 31 +; GFX9-NEXT: s_and_b32 s20, s20, 1 ; GFX9-NEXT: s_add_i32 s21, s21, s20 ; GFX9-NEXT: s_mul_i32 s20, s4, s8 ; GFX9-NEXT: s_mul_i32 s22, s3, s9 ; GFX9-NEXT: s_add_u32 s20, s20, s22 ; GFX9-NEXT: s_cselect_b32 s22, 1, 0 -; GFX9-NEXT: s_lshl_b32 s22, s22, 31 ; GFX9-NEXT: s_mul_i32 s23, s2, s10 -; GFX9-NEXT: s_lshr_b32 s22, s22, 31 +; GFX9-NEXT: s_and_b32 s22, s22, 1 ; GFX9-NEXT: s_add_u32 s20, s20, s23 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_mul_i32 s24, s1, s11 ; GFX9-NEXT: s_add_i32 s22, s22, s23 ; GFX9-NEXT: s_add_u32 s20, s20, s24 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_mul_i32 s25, s0, s12 ; GFX9-NEXT: s_add_i32 s22, s22, s23 ; GFX9-NEXT: s_add_u32 s20, s20, s25 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_mul_hi_u32 s26, s3, s8 ; GFX9-NEXT: s_add_i32 s22, s22, s23 ; GFX9-NEXT: s_add_u32 s20, s20, s26 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_mul_hi_u32 s27, s2, s9 ; GFX9-NEXT: s_add_i32 s22, s22, s23 ; GFX9-NEXT: s_add_u32 s20, s20, s27 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_mul_hi_u32 s28, s1, s10 ; GFX9-NEXT: s_add_i32 s22, s22, s23 ; GFX9-NEXT: s_add_u32 s20, s20, s28 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_mul_hi_u32 s29, s0, s11 ; GFX9-NEXT: s_add_i32 s22, s22, s23 ; GFX9-NEXT: s_add_u32 s20, s20, s29 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_add_i32 s22, s22, s23 ; GFX9-NEXT: s_add_u32 s20, s20, s21 ; GFX9-NEXT: s_cselect_b32 s21, 1, 0 -; GFX9-NEXT: s_lshl_b32 s21, s21, 31 -; GFX9-NEXT: s_lshr_b32 s21, s21, 31 +; GFX9-NEXT: s_and_b32 s21, s21, 1 ; GFX9-NEXT: s_add_i32 s22, s22, s21 ; GFX9-NEXT: s_mul_i32 s21, s5, s8 ; GFX9-NEXT: s_mul_i32 s23, s4, s9 ; GFX9-NEXT: s_add_u32 s21, s21, s23 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 ; GFX9-NEXT: s_mul_i32 s24, s3, s10 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_add_u32 s21, s21, s24 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_mul_i32 s25, s2, s11 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s25 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_mul_i32 s26, s1, s12 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s26 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_mul_i32 s27, s0, s13 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s27 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_mul_hi_u32 s28, s4, s8 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s28 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_mul_hi_u32 s29, s3, s9 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s29 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_mul_hi_u32 s30, s2, s10 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s30 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_mul_hi_u32 s31, s1, s11 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s31 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_mul_hi_u32 s32, s0, s12 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s32 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_add_i32 s23, s23, s24 ; GFX9-NEXT: s_add_u32 s21, s21, s22 ; GFX9-NEXT: s_cselect_b32 s22, 1, 0 -; GFX9-NEXT: s_lshl_b32 s22, s22, 31 -; GFX9-NEXT: s_lshr_b32 s22, s22, 31 +; GFX9-NEXT: s_and_b32 s22, s22, 1 ; GFX9-NEXT: s_add_i32 s23, s23, s22 ; GFX9-NEXT: s_mul_i32 s22, s6, s8 ; GFX9-NEXT: s_mul_i32 s24, s5, s9 ; GFX9-NEXT: s_add_u32 s22, s22, s24 ; GFX9-NEXT: s_cselect_b32 s24, 1, 0 -; GFX9-NEXT: s_lshl_b32 s24, s24, 31 ; GFX9-NEXT: s_mul_i32 s25, s4, s10 -; GFX9-NEXT: s_lshr_b32 s24, s24, 31 +; GFX9-NEXT: s_and_b32 s24, s24, 1 ; GFX9-NEXT: s_add_u32 s22, s22, s25 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_i32 s26, s3, s11 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s26 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_i32 s27, s2, s12 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s27 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_i32 s28, s1, s13 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s28 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_i32 s29, s0, s14 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s29 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_hi_u32 s30, s5, s8 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s30 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_hi_u32 s31, s4, s9 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s31 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_hi_u32 s32, s3, s10 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s32 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_hi_u32 s33, s2, s11 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s33 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_hi_u32 s34, s1, s12 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s34 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_mul_hi_u32 s35, s0, s13 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s35 ; GFX9-NEXT: s_cselect_b32 s25, 1, 0 -; GFX9-NEXT: s_lshl_b32 s25, s25, 31 -; GFX9-NEXT: s_lshr_b32 s25, s25, 31 +; GFX9-NEXT: s_and_b32 s25, s25, 1 ; GFX9-NEXT: s_add_i32 s24, s24, s25 ; GFX9-NEXT: s_add_u32 s22, s22, s23 ; GFX9-NEXT: s_cselect_b32 s23, 1, 0 -; GFX9-NEXT: s_lshl_b32 s23, s23, 31 -; GFX9-NEXT: s_lshr_b32 s23, s23, 31 +; GFX9-NEXT: s_and_b32 s23, s23, 1 ; GFX9-NEXT: s_add_i32 s24, s24, s23 ; GFX9-NEXT: s_mul_i32 s23, s6, s9 ; GFX9-NEXT: s_mul_i32 s7, s7, s8 @@ -1665,13 +1559,13 @@ define amdgpu_ps <8 x i32> @s_mul_i256(i256 inreg %num, i256 inreg %den) { ; GFX9-NEXT: s_mul_hi_u32 s2, s2, s12 ; GFX9-NEXT: s_add_i32 s2, s3, s2 ; GFX9-NEXT: s_mul_hi_u32 s1, s1, s13 -; GFX9-NEXT: s_mul_i32 s17, s0, s8 +; GFX9-NEXT: s_mul_i32 s16, s0, s8 ; GFX9-NEXT: s_add_i32 s1, s2, s1 ; GFX9-NEXT: s_mul_hi_u32 s0, s0, s14 ; GFX9-NEXT: s_add_i32 s0, s1, s0 ; GFX9-NEXT: s_add_i32 s7, s0, s24 -; GFX9-NEXT: s_mov_b32 s0, s17 -; GFX9-NEXT: s_mov_b32 s1, s16 +; GFX9-NEXT: s_mov_b32 s0, s16 +; GFX9-NEXT: s_mov_b32 s1, s17 ; GFX9-NEXT: s_mov_b32 s2, s18 ; GFX9-NEXT: s_mov_b32 s3, s19 ; GFX9-NEXT: s_mov_b32 s4, s20 diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-anyext.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-anyext.mir index 28d5b16cc91b89..5c2bc3e9311204 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-anyext.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-anyext.mir @@ -22,10 +22,12 @@ legalized: true body: | bb.0: - liveins: $vgpr0_vgpr1 + liveins: $vgpr0 ; CHECK-LABEL: name: anyext_s32_to_s64_v ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s64) = G_ANYEXT [[COPY]](s32) + ; CHECK: [[COPY1:%[0-9]+]]:vgpr(s32) = COPY [[COPY]](s32) + ; CHECK: [[DEF:%[0-9]+]]:vgpr(s32) = G_IMPLICIT_DEF + ; CHECK: [[MV:%[0-9]+]]:vgpr(s64) = G_MERGE_VALUES [[COPY1]](s32), [[DEF]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s64) = G_ANYEXT %0 ... @@ -98,7 +100,10 @@ body: | ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 ; CHECK: [[COPY1:%[0-9]+]]:vgpr(s32) = COPY $vgpr1 ; CHECK: [[ICMP:%[0-9]+]]:vcc(s1) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s16) = G_ANYEXT [[ICMP]](s1) + ; CHECK: [[C:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 1 + ; CHECK: [[C1:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 0 + ; CHECK: [[SELECT:%[0-9]+]]:vgpr(s32) = G_SELECT [[ICMP]](s1), [[C]], [[C1]] + ; CHECK: [[TRUNC:%[0-9]+]]:vgpr(s16) = G_TRUNC [[SELECT]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s32) = COPY $vgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -116,7 +121,9 @@ body: | ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 ; CHECK: [[COPY1:%[0-9]+]]:vgpr(s32) = COPY $vgpr1 ; CHECK: [[ICMP:%[0-9]+]]:vcc(s1) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s32) = G_ANYEXT [[ICMP]](s1) + ; CHECK: [[C:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 1 + ; CHECK: [[C1:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 0 + ; CHECK: [[SELECT:%[0-9]+]]:vgpr(s32) = G_SELECT [[ICMP]](s1), [[C]], [[C1]] %0:_(s32) = COPY $vgpr0 %1:_(s32) = COPY $vgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -134,7 +141,11 @@ body: | ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 ; CHECK: [[COPY1:%[0-9]+]]:vgpr(s32) = COPY $vgpr1 ; CHECK: [[ICMP:%[0-9]+]]:vcc(s1) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s64) = G_ANYEXT [[ICMP]](s1) + ; CHECK: [[C:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 1 + ; CHECK: [[C1:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 0 + ; CHECK: [[SELECT:%[0-9]+]]:vgpr(s32) = G_SELECT [[ICMP]](s1), [[C]], [[C1]] + ; CHECK: [[COPY2:%[0-9]+]]:vgpr(s32) = COPY [[SELECT]](s32) + ; CHECK: [[MV:%[0-9]+]]:vgpr(s64) = G_MERGE_VALUES [[SELECT]](s32), [[COPY2]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s32) = COPY $vgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -231,7 +242,9 @@ body: | ; CHECK-LABEL: name: anyext_s1_to_s64_vgpr ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:vgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s64) = G_ANYEXT [[TRUNC]](s1) + ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s32) = G_ANYEXT [[TRUNC]](s1) + ; CHECK: [[DEF:%[0-9]+]]:vgpr(s32) = G_IMPLICIT_DEF + ; CHECK: [[MV:%[0-9]+]]:vgpr(s64) = G_MERGE_VALUES [[ANYEXT]](s32), [[DEF]](s32) %0:_(s32) = COPY $vgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s64) = G_ANYEXT %1 diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-sext.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-sext.mir index 0f37d771028058..fec347169d0c83 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-sext.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-sext.mir @@ -61,10 +61,7 @@ body: | ; CHECK: [[COPY1:%[0-9]+]]:sgpr(s32) = COPY $sgpr1 ; CHECK: [[ICMP:%[0-9]+]]:sgpr(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[ICMP]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s16) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 15 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s16) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[ASHR:%[0-9]+]]:sgpr(s16) = G_ASHR [[SHL]], [[C]](s32) + ; CHECK: [[SEXT:%[0-9]+]]:sgpr(s16) = G_SEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s32) = COPY $sgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -83,10 +80,7 @@ body: | ; CHECK: [[COPY1:%[0-9]+]]:sgpr(s32) = COPY $sgpr1 ; CHECK: [[ICMP:%[0-9]+]]:sgpr(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[ICMP]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s32) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 31 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s32) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[ASHR:%[0-9]+]]:sgpr(s32) = G_ASHR [[SHL]], [[C]](s32) + ; CHECK: [[SEXT:%[0-9]+]]:sgpr(s32) = G_SEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s32) = COPY $sgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -105,10 +99,7 @@ body: | ; CHECK: [[COPY1:%[0-9]+]]:sgpr(s32) = COPY $sgpr1 ; CHECK: [[ICMP:%[0-9]+]]:sgpr(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[ICMP]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s64) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 63 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s64) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[ASHR:%[0-9]+]]:sgpr(s64) = G_ASHR [[SHL]], [[C]](s32) + ; CHECK: [[SEXT:%[0-9]+]]:sgpr(s64) = G_SEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s32) = COPY $sgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -188,10 +179,7 @@ body: | ; CHECK-LABEL: name: sext_s1_to_s16_sgpr ; CHECK: [[COPY:%[0-9]+]]:sgpr(s32) = COPY $sgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s16) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 15 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s16) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[ASHR:%[0-9]+]]:sgpr(s16) = G_ASHR [[SHL]], [[C]](s32) + ; CHECK: [[SEXT:%[0-9]+]]:sgpr(s16) = G_SEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s16) = G_SEXT %1 @@ -207,10 +195,7 @@ body: | ; CHECK-LABEL: name: sext_s1_to_s32_sgpr ; CHECK: [[COPY:%[0-9]+]]:sgpr(s32) = COPY $sgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s32) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 31 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s32) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[ASHR:%[0-9]+]]:sgpr(s32) = G_ASHR [[SHL]], [[C]](s32) + ; CHECK: [[SEXT:%[0-9]+]]:sgpr(s32) = G_SEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s32) = G_SEXT %1 @@ -226,10 +211,7 @@ body: | ; CHECK-LABEL: name: sext_s1_to_s64_sgpr ; CHECK: [[COPY:%[0-9]+]]:sgpr(s32) = COPY $sgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s64) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 63 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s64) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[ASHR:%[0-9]+]]:sgpr(s64) = G_ASHR [[SHL]], [[C]](s32) + ; CHECK: [[SEXT:%[0-9]+]]:sgpr(s64) = G_SEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s64) = G_SEXT %1 @@ -245,10 +227,7 @@ body: | ; CHECK-LABEL: name: sext_s1_to_s16_vgpr ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:vgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s16) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 15 - ; CHECK: [[SHL:%[0-9]+]]:vgpr(s16) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[ASHR:%[0-9]+]]:vgpr(s16) = G_ASHR [[SHL]], [[C]](s32) + ; CHECK: [[SEXT:%[0-9]+]]:vgpr(s16) = G_SEXT [[TRUNC]](s1) %0:_(s32) = COPY $vgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s16) = G_SEXT %1 @@ -264,10 +243,7 @@ body: | ; CHECK-LABEL: name: sext_s1_to_s32_vgpr ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:vgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s32) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 31 - ; CHECK: [[SHL:%[0-9]+]]:vgpr(s32) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[ASHR:%[0-9]+]]:vgpr(s32) = G_ASHR [[SHL]], [[C]](s32) + ; CHECK: [[SEXT:%[0-9]+]]:vgpr(s32) = G_SEXT [[TRUNC]](s1) %0:_(s32) = COPY $vgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s32) = G_SEXT %1 diff --git a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-zext.mir b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-zext.mir index ee22c54205d7ad..ef83a4c6c52967 100644 --- a/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-zext.mir +++ b/llvm/test/CodeGen/AMDGPU/GlobalISel/regbankselect-zext.mir @@ -60,10 +60,7 @@ body: | ; CHECK: [[COPY1:%[0-9]+]]:sgpr(s32) = COPY $sgpr1 ; CHECK: [[ICMP:%[0-9]+]]:sgpr(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[ICMP]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s16) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 15 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s16) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[LSHR:%[0-9]+]]:sgpr(s16) = G_LSHR [[SHL]], [[C]](s32) + ; CHECK: [[ZEXT:%[0-9]+]]:sgpr(s16) = G_ZEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s32) = COPY $sgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -82,10 +79,7 @@ body: | ; CHECK: [[COPY1:%[0-9]+]]:sgpr(s32) = COPY $sgpr1 ; CHECK: [[ICMP:%[0-9]+]]:sgpr(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[ICMP]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s32) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 31 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s32) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[LSHR:%[0-9]+]]:sgpr(s32) = G_LSHR [[SHL]], [[C]](s32) + ; CHECK: [[ZEXT:%[0-9]+]]:sgpr(s32) = G_ZEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s32) = COPY $sgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -104,10 +98,7 @@ body: | ; CHECK: [[COPY1:%[0-9]+]]:sgpr(s32) = COPY $sgpr1 ; CHECK: [[ICMP:%[0-9]+]]:sgpr(s32) = G_ICMP intpred(eq), [[COPY]](s32), [[COPY1]] ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[ICMP]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s64) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 63 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s64) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[LSHR:%[0-9]+]]:sgpr(s64) = G_LSHR [[SHL]], [[C]](s32) + ; CHECK: [[ZEXT:%[0-9]+]]:sgpr(s64) = G_ZEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s32) = COPY $sgpr1 %2:_(s1) = G_ICMP intpred(eq), %0, %1 @@ -187,10 +178,7 @@ body: | ; CHECK-LABEL: name: zext_s1_to_s16_sgpr ; CHECK: [[COPY:%[0-9]+]]:sgpr(s32) = COPY $sgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s16) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 15 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s16) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[LSHR:%[0-9]+]]:sgpr(s16) = G_LSHR [[SHL]], [[C]](s32) + ; CHECK: [[ZEXT:%[0-9]+]]:sgpr(s16) = G_ZEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s16) = G_ZEXT %1 @@ -206,10 +194,7 @@ body: | ; CHECK-LABEL: name: zext_s1_to_s32_sgpr ; CHECK: [[COPY:%[0-9]+]]:sgpr(s32) = COPY $sgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s32) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 31 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s32) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[LSHR:%[0-9]+]]:sgpr(s32) = G_LSHR [[SHL]], [[C]](s32) + ; CHECK: [[ZEXT:%[0-9]+]]:sgpr(s32) = G_ZEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s32) = G_ZEXT %1 @@ -225,10 +210,7 @@ body: | ; CHECK-LABEL: name: zext_s1_to_s64_sgpr ; CHECK: [[COPY:%[0-9]+]]:sgpr(s32) = COPY $sgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:sgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:sgpr(s64) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:sgpr(s32) = G_CONSTANT i32 63 - ; CHECK: [[SHL:%[0-9]+]]:sgpr(s64) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[LSHR:%[0-9]+]]:sgpr(s64) = G_LSHR [[SHL]], [[C]](s32) + ; CHECK: [[ZEXT:%[0-9]+]]:sgpr(s64) = G_ZEXT [[TRUNC]](s1) %0:_(s32) = COPY $sgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s64) = G_ZEXT %1 @@ -244,10 +226,7 @@ body: | ; CHECK-LABEL: name: zext_s1_to_s16_vgpr ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:vgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s16) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 15 - ; CHECK: [[SHL:%[0-9]+]]:vgpr(s16) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[LSHR:%[0-9]+]]:vgpr(s16) = G_LSHR [[SHL]], [[C]](s32) + ; CHECK: [[ZEXT:%[0-9]+]]:vgpr(s16) = G_ZEXT [[TRUNC]](s1) %0:_(s32) = COPY $vgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s16) = G_ZEXT %1 @@ -263,10 +242,7 @@ body: | ; CHECK-LABEL: name: zext_s1_to_s32_vgpr ; CHECK: [[COPY:%[0-9]+]]:vgpr(s32) = COPY $vgpr0 ; CHECK: [[TRUNC:%[0-9]+]]:vgpr(s1) = G_TRUNC [[COPY]](s32) - ; CHECK: [[ANYEXT:%[0-9]+]]:vgpr(s32) = G_ANYEXT [[TRUNC]](s1) - ; CHECK: [[C:%[0-9]+]]:vgpr(s32) = G_CONSTANT i32 31 - ; CHECK: [[SHL:%[0-9]+]]:vgpr(s32) = G_SHL [[ANYEXT]], [[C]](s32) - ; CHECK: [[LSHR:%[0-9]+]]:vgpr(s32) = G_LSHR [[SHL]], [[C]](s32) + ; CHECK: [[ZEXT:%[0-9]+]]:vgpr(s32) = G_ZEXT [[TRUNC]](s1) %0:_(s32) = COPY $vgpr0 %1:_(s1) = G_TRUNC %0 %2:_(s32) = G_ZEXT %1 diff --git a/llvm/test/CodeGen/AMDGPU/llvm.round.f64.ll b/llvm/test/CodeGen/AMDGPU/llvm.round.f64.ll index 7df72dfc1eae80..05bf7e9473e5ab 100644 --- a/llvm/test/CodeGen/AMDGPU/llvm.round.f64.ll +++ b/llvm/test/CodeGen/AMDGPU/llvm.round.f64.ll @@ -5,47 +5,39 @@ define amdgpu_kernel void @round_f64(double addrspace(1)* %out, double %x) #0 { ; SI-LABEL: round_f64: ; SI: ; %bb.0: -; SI-NEXT: s_load_dwordx4 s[0:3], s[0:1], 0x9 +; SI-NEXT: s_load_dwordx4 s[8:11], s[0:1], 0x9 ; SI-NEXT: s_mov_b32 s6, -1 -; SI-NEXT: s_mov_b32 s11, 0x80000 -; SI-NEXT: s_mov_b32 s10, 0 -; SI-NEXT: s_mov_b32 s7, 0xf000 +; SI-NEXT: s_mov_b32 s3, 0xfffff +; SI-NEXT: s_mov_b32 s2, s6 +; SI-NEXT: v_mov_b32_e32 v4, 0x3ff00000 ; SI-NEXT: s_waitcnt lgkmcnt(0) -; SI-NEXT: s_mov_b32 s4, s0 -; SI-NEXT: s_bfe_u32 s0, s3, 0xb0014 -; SI-NEXT: s_add_i32 s12, s0, 0xfffffc01 -; SI-NEXT: s_mov_b32 s5, s1 -; SI-NEXT: s_mov_b32 s1, 0xfffff -; SI-NEXT: s_mov_b32 s0, s6 -; SI-NEXT: s_lshr_b64 s[0:1], s[0:1], s12 -; SI-NEXT: s_and_b64 s[8:9], s[2:3], s[0:1] -; SI-NEXT: s_lshr_b64 s[10:11], s[10:11], s12 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[8:9], 0 -; SI-NEXT: v_mov_b32_e32 v1, s10 -; SI-NEXT: v_mov_b32_e32 v0, s11 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v1, vcc -; SI-NEXT: v_cndmask_b32_e32 v0, 0, v0, vcc -; SI-NEXT: v_mov_b32_e32 v2, s3 -; SI-NEXT: v_add_i32_e32 v1, vcc, s2, v1 -; SI-NEXT: v_addc_u32_e32 v0, vcc, v2, v0, vcc -; SI-NEXT: v_not_b32_e32 v2, s0 -; SI-NEXT: v_and_b32_e32 v2, v1, v2 -; SI-NEXT: v_not_b32_e32 v1, s1 -; SI-NEXT: v_and_b32_e32 v0, v0, v1 -; SI-NEXT: v_mov_b32_e32 v1, 0x3ff00000 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s12, -1 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v1, vcc -; SI-NEXT: s_brev_b32 s0, -2 -; SI-NEXT: v_mov_b32_e32 v3, s3 -; SI-NEXT: v_bfi_b32 v1, s0, v1, v3 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s12, 0 +; SI-NEXT: s_bfe_u32 s0, s11, 0xb0014 +; SI-NEXT: s_add_i32 s5, s0, 0xfffffc01 +; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s5 +; SI-NEXT: s_andn2_b64 s[2:3], s[10:11], s[0:1] +; SI-NEXT: s_and_b32 s0, s11, 0x80000000 +; SI-NEXT: v_mov_b32_e32 v1, s0 +; SI-NEXT: v_mov_b32_e32 v0, s3 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s5, 0 ; SI-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc -; SI-NEXT: v_mov_b32_e32 v1, s3 -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s12, 51 +; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s5, 51 +; SI-NEXT: v_mov_b32_e32 v1, s11 ; SI-NEXT: v_cndmask_b32_e64 v1, v0, v1, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v0, v2, 0, vcc -; SI-NEXT: v_mov_b32_e32 v2, s2 +; SI-NEXT: v_mov_b32_e32 v0, s2 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, 0, vcc +; SI-NEXT: v_mov_b32_e32 v2, s10 ; SI-NEXT: v_cndmask_b32_e64 v0, v0, v2, s[0:1] +; SI-NEXT: v_add_f64 v[2:3], s[10:11], -v[0:1] +; SI-NEXT: s_brev_b32 s0, -2 +; SI-NEXT: v_mov_b32_e32 v5, s11 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[2:3]|, 0.5 +; SI-NEXT: v_bfi_b32 v4, s0, v4, v5 +; SI-NEXT: v_cndmask_b32_e32 v3, 0, v4, vcc +; SI-NEXT: v_mov_b32_e32 v2, 0 +; SI-NEXT: v_add_f64 v[0:1], v[0:1], v[2:3] +; SI-NEXT: s_mov_b32 s7, 0xf000 +; SI-NEXT: s_mov_b32 s4, s8 +; SI-NEXT: s_mov_b32 s5, s9 ; SI-NEXT: buffer_store_dwordx2 v[0:1], off, s[4:7], 0 ; SI-NEXT: s_endpgm ; @@ -85,38 +77,33 @@ define amdgpu_kernel void @v_round_f64(double addrspace(1)* %out, double addrspa ; SI-NEXT: s_waitcnt lgkmcnt(0) ; SI-NEXT: s_mov_b64 s[0:1], s[6:7] ; SI-NEXT: buffer_load_dwordx2 v[2:3], v[0:1], s[0:3], 0 addr64 -; SI-NEXT: s_movk_i32 s11, 0xfc01 -; SI-NEXT: s_mov_b32 s9, 0xfffff -; SI-NEXT: s_mov_b32 s8, -1 +; SI-NEXT: s_movk_i32 s9, 0xfc01 +; SI-NEXT: s_mov_b32 s7, 0xfffff +; SI-NEXT: s_mov_b32 s6, -1 +; SI-NEXT: s_brev_b32 s8, -2 ; SI-NEXT: v_mov_b32_e32 v8, 0x3ff00000 -; SI-NEXT: s_brev_b32 s10, -2 -; SI-NEXT: s_mov_b64 s[6:7], s[2:3] -; SI-NEXT: s_mov_b32 s3, 0x80000 ; SI-NEXT: s_waitcnt vmcnt(0) ; SI-NEXT: v_bfe_u32 v4, v3, 20, 11 -; SI-NEXT: v_add_i32_e32 v10, vcc, s11, v4 -; SI-NEXT: v_lshr_b64 v[4:5], s[8:9], v10 -; SI-NEXT: v_cmp_eq_u32_e32 vcc, -1, v10 -; SI-NEXT: v_cndmask_b32_e32 v8, 0, v8, vcc -; SI-NEXT: v_bfi_b32 v11, s10, v8, v3 -; SI-NEXT: v_and_b32_e32 v9, v3, v5 -; SI-NEXT: v_and_b32_e32 v8, v2, v4 -; SI-NEXT: v_lshr_b64 v[6:7], s[2:3], v10 -; SI-NEXT: v_cmp_ne_u64_e32 vcc, 0, v[8:9] +; SI-NEXT: v_add_i32_e32 v6, vcc, s9, v4 +; SI-NEXT: v_lshr_b64 v[4:5], s[6:7], v6 +; SI-NEXT: v_and_b32_e32 v7, 0x80000000, v3 ; SI-NEXT: v_not_b32_e32 v4, v4 -; SI-NEXT: v_cndmask_b32_e32 v6, 0, v6, vcc -; SI-NEXT: v_cndmask_b32_e32 v7, 0, v7, vcc -; SI-NEXT: v_add_i32_e32 v6, vcc, v2, v6 -; SI-NEXT: v_addc_u32_e32 v7, vcc, v3, v7, vcc ; SI-NEXT: v_not_b32_e32 v5, v5 -; SI-NEXT: v_and_b32_e32 v5, v7, v5 -; SI-NEXT: v_cmp_gt_i32_e32 vcc, 0, v10 -; SI-NEXT: v_and_b32_e32 v4, v6, v4 -; SI-NEXT: v_cndmask_b32_e32 v5, v5, v11, vcc +; SI-NEXT: v_and_b32_e32 v5, v3, v5 +; SI-NEXT: v_cmp_gt_i32_e32 vcc, 0, v6 +; SI-NEXT: v_and_b32_e32 v4, v2, v4 +; SI-NEXT: v_cndmask_b32_e32 v5, v5, v7, vcc ; SI-NEXT: v_cndmask_b32_e64 v4, v4, 0, vcc -; SI-NEXT: v_cmp_lt_i32_e32 vcc, 51, v10 -; SI-NEXT: v_cndmask_b32_e32 v3, v5, v3, vcc -; SI-NEXT: v_cndmask_b32_e32 v2, v4, v2, vcc +; SI-NEXT: v_cmp_lt_i32_e32 vcc, 51, v6 +; SI-NEXT: v_cndmask_b32_e32 v5, v5, v3, vcc +; SI-NEXT: v_cndmask_b32_e32 v4, v4, v2, vcc +; SI-NEXT: v_add_f64 v[6:7], v[2:3], -v[4:5] +; SI-NEXT: v_bfi_b32 v2, s8, v8, v3 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[6:7]|, 0.5 +; SI-NEXT: s_mov_b64 s[6:7], s[2:3] +; SI-NEXT: v_cndmask_b32_e32 v3, 0, v2, vcc +; SI-NEXT: v_mov_b32_e32 v2, 0 +; SI-NEXT: v_add_f64 v[2:3], v[4:5], v[2:3] ; SI-NEXT: buffer_store_dwordx2 v[2:3], v[0:1], s[4:7], 0 addr64 ; SI-NEXT: s_endpgm ; @@ -158,73 +145,60 @@ define amdgpu_kernel void @round_v2f64(<2 x double> addrspace(1)* %out, <2 x dou ; SI-NEXT: s_load_dwordx2 s[4:5], s[0:1], 0x9 ; SI-NEXT: s_load_dwordx4 s[8:11], s[0:1], 0xd ; SI-NEXT: s_mov_b32 s6, -1 -; SI-NEXT: s_movk_i32 s18, 0xfc01 +; SI-NEXT: s_movk_i32 s7, 0xfc01 ; SI-NEXT: s_mov_b32 s3, 0xfffff ; SI-NEXT: s_mov_b32 s2, s6 ; SI-NEXT: s_waitcnt lgkmcnt(0) ; SI-NEXT: s_bfe_u32 s0, s11, 0xb0014 -; SI-NEXT: s_add_i32 s19, s0, s18 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s19 -; SI-NEXT: s_and_b64 s[12:13], s[10:11], s[0:1] -; SI-NEXT: s_mov_b32 s15, 0x80000 -; SI-NEXT: s_mov_b32 s14, 0 -; SI-NEXT: s_lshr_b64 s[16:17], s[14:15], s19 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[12:13], 0 -; SI-NEXT: v_mov_b32_e32 v1, s16 -; SI-NEXT: v_mov_b32_e32 v0, s17 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v1, vcc -; SI-NEXT: v_cndmask_b32_e32 v0, 0, v0, vcc -; SI-NEXT: v_mov_b32_e32 v2, s11 -; SI-NEXT: v_add_i32_e32 v1, vcc, s10, v1 -; SI-NEXT: v_addc_u32_e32 v0, vcc, v2, v0, vcc -; SI-NEXT: v_not_b32_e32 v2, s0 -; SI-NEXT: v_and_b32_e32 v1, v1, v2 -; SI-NEXT: v_not_b32_e32 v2, s1 -; SI-NEXT: v_mov_b32_e32 v4, 0x3ff00000 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s19, -1 -; SI-NEXT: v_and_b32_e32 v0, v0, v2 -; SI-NEXT: v_cndmask_b32_e32 v2, 0, v4, vcc -; SI-NEXT: s_brev_b32 s12, -2 -; SI-NEXT: v_mov_b32_e32 v3, s11 -; SI-NEXT: v_bfi_b32 v2, s12, v2, v3 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s19, 0 -; SI-NEXT: v_cndmask_b32_e32 v0, v0, v2, vcc -; SI-NEXT: v_mov_b32_e32 v2, s11 -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s19, 51 -; SI-NEXT: v_cndmask_b32_e64 v3, v0, v2, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v0, v1, 0, vcc -; SI-NEXT: v_mov_b32_e32 v1, s10 -; SI-NEXT: v_cndmask_b32_e64 v2, v0, v1, s[0:1] +; SI-NEXT: s_add_i32 s14, s0, s7 +; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s14 +; SI-NEXT: s_brev_b32 s15, 1 +; SI-NEXT: s_andn2_b64 s[12:13], s[10:11], s[0:1] +; SI-NEXT: s_and_b32 s0, s11, s15 +; SI-NEXT: v_mov_b32_e32 v1, s0 +; SI-NEXT: v_mov_b32_e32 v0, s13 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s14, 0 +; SI-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc +; SI-NEXT: v_mov_b32_e32 v1, s11 +; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s14, 51 +; SI-NEXT: v_cndmask_b32_e64 v1, v0, v1, s[0:1] +; SI-NEXT: v_mov_b32_e32 v0, s12 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, 0, vcc +; SI-NEXT: v_mov_b32_e32 v2, s10 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, v2, s[0:1] +; SI-NEXT: v_add_f64 v[2:3], s[10:11], -v[0:1] ; SI-NEXT: s_bfe_u32 s0, s9, 0xb0014 -; SI-NEXT: s_add_i32 s13, s0, s18 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s13 -; SI-NEXT: s_and_b64 s[2:3], s[8:9], s[0:1] -; SI-NEXT: s_lshr_b64 s[10:11], s[14:15], s13 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[2:3], 0 -; SI-NEXT: v_mov_b32_e32 v1, s10 -; SI-NEXT: v_mov_b32_e32 v0, s11 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v1, vcc -; SI-NEXT: v_cndmask_b32_e32 v0, 0, v0, vcc -; SI-NEXT: v_mov_b32_e32 v5, s9 -; SI-NEXT: v_add_i32_e32 v1, vcc, s8, v1 -; SI-NEXT: v_addc_u32_e32 v0, vcc, v5, v0, vcc -; SI-NEXT: v_not_b32_e32 v5, s0 -; SI-NEXT: v_and_b32_e32 v5, v1, v5 -; SI-NEXT: v_not_b32_e32 v1, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s13, -1 -; SI-NEXT: v_and_b32_e32 v0, v0, v1 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v4, vcc -; SI-NEXT: v_mov_b32_e32 v4, s9 -; SI-NEXT: v_bfi_b32 v1, s12, v1, v4 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s13, 0 +; SI-NEXT: s_add_i32 s7, s0, s7 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[2:3]|, 0.5 +; SI-NEXT: s_brev_b32 s10, -2 +; SI-NEXT: v_mov_b32_e32 v6, 0x3ff00000 +; SI-NEXT: v_mov_b32_e32 v4, s11 +; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s7 +; SI-NEXT: v_bfi_b32 v4, s10, v6, v4 +; SI-NEXT: v_cndmask_b32_e32 v3, 0, v4, vcc +; SI-NEXT: v_mov_b32_e32 v2, 0 +; SI-NEXT: s_andn2_b64 s[2:3], s[8:9], s[0:1] +; SI-NEXT: s_and_b32 s0, s9, s15 +; SI-NEXT: v_add_f64 v[2:3], v[0:1], v[2:3] +; SI-NEXT: v_mov_b32_e32 v1, s0 +; SI-NEXT: v_mov_b32_e32 v0, s3 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s7, 0 ; SI-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc +; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s7, 51 ; SI-NEXT: v_mov_b32_e32 v1, s9 -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s13, 51 ; SI-NEXT: v_cndmask_b32_e64 v1, v0, v1, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v0, v5, 0, vcc +; SI-NEXT: v_mov_b32_e32 v0, s2 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, 0, vcc ; SI-NEXT: v_mov_b32_e32 v4, s8 -; SI-NEXT: s_mov_b32 s7, 0xf000 ; SI-NEXT: v_cndmask_b32_e64 v0, v0, v4, s[0:1] +; SI-NEXT: v_add_f64 v[4:5], s[8:9], -v[0:1] +; SI-NEXT: v_mov_b32_e32 v7, s9 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[4:5]|, 0.5 +; SI-NEXT: v_bfi_b32 v6, s10, v6, v7 +; SI-NEXT: v_cndmask_b32_e32 v5, 0, v6, vcc +; SI-NEXT: v_mov_b32_e32 v4, 0 +; SI-NEXT: v_add_f64 v[0:1], v[0:1], v[4:5] +; SI-NEXT: s_mov_b32 s7, 0xf000 ; SI-NEXT: buffer_store_dwordx4 v[0:3], off, s[4:7], 0 ; SI-NEXT: s_endpgm ; @@ -266,127 +240,102 @@ define amdgpu_kernel void @round_v4f64(<4 x double> addrspace(1)* %out, <4 x dou ; SI-NEXT: s_load_dwordx2 s[4:5], s[0:1], 0x9 ; SI-NEXT: s_load_dwordx8 s[8:15], s[0:1], 0x11 ; SI-NEXT: s_mov_b32 s6, -1 -; SI-NEXT: s_movk_i32 s22, 0xfc01 +; SI-NEXT: s_movk_i32 s18, 0xfc01 ; SI-NEXT: s_mov_b32 s3, 0xfffff ; SI-NEXT: s_mov_b32 s2, s6 ; SI-NEXT: s_waitcnt lgkmcnt(0) ; SI-NEXT: s_bfe_u32 s0, s11, 0xb0014 -; SI-NEXT: s_add_i32 s23, s0, s22 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s23 -; SI-NEXT: s_and_b64 s[16:17], s[10:11], s[0:1] -; SI-NEXT: s_mov_b32 s19, 0x80000 -; SI-NEXT: s_mov_b32 s18, 0 -; SI-NEXT: s_lshr_b64 s[20:21], s[18:19], s23 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[16:17], 0 -; SI-NEXT: v_mov_b32_e32 v1, s20 -; SI-NEXT: v_mov_b32_e32 v0, s21 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v1, vcc -; SI-NEXT: v_cndmask_b32_e32 v0, 0, v0, vcc -; SI-NEXT: v_mov_b32_e32 v2, s11 -; SI-NEXT: v_add_i32_e32 v1, vcc, s10, v1 -; SI-NEXT: v_addc_u32_e32 v0, vcc, v2, v0, vcc -; SI-NEXT: v_not_b32_e32 v2, s0 -; SI-NEXT: v_and_b32_e32 v1, v1, v2 -; SI-NEXT: v_not_b32_e32 v2, s1 -; SI-NEXT: v_mov_b32_e32 v4, 0x3ff00000 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s23, -1 -; SI-NEXT: v_and_b32_e32 v0, v0, v2 -; SI-NEXT: v_cndmask_b32_e32 v2, 0, v4, vcc -; SI-NEXT: s_brev_b32 s20, -2 -; SI-NEXT: v_mov_b32_e32 v3, s11 -; SI-NEXT: v_bfi_b32 v2, s20, v2, v3 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s23, 0 -; SI-NEXT: v_cndmask_b32_e32 v0, v0, v2, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s23, 51 -; SI-NEXT: v_cndmask_b32_e64 v3, v0, v3, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v0, v1, 0, vcc -; SI-NEXT: v_mov_b32_e32 v1, s10 -; SI-NEXT: v_cndmask_b32_e64 v2, v0, v1, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s9, 0xb0014 -; SI-NEXT: s_add_i32 s21, s0, s22 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s21 -; SI-NEXT: s_and_b64 s[10:11], s[8:9], s[0:1] -; SI-NEXT: s_lshr_b64 s[16:17], s[18:19], s21 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[10:11], 0 -; SI-NEXT: v_mov_b32_e32 v1, s16 +; SI-NEXT: s_add_i32 s19, s0, s18 +; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s19 +; SI-NEXT: s_brev_b32 s20, 1 +; SI-NEXT: s_andn2_b64 s[16:17], s[10:11], s[0:1] +; SI-NEXT: s_and_b32 s0, s11, s20 +; SI-NEXT: v_mov_b32_e32 v1, s0 ; SI-NEXT: v_mov_b32_e32 v0, s17 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v1, vcc -; SI-NEXT: v_cndmask_b32_e32 v0, 0, v0, vcc -; SI-NEXT: v_mov_b32_e32 v5, s9 -; SI-NEXT: v_add_i32_e32 v1, vcc, s8, v1 -; SI-NEXT: v_addc_u32_e32 v0, vcc, v5, v0, vcc -; SI-NEXT: v_not_b32_e32 v5, s0 -; SI-NEXT: v_and_b32_e32 v5, v1, v5 -; SI-NEXT: v_not_b32_e32 v1, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s21, -1 -; SI-NEXT: v_and_b32_e32 v0, v0, v1 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v4, vcc -; SI-NEXT: v_mov_b32_e32 v6, s9 -; SI-NEXT: v_bfi_b32 v1, s20, v1, v6 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s21, 0 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s19, 0 +; SI-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc +; SI-NEXT: v_mov_b32_e32 v4, s11 +; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s19, 51 +; SI-NEXT: v_cndmask_b32_e64 v1, v0, v4, s[0:1] +; SI-NEXT: v_mov_b32_e32 v0, s16 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, 0, vcc +; SI-NEXT: v_mov_b32_e32 v2, s10 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, v2, s[0:1] +; SI-NEXT: v_add_f64 v[2:3], s[10:11], -v[0:1] +; SI-NEXT: s_bfe_u32 s0, s9, 0xb0014 +; SI-NEXT: s_add_i32 s17, s0, s18 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[2:3]|, 0.5 +; SI-NEXT: s_brev_b32 s16, -2 +; SI-NEXT: v_mov_b32_e32 v12, 0x3ff00000 +; SI-NEXT: v_bfi_b32 v4, s16, v12, v4 +; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s17 +; SI-NEXT: v_cndmask_b32_e32 v3, 0, v4, vcc +; SI-NEXT: v_mov_b32_e32 v2, 0 +; SI-NEXT: s_andn2_b64 s[10:11], s[8:9], s[0:1] +; SI-NEXT: s_and_b32 s0, s9, s20 +; SI-NEXT: v_add_f64 v[2:3], v[0:1], v[2:3] +; SI-NEXT: v_mov_b32_e32 v1, s0 +; SI-NEXT: v_mov_b32_e32 v0, s11 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s17, 0 ; SI-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s21, 51 +; SI-NEXT: v_mov_b32_e32 v6, s9 +; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s17, 51 ; SI-NEXT: v_cndmask_b32_e64 v1, v0, v6, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v0, v5, 0, vcc -; SI-NEXT: v_mov_b32_e32 v5, s8 -; SI-NEXT: v_cndmask_b32_e64 v0, v0, v5, s[0:1] +; SI-NEXT: v_mov_b32_e32 v0, s10 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, 0, vcc +; SI-NEXT: v_mov_b32_e32 v4, s8 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, v4, s[0:1] +; SI-NEXT: v_add_f64 v[4:5], s[8:9], -v[0:1] ; SI-NEXT: s_bfe_u32 s0, s15, 0xb0014 -; SI-NEXT: s_add_i32 s16, s0, s22 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s16 -; SI-NEXT: s_and_b64 s[8:9], s[14:15], s[0:1] -; SI-NEXT: s_lshr_b64 s[10:11], s[18:19], s16 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[8:9], 0 -; SI-NEXT: v_mov_b32_e32 v6, s10 -; SI-NEXT: v_mov_b32_e32 v5, s11 -; SI-NEXT: v_cndmask_b32_e32 v6, 0, v6, vcc -; SI-NEXT: v_cndmask_b32_e32 v5, 0, v5, vcc -; SI-NEXT: v_mov_b32_e32 v7, s15 -; SI-NEXT: v_add_i32_e32 v6, vcc, s14, v6 -; SI-NEXT: v_addc_u32_e32 v5, vcc, v7, v5, vcc -; SI-NEXT: v_not_b32_e32 v7, s0 -; SI-NEXT: v_and_b32_e32 v6, v6, v7 -; SI-NEXT: v_not_b32_e32 v7, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s16, -1 -; SI-NEXT: v_and_b32_e32 v5, v5, v7 -; SI-NEXT: v_cndmask_b32_e32 v7, 0, v4, vcc -; SI-NEXT: v_mov_b32_e32 v8, s15 -; SI-NEXT: v_bfi_b32 v7, s20, v7, v8 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s16, 0 -; SI-NEXT: v_cndmask_b32_e32 v5, v5, v7, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s16, 51 -; SI-NEXT: v_cndmask_b32_e64 v7, v5, v8, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v5, v6, 0, vcc -; SI-NEXT: v_mov_b32_e32 v6, s14 -; SI-NEXT: v_cndmask_b32_e64 v6, v5, v6, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s13, 0xb0014 -; SI-NEXT: s_add_i32 s10, s0, s22 +; SI-NEXT: s_add_i32 s10, s0, s18 ; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s10 -; SI-NEXT: s_and_b64 s[2:3], s[12:13], s[0:1] -; SI-NEXT: s_lshr_b64 s[8:9], s[18:19], s10 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[2:3], 0 -; SI-NEXT: v_mov_b32_e32 v8, s8 -; SI-NEXT: v_mov_b32_e32 v5, s9 -; SI-NEXT: v_cndmask_b32_e32 v8, 0, v8, vcc -; SI-NEXT: v_cndmask_b32_e32 v5, 0, v5, vcc -; SI-NEXT: v_mov_b32_e32 v9, s13 -; SI-NEXT: v_add_i32_e32 v8, vcc, s12, v8 -; SI-NEXT: v_addc_u32_e32 v5, vcc, v9, v5, vcc -; SI-NEXT: v_not_b32_e32 v9, s0 -; SI-NEXT: v_and_b32_e32 v8, v8, v9 -; SI-NEXT: v_not_b32_e32 v9, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s10, -1 -; SI-NEXT: v_and_b32_e32 v5, v5, v9 -; SI-NEXT: v_cndmask_b32_e32 v4, 0, v4, vcc -; SI-NEXT: v_mov_b32_e32 v9, s13 -; SI-NEXT: v_bfi_b32 v4, s20, v4, v9 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[4:5]|, 0.5 +; SI-NEXT: s_andn2_b64 s[8:9], s[14:15], s[0:1] +; SI-NEXT: v_bfi_b32 v6, s16, v12, v6 +; SI-NEXT: s_and_b32 s0, s15, s20 +; SI-NEXT: v_cndmask_b32_e32 v9, 0, v6, vcc +; SI-NEXT: v_mov_b32_e32 v5, s0 +; SI-NEXT: v_mov_b32_e32 v4, s9 ; SI-NEXT: v_cmp_lt_i32_e64 vcc, s10, 0 -; SI-NEXT: v_cndmask_b32_e32 v4, v5, v4, vcc +; SI-NEXT: v_cndmask_b32_e32 v4, v4, v5, vcc +; SI-NEXT: v_mov_b32_e32 v10, s15 ; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s10, 51 -; SI-NEXT: v_cndmask_b32_e64 v5, v4, v9, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v4, v8, 0, vcc -; SI-NEXT: v_mov_b32_e32 v8, s12 +; SI-NEXT: v_cndmask_b32_e64 v5, v4, v10, s[0:1] +; SI-NEXT: v_mov_b32_e32 v4, s8 +; SI-NEXT: v_cndmask_b32_e64 v4, v4, 0, vcc +; SI-NEXT: v_mov_b32_e32 v6, s14 +; SI-NEXT: v_cndmask_b32_e64 v4, v4, v6, s[0:1] +; SI-NEXT: v_add_f64 v[6:7], s[14:15], -v[4:5] +; SI-NEXT: s_bfe_u32 s0, s13, 0xb0014 +; SI-NEXT: s_add_i32 s8, s0, s18 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[6:7]|, 0.5 +; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s8 +; SI-NEXT: v_bfi_b32 v10, s16, v12, v10 +; SI-NEXT: v_cndmask_b32_e32 v7, 0, v10, vcc +; SI-NEXT: v_mov_b32_e32 v6, 0 +; SI-NEXT: s_andn2_b64 s[2:3], s[12:13], s[0:1] +; SI-NEXT: s_and_b32 s0, s13, s20 +; SI-NEXT: v_add_f64 v[6:7], v[4:5], v[6:7] +; SI-NEXT: v_mov_b32_e32 v5, s0 +; SI-NEXT: v_mov_b32_e32 v4, s3 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s8, 0 +; SI-NEXT: v_mov_b32_e32 v13, s13 +; SI-NEXT: v_cndmask_b32_e32 v4, v4, v5, vcc +; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s8, 51 +; SI-NEXT: v_cndmask_b32_e64 v5, v4, v13, s[0:1] +; SI-NEXT: v_mov_b32_e32 v4, s2 +; SI-NEXT: v_cndmask_b32_e64 v4, v4, 0, vcc +; SI-NEXT: v_mov_b32_e32 v10, s12 +; SI-NEXT: v_cndmask_b32_e64 v4, v4, v10, s[0:1] +; SI-NEXT: v_add_f64 v[10:11], s[12:13], -v[4:5] +; SI-NEXT: v_bfi_b32 v12, s16, v12, v13 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[10:11]|, 0.5 +; SI-NEXT: v_mov_b32_e32 v10, 0 +; SI-NEXT: v_cndmask_b32_e32 v11, 0, v12, vcc +; SI-NEXT: v_mov_b32_e32 v8, 0 +; SI-NEXT: v_add_f64 v[4:5], v[4:5], v[10:11] ; SI-NEXT: s_mov_b32 s7, 0xf000 -; SI-NEXT: v_cndmask_b32_e64 v4, v4, v8, s[0:1] +; SI-NEXT: v_add_f64 v[0:1], v[0:1], v[8:9] ; SI-NEXT: buffer_store_dwordx4 v[4:7], off, s[4:7], 0 offset:16 ; SI-NEXT: buffer_store_dwordx4 v[0:3], off, s[4:7], 0 ; SI-NEXT: s_endpgm @@ -443,244 +392,196 @@ define amdgpu_kernel void @round_v4f64(<4 x double> addrspace(1)* %out, <4 x dou define amdgpu_kernel void @round_v8f64(<8 x double> addrspace(1)* %out, <8 x double> %in) #0 { ; SI-LABEL: round_v8f64: ; SI: ; %bb.0: -; SI-NEXT: s_load_dwordx2 s[4:5], s[0:1], 0x9 ; SI-NEXT: s_load_dwordx16 s[8:23], s[0:1], 0x19 ; SI-NEXT: s_mov_b32 s6, -1 -; SI-NEXT: s_movk_i32 s30, 0xfc01 -; SI-NEXT: s_mov_b32 s3, 0xfffff -; SI-NEXT: s_mov_b32 s2, s6 +; SI-NEXT: s_movk_i32 s7, 0xfc01 +; SI-NEXT: s_mov_b32 s5, 0xfffff +; SI-NEXT: s_mov_b32 s4, s6 ; SI-NEXT: s_waitcnt lgkmcnt(0) -; SI-NEXT: s_bfe_u32 s0, s11, 0xb0014 -; SI-NEXT: s_add_i32 s31, s0, s30 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s31 -; SI-NEXT: s_and_b64 s[26:27], s[10:11], s[0:1] -; SI-NEXT: s_mov_b32 s25, 0x80000 -; SI-NEXT: s_mov_b32 s24, 0 -; SI-NEXT: s_lshr_b64 s[28:29], s[24:25], s31 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[26:27], 0 -; SI-NEXT: v_mov_b32_e32 v1, s28 -; SI-NEXT: v_mov_b32_e32 v0, s29 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v1, vcc -; SI-NEXT: v_cndmask_b32_e32 v0, 0, v0, vcc -; SI-NEXT: v_mov_b32_e32 v2, s11 -; SI-NEXT: v_add_i32_e32 v1, vcc, s10, v1 -; SI-NEXT: v_addc_u32_e32 v0, vcc, v2, v0, vcc -; SI-NEXT: v_not_b32_e32 v2, s0 -; SI-NEXT: v_and_b32_e32 v1, v1, v2 -; SI-NEXT: v_not_b32_e32 v2, s1 -; SI-NEXT: v_mov_b32_e32 v12, 0x3ff00000 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s31, -1 -; SI-NEXT: v_and_b32_e32 v0, v0, v2 -; SI-NEXT: v_cndmask_b32_e32 v2, 0, v12, vcc -; SI-NEXT: s_brev_b32 s28, -2 -; SI-NEXT: v_mov_b32_e32 v3, s11 -; SI-NEXT: v_bfi_b32 v2, s28, v2, v3 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s31, 0 -; SI-NEXT: v_cndmask_b32_e32 v0, v0, v2, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s31, 51 -; SI-NEXT: v_cndmask_b32_e64 v3, v0, v3, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v0, v1, 0, vcc -; SI-NEXT: v_mov_b32_e32 v1, s10 -; SI-NEXT: v_cndmask_b32_e64 v2, v0, v1, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s9, 0xb0014 -; SI-NEXT: s_add_i32 s29, s0, s30 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s29 -; SI-NEXT: s_and_b64 s[10:11], s[8:9], s[0:1] -; SI-NEXT: s_lshr_b64 s[26:27], s[24:25], s29 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[10:11], 0 -; SI-NEXT: v_mov_b32_e32 v1, s26 -; SI-NEXT: v_mov_b32_e32 v0, s27 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v1, vcc -; SI-NEXT: v_cndmask_b32_e32 v0, 0, v0, vcc -; SI-NEXT: v_mov_b32_e32 v4, s9 -; SI-NEXT: v_add_i32_e32 v1, vcc, s8, v1 -; SI-NEXT: v_addc_u32_e32 v0, vcc, v4, v0, vcc -; SI-NEXT: v_not_b32_e32 v4, s0 -; SI-NEXT: v_and_b32_e32 v4, v1, v4 -; SI-NEXT: v_not_b32_e32 v1, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s29, -1 -; SI-NEXT: v_and_b32_e32 v0, v0, v1 -; SI-NEXT: v_cndmask_b32_e32 v1, 0, v12, vcc -; SI-NEXT: v_mov_b32_e32 v5, s9 -; SI-NEXT: v_bfi_b32 v1, s28, v1, v5 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s29, 0 -; SI-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s29, 51 -; SI-NEXT: v_cndmask_b32_e64 v1, v0, v5, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v0, v4, 0, vcc -; SI-NEXT: v_mov_b32_e32 v4, s8 -; SI-NEXT: v_cndmask_b32_e64 v0, v0, v4, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s15, 0xb0014 -; SI-NEXT: s_add_i32 s26, s0, s30 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s26 -; SI-NEXT: s_and_b64 s[8:9], s[14:15], s[0:1] -; SI-NEXT: s_lshr_b64 s[10:11], s[24:25], s26 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[8:9], 0 -; SI-NEXT: v_mov_b32_e32 v5, s10 -; SI-NEXT: v_mov_b32_e32 v4, s11 -; SI-NEXT: v_cndmask_b32_e32 v5, 0, v5, vcc -; SI-NEXT: v_cndmask_b32_e32 v4, 0, v4, vcc -; SI-NEXT: v_mov_b32_e32 v6, s15 -; SI-NEXT: v_add_i32_e32 v5, vcc, s14, v5 -; SI-NEXT: v_addc_u32_e32 v4, vcc, v6, v4, vcc -; SI-NEXT: v_not_b32_e32 v6, s0 -; SI-NEXT: v_and_b32_e32 v5, v5, v6 -; SI-NEXT: v_not_b32_e32 v6, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s26, -1 -; SI-NEXT: v_and_b32_e32 v4, v4, v6 -; SI-NEXT: v_cndmask_b32_e32 v6, 0, v12, vcc -; SI-NEXT: v_mov_b32_e32 v7, s15 -; SI-NEXT: v_bfi_b32 v6, s28, v6, v7 +; SI-NEXT: s_bfe_u32 s2, s11, 0xb0014 +; SI-NEXT: s_add_i32 s26, s2, s7 +; SI-NEXT: s_lshr_b64 s[2:3], s[4:5], s26 +; SI-NEXT: s_brev_b32 s27, 1 +; SI-NEXT: s_andn2_b64 s[24:25], s[10:11], s[2:3] +; SI-NEXT: s_and_b32 s2, s11, s27 +; SI-NEXT: v_mov_b32_e32 v1, s2 +; SI-NEXT: v_mov_b32_e32 v0, s25 ; SI-NEXT: v_cmp_lt_i32_e64 vcc, s26, 0 -; SI-NEXT: v_cndmask_b32_e32 v4, v4, v6, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s26, 51 -; SI-NEXT: v_cndmask_b32_e64 v7, v4, v7, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v4, v5, 0, vcc -; SI-NEXT: v_mov_b32_e32 v5, s14 -; SI-NEXT: v_cndmask_b32_e64 v6, v4, v5, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s13, 0xb0014 -; SI-NEXT: s_add_i32 s14, s0, s30 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s14 -; SI-NEXT: s_and_b64 s[8:9], s[12:13], s[0:1] -; SI-NEXT: s_lshr_b64 s[10:11], s[24:25], s14 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[8:9], 0 -; SI-NEXT: v_mov_b32_e32 v5, s10 +; SI-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc ; SI-NEXT: v_mov_b32_e32 v4, s11 -; SI-NEXT: v_cndmask_b32_e32 v5, 0, v5, vcc -; SI-NEXT: v_cndmask_b32_e32 v4, 0, v4, vcc -; SI-NEXT: v_mov_b32_e32 v8, s13 -; SI-NEXT: v_add_i32_e32 v5, vcc, s12, v5 -; SI-NEXT: v_addc_u32_e32 v4, vcc, v8, v4, vcc -; SI-NEXT: v_not_b32_e32 v8, s0 -; SI-NEXT: v_and_b32_e32 v8, v5, v8 -; SI-NEXT: v_not_b32_e32 v5, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s14, -1 -; SI-NEXT: v_and_b32_e32 v4, v4, v5 -; SI-NEXT: v_cndmask_b32_e32 v5, 0, v12, vcc -; SI-NEXT: v_mov_b32_e32 v9, s13 -; SI-NEXT: v_bfi_b32 v5, s28, v5, v9 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s14, 0 +; SI-NEXT: v_cmp_gt_i32_e64 s[2:3], s26, 51 +; SI-NEXT: v_cndmask_b32_e64 v1, v0, v4, s[2:3] +; SI-NEXT: v_mov_b32_e32 v0, s24 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, 0, vcc +; SI-NEXT: v_mov_b32_e32 v2, s10 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, v2, s[2:3] +; SI-NEXT: v_add_f64 v[2:3], s[10:11], -v[0:1] +; SI-NEXT: s_bfe_u32 s2, s9, 0xb0014 +; SI-NEXT: s_add_i32 s25, s2, s7 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[2:3]|, 0.5 +; SI-NEXT: s_brev_b32 s24, -2 +; SI-NEXT: v_mov_b32_e32 v18, 0x3ff00000 +; SI-NEXT: v_bfi_b32 v4, s24, v18, v4 +; SI-NEXT: s_lshr_b64 s[2:3], s[4:5], s25 +; SI-NEXT: v_cndmask_b32_e32 v3, 0, v4, vcc +; SI-NEXT: v_mov_b32_e32 v2, 0 +; SI-NEXT: s_andn2_b64 s[10:11], s[8:9], s[2:3] +; SI-NEXT: s_and_b32 s2, s9, s27 +; SI-NEXT: v_add_f64 v[2:3], v[0:1], v[2:3] +; SI-NEXT: v_mov_b32_e32 v1, s2 +; SI-NEXT: v_mov_b32_e32 v0, s11 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s25, 0 +; SI-NEXT: v_cndmask_b32_e32 v0, v0, v1, vcc +; SI-NEXT: v_mov_b32_e32 v6, s9 +; SI-NEXT: v_cmp_gt_i32_e64 s[2:3], s25, 51 +; SI-NEXT: v_cndmask_b32_e64 v1, v0, v6, s[2:3] +; SI-NEXT: v_mov_b32_e32 v0, s10 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, 0, vcc +; SI-NEXT: v_mov_b32_e32 v4, s8 +; SI-NEXT: v_cndmask_b32_e64 v0, v0, v4, s[2:3] +; SI-NEXT: v_add_f64 v[4:5], s[8:9], -v[0:1] +; SI-NEXT: s_bfe_u32 s2, s15, 0xb0014 +; SI-NEXT: s_add_i32 s10, s2, s7 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[4:5]|, 0.5 +; SI-NEXT: v_bfi_b32 v6, s24, v18, v6 +; SI-NEXT: s_lshr_b64 s[2:3], s[4:5], s10 +; SI-NEXT: v_cndmask_b32_e32 v5, 0, v6, vcc +; SI-NEXT: v_mov_b32_e32 v4, 0 +; SI-NEXT: s_andn2_b64 s[8:9], s[14:15], s[2:3] +; SI-NEXT: s_and_b32 s2, s15, s27 +; SI-NEXT: v_add_f64 v[0:1], v[0:1], v[4:5] +; SI-NEXT: v_mov_b32_e32 v5, s2 +; SI-NEXT: v_mov_b32_e32 v4, s9 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s10, 0 ; SI-NEXT: v_cndmask_b32_e32 v4, v4, v5, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s14, 51 -; SI-NEXT: v_cndmask_b32_e64 v5, v4, v9, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v4, v8, 0, vcc +; SI-NEXT: v_mov_b32_e32 v8, s15 +; SI-NEXT: v_cmp_gt_i32_e64 s[2:3], s10, 51 +; SI-NEXT: v_cndmask_b32_e64 v5, v4, v8, s[2:3] +; SI-NEXT: v_mov_b32_e32 v4, s8 +; SI-NEXT: v_cndmask_b32_e64 v4, v4, 0, vcc +; SI-NEXT: v_mov_b32_e32 v6, s14 +; SI-NEXT: v_cndmask_b32_e64 v4, v4, v6, s[2:3] +; SI-NEXT: v_add_f64 v[6:7], s[14:15], -v[4:5] +; SI-NEXT: s_bfe_u32 s2, s13, 0xb0014 +; SI-NEXT: s_add_i32 s10, s2, s7 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[6:7]|, 0.5 +; SI-NEXT: v_bfi_b32 v8, s24, v18, v8 +; SI-NEXT: s_lshr_b64 s[2:3], s[4:5], s10 +; SI-NEXT: v_cndmask_b32_e32 v7, 0, v8, vcc +; SI-NEXT: v_mov_b32_e32 v6, 0 +; SI-NEXT: s_andn2_b64 s[8:9], s[12:13], s[2:3] +; SI-NEXT: s_and_b32 s2, s13, s27 +; SI-NEXT: v_add_f64 v[6:7], v[4:5], v[6:7] +; SI-NEXT: v_mov_b32_e32 v5, s2 +; SI-NEXT: v_mov_b32_e32 v4, s9 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s10, 0 +; SI-NEXT: v_cndmask_b32_e32 v4, v4, v5, vcc +; SI-NEXT: v_mov_b32_e32 v10, s13 +; SI-NEXT: v_cmp_gt_i32_e64 s[2:3], s10, 51 +; SI-NEXT: v_cndmask_b32_e64 v5, v4, v10, s[2:3] +; SI-NEXT: v_mov_b32_e32 v4, s8 +; SI-NEXT: v_cndmask_b32_e64 v4, v4, 0, vcc ; SI-NEXT: v_mov_b32_e32 v8, s12 -; SI-NEXT: v_cndmask_b32_e64 v4, v4, v8, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s19, 0xb0014 -; SI-NEXT: s_add_i32 s12, s0, s30 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s12 -; SI-NEXT: s_and_b64 s[8:9], s[18:19], s[0:1] -; SI-NEXT: s_lshr_b64 s[10:11], s[24:25], s12 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[8:9], 0 -; SI-NEXT: v_mov_b32_e32 v9, s10 -; SI-NEXT: v_mov_b32_e32 v8, s11 -; SI-NEXT: v_cndmask_b32_e32 v9, 0, v9, vcc -; SI-NEXT: v_cndmask_b32_e32 v8, 0, v8, vcc -; SI-NEXT: v_mov_b32_e32 v10, s19 -; SI-NEXT: v_add_i32_e32 v9, vcc, s18, v9 -; SI-NEXT: v_addc_u32_e32 v8, vcc, v10, v8, vcc -; SI-NEXT: v_not_b32_e32 v10, s0 -; SI-NEXT: v_and_b32_e32 v9, v9, v10 -; SI-NEXT: v_not_b32_e32 v10, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s12, -1 -; SI-NEXT: v_and_b32_e32 v8, v8, v10 -; SI-NEXT: v_cndmask_b32_e32 v10, 0, v12, vcc -; SI-NEXT: v_mov_b32_e32 v11, s19 -; SI-NEXT: v_bfi_b32 v10, s28, v10, v11 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s12, 0 -; SI-NEXT: v_cndmask_b32_e32 v8, v8, v10, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s12, 51 -; SI-NEXT: v_cndmask_b32_e64 v11, v8, v11, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v8, v9, 0, vcc +; SI-NEXT: v_cndmask_b32_e64 v4, v4, v8, s[2:3] +; SI-NEXT: v_add_f64 v[8:9], s[12:13], -v[4:5] +; SI-NEXT: s_bfe_u32 s2, s19, 0xb0014 +; SI-NEXT: s_add_i32 s10, s2, s7 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[8:9]|, 0.5 +; SI-NEXT: v_bfi_b32 v10, s24, v18, v10 +; SI-NEXT: s_lshr_b64 s[2:3], s[4:5], s10 +; SI-NEXT: v_cndmask_b32_e32 v9, 0, v10, vcc +; SI-NEXT: v_mov_b32_e32 v8, 0 +; SI-NEXT: s_andn2_b64 s[8:9], s[18:19], s[2:3] +; SI-NEXT: s_and_b32 s2, s19, s27 +; SI-NEXT: v_add_f64 v[4:5], v[4:5], v[8:9] +; SI-NEXT: v_mov_b32_e32 v9, s2 +; SI-NEXT: v_mov_b32_e32 v8, s9 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s10, 0 +; SI-NEXT: v_cndmask_b32_e32 v8, v8, v9, vcc +; SI-NEXT: v_mov_b32_e32 v19, s19 +; SI-NEXT: v_cmp_gt_i32_e64 s[2:3], s10, 51 +; SI-NEXT: v_cndmask_b32_e64 v13, v8, v19, s[2:3] +; SI-NEXT: v_mov_b32_e32 v8, s8 +; SI-NEXT: v_cndmask_b32_e64 v8, v8, 0, vcc ; SI-NEXT: v_mov_b32_e32 v9, s18 -; SI-NEXT: v_cndmask_b32_e64 v10, v8, v9, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s17, 0xb0014 -; SI-NEXT: s_add_i32 s12, s0, s30 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s12 -; SI-NEXT: s_and_b64 s[8:9], s[16:17], s[0:1] -; SI-NEXT: s_lshr_b64 s[10:11], s[24:25], s12 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[8:9], 0 -; SI-NEXT: v_mov_b32_e32 v9, s10 +; SI-NEXT: v_cndmask_b32_e64 v12, v8, v9, s[2:3] +; SI-NEXT: s_bfe_u32 s2, s17, 0xb0014 +; SI-NEXT: s_add_i32 s12, s2, s7 +; SI-NEXT: s_lshr_b64 s[2:3], s[4:5], s12 +; SI-NEXT: s_andn2_b64 s[8:9], s[16:17], s[2:3] +; SI-NEXT: s_bfe_u32 s2, s23, 0xb0014 +; SI-NEXT: s_add_i32 s14, s2, s7 +; SI-NEXT: s_lshr_b64 s[2:3], s[4:5], s14 +; SI-NEXT: s_andn2_b64 s[10:11], s[22:23], s[2:3] +; SI-NEXT: s_and_b32 s2, s23, s27 +; SI-NEXT: v_mov_b32_e32 v9, s2 ; SI-NEXT: v_mov_b32_e32 v8, s11 -; SI-NEXT: v_cndmask_b32_e32 v9, 0, v9, vcc -; SI-NEXT: v_cndmask_b32_e32 v8, 0, v8, vcc -; SI-NEXT: v_mov_b32_e32 v13, s17 -; SI-NEXT: v_add_i32_e32 v9, vcc, s16, v9 -; SI-NEXT: v_addc_u32_e32 v8, vcc, v13, v8, vcc -; SI-NEXT: v_not_b32_e32 v13, s0 -; SI-NEXT: v_and_b32_e32 v13, v9, v13 -; SI-NEXT: v_not_b32_e32 v9, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s12, -1 -; SI-NEXT: v_and_b32_e32 v8, v8, v9 -; SI-NEXT: v_cndmask_b32_e32 v9, 0, v12, vcc -; SI-NEXT: v_mov_b32_e32 v14, s17 -; SI-NEXT: v_bfi_b32 v9, s28, v9, v14 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s12, 0 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s14, 0 ; SI-NEXT: v_cndmask_b32_e32 v8, v8, v9, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s12, 51 -; SI-NEXT: v_cndmask_b32_e64 v9, v8, v14, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v8, v13, 0, vcc -; SI-NEXT: v_mov_b32_e32 v13, s16 -; SI-NEXT: v_cndmask_b32_e64 v8, v8, v13, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s23, 0xb0014 -; SI-NEXT: s_add_i32 s12, s0, s30 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s12 -; SI-NEXT: s_and_b64 s[8:9], s[22:23], s[0:1] -; SI-NEXT: s_lshr_b64 s[10:11], s[24:25], s12 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[8:9], 0 -; SI-NEXT: v_mov_b32_e32 v14, s10 -; SI-NEXT: v_mov_b32_e32 v13, s11 -; SI-NEXT: v_cndmask_b32_e32 v14, 0, v14, vcc -; SI-NEXT: v_cndmask_b32_e32 v13, 0, v13, vcc -; SI-NEXT: v_mov_b32_e32 v15, s23 -; SI-NEXT: v_add_i32_e32 v14, vcc, s22, v14 -; SI-NEXT: v_addc_u32_e32 v13, vcc, v15, v13, vcc -; SI-NEXT: v_not_b32_e32 v15, s0 -; SI-NEXT: v_and_b32_e32 v14, v14, v15 -; SI-NEXT: v_not_b32_e32 v15, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s12, -1 -; SI-NEXT: v_and_b32_e32 v13, v13, v15 -; SI-NEXT: v_cndmask_b32_e32 v15, 0, v12, vcc ; SI-NEXT: v_mov_b32_e32 v16, s23 -; SI-NEXT: v_bfi_b32 v15, s28, v15, v16 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s12, 0 -; SI-NEXT: v_cndmask_b32_e32 v13, v13, v15, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s12, 51 -; SI-NEXT: v_cndmask_b32_e64 v15, v13, v16, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v13, v14, 0, vcc -; SI-NEXT: v_mov_b32_e32 v14, s22 -; SI-NEXT: v_cndmask_b32_e64 v14, v13, v14, s[0:1] -; SI-NEXT: s_bfe_u32 s0, s21, 0xb0014 -; SI-NEXT: s_add_i32 s10, s0, s30 -; SI-NEXT: s_lshr_b64 s[0:1], s[2:3], s10 -; SI-NEXT: s_and_b64 s[2:3], s[20:21], s[0:1] -; SI-NEXT: s_lshr_b64 s[8:9], s[24:25], s10 -; SI-NEXT: v_cmp_ne_u64_e64 vcc, s[2:3], 0 -; SI-NEXT: v_mov_b32_e32 v16, s8 -; SI-NEXT: v_mov_b32_e32 v13, s9 -; SI-NEXT: v_cndmask_b32_e32 v16, 0, v16, vcc -; SI-NEXT: v_cndmask_b32_e32 v13, 0, v13, vcc -; SI-NEXT: v_mov_b32_e32 v17, s21 -; SI-NEXT: v_add_i32_e32 v16, vcc, s20, v16 -; SI-NEXT: v_addc_u32_e32 v13, vcc, v17, v13, vcc -; SI-NEXT: v_not_b32_e32 v17, s0 -; SI-NEXT: v_and_b32_e32 v16, v16, v17 -; SI-NEXT: v_not_b32_e32 v17, s1 -; SI-NEXT: v_cmp_eq_u32_e64 vcc, s10, -1 -; SI-NEXT: v_and_b32_e32 v13, v13, v17 -; SI-NEXT: v_cndmask_b32_e32 v12, 0, v12, vcc +; SI-NEXT: v_cmp_gt_i32_e64 s[2:3], s14, 51 +; SI-NEXT: v_cndmask_b32_e64 v9, v8, v16, s[2:3] +; SI-NEXT: v_mov_b32_e32 v8, s10 +; SI-NEXT: v_cndmask_b32_e64 v8, v8, 0, vcc +; SI-NEXT: v_mov_b32_e32 v10, s22 +; SI-NEXT: v_cndmask_b32_e64 v8, v8, v10, s[2:3] +; SI-NEXT: s_bfe_u32 s2, s21, 0xb0014 +; SI-NEXT: s_add_i32 s7, s2, s7 +; SI-NEXT: s_lshr_b64 s[2:3], s[4:5], s7 +; SI-NEXT: s_andn2_b64 s[4:5], s[20:21], s[2:3] +; SI-NEXT: s_and_b32 s2, s21, s27 +; SI-NEXT: v_mov_b32_e32 v11, s2 +; SI-NEXT: v_mov_b32_e32 v10, s5 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s7, 0 +; SI-NEXT: v_cndmask_b32_e32 v10, v10, v11, vcc +; SI-NEXT: v_cmp_gt_i32_e64 s[2:3], s7, 51 ; SI-NEXT: v_mov_b32_e32 v17, s21 -; SI-NEXT: v_bfi_b32 v12, s28, v12, v17 -; SI-NEXT: v_cmp_lt_i32_e64 vcc, s10, 0 -; SI-NEXT: v_cndmask_b32_e32 v12, v13, v12, vcc -; SI-NEXT: v_cmp_gt_i32_e64 s[0:1], s10, 51 -; SI-NEXT: v_cndmask_b32_e64 v13, v12, v17, s[0:1] -; SI-NEXT: v_cndmask_b32_e64 v12, v16, 0, vcc -; SI-NEXT: v_mov_b32_e32 v16, s20 +; SI-NEXT: v_cndmask_b32_e64 v15, v10, v17, s[2:3] +; SI-NEXT: v_mov_b32_e32 v10, s4 +; SI-NEXT: v_cndmask_b32_e64 v10, v10, 0, vcc +; SI-NEXT: v_mov_b32_e32 v11, s20 +; SI-NEXT: v_cndmask_b32_e64 v14, v10, v11, s[2:3] +; SI-NEXT: v_add_f64 v[10:11], s[20:21], -v[14:15] +; SI-NEXT: v_bfi_b32 v16, s24, v18, v16 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[10:11]|, 0.5 +; SI-NEXT: v_add_f64 v[10:11], s[22:23], -v[8:9] +; SI-NEXT: v_bfi_b32 v17, s24, v18, v17 +; SI-NEXT: v_cmp_ge_f64_e64 s[2:3], |v[10:11]|, 0.5 +; SI-NEXT: v_mov_b32_e32 v10, 0 +; SI-NEXT: v_cndmask_b32_e64 v11, 0, v16, s[2:3] +; SI-NEXT: v_add_f64 v[10:11], v[8:9], v[10:11] +; SI-NEXT: v_cndmask_b32_e32 v9, 0, v17, vcc +; SI-NEXT: v_mov_b32_e32 v8, 0 +; SI-NEXT: s_and_b32 s13, s17, s27 +; SI-NEXT: v_add_f64 v[8:9], v[14:15], v[8:9] +; SI-NEXT: v_mov_b32_e32 v14, s9 +; SI-NEXT: v_mov_b32_e32 v15, s13 +; SI-NEXT: v_cmp_lt_i32_e64 vcc, s12, 0 +; SI-NEXT: v_cndmask_b32_e32 v14, v14, v15, vcc +; SI-NEXT: v_mov_b32_e32 v15, s17 +; SI-NEXT: v_cmp_gt_i32_e64 s[2:3], s12, 51 +; SI-NEXT: v_cndmask_b32_e64 v17, v14, v15, s[2:3] +; SI-NEXT: v_mov_b32_e32 v14, s8 +; SI-NEXT: v_cndmask_b32_e64 v14, v14, 0, vcc +; SI-NEXT: v_mov_b32_e32 v16, s16 +; SI-NEXT: v_cndmask_b32_e64 v16, v14, v16, s[2:3] +; SI-NEXT: v_bfi_b32 v19, s24, v18, v19 +; SI-NEXT: v_bfi_b32 v18, s24, v18, v15 +; SI-NEXT: v_add_f64 v[14:15], s[16:17], -v[16:17] +; SI-NEXT: s_load_dwordx2 s[4:5], s[0:1], 0x9 +; SI-NEXT: v_cmp_ge_f64_e64 vcc, |v[14:15]|, 0.5 +; SI-NEXT: v_add_f64 v[14:15], s[18:19], -v[12:13] ; SI-NEXT: s_mov_b32 s7, 0xf000 -; SI-NEXT: v_cndmask_b32_e64 v12, v12, v16, s[0:1] -; SI-NEXT: buffer_store_dwordx4 v[12:15], off, s[4:7], 0 offset:48 -; SI-NEXT: buffer_store_dwordx4 v[8:11], off, s[4:7], 0 offset:32 +; SI-NEXT: v_cmp_ge_f64_e64 s[0:1], |v[14:15]|, 0.5 +; SI-NEXT: v_mov_b32_e32 v14, 0 +; SI-NEXT: v_cndmask_b32_e64 v15, 0, v19, s[0:1] +; SI-NEXT: v_add_f64 v[14:15], v[12:13], v[14:15] +; SI-NEXT: v_cndmask_b32_e32 v13, 0, v18, vcc +; SI-NEXT: v_mov_b32_e32 v12, 0 +; SI-NEXT: v_add_f64 v[12:13], v[16:17], v[12:13] +; SI-NEXT: s_waitcnt lgkmcnt(0) +; SI-NEXT: buffer_store_dwordx4 v[8:11], off, s[4:7], 0 offset:48 +; SI-NEXT: buffer_store_dwordx4 v[12:15], off, s[4:7], 0 offset:32 ; SI-NEXT: buffer_store_dwordx4 v[4:7], off, s[4:7], 0 offset:16 ; SI-NEXT: buffer_store_dwordx4 v[0:3], off, s[4:7], 0 ; SI-NEXT: s_endpgm diff --git a/llvm/test/CodeGen/AMDGPU/lower-mem-intrinsics.ll b/llvm/test/CodeGen/AMDGPU/lower-mem-intrinsics.ll index 04a530d58a424c..29206d2f5cf8c5 100644 --- a/llvm/test/CodeGen/AMDGPU/lower-mem-intrinsics.ll +++ b/llvm/test/CodeGen/AMDGPU/lower-mem-intrinsics.ll @@ -24,9 +24,9 @@ define amdgpu_kernel void @min_size_large_static_memcpy_caller0(i8 addrspace(1)* ; OPT: load-store-loop: ; OPT-NEXT: [[LOOP_INDEX:%.*]] = phi i64 [ 0, [[TMP0:%.*]] ], [ [[TMP4:%.*]], [[LOAD_STORE_LOOP]] ] ; OPT-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: [[TMP2:%.*]] = load i8, i8 addrspace(1)* [[TMP1]] +; OPT-NEXT: [[TMP2:%.*]] = load i8, i8 addrspace(1)* [[TMP1]], align 1 ; OPT-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: store i8 [[TMP2]], i8 addrspace(1)* [[TMP3]] +; OPT-NEXT: store i8 [[TMP2]], i8 addrspace(1)* [[TMP3]], align 1 ; OPT-NEXT: [[TMP4]] = add i64 [[LOOP_INDEX]], 1 ; OPT-NEXT: [[TMP5:%.*]] = icmp ult i64 [[TMP4]], 1025 ; OPT-NEXT: br i1 [[TMP5]], label [[LOAD_STORE_LOOP]], label [[MEMCPY_SPLIT:%.*]] @@ -57,9 +57,9 @@ define amdgpu_kernel void @min_size_large_static_memmove_caller0(i8 addrspace(1) ; OPT-NEXT: [[TMP1:%.*]] = phi i64 [ [[INDEX_PTR:%.*]], [[COPY_BACKWARDS_LOOP]] ], [ 1025, [[COPY_BACKWARDS]] ] ; OPT-NEXT: [[INDEX_PTR]] = sub i64 [[TMP1]], 1 ; OPT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[INDEX_PTR]] -; OPT-NEXT: [[ELEMENT:%.*]] = load i8, i8 addrspace(1)* [[TMP2]] +; OPT-NEXT: [[ELEMENT:%.*]] = load i8, i8 addrspace(1)* [[TMP2]], align 1 ; OPT-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST]], i64 [[INDEX_PTR]] -; OPT-NEXT: store i8 [[ELEMENT]], i8 addrspace(1)* [[TMP3]] +; OPT-NEXT: store i8 [[ELEMENT]], i8 addrspace(1)* [[TMP3]], align 1 ; OPT-NEXT: [[TMP4:%.*]] = icmp eq i64 [[INDEX_PTR]], 0 ; OPT-NEXT: br i1 [[TMP4]], label [[MEMMOVE_DONE]], label [[COPY_BACKWARDS_LOOP]] ; OPT: copy_forward: @@ -67,9 +67,9 @@ define amdgpu_kernel void @min_size_large_static_memmove_caller0(i8 addrspace(1) ; OPT: copy_forward_loop: ; OPT-NEXT: [[INDEX_PTR1:%.*]] = phi i64 [ [[INDEX_INCREMENT:%.*]], [[COPY_FORWARD_LOOP]] ], [ 0, [[COPY_FORWARD]] ] ; OPT-NEXT: [[TMP5:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[INDEX_PTR1]] -; OPT-NEXT: [[ELEMENT2:%.*]] = load i8, i8 addrspace(1)* [[TMP5]] +; OPT-NEXT: [[ELEMENT2:%.*]] = load i8, i8 addrspace(1)* [[TMP5]], align 1 ; OPT-NEXT: [[TMP6:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST]], i64 [[INDEX_PTR1]] -; OPT-NEXT: store i8 [[ELEMENT2]], i8 addrspace(1)* [[TMP6]] +; OPT-NEXT: store i8 [[ELEMENT2]], i8 addrspace(1)* [[TMP6]], align 1 ; OPT-NEXT: [[INDEX_INCREMENT]] = add i64 [[INDEX_PTR1]], 1 ; OPT-NEXT: [[TMP7:%.*]] = icmp eq i64 [[INDEX_INCREMENT]], 1025 ; OPT-NEXT: br i1 [[TMP7]], label [[MEMMOVE_DONE]], label [[COPY_FORWARD_LOOP]] @@ -95,7 +95,7 @@ define amdgpu_kernel void @min_size_large_static_memset_caller0(i8 addrspace(1)* ; OPT: loadstoreloop: ; OPT-NEXT: [[TMP1:%.*]] = phi i64 [ 0, [[TMP0:%.*]] ], [ [[TMP3:%.*]], [[LOADSTORELOOP]] ] ; OPT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST:%.*]], i64 [[TMP1]] -; OPT-NEXT: store i8 [[VAL:%.*]], i8 addrspace(1)* [[TMP2]] +; OPT-NEXT: store i8 [[VAL:%.*]], i8 addrspace(1)* [[TMP2]], align 1 ; OPT-NEXT: [[TMP3]] = add i64 [[TMP1]], 1 ; OPT-NEXT: [[TMP4:%.*]] = icmp ult i64 [[TMP3]], 1025 ; OPT-NEXT: br i1 [[TMP4]], label [[LOADSTORELOOP]], label [[SPLIT]] @@ -113,9 +113,9 @@ define amdgpu_kernel void @variable_memcpy_caller0(i8 addrspace(1)* %dst, i8 add ; OPT: loop-memcpy-expansion: ; OPT-NEXT: [[LOOP_INDEX:%.*]] = phi i64 [ 0, [[TMP0:%.*]] ], [ [[TMP5:%.*]], [[LOOP_MEMCPY_EXPANSION]] ] ; OPT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(1)* [[TMP2]] +; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(1)* [[TMP2]], align 1 ; OPT-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]] +; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]], align 1 ; OPT-NEXT: [[TMP5]] = add i64 [[LOOP_INDEX]], 1 ; OPT-NEXT: [[TMP6:%.*]] = icmp ult i64 [[TMP5]], [[N]] ; OPT-NEXT: br i1 [[TMP6]], label [[LOOP_MEMCPY_EXPANSION]], label [[POST_LOOP_MEMCPY_EXPANSION]] @@ -133,9 +133,9 @@ define amdgpu_kernel void @variable_memcpy_caller1(i8 addrspace(1)* %dst, i8 add ; OPT: loop-memcpy-expansion: ; OPT-NEXT: [[LOOP_INDEX:%.*]] = phi i64 [ 0, [[TMP0:%.*]] ], [ [[TMP5:%.*]], [[LOOP_MEMCPY_EXPANSION]] ] ; OPT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(1)* [[TMP2]] +; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(1)* [[TMP2]], align 1 ; OPT-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]] +; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]], align 1 ; OPT-NEXT: [[TMP5]] = add i64 [[LOOP_INDEX]], 1 ; OPT-NEXT: [[TMP6:%.*]] = icmp ult i64 [[TMP5]], [[N]] ; OPT-NEXT: br i1 [[TMP6]], label [[LOOP_MEMCPY_EXPANSION]], label [[POST_LOOP_MEMCPY_EXPANSION]] @@ -153,9 +153,9 @@ define amdgpu_kernel void @memcpy_multi_use_one_function(i8 addrspace(1)* %dst0, ; OPT: loop-memcpy-expansion2: ; OPT-NEXT: [[LOOP_INDEX3:%.*]] = phi i64 [ 0, [[TMP0:%.*]] ], [ [[TMP5:%.*]], [[LOOP_MEMCPY_EXPANSION2]] ] ; OPT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC:%.*]], i64 [[LOOP_INDEX3]] -; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(1)* [[TMP2]] +; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(1)* [[TMP2]], align 1 ; OPT-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST0:%.*]], i64 [[LOOP_INDEX3]] -; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]] +; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]], align 1 ; OPT-NEXT: [[TMP5]] = add i64 [[LOOP_INDEX3]], 1 ; OPT-NEXT: [[TMP6:%.*]] = icmp ult i64 [[TMP5]], [[N]] ; OPT-NEXT: br i1 [[TMP6]], label [[LOOP_MEMCPY_EXPANSION2]], label [[POST_LOOP_MEMCPY_EXPANSION1]] @@ -165,9 +165,9 @@ define amdgpu_kernel void @memcpy_multi_use_one_function(i8 addrspace(1)* %dst0, ; OPT: loop-memcpy-expansion: ; OPT-NEXT: [[LOOP_INDEX:%.*]] = phi i64 [ 0, [[POST_LOOP_MEMCPY_EXPANSION1]] ], [ [[TMP11:%.*]], [[LOOP_MEMCPY_EXPANSION]] ] ; OPT-NEXT: [[TMP8:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[LOOP_INDEX]] -; OPT-NEXT: [[TMP9:%.*]] = load i8, i8 addrspace(1)* [[TMP8]] +; OPT-NEXT: [[TMP9:%.*]] = load i8, i8 addrspace(1)* [[TMP8]], align 1 ; OPT-NEXT: [[TMP10:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST1:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: store i8 [[TMP9]], i8 addrspace(1)* [[TMP10]] +; OPT-NEXT: store i8 [[TMP9]], i8 addrspace(1)* [[TMP10]], align 1 ; OPT-NEXT: [[TMP11]] = add i64 [[LOOP_INDEX]], 1 ; OPT-NEXT: [[TMP12:%.*]] = icmp ult i64 [[TMP11]], [[M]] ; OPT-NEXT: br i1 [[TMP12]], label [[LOOP_MEMCPY_EXPANSION]], label [[POST_LOOP_MEMCPY_EXPANSION]] @@ -186,9 +186,9 @@ define amdgpu_kernel void @memcpy_alt_type(i8 addrspace(1)* %dst, i8 addrspace(3 ; OPT: loop-memcpy-expansion: ; OPT-NEXT: [[LOOP_INDEX:%.*]] = phi i32 [ 0, [[TMP0:%.*]] ], [ [[TMP5:%.*]], [[LOOP_MEMCPY_EXPANSION]] ] ; OPT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, i8 addrspace(3)* [[SRC:%.*]], i32 [[LOOP_INDEX]] -; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(3)* [[TMP2]] +; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(3)* [[TMP2]], align 1 ; OPT-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST:%.*]], i32 [[LOOP_INDEX]] -; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]] +; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]], align 1 ; OPT-NEXT: [[TMP5]] = add i32 [[LOOP_INDEX]], 1 ; OPT-NEXT: [[TMP6:%.*]] = icmp ult i32 [[TMP5]], [[N]] ; OPT-NEXT: br i1 [[TMP6]], label [[LOOP_MEMCPY_EXPANSION]], label [[POST_LOOP_MEMCPY_EXPANSION]] @@ -207,9 +207,9 @@ define amdgpu_kernel void @memcpy_multi_use_one_function_keep_small(i8 addrspace ; OPT: loop-memcpy-expansion: ; OPT-NEXT: [[LOOP_INDEX:%.*]] = phi i64 [ 0, [[TMP0:%.*]] ], [ [[TMP5:%.*]], [[LOOP_MEMCPY_EXPANSION]] ] ; OPT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(1)* [[TMP2]] +; OPT-NEXT: [[TMP3:%.*]] = load i8, i8 addrspace(1)* [[TMP2]], align 1 ; OPT-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DST0:%.*]], i64 [[LOOP_INDEX]] -; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]] +; OPT-NEXT: store i8 [[TMP3]], i8 addrspace(1)* [[TMP4]], align 1 ; OPT-NEXT: [[TMP5]] = add i64 [[LOOP_INDEX]], 1 ; OPT-NEXT: [[TMP6:%.*]] = icmp ult i64 [[TMP5]], [[N]] ; OPT-NEXT: br i1 [[TMP6]], label [[LOOP_MEMCPY_EXPANSION]], label [[POST_LOOP_MEMCPY_EXPANSION]] diff --git a/llvm/test/CodeGen/AMDGPU/memcpy-inline-fails.ll b/llvm/test/CodeGen/AMDGPU/memcpy-inline-fails.ll index 19569c55c8b0c2..88107ea23252b7 100644 --- a/llvm/test/CodeGen/AMDGPU/memcpy-inline-fails.ll +++ b/llvm/test/CodeGen/AMDGPU/memcpy-inline-fails.ll @@ -1,4 +1,3 @@ -; XFAIL: windows-gnu,windows-msvc ; NOTE: This is expected to fail on target that do not support memcpy. ; RUN: llc < %s -mtriple=r600-unknown-linux-gnu 2> %t.err || true ; RUN: FileCheck --input-file %t.err %s diff --git a/llvm/test/CodeGen/X86/avx512-calling-conv.ll b/llvm/test/CodeGen/X86/avx512-calling-conv.ll index 09fbf9e06c5fd8..c42bd502b12a0c 100644 --- a/llvm/test/CodeGen/X86/avx512-calling-conv.ll +++ b/llvm/test/CodeGen/X86/avx512-calling-conv.ll @@ -3,6 +3,7 @@ ; RUN: llc < %s -mtriple=x86_64-apple-darwin9 -mcpu=knl -x86-enable-old-knl-abi | FileCheck %s --check-prefix=ALL_X64 --check-prefix=KNL --check-prefix=KNL-OLD ; RUN: llc < %s -mtriple=x86_64-apple-darwin9 -mcpu=skx | FileCheck %s --check-prefix=ALL_X64 --check-prefix=SKX ; RUN: llc < %s -mtriple=i686-apple-darwin9 -mcpu=knl | FileCheck %s --check-prefix=KNL_X32 +; RUN: llc < %s -mtriple=x86_64-apple-darwin9 -mcpu=skx -fast-isel | FileCheck %s --check-prefix=FASTISEL define <16 x i1> @test1() { ; ALL_X64-LABEL: test1: @@ -14,6 +15,11 @@ define <16 x i1> @test1() { ; KNL_X32: ## %bb.0: ; KNL_X32-NEXT: vxorps %xmm0, %xmm0, %xmm0 ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test1: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: vxorps %xmm0, %xmm0, %xmm0 +; FASTISEL-NEXT: retq ret <16 x i1> zeroinitializer } @@ -27,6 +33,16 @@ define <16 x i1> @test2(<16 x i1>%a, <16 x i1>%b) { ; KNL_X32: ## %bb.0: ; KNL_X32-NEXT: vandps %xmm1, %xmm0, %xmm0 ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test2: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: vpsllw $7, %xmm1, %xmm1 +; FASTISEL-NEXT: vpmovb2m %xmm1, %k0 +; FASTISEL-NEXT: vpsllw $7, %xmm0, %xmm0 +; FASTISEL-NEXT: vpmovb2m %xmm0, %k1 +; FASTISEL-NEXT: kandw %k0, %k1, %k0 +; FASTISEL-NEXT: vpmovm2b %k0, %xmm0 +; FASTISEL-NEXT: retq %c = and <16 x i1>%a, %b ret <16 x i1> %c } @@ -41,6 +57,16 @@ define <8 x i1> @test3(<8 x i1>%a, <8 x i1>%b) { ; KNL_X32: ## %bb.0: ; KNL_X32-NEXT: vandps %xmm1, %xmm0, %xmm0 ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test3: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: vpsllw $15, %xmm1, %xmm1 +; FASTISEL-NEXT: vpmovw2m %xmm1, %k0 +; FASTISEL-NEXT: vpsllw $15, %xmm0, %xmm0 +; FASTISEL-NEXT: vpmovw2m %xmm0, %k1 +; FASTISEL-NEXT: kandb %k0, %k1, %k0 +; FASTISEL-NEXT: vpmovm2w %k0, %xmm0 +; FASTISEL-NEXT: retq %c = and <8 x i1>%a, %b ret <8 x i1> %c } @@ -55,6 +81,16 @@ define <4 x i1> @test4(<4 x i1>%a, <4 x i1>%b) { ; KNL_X32: ## %bb.0: ; KNL_X32-NEXT: vandps %xmm1, %xmm0, %xmm0 ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test4: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: vpslld $31, %xmm1, %xmm1 +; FASTISEL-NEXT: vpmovd2m %xmm1, %k0 +; FASTISEL-NEXT: vpslld $31, %xmm0, %xmm0 +; FASTISEL-NEXT: vpmovd2m %xmm0, %k1 +; FASTISEL-NEXT: kandw %k0, %k1, %k0 +; FASTISEL-NEXT: vpmovm2d %k0, %xmm0 +; FASTISEL-NEXT: retq %c = and <4 x i1>%a, %b ret <4 x i1> %c } @@ -103,6 +139,20 @@ define <8 x i32> @test5(<8 x i32>%a, <8 x i32>%b) { ; KNL_X32-NEXT: vpsrad $31, %ymm0, %ymm0 ; KNL_X32-NEXT: addl $12, %esp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test5: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rax +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: vpcmpgtd %ymm1, %ymm0, %k0 +; FASTISEL-NEXT: vpmovm2w %k0, %xmm0 +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: callq _func8xi1 +; FASTISEL-NEXT: vpsllw $15, %xmm0, %xmm0 +; FASTISEL-NEXT: vpmovw2m %xmm0, %k0 +; FASTISEL-NEXT: vpmovm2d %k0, %ymm0 +; FASTISEL-NEXT: popq %rax +; FASTISEL-NEXT: retq %cmpRes = icmp sgt <8 x i32>%a, %b %resi = call <8 x i1> @func8xi1(<8 x i1> %cmpRes) %res = sext <8 x i1>%resi to <8 x i32> @@ -153,6 +203,20 @@ define <16 x i32> @test6(<16 x i32>%a, <16 x i32>%b) { ; KNL_X32-NEXT: vpsrad $31, %zmm0, %zmm0 ; KNL_X32-NEXT: addl $12, %esp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test6: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rax +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: vpcmpgtd %zmm1, %zmm0, %k0 +; FASTISEL-NEXT: vpmovm2b %k0, %xmm0 +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: callq _func16xi1 +; FASTISEL-NEXT: vpsllw $7, %xmm0, %xmm0 +; FASTISEL-NEXT: vpmovb2m %xmm0, %k0 +; FASTISEL-NEXT: vpmovm2d %k0, %zmm0 +; FASTISEL-NEXT: popq %rax +; FASTISEL-NEXT: retq %cmpRes = icmp sgt <16 x i32>%a, %b %resi = call <16 x i1> @func16xi1(<16 x i1> %cmpRes) %res = sext <16 x i1>%resi to <16 x i32> @@ -183,6 +247,19 @@ define <4 x i32> @test7(<4 x i32>%a, <4 x i32>%b) { ; KNL_X32-NEXT: vpsrad $31, %xmm0, %xmm0 ; KNL_X32-NEXT: addl $12, %esp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test7: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rax +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: vpcmpgtd %xmm1, %xmm0, %k0 +; FASTISEL-NEXT: vpmovm2d %k0, %xmm0 +; FASTISEL-NEXT: callq _func4xi1 +; FASTISEL-NEXT: vpslld $31, %xmm0, %xmm0 +; FASTISEL-NEXT: vpmovd2m %xmm0, %k0 +; FASTISEL-NEXT: vpmovm2d %k0, %xmm0 +; FASTISEL-NEXT: popq %rax +; FASTISEL-NEXT: retq %cmpRes = icmp sgt <4 x i32>%a, %b %resi = call <4 x i1> @func4xi1(<4 x i1> %cmpRes) %res = sext <4 x i1>%resi to <4 x i32> @@ -225,6 +302,18 @@ define <8 x i1> @test7a(<8 x i32>%a, <8 x i32>%b) { ; KNL_X32-NEXT: vandps LCPI7_0, %xmm0, %xmm0 ; KNL_X32-NEXT: addl $12, %esp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test7a: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rax +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: vpcmpgtd %ymm1, %ymm0, %k0 +; FASTISEL-NEXT: vpmovm2w %k0, %xmm0 +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: callq _func8xi1 +; FASTISEL-NEXT: vpand {{.*}}(%rip), %xmm0, %xmm0 +; FASTISEL-NEXT: popq %rax +; FASTISEL-NEXT: retq %cmpRes = icmp sgt <8 x i32>%a, %b %resi = call <8 x i1> @func8xi1(<8 x i1> %cmpRes) %res = and <8 x i1>%resi, @@ -249,6 +338,15 @@ define <16 x i8> @test8(<16 x i8> %a1, <16 x i8> %a2, i1 %cond) { ; KNL_X32-NEXT: vmovaps %xmm1, %xmm0 ; KNL_X32-NEXT: LBB8_2: ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test8: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: testb $1, %dil +; FASTISEL-NEXT: jne LBB8_2 +; FASTISEL-NEXT: ## %bb.1: +; FASTISEL-NEXT: vmovaps %xmm1, %xmm0 +; FASTISEL-NEXT: LBB8_2: +; FASTISEL-NEXT: retq %res = select i1 %cond, <16 x i8> %a1, <16 x i8> %a2 ret <16 x i8> %res } @@ -266,6 +364,12 @@ define i1 @test9(double %a, double %b) { ; KNL_X32-NEXT: vucomisd {{[0-9]+}}(%esp), %xmm0 ; KNL_X32-NEXT: setb %al ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test9: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: vucomisd %xmm0, %xmm1 +; FASTISEL-NEXT: setb %al +; FASTISEL-NEXT: retq %c = fcmp ugt double %a, %b ret i1 %c } @@ -286,6 +390,13 @@ define i32 @test10(i32 %a, i32 %b, i1 %cond) { ; KNL_X32-NEXT: cmovnel %eax, %ecx ; KNL_X32-NEXT: movl (%ecx), %eax ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test10: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: movl %edi, %eax +; FASTISEL-NEXT: testb $1, %dl +; FASTISEL-NEXT: cmovel %esi, %eax +; FASTISEL-NEXT: retq %c = select i1 %cond, i32 %a, i32 %b ret i32 %c } @@ -303,6 +414,12 @@ define i1 @test11(i32 %a, i32 %b) { ; KNL_X32-NEXT: cmpl {{[0-9]+}}(%esp), %eax ; KNL_X32-NEXT: setg %al ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test11: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: cmpl %esi, %edi +; FASTISEL-NEXT: setg %al +; FASTISEL-NEXT: retq %c = icmp sgt i32 %a, %b ret i1 %c } @@ -369,6 +486,34 @@ define i32 @test12(i32 %a1, i32 %a2, i32 %b1) { ; KNL_X32-NEXT: popl %edi ; KNL_X32-NEXT: popl %ebx ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test12: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rbp +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: pushq %r14 +; FASTISEL-NEXT: .cfi_def_cfa_offset 24 +; FASTISEL-NEXT: pushq %rbx +; FASTISEL-NEXT: .cfi_def_cfa_offset 32 +; FASTISEL-NEXT: .cfi_offset %rbx, -32 +; FASTISEL-NEXT: .cfi_offset %r14, -24 +; FASTISEL-NEXT: .cfi_offset %rbp, -16 +; FASTISEL-NEXT: movl %esi, %r14d +; FASTISEL-NEXT: movl %edi, %ebp +; FASTISEL-NEXT: movl %edx, %esi +; FASTISEL-NEXT: callq _test11 +; FASTISEL-NEXT: movzbl %al, %ebx +; FASTISEL-NEXT: movl %ebp, %edi +; FASTISEL-NEXT: movl %r14d, %esi +; FASTISEL-NEXT: movl %ebx, %edx +; FASTISEL-NEXT: callq _test10 +; FASTISEL-NEXT: xorl %ecx, %ecx +; FASTISEL-NEXT: testb $1, %bl +; FASTISEL-NEXT: cmovel %ecx, %eax +; FASTISEL-NEXT: popq %rbx +; FASTISEL-NEXT: popq %r14 +; FASTISEL-NEXT: popq %rbp +; FASTISEL-NEXT: retq %cond = call i1 @test11(i32 %a1, i32 %b1) %res = call i32 @test10(i32 %a1, i32 %a2, i1 %cond) %res1 = select i1 %cond, i32 %res, i32 0 @@ -395,6 +540,13 @@ define <1 x i1> @test13(<1 x i1>* %foo) { ; KNL_X32-NEXT: movzbl (%eax), %eax ; KNL_X32-NEXT: ## kill: def $al killed $al killed $eax ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test13: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: kmovb (%rdi), %k0 +; FASTISEL-NEXT: kmovd %k0, %eax +; FASTISEL-NEXT: ## kill: def $al killed $al killed $eax +; FASTISEL-NEXT: retq %bar = load <1 x i1>, <1 x i1>* %foo ret <1 x i1> %bar } @@ -453,6 +605,19 @@ define void @test14(<32 x i16>* %x) { ; KNL_X32-NEXT: addl $8, %esp ; KNL_X32-NEXT: popl %esi ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test14: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rbx +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: .cfi_offset %rbx, -16 +; FASTISEL-NEXT: movq %rdi, %rbx +; FASTISEL-NEXT: vmovaps (%rdi), %zmm0 +; FASTISEL-NEXT: callq _test14_callee +; FASTISEL-NEXT: vmovaps %zmm0, (%rbx) +; FASTISEL-NEXT: popq %rbx +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: retq %a = load <32 x i16>, <32 x i16>* %x %b = call <32 x i16> @test14_callee(<32 x i16> %a) store <32 x i16> %b, <32 x i16>* %x @@ -514,6 +679,19 @@ define void @test15(<64 x i8>* %x) { ; KNL_X32-NEXT: addl $8, %esp ; KNL_X32-NEXT: popl %esi ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: test15: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rbx +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: .cfi_offset %rbx, -16 +; FASTISEL-NEXT: movq %rdi, %rbx +; FASTISEL-NEXT: vmovaps (%rdi), %zmm0 +; FASTISEL-NEXT: callq _test15_callee +; FASTISEL-NEXT: vmovaps %zmm0, (%rbx) +; FASTISEL-NEXT: popq %rbx +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: retq %a = load <64 x i8>, <64 x i8>* %x %b = call <64 x i8> @test15_callee(<64 x i8> %a) store <64 x i8> %b, <64 x i8>* %x @@ -1497,6 +1675,321 @@ define <17 x i1> @test16(<17 x i1> %a, <17 x i1> %b) nounwind { ; KNL_X32-NEXT: popl %ebx ; KNL_X32-NEXT: popl %ebp ; KNL_X32-NEXT: retl $4 +; +; FASTISEL-LABEL: test16: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rbp +; FASTISEL-NEXT: pushq %r15 +; FASTISEL-NEXT: pushq %r14 +; FASTISEL-NEXT: pushq %r13 +; FASTISEL-NEXT: pushq %r12 +; FASTISEL-NEXT: pushq %rbx +; FASTISEL-NEXT: movq %rdi, %rax +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: movl $-3, %edi +; FASTISEL-NEXT: kmovd %edi, %k2 +; FASTISEL-NEXT: kmovd %k2, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k2, %k0, %k0 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $30, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-5, %edi +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovd %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $29, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-9, %edi +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovd %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $28, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: movl $-17, %edi +; FASTISEL-NEXT: kmovd %edi, %k2 +; FASTISEL-NEXT: kmovd %k2, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k2, %k0, %k0 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $27, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-33, %edi +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovd %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $26, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-65, %edi +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovd %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $25, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: movl $-129, %edi +; FASTISEL-NEXT: kmovd %edi, %k2 +; FASTISEL-NEXT: kmovd %k2, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k2, %k0, %k0 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $24, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-257, %edi ## imm = 0xFEFF +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovd %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $23, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-513, %edi ## imm = 0xFDFF +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovd %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $22, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: movl $-1025, %edi ## imm = 0xFBFF +; FASTISEL-NEXT: kmovd %edi, %k6 +; FASTISEL-NEXT: kandd %k6, %k0, %k0 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $21, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-2049, %edi ## imm = 0xF7FF +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovd %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $20, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-4097, %edi ## imm = 0xEFFF +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovd %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $19, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: movl $-8193, %edi ## imm = 0xDFFF +; FASTISEL-NEXT: kmovd %edi, %k4 +; FASTISEL-NEXT: kandd %k4, %k0, %k0 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $18, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-16385, %edi ## imm = 0xBFFF +; FASTISEL-NEXT: kmovd %edi, %k5 +; FASTISEL-NEXT: kandd %k5, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $17, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: movl $-32769, %edi ## imm = 0xFFFF7FFF +; FASTISEL-NEXT: kmovd %edi, %k3 +; FASTISEL-NEXT: kandd %k3, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k7 +; FASTISEL-NEXT: kshiftld $31, %k7, %k7 +; FASTISEL-NEXT: kshiftrd $16, %k7, %k7 +; FASTISEL-NEXT: kord %k7, %k0, %k7 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: movl $-65537, %edi ## imm = 0xFFFEFFFF +; FASTISEL-NEXT: kmovd %edi, %k2 +; FASTISEL-NEXT: kandd %k2, %k7, %k7 +; FASTISEL-NEXT: kshiftld $31, %k0, %k0 +; FASTISEL-NEXT: kshiftrd $15, %k0, %k0 +; FASTISEL-NEXT: kord %k0, %k7, %k0 +; FASTISEL-NEXT: kmovd %k0, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill +; FASTISEL-NEXT: kmovd %esi, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd %edx, %k7 +; FASTISEL-NEXT: kshiftld $31, %k7, %k7 +; FASTISEL-NEXT: kshiftrd $30, %k7, %k7 +; FASTISEL-NEXT: kord %k7, %k0, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd %ecx, %k7 +; FASTISEL-NEXT: kshiftld $31, %k7, %k7 +; FASTISEL-NEXT: kshiftrd $29, %k7, %k7 +; FASTISEL-NEXT: kord %k7, %k0, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd %r8d, %k7 +; FASTISEL-NEXT: kshiftld $31, %k7, %k7 +; FASTISEL-NEXT: kshiftrd $28, %k7, %k7 +; FASTISEL-NEXT: kord %k7, %k0, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd %r9d, %k7 +; FASTISEL-NEXT: kshiftld $31, %k7, %k7 +; FASTISEL-NEXT: kshiftrd $27, %k7, %k7 +; FASTISEL-NEXT: kord %k7, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k7 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k1 +; FASTISEL-NEXT: kshiftld $31, %k7, %k7 +; FASTISEL-NEXT: kshiftrd $26, %k7, %k7 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: kord %k7, %k1, %k1 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k7 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k7, %k1, %k1 +; FASTISEL-NEXT: kshiftld $31, %k0, %k0 +; FASTISEL-NEXT: kshiftrd $25, %k0, %k0 +; FASTISEL-NEXT: kord %k0, %k1, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $24, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $23, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $22, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kandd %k6, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $21, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k6 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k6, %k0, %k0 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $20, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k6 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kshiftld $31, %k6, %k1 +; FASTISEL-NEXT: kshiftrd $19, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kandd %k4, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $18, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kandd %k5, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $17, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kandd %k3, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $16, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kandd %k2, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftld $31, %k1, %k1 +; FASTISEL-NEXT: kshiftrd $15, %k1, %k1 +; FASTISEL-NEXT: kord %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 4-byte Reload +; FASTISEL-NEXT: kandd %k1, %k0, %k0 +; FASTISEL-NEXT: kshiftrd $16, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r8d +; FASTISEL-NEXT: kshiftrd $1, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r9d +; FASTISEL-NEXT: kshiftrd $2, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r10d +; FASTISEL-NEXT: kshiftrd $3, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r11d +; FASTISEL-NEXT: kshiftrd $4, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r12d +; FASTISEL-NEXT: kshiftrd $5, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r15d +; FASTISEL-NEXT: kshiftrd $6, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r14d +; FASTISEL-NEXT: kshiftrd $7, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r13d +; FASTISEL-NEXT: kshiftrd $8, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %ebx +; FASTISEL-NEXT: kshiftrd $9, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %esi +; FASTISEL-NEXT: kshiftrd $10, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %ebp +; FASTISEL-NEXT: kshiftrd $11, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %ecx +; FASTISEL-NEXT: kshiftrd $12, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %edx +; FASTISEL-NEXT: kshiftrd $13, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %edi +; FASTISEL-NEXT: kshiftrd $14, %k0, %k1 +; FASTISEL-NEXT: andl $1, %r8d +; FASTISEL-NEXT: movb %r8b, 2(%rax) +; FASTISEL-NEXT: kmovd %k0, %r8d +; FASTISEL-NEXT: andl $1, %r8d +; FASTISEL-NEXT: andl $1, %r9d +; FASTISEL-NEXT: leal (%r8,%r9,2), %r8d +; FASTISEL-NEXT: kmovd %k1, %r9d +; FASTISEL-NEXT: kshiftrd $15, %k0, %k0 +; FASTISEL-NEXT: andl $1, %r10d +; FASTISEL-NEXT: leal (%r8,%r10,4), %r8d +; FASTISEL-NEXT: kmovd %k0, %r10d +; FASTISEL-NEXT: andl $1, %r11d +; FASTISEL-NEXT: leal (%r8,%r11,8), %r8d +; FASTISEL-NEXT: andl $1, %r12d +; FASTISEL-NEXT: shll $4, %r12d +; FASTISEL-NEXT: orl %r8d, %r12d +; FASTISEL-NEXT: andl $1, %r15d +; FASTISEL-NEXT: shll $5, %r15d +; FASTISEL-NEXT: orl %r12d, %r15d +; FASTISEL-NEXT: andl $1, %r14d +; FASTISEL-NEXT: shll $6, %r14d +; FASTISEL-NEXT: andl $1, %r13d +; FASTISEL-NEXT: shll $7, %r13d +; FASTISEL-NEXT: orl %r14d, %r13d +; FASTISEL-NEXT: andl $1, %ebx +; FASTISEL-NEXT: shll $8, %ebx +; FASTISEL-NEXT: orl %r13d, %ebx +; FASTISEL-NEXT: andl $1, %esi +; FASTISEL-NEXT: shll $9, %esi +; FASTISEL-NEXT: orl %ebx, %esi +; FASTISEL-NEXT: andl $1, %ebp +; FASTISEL-NEXT: shll $10, %ebp +; FASTISEL-NEXT: orl %esi, %ebp +; FASTISEL-NEXT: orl %r15d, %ebp +; FASTISEL-NEXT: andl $1, %ecx +; FASTISEL-NEXT: shll $11, %ecx +; FASTISEL-NEXT: andl $1, %edx +; FASTISEL-NEXT: shll $12, %edx +; FASTISEL-NEXT: orl %ecx, %edx +; FASTISEL-NEXT: andl $1, %edi +; FASTISEL-NEXT: shll $13, %edi +; FASTISEL-NEXT: orl %edx, %edi +; FASTISEL-NEXT: andl $1, %r9d +; FASTISEL-NEXT: shll $14, %r9d +; FASTISEL-NEXT: orl %edi, %r9d +; FASTISEL-NEXT: andl $1, %r10d +; FASTISEL-NEXT: shll $15, %r10d +; FASTISEL-NEXT: orl %r9d, %r10d +; FASTISEL-NEXT: orl %ebp, %r10d +; FASTISEL-NEXT: movw %r10w, (%rax) +; FASTISEL-NEXT: popq %rbx +; FASTISEL-NEXT: popq %r12 +; FASTISEL-NEXT: popq %r13 +; FASTISEL-NEXT: popq %r14 +; FASTISEL-NEXT: popq %r15 +; FASTISEL-NEXT: popq %rbp +; FASTISEL-NEXT: retq %c = and <17 x i1> %a, %b ret <17 x i1> %c } @@ -2700,6 +3193,383 @@ define <7 x i1> @test17(<7 x i1> %a, <7 x i1> %b, <7 x i1> %c, <7 x i1> %d, <7 x ; KNL_X32-NEXT: addl $16, %esp ; KNL_X32-NEXT: popl %ebx ; KNL_X32-NEXT: retl $4 +; +; FASTISEL-LABEL: test17: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: movq %rdi, %rax +; FASTISEL-NEXT: movb $-3, %dil +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $6, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: movb $-5, %dil +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $5, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k3 +; FASTISEL-NEXT: movb $-9, %dil +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kshiftlb $7, %k3, %k3 +; FASTISEL-NEXT: kshiftrb $4, %k3, %k3 +; FASTISEL-NEXT: korb %k3, %k0, %k0 +; FASTISEL-NEXT: movb $-17, %dil +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k4 +; FASTISEL-NEXT: kshiftlb $7, %k4, %k4 +; FASTISEL-NEXT: kshiftrb $3, %k4, %k4 +; FASTISEL-NEXT: korb %k4, %k0, %k0 +; FASTISEL-NEXT: movb $-33, %dil +; FASTISEL-NEXT: kmovd %edi, %k1 +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovq %k1, %k4 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k5 +; FASTISEL-NEXT: kshiftlb $7, %k5, %k5 +; FASTISEL-NEXT: kshiftrb $2, %k5, %k5 +; FASTISEL-NEXT: korb %k5, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k7 +; FASTISEL-NEXT: movb $-65, %dil +; FASTISEL-NEXT: kmovd %edi, %k6 +; FASTISEL-NEXT: kandb %k6, %k0, %k1 +; FASTISEL-NEXT: kshiftlb $7, %k7, %k7 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: kshiftrb $1, %k7, %k7 +; FASTISEL-NEXT: korb %k7, %k1, %k7 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k3 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k3, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $6, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k2 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k2, %k0, %k2 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $5, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: korb %k1, %k2, %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k5 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k5, %k1, %k1 +; FASTISEL-NEXT: kshiftlb $7, %k0, %k0 +; FASTISEL-NEXT: kshiftrb $4, %k0, %k0 +; FASTISEL-NEXT: korb %k0, %k1, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k2 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k2, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $3, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k4, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $2, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k6, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $1, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k7, %k0, %k0 +; FASTISEL-NEXT: kmovw %k0, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: kandb %k3, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $6, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k7 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k7, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $5, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k5, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $4, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kmovq %k2, %k3 +; FASTISEL-NEXT: kandb %k2, %k0, %k0 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $3, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k4, %k0, %k0 +; FASTISEL-NEXT: kmovq %k4, %k5 +; FASTISEL-NEXT: kmovw %k4, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kshiftlb $7, %k2, %k1 +; FASTISEL-NEXT: kshiftrb $2, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovq %k6, %k4 +; FASTISEL-NEXT: kandb %k6, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $1, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw %k0, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k6 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k6, %k0, %k0 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $6, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k7, %k0, %k0 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k1 +; FASTISEL-NEXT: kshiftrb $5, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k7 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k7, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $4, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k3, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $3, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k5, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $2, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k4, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $1, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw %k0, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kandb %k6, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $6, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k5 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k5, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $5, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kandb %k7, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $4, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kandb %k3, %k1, %k1 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $3, %k2, %k2 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k2 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k2, %k1, %k1 +; FASTISEL-NEXT: kshiftlb $7, %k0, %k0 +; FASTISEL-NEXT: kshiftrb $2, %k0, %k0 +; FASTISEL-NEXT: korb %k0, %k1, %k0 +; FASTISEL-NEXT: kmovq %k4, %k3 +; FASTISEL-NEXT: kmovw %k4, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kandb %k4, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $1, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw %k0, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: kmovq %k6, %k4 +; FASTISEL-NEXT: kandb %k6, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $6, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k5, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $5, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k7, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $4, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k6 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k6, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $3, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kandb %k2, %k0, %k0 +; FASTISEL-NEXT: kmovq %k2, %k7 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $2, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k3, %k0, %k0 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftrb $1, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k4, %k2, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $6, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kandb %k5, %k1, %k1 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $5, %k2, %k2 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k3 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k4 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k4, %k1, %k1 +; FASTISEL-NEXT: kshiftlb $7, %k3, %k2 +; FASTISEL-NEXT: kshiftrb $4, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kandb %k6, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $3, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kandb %k7, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $2, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k3 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k3, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $1, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kandb %k0, %k1, %k0 +; FASTISEL-NEXT: kmovw %k0, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k5 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k5, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $6, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $5, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k4, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $4, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kandb %k6, %k0, %k0 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $3, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k7, %k0, %k0 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k1 +; FASTISEL-NEXT: kshiftrb $2, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kandb %k3, %k0, %k0 +; FASTISEL-NEXT: kmovq %k3, %k7 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k1 +; FASTISEL-NEXT: kshiftlb $7, %k1, %k1 +; FASTISEL-NEXT: kshiftrb $1, %k1, %k1 +; FASTISEL-NEXT: korb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovd %esi, %k1 +; FASTISEL-NEXT: kandb %k5, %k1, %k1 +; FASTISEL-NEXT: kmovd %edx, %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $6, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k2 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovd %ecx, %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $5, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kandb %k4, %k1, %k1 +; FASTISEL-NEXT: kmovd %r8d, %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $4, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kandb %k6, %k1, %k1 +; FASTISEL-NEXT: kmovd %r9d, %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $3, %k2, %k2 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k3 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k2 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k2, %k1, %k1 +; FASTISEL-NEXT: kshiftlb $7, %k3, %k2 +; FASTISEL-NEXT: kshiftrb $2, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kandb %k7, %k1, %k1 +; FASTISEL-NEXT: kmovb {{[0-9]+}}(%rsp), %k2 +; FASTISEL-NEXT: kshiftlb $7, %k2, %k2 +; FASTISEL-NEXT: kshiftrb $1, %k2, %k2 +; FASTISEL-NEXT: korb %k2, %k1, %k1 +; FASTISEL-NEXT: kandb %k0, %k1, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 ## 2-byte Reload +; FASTISEL-NEXT: kandb %k1, %k0, %k0 +; FASTISEL-NEXT: kshiftrb $6, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r8d +; FASTISEL-NEXT: kshiftrb $5, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r9d +; FASTISEL-NEXT: kshiftrb $4, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %r10d +; FASTISEL-NEXT: kshiftrb $3, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %edi +; FASTISEL-NEXT: kshiftrb $2, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %ecx +; FASTISEL-NEXT: kshiftrb $1, %k0, %k1 +; FASTISEL-NEXT: kmovd %k1, %edx +; FASTISEL-NEXT: kmovd %k0, %esi +; FASTISEL-NEXT: andb $1, %sil +; FASTISEL-NEXT: andb $1, %dl +; FASTISEL-NEXT: addb %dl, %dl +; FASTISEL-NEXT: orb %sil, %dl +; FASTISEL-NEXT: andb $1, %cl +; FASTISEL-NEXT: shlb $2, %cl +; FASTISEL-NEXT: orb %dl, %cl +; FASTISEL-NEXT: andb $1, %dil +; FASTISEL-NEXT: shlb $3, %dil +; FASTISEL-NEXT: orb %cl, %dil +; FASTISEL-NEXT: andb $1, %r10b +; FASTISEL-NEXT: shlb $4, %r10b +; FASTISEL-NEXT: orb %dil, %r10b +; FASTISEL-NEXT: andb $1, %r9b +; FASTISEL-NEXT: shlb $5, %r9b +; FASTISEL-NEXT: orb %r10b, %r9b +; FASTISEL-NEXT: shlb $6, %r8b +; FASTISEL-NEXT: orb %r9b, %r8b +; FASTISEL-NEXT: andb $127, %r8b +; FASTISEL-NEXT: movb %r8b, (%rax) +; FASTISEL-NEXT: retq %j = and <7 x i1> %a, %b %k = and <7 x i1> %j, %c %l = and <7 x i1> %k, %d @@ -2757,6 +3627,19 @@ define void @v2i1_mem(<128 x i32> %x, <2 x i1> %y) { ; KNL_X32-NEXT: movl %ebp, %esp ; KNL_X32-NEXT: popl %ebp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: v2i1_mem: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: subq $24, %rsp +; FASTISEL-NEXT: .cfi_def_cfa_offset 32 +; FASTISEL-NEXT: vpsllq $63, {{[0-9]+}}(%rsp), %xmm8 +; FASTISEL-NEXT: vpmovq2m %xmm8, %k0 +; FASTISEL-NEXT: vpmovm2q %k0, %xmm8 +; FASTISEL-NEXT: vmovdqa %xmm8, (%rsp) +; FASTISEL-NEXT: callq _v2i1_mem_callee +; FASTISEL-NEXT: addq $24, %rsp +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: retq call void @v2i1_mem_callee(<128 x i32> %x, <2 x i1> %y) ret void } @@ -2807,6 +3690,19 @@ define void @v4i1_mem(<128 x i32> %x, <4 x i1> %y) { ; KNL_X32-NEXT: movl %ebp, %esp ; KNL_X32-NEXT: popl %ebp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: v4i1_mem: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: subq $24, %rsp +; FASTISEL-NEXT: .cfi_def_cfa_offset 32 +; FASTISEL-NEXT: vpslld $31, {{[0-9]+}}(%rsp), %xmm8 +; FASTISEL-NEXT: vpmovd2m %xmm8, %k0 +; FASTISEL-NEXT: vpmovm2d %k0, %xmm8 +; FASTISEL-NEXT: vmovdqa %xmm8, (%rsp) +; FASTISEL-NEXT: callq _v4i1_mem_callee +; FASTISEL-NEXT: addq $24, %rsp +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: retq call void @v4i1_mem_callee(<128 x i32> %x, <4 x i1> %y) ret void } @@ -2857,6 +3753,19 @@ define void @v8i1_mem(<128 x i32> %x, <8 x i1> %y) { ; KNL_X32-NEXT: movl %ebp, %esp ; KNL_X32-NEXT: popl %ebp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: v8i1_mem: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: subq $24, %rsp +; FASTISEL-NEXT: .cfi_def_cfa_offset 32 +; FASTISEL-NEXT: vpsllw $15, {{[0-9]+}}(%rsp), %xmm8 +; FASTISEL-NEXT: vpmovw2m %xmm8, %k0 +; FASTISEL-NEXT: vpmovm2w %k0, %xmm8 +; FASTISEL-NEXT: vmovdqa %xmm8, (%rsp) +; FASTISEL-NEXT: callq _v8i1_mem_callee +; FASTISEL-NEXT: addq $24, %rsp +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: retq call void @v8i1_mem_callee(<128 x i32> %x, <8 x i1> %y) ret void } @@ -2907,6 +3816,19 @@ define void @v16i1_mem(<128 x i32> %x, <16 x i1> %y) { ; KNL_X32-NEXT: movl %ebp, %esp ; KNL_X32-NEXT: popl %ebp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: v16i1_mem: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: subq $24, %rsp +; FASTISEL-NEXT: .cfi_def_cfa_offset 32 +; FASTISEL-NEXT: vpsllw $7, {{[0-9]+}}(%rsp), %xmm8 +; FASTISEL-NEXT: vpmovb2m %xmm8, %k0 +; FASTISEL-NEXT: vpmovm2b %k0, %xmm8 +; FASTISEL-NEXT: vmovdqa %xmm8, (%rsp) +; FASTISEL-NEXT: callq _v16i1_mem_callee +; FASTISEL-NEXT: addq $24, %rsp +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: retq call void @v16i1_mem_callee(<128 x i32> %x, <16 x i1> %y) ret void } @@ -2969,6 +3891,25 @@ define void @v32i1_mem(<128 x i32> %x, <32 x i1> %y) { ; KNL_X32-NEXT: movl %ebp, %esp ; KNL_X32-NEXT: popl %ebp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: v32i1_mem: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rbp +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: .cfi_offset %rbp, -16 +; FASTISEL-NEXT: movq %rsp, %rbp +; FASTISEL-NEXT: .cfi_def_cfa_register %rbp +; FASTISEL-NEXT: andq $-32, %rsp +; FASTISEL-NEXT: subq $64, %rsp +; FASTISEL-NEXT: vpsllw $7, 16(%rbp), %ymm8 +; FASTISEL-NEXT: vpmovb2m %ymm8, %k0 +; FASTISEL-NEXT: vpmovm2b %k0, %ymm8 +; FASTISEL-NEXT: vmovdqa %ymm8, (%rsp) +; FASTISEL-NEXT: callq _v32i1_mem_callee +; FASTISEL-NEXT: movq %rbp, %rsp +; FASTISEL-NEXT: popq %rbp +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: retq call void @v32i1_mem_callee(<128 x i32> %x, <32 x i1> %y) ret void } @@ -3265,6 +4206,25 @@ define void @v64i1_mem(<128 x i32> %x, <64 x i1> %y) { ; KNL_X32-NEXT: movl %ebp, %esp ; KNL_X32-NEXT: popl %ebp ; KNL_X32-NEXT: retl +; +; FASTISEL-LABEL: v64i1_mem: +; FASTISEL: ## %bb.0: +; FASTISEL-NEXT: pushq %rbp +; FASTISEL-NEXT: .cfi_def_cfa_offset 16 +; FASTISEL-NEXT: .cfi_offset %rbp, -16 +; FASTISEL-NEXT: movq %rsp, %rbp +; FASTISEL-NEXT: .cfi_def_cfa_register %rbp +; FASTISEL-NEXT: andq $-64, %rsp +; FASTISEL-NEXT: subq $128, %rsp +; FASTISEL-NEXT: vpsllw $7, 16(%rbp), %zmm8 +; FASTISEL-NEXT: vpmovb2m %zmm8, %k0 +; FASTISEL-NEXT: vpmovm2b %k0, %zmm8 +; FASTISEL-NEXT: vmovdqa64 %zmm8, (%rsp) +; FASTISEL-NEXT: callq _v64i1_mem_callee +; FASTISEL-NEXT: movq %rbp, %rsp +; FASTISEL-NEXT: popq %rbp +; FASTISEL-NEXT: vzeroupper +; FASTISEL-NEXT: retq call void @v64i1_mem_callee(<128 x i32> %x, <64 x i1> %y) ret void } diff --git a/llvm/test/CodeGen/X86/basicblock-sections-cold.ll b/llvm/test/CodeGen/X86/basicblock-sections-cold.ll new file mode 100644 index 00000000000000..5ddaf8f7cf7f3a --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections-cold.ll @@ -0,0 +1,41 @@ +; Check if basic blocks that don't get unique sections are placed in cold sections. +; Basic block with id 1 and 2 must be in the cold section. +; RUN: echo '!_Z3bazb' > %t +; RUN: echo '!!0' >> %t +; RUN: cat %t +; RUN: llc < %s -mtriple=x86_64-pc-linux -function-sections -basicblock-sections=%t -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS + +define void @_Z3bazb(i1 zeroext) { + %2 = alloca i8, align 1 + %3 = zext i1 %0 to i8 + store i8 %3, i8* %2, align 1 + %4 = load i8, i8* %2, align 1 + %5 = trunc i8 %4 to i1 + br i1 %5, label %6, label %8 + +6: ; preds = %1 + %7 = call i32 @_Z3barv() + br label %10 + +8: ; preds = %1 + %9 = call i32 @_Z3foov() + br label %10 + +10: ; preds = %8, %6 + ret void +} + +declare i32 @_Z3barv() #1 + +declare i32 @_Z3foov() #1 + +; LINUX-SECTIONS: .section .text._Z3bazb,"ax",@progbits +; LINUX-SECTIONS: _Z3bazb: +; Check that the basic block with id 1 doesn't get a section. +; LINUX-SECTIONS-NOT: .section .text._Z3bazb.r.BB._Z3bazb,"ax",@progbits,unique +; Check that a single cold section is started here and id 1 and 2 blocks are placed here. +; LINUX-SECTIONS: .section .text._Z3bazb.unlikely,"ax",@progbits +; LINUX-SECTIONS: r.BB._Z3bazb: +; LINUX-SECTIONS-NOT: .section .text._Z3bazb.rr.BB._Z3bazb,"ax",@progbits,unique +; LINUX-SECTIONS: rr.BB._Z3bazb: +; LINUX-SECTIONS: .size _Z3bazb, .Lfunc_end{{[0-9]}}-_Z3bazb diff --git a/llvm/test/CodeGen/X86/basicblock-sections-directjumps.ll b/llvm/test/CodeGen/X86/basicblock-sections-directjumps.ll new file mode 100644 index 00000000000000..7038b689ab506d --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections-directjumps.ll @@ -0,0 +1,38 @@ +; RUN: llc < %s -mtriple=x86_64-pc-linux -function-sections -basicblock-sections=all -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS +; RUN: llc < %s -mtriple=i386-unknown-linux-gnu -function-sections -basicblock-sections=all -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS + +define void @_Z3bazb(i1 zeroext) { + %2 = alloca i8, align 1 + %3 = zext i1 %0 to i8 + store i8 %3, i8* %2, align 1 + %4 = load i8, i8* %2, align 1 + %5 = trunc i8 %4 to i1 + br i1 %5, label %6, label %9 + +6: ; preds = %1 + %7 = call i32 @_Z3barv() + %8 = trunc i32 %7 to i1 + br i1 %8, label %11, label %9 + +9: ; preds = %1 + %10 = call i32 @_Z3foov() + br label %11 + +11: ; preds = %9, %6 + ret void +} + +declare i32 @_Z3barv() #1 + +declare i32 @_Z3foov() #1 + + +; LINUX-SECTIONS: .section .text._Z3bazb,"ax",@progbits +; LINUX-SECTIONS: _Z3bazb: +; LINUX-SECTIONS: jmp a.BB._Z3bazb +; LINUX-SECTIONS: .section .text._Z3bazb.a.BB._Z3bazb,"ax",@progbits,unique,1 +; LINUX-SECTIONS: a.BB._Z3bazb: +; LINUX-SECTIONS: jmp aa.BB._Z3bazb +; LINUX-SECTIONS: .section .text._Z3bazb.aa.BB._Z3bazb,"ax",@progbits,unique,2 +; LINUX-SECTIONS: aa.BB._Z3bazb: +; LINUX-SECTIONS: jmp raa.BB._Z3bazb diff --git a/llvm/test/CodeGen/X86/basicblock-sections-eh.ll b/llvm/test/CodeGen/X86/basicblock-sections-eh.ll new file mode 100644 index 00000000000000..239ac4000fe6da --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections-eh.ll @@ -0,0 +1,84 @@ +; Check if landing pads are kept in a separate eh section +; RUN: llc < %s -mtriple=i386-unknown-linux-gnu -function-sections -basicblock-sections=all -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS + +@_ZTIb = external constant i8* +define i32 @_Z3foob(i1 zeroext %0) #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { + %2 = alloca i32, align 4 + %3 = alloca i8, align 1 + %4 = alloca i8* + %5 = alloca i32 + %6 = alloca i8, align 1 + %7 = zext i1 %0 to i8 + store i8 %7, i8* %3, align 1 + %8 = load i8, i8* %3, align 1 + %9 = trunc i8 %8 to i1 + br i1 %9, label %10, label %11 + +10: ; preds = %1 + store i32 1, i32* %2, align 4 + br label %31 + +11: ; preds = %1 + %12 = call i8* @__cxa_allocate_exception(i64 1) #2 + %13 = load i8, i8* %3, align 1 + %14 = trunc i8 %13 to i1 + %15 = zext i1 %14 to i8 + store i8 %15, i8* %12, align 16 + invoke void @__cxa_throw(i8* %12, i8* bitcast (i8** @_ZTIb to i8*), i8* null) #3 + to label %38 unwind label %16 + +16: ; preds = %11 + %17 = landingpad { i8*, i32 } + catch i8* bitcast (i8** @_ZTIb to i8*) + %18 = extractvalue { i8*, i32 } %17, 0 + store i8* %18, i8** %4, align 8 + %19 = extractvalue { i8*, i32 } %17, 1 + store i32 %19, i32* %5, align 4 + br label %20 + +20: ; preds = %16 + %21 = load i32, i32* %5, align 4 + %22 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIb to i8*)) #2 + %23 = icmp eq i32 %21, %22 + br i1 %23, label %24, label %33 + +24: ; preds = %20 + %25 = load i8*, i8** %4, align 8 + %26 = call i8* @__cxa_begin_catch(i8* %25) #2 + %27 = load i8, i8* %26, align 1 + %28 = trunc i8 %27 to i1 + %29 = zext i1 %28 to i8 + store i8 %29, i8* %6, align 1 + call void @__cxa_end_catch() #2 + br label %30 + +30: ; preds = %24 + store i32 0, i32* %2, align 4 + br label %31 + +31: ; preds = %30, %10 + %32 = load i32, i32* %2, align 4 + ret i32 %32 + +33: ; preds = %20 + %34 = load i8*, i8** %4, align 8 + %35 = load i32, i32* %5, align 4 + %36 = insertvalue { i8*, i32 } undef, i8* %34, 0 + %37 = insertvalue { i8*, i32 } %36, i32 %35, 1 + resume { i8*, i32 } %37 + +38: ; preds = %11 + unreachable +} +declare i8* @__cxa_allocate_exception(i64) +declare void @__cxa_throw(i8*, i8*, i8*) +declare i32 @__gxx_personality_v0(...) +; Function Attrs: nounwind readnone +declare i32 @llvm.eh.typeid.for(i8*) #1 +declare i8* @__cxa_begin_catch(i8*) +declare void @__cxa_end_catch() + +;LINUX-SECTIONS: .section .text._Z3foob,"ax",@progbits +;LINUX-SECTIONS: _Z3foob: +;LINUX-SECTIONS: .section .text._Z3foob.eh,"ax",@progbits +;LINUX-SECTIONS: l{{[a|r]*}}.BB._Z3foob: diff --git a/llvm/test/CodeGen/X86/basicblock-sections-labels.ll b/llvm/test/CodeGen/X86/basicblock-sections-labels.ll new file mode 100644 index 00000000000000..2f077e68669243 --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections-labels.ll @@ -0,0 +1,33 @@ +; Check the basic block sections labels option +; RUN: llc < %s -mtriple=x86_64-pc-linux -function-sections -basicblock-sections=labels | FileCheck %s -check-prefix=LINUX-LABELS + +define void @_Z3bazb(i1 zeroext) { + %2 = alloca i8, align 1 + %3 = zext i1 %0 to i8 + store i8 %3, i8* %2, align 1 + %4 = load i8, i8* %2, align 1 + %5 = trunc i8 %4 to i1 + br i1 %5, label %6, label %8 + +6: ; preds = %1 + %7 = call i32 @_Z3barv() + br label %10 + +8: ; preds = %1 + %9 = call i32 @_Z3foov() + br label %10 + +10: ; preds = %8, %6 + ret void +} + +declare i32 @_Z3barv() #1 + +declare i32 @_Z3foov() #1 + +; LINUX-LABELS: .section +; LINUX-LABELS: _Z3bazb: +; LINUX-LABELS-NOT: .section +; LINUX-LABELS: r.BB._Z3bazb: +; LINUX-LABELS-NOT: .section +; LINUX-LABELS: rr.BB._Z3bazb: diff --git a/llvm/test/CodeGen/X86/basicblock-sections-list.ll b/llvm/test/CodeGen/X86/basicblock-sections-list.ll new file mode 100644 index 00000000000000..93db874165cf3c --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections-list.ll @@ -0,0 +1,76 @@ +; Check the basic block sections list option. +; RUN: echo '!_Z3foob' > %t +; RUN: llc < %s -mtriple=x86_64-pc-linux -function-sections -basicblock-sections=%t -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS + +define i32 @_Z3foob(i1 zeroext %0) #0 { + %2 = alloca i32, align 4 + %3 = alloca i8, align 1 + %4 = zext i1 %0 to i8 + store i8 %4, i8* %3, align 1 + %5 = load i8, i8* %3, align 1 + %6 = trunc i8 %5 to i1 + %7 = zext i1 %6 to i32 + %8 = icmp sgt i32 %7, 0 + br i1 %8, label %9, label %11 + +9: ; preds = %1 + %10 = call i32 @_Z3barv() + store i32 %10, i32* %2, align 4 + br label %13 + +11: ; preds = %1 + %12 = call i32 @_Z3bazv() + store i32 %12, i32* %2, align 4 + br label %13 + +13: ; preds = %11, %9 + %14 = load i32, i32* %2, align 4 + ret i32 %14 +} + +declare i32 @_Z3barv() #1 +declare i32 @_Z3bazv() #1 + +define i32 @_Z3zipb(i1 zeroext %0) #0 { + %2 = alloca i32, align 4 + %3 = alloca i8, align 1 + %4 = zext i1 %0 to i8 + store i8 %4, i8* %3, align 1 + %5 = load i8, i8* %3, align 1 + %6 = trunc i8 %5 to i1 + %7 = zext i1 %6 to i32 + %8 = icmp sgt i32 %7, 0 + br i1 %8, label %9, label %11 + +9: ; preds = %1 + %10 = call i32 @_Z3barv() + store i32 %10, i32* %2, align 4 + br label %13 + +11: ; preds = %1 + %12 = call i32 @_Z3bazv() + store i32 %12, i32* %2, align 4 + br label %13 + +13: ; preds = %11, %9 + %14 = load i32, i32* %2, align 4 + ret i32 %14 +} + +; LINUX-SECTIONS: .section .text._Z3foob,"ax",@progbits +; LINUX-SECTIONS: _Z3foob: +; LINUX-SECTIONS: .section .text._Z3foob.a.BB._Z3foob,"ax",@progbits,unique,1 +; LINUX-SECTIONS: a.BB._Z3foob: +; LINUX-SECTIONS: .section .text._Z3foob.aa.BB._Z3foob,"ax",@progbits,unique,2 +; LINUX-SECTIONS: aa.BB._Z3foob: +; LINUX-SECTIONS: .section .text._Z3foob.raa.BB._Z3foob,"ax",@progbits,unique,3 +; LINUX-SECTIONS: raa.BB._Z3foob: + +; LINUX-SECTIONS: .section .text._Z3zipb,"ax",@progbits +; LINUX-SECTIONS: _Z3zipb: +; LINUX-SECTIONS-NOT: .section .text._Z3zipb.a.BB._Z3zipb,"ax",@progbits,unique,1 +; LINUX-SECTIONS-NOT: a.BB._Z3zipb: +; LINUX-SECTIONS-NOT: .section .text._Z3zipb.aa.BB._Z3zipb,"ax",@progbits,unique,2 +; LINUX-SECTIONS-NOT: aa.BB._Z3zipb: +; LINUX-SECTIONS-NOT: .section .text._Z3zipb.raa.BB._Z3zipb,"ax",@progbits,unique,3 +; LINUX-SECTIONS-NOT: raa.BB._Z3zipb: diff --git a/llvm/test/CodeGen/X86/basicblock-sections-listbb.ll b/llvm/test/CodeGen/X86/basicblock-sections-listbb.ll new file mode 100644 index 00000000000000..9bc8cacb4aa927 --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections-listbb.ll @@ -0,0 +1,38 @@ +; Fine-grained basic block sections, subset of basic blocks in a function. +; Only basic block with id 2 must get a section. +; RUN: echo '!_Z3bazb' > %t +; RUN: echo '!!2' >> %t +; RUN: llc < %s -mtriple=x86_64-pc-linux -function-sections -basicblock-sections=%t -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS + +define void @_Z3bazb(i1 zeroext) { + %2 = alloca i8, align 1 + %3 = zext i1 %0 to i8 + store i8 %3, i8* %2, align 1 + %4 = load i8, i8* %2, align 1 + %5 = trunc i8 %4 to i1 + br i1 %5, label %6, label %8 + +6: ; preds = %1 + %7 = call i32 @_Z3barv() + br label %10 + +8: ; preds = %1 + %9 = call i32 @_Z3foov() + br label %10 + +10: ; preds = %8, %6 + ret void +} + +declare i32 @_Z3barv() #1 + +declare i32 @_Z3foov() #1 + +; LINUX-SECTIONS: .section .text._Z3bazb,"ax",@progbits +; LINUX-SECTIONS: _Z3bazb: +; Check that the basic block with id 1 doesn't get a section. +; LINUX-SECTIONS-NOT: .section .text._Z3bazb.r.BB._Z3bazb,"ax",@progbits,unique +; LINUX-SECTIONS: r.BB._Z3bazb: +; LINUX-SECTIONS: .section .text._Z3bazb.rr.BB._Z3bazb,"ax",@progbits,unique +; LINUX-SECTIONS: rr.BB._Z3bazb: +; LINUX-SECTIONS: .size rr.BB._Z3bazb, .Ltmp1-rr.BB._Z3bazb diff --git a/llvm/test/CodeGen/X86/basicblock-sections-mir-parse.mir b/llvm/test/CodeGen/X86/basicblock-sections-mir-parse.mir new file mode 100644 index 00000000000000..81db8b03272880 --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections-mir-parse.mir @@ -0,0 +1,131 @@ +# Start after bbsections0-prepare and check if the right code is generated. +# RUN: llc -mtriple x86_64-unknown-linux-gnu -start-after=bbsections-prepare %s -o - | FileCheck %s -check-prefix=CHECK + + +# How to generate the input: +# foo.cc +# int foo(bool k) { +# if (k) return 1; +# return 0; +# } +# +# clang -O0 -S -emit-llvm foo.cc +# llc < foo.ll -stop-after=bbsections-prepare -basicblock-sections=all + +--- | + ; Function Attrs: noinline nounwind optnone uwtable + define dso_local i32 @_Z3foob(i1 zeroext %0) #0 { + %2 = alloca i32, align 4 + %3 = alloca i8, align 1 + %4 = zext i1 %0 to i8 + store i8 %4, i8* %3, align 1 + %5 = load i8, i8* %3, align 1 + %6 = trunc i8 %5 to i1 + br i1 %6, label %7, label %8 + + 7: ; preds = %1 + store i32 1, i32* %2, align 4 + br label %9 + + 8: ; preds = %1 + store i32 0, i32* %2, align 4 + br label %9 + + 9: ; preds = %8, %7 + %10 = load i32, i32* %2, align 4 + ret i32 %10 + } + + attributes #0 = { "frame-pointer"="all" "target-cpu"="x86-64" } + + +... +--- +name: _Z3foob +alignment: 16 +exposesReturnsTwice: false +legalized: false +regBankSelected: false +selected: false +failedISel: false +tracksRegLiveness: true +hasWinCFI: false +registers: [] +liveins: + - { reg: '$edi', virtual-reg: '' } +frameInfo: + isFrameAddressTaken: false + isReturnAddressTaken: false + hasStackMap: false + hasPatchPoint: false + stackSize: 8 + offsetAdjustment: -8 + maxAlignment: 4 + adjustsStack: false + hasCalls: false + stackProtector: '' + maxCallFrameSize: 0 + cvBytesOfCalleeSavedRegisters: 0 + hasOpaqueSPAdjustment: false + hasVAStart: false + hasMustTailInVarArgFunc: false + localFrameSize: 0 + savePoint: '' + restorePoint: '' +fixedStack: + - { id: 0, type: spill-slot, offset: -16, size: 8, alignment: 16, stack-id: default, + callee-saved-register: '', callee-saved-restored: true, debug-info-variable: '', + debug-info-expression: '', debug-info-location: '' } +stack: + - { id: 0, type: default, offset: -24, size: 4, + alignment: 4, stack-id: default, callee-saved-register: '', callee-saved-restored: true, + debug-info-variable: '', debug-info-expression: '', debug-info-location: '' } + - { id: 1, type: default, offset: -17, size: 1, + alignment: 1, stack-id: default, callee-saved-register: '', callee-saved-restored: true, + debug-info-variable: '', debug-info-expression: '', debug-info-location: '' } +callSites: [] +constants: [] +machineFunctionInfo: {} +body: | + bb.0 (%ir-block.1, bbsections Entry): + successors: %bb.2(0x40000000), %bb.1(0x40000000) + liveins: $edi + + frame-setup PUSH64r killed $rbp, implicit-def $rsp, implicit $rsp + CFI_INSTRUCTION def_cfa_offset 16 + CFI_INSTRUCTION offset $rbp, -16 + $rbp = frame-setup MOV64rr $rsp + CFI_INSTRUCTION def_cfa_register $rbp + renamable $dil = AND8ri renamable $dil, 1, implicit-def dead $eflags, implicit killed $edi, implicit-def $edi + MOV8mr $rbp, 1, $noreg, -1, $noreg, renamable $dil, implicit killed $edi :: (store 1 into %ir.3) + TEST8mi $rbp, 1, $noreg, -1, $noreg, 1, implicit-def $eflags :: (load 1 from %ir.3) + JCC_1 %bb.2, 4, implicit killed $eflags + JMP_1 %bb.1 + + bb.1 (%ir-block.7, bbsections Unique): + successors: %bb.3(0x80000000) + + MOV32mi $rbp, 1, $noreg, -8, $noreg, 1 :: (store 4 into %ir.2) + JMP_1 %bb.3 + + bb.2 (%ir-block.8, bbsections Unique): + successors: %bb.3(0x80000000) + + MOV32mi $rbp, 1, $noreg, -8, $noreg, 0 :: (store 4 into %ir.2) + JMP_1 %bb.3 + + bb.3 (%ir-block.9, bbsections Unique): + renamable $eax = MOV32rm $rbp, 1, $noreg, -8, $noreg :: (load 4 from %ir.2) + $rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp + CFI_INSTRUCTION def_cfa $rsp, 8 + RETQ implicit $eax + +... + +# CHECK: _Z3foob: +# CHECK: .section .text,"ax",@progbits,unique +# CHECK: a.BB._Z3foob: +# CHECK: .section .text,"ax",@progbits,unique +# CHECK: aa.BB._Z3foob: +# CHECK: .section .text,"ax",@progbits,unique +# CHECK: aaa.BB._Z3foob: diff --git a/llvm/test/CodeGen/X86/basicblock-sections-mir-print.ll b/llvm/test/CodeGen/X86/basicblock-sections-mir-print.ll new file mode 100644 index 00000000000000..93ac4d1af942e0 --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections-mir-print.ll @@ -0,0 +1,32 @@ +; Stop after bbsections-prepare and check MIR output for section type. +; RUN: echo '!_Z3foob' > %t +; RUN: echo '!!1' >> %t +; RUN: llc < %s -O0 -mtriple=x86_64-pc-linux -function-sections -basicblock-sections=%t -stop-after=bbsections-prepare | FileCheck %s -check-prefix=CHECK + +@_ZTIb = external constant i8* +define dso_local i32 @_Z3foob(i1 zeroext %0) { + %2 = alloca i32, align 4 + %3 = alloca i8, align 1 + %4 = zext i1 %0 to i8 + store i8 %4, i8* %3, align 1 + %5 = load i8, i8* %3, align 1 + %6 = trunc i8 %5 to i1 + br i1 %6, label %7, label %8 + +7: ; preds = %1 + store i32 1, i32* %2, align 4 + br label %9 + +8: ; preds = %1 + store i32 0, i32* %2, align 4 + br label %9 + +9: ; preds = %8, %7 + %10 = load i32, i32* %2, align 4 + ret i32 %10 +} + +; CHECK: bbsections Entry +; CHECK: bbsections Cold +; CHECK: bbsections Cold +; CHECK: bbsections Unique diff --git a/llvm/test/CodeGen/X86/basicblock-sections.ll b/llvm/test/CodeGen/X86/basicblock-sections.ll new file mode 100644 index 00000000000000..3ba4d4ac928264 --- /dev/null +++ b/llvm/test/CodeGen/X86/basicblock-sections.ll @@ -0,0 +1,36 @@ +; RUN: llc < %s -mtriple=x86_64-pc-linux -function-sections -basicblock-sections=all -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS +; RUN: llc < %s -mtriple=i386-unknown-linux-gnu -function-sections -basicblock-sections=all -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS + +define void @_Z3bazb(i1 zeroext) { + %2 = alloca i8, align 1 + %3 = zext i1 %0 to i8 + store i8 %3, i8* %2, align 1 + %4 = load i8, i8* %2, align 1 + %5 = trunc i8 %4 to i1 + br i1 %5, label %6, label %8 + +6: ; preds = %1 + %7 = call i32 @_Z3barv() + br label %10 + +8: ; preds = %1 + %9 = call i32 @_Z3foov() + br label %10 + +10: ; preds = %8, %6 + ret void +} + +declare i32 @_Z3barv() #1 + +declare i32 @_Z3foov() #1 + + +; LINUX-SECTIONS: .section .text._Z3bazb,"ax",@progbits +; LINUX-SECTIONS: _Z3bazb: +; LINUX-SECTIONS: .section .text._Z3bazb.r.BB._Z3bazb,"ax",@progbits,unique,1 +; LINUX-SECTIONS: r.BB._Z3bazb: +; LINUX-SECTIONS: .size r.BB._Z3bazb, .Ltmp0-r.BB._Z3bazb +; LINUX-SECTIONS: .section .text._Z3bazb.rr.BB._Z3bazb,"ax",@progbits,unique,2 +; LINUX-SECTIONS: rr.BB._Z3bazb: +; LINUX-SECTIONS: .size rr.BB._Z3bazb, .Ltmp1-rr.BB._Z3bazb diff --git a/llvm/test/CodeGen/X86/movmsk-cmp.ll b/llvm/test/CodeGen/X86/movmsk-cmp.ll index 7f0a1418a7192c..4fdde8c06641b8 100644 --- a/llvm/test/CodeGen/X86/movmsk-cmp.ll +++ b/llvm/test/CodeGen/X86/movmsk-cmp.ll @@ -4225,40 +4225,25 @@ define i1 @movmsk_v16i8(<16 x i8> %x, <16 x i8> %y) { ret i1 %u2 } -; TODO: Replace shift+mask chain with NOT+TEST+SETE define i1 @movmsk_v8i16(<8 x i16> %x, <8 x i16> %y) { ; SSE2-LABEL: movmsk_v8i16: ; SSE2: # %bb.0: ; SSE2-NEXT: pcmpgtw %xmm1, %xmm0 ; SSE2-NEXT: packsswb %xmm0, %xmm0 -; SSE2-NEXT: pmovmskb %xmm0, %ecx -; SSE2-NEXT: movl %ecx, %eax -; SSE2-NEXT: shrb $7, %al -; SSE2-NEXT: movl %ecx, %edx -; SSE2-NEXT: andb $16, %dl -; SSE2-NEXT: shrb $4, %dl -; SSE2-NEXT: andb %al, %dl -; SSE2-NEXT: movl %ecx, %eax -; SSE2-NEXT: shrb %al -; SSE2-NEXT: andb %dl, %al -; SSE2-NEXT: andb %cl, %al +; SSE2-NEXT: pmovmskb %xmm0, %eax +; SSE2-NEXT: andb $-109, %al +; SSE2-NEXT: cmpb $-109, %al +; SSE2-NEXT: sete %al ; SSE2-NEXT: retq ; ; AVX-LABEL: movmsk_v8i16: ; AVX: # %bb.0: ; AVX-NEXT: vpcmpgtw %xmm1, %xmm0, %xmm0 ; AVX-NEXT: vpacksswb %xmm0, %xmm0, %xmm0 -; AVX-NEXT: vpmovmskb %xmm0, %ecx -; AVX-NEXT: movl %ecx, %eax -; AVX-NEXT: shrb $7, %al -; AVX-NEXT: movl %ecx, %edx -; AVX-NEXT: andb $16, %dl -; AVX-NEXT: shrb $4, %dl -; AVX-NEXT: andb %al, %dl -; AVX-NEXT: movl %ecx, %eax -; AVX-NEXT: shrb %al -; AVX-NEXT: andb %dl, %al -; AVX-NEXT: andb %cl, %al +; AVX-NEXT: vpmovmskb %xmm0, %eax +; AVX-NEXT: andb $-109, %al +; AVX-NEXT: cmpb $-109, %al +; AVX-NEXT: sete %al ; AVX-NEXT: retq ; ; KNL-LABEL: movmsk_v8i16: @@ -4266,34 +4251,20 @@ define i1 @movmsk_v8i16(<8 x i16> %x, <8 x i16> %y) { ; KNL-NEXT: vpcmpgtw %xmm1, %xmm0, %xmm0 ; KNL-NEXT: vpmovsxwq %xmm0, %zmm0 ; KNL-NEXT: vptestmq %zmm0, %zmm0, %k0 -; KNL-NEXT: kshiftrw $4, %k0, %k1 -; KNL-NEXT: kmovw %k1, %ecx -; KNL-NEXT: kshiftrw $7, %k0, %k1 -; KNL-NEXT: kmovw %k1, %eax -; KNL-NEXT: kshiftrw $1, %k0, %k1 -; KNL-NEXT: kmovw %k1, %edx -; KNL-NEXT: kmovw %k0, %esi -; KNL-NEXT: andb %cl, %al -; KNL-NEXT: andb %dl, %al -; KNL-NEXT: andb %sil, %al -; KNL-NEXT: # kill: def $al killed $al killed $eax +; KNL-NEXT: kmovw %k0, %eax +; KNL-NEXT: andb $-109, %al +; KNL-NEXT: cmpb $-109, %al +; KNL-NEXT: sete %al ; KNL-NEXT: vzeroupper ; KNL-NEXT: retq ; ; SKX-LABEL: movmsk_v8i16: ; SKX: # %bb.0: ; SKX-NEXT: vpcmpgtw %xmm1, %xmm0, %k0 -; SKX-NEXT: kshiftrb $4, %k0, %k1 -; SKX-NEXT: kmovd %k1, %ecx -; SKX-NEXT: kshiftrb $7, %k0, %k1 -; SKX-NEXT: kmovd %k1, %eax -; SKX-NEXT: kshiftrb $1, %k0, %k1 -; SKX-NEXT: kmovd %k1, %edx -; SKX-NEXT: kmovd %k0, %esi -; SKX-NEXT: andb %cl, %al -; SKX-NEXT: andb %dl, %al -; SKX-NEXT: andb %sil, %al -; SKX-NEXT: # kill: def $al killed $al killed $eax +; SKX-NEXT: kmovd %k0, %eax +; SKX-NEXT: andb $-109, %al +; SKX-NEXT: cmpb $-109, %al +; SKX-NEXT: sete %al ; SKX-NEXT: retq %cmp = icmp sgt <8 x i16> %x, %y %e1 = extractelement <8 x i1> %cmp, i32 0 @@ -4478,30 +4449,18 @@ define i1 @movmsk_v4f32(<4 x float> %x, <4 x float> %y) { ; KNL-NEXT: # kill: def $xmm1 killed $xmm1 def $zmm1 ; KNL-NEXT: # kill: def $xmm0 killed $xmm0 def $zmm0 ; KNL-NEXT: vcmpeq_uqps %zmm1, %zmm0, %k0 -; KNL-NEXT: kshiftrw $3, %k0, %k1 -; KNL-NEXT: kmovw %k1, %ecx -; KNL-NEXT: kshiftrw $2, %k0, %k1 -; KNL-NEXT: kmovw %k1, %eax -; KNL-NEXT: kshiftrw $1, %k0, %k0 -; KNL-NEXT: kmovw %k0, %edx -; KNL-NEXT: orb %cl, %al -; KNL-NEXT: orb %dl, %al -; KNL-NEXT: # kill: def $al killed $al killed $eax +; KNL-NEXT: kmovw %k0, %eax +; KNL-NEXT: testb $14, %al +; KNL-NEXT: setne %al ; KNL-NEXT: vzeroupper ; KNL-NEXT: retq ; ; SKX-LABEL: movmsk_v4f32: ; SKX: # %bb.0: ; SKX-NEXT: vcmpeq_uqps %xmm1, %xmm0, %k0 -; SKX-NEXT: kshiftrb $3, %k0, %k1 -; SKX-NEXT: kmovd %k1, %ecx -; SKX-NEXT: kshiftrb $2, %k0, %k1 -; SKX-NEXT: kmovd %k1, %eax -; SKX-NEXT: kshiftrb $1, %k0, %k0 -; SKX-NEXT: kmovd %k0, %edx -; SKX-NEXT: orb %cl, %al -; SKX-NEXT: orb %dl, %al -; SKX-NEXT: # kill: def $al killed $al killed $eax +; SKX-NEXT: kmovd %k0, %eax +; SKX-NEXT: testb $14, %al +; SKX-NEXT: setne %al ; SKX-NEXT: retq %cmp = fcmp ueq <4 x float> %x, %y %e1 = extractelement <4 x i1> %cmp, i32 1 diff --git a/llvm/test/CodeGen/X86/stack-folding-avx512bf16.ll b/llvm/test/CodeGen/X86/stack-folding-avx512bf16.ll index e368b08798a872..dbc7ddeb824455 100644 --- a/llvm/test/CodeGen/X86/stack-folding-avx512bf16.ll +++ b/llvm/test/CodeGen/X86/stack-folding-avx512bf16.ll @@ -32,9 +32,9 @@ define <32 x i16> @stack_fold_cvtne2ps2bf16_mask(<16 x float> %a0, <16 x float> ; CHECK-NEXT: nop ; CHECK-NEXT: #NO_APP ; CHECK-NEXT: kmovd %esi, %k1 -; CHECK-NEXT: vmovdqa64 (%rdi), %zmm2 +; CHECK-NEXT: vmovaps (%rdi), %zmm2 ; CHECK-NEXT: vcvtne2ps2bf16 {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload -; CHECK-NEXT: vmovdqa64 %zmm2, %zmm0 +; CHECK-NEXT: vmovaps %zmm2, %zmm0 ; CHECK-NEXT: retq %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"() %2 = call <32 x i16> @llvm.x86.avx512bf16.cvtne2ps2bf16.512(<16 x float> %a0, <16 x float> %a1) @@ -194,9 +194,9 @@ define <16 x i16> @stack_fold_cvtne2ps2bf16_mask_ymm(<8 x float> %a0, <8 x float ; CHECK-NEXT: nop ; CHECK-NEXT: #NO_APP ; CHECK-NEXT: kmovd %esi, %k1 -; CHECK-NEXT: vmovdqa (%rdi), %ymm2 +; CHECK-NEXT: vmovaps (%rdi), %ymm2 ; CHECK-NEXT: vcvtne2ps2bf16 {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 {%k1} # 32-byte Folded Reload -; CHECK-NEXT: vmovdqa %ymm2, %ymm0 +; CHECK-NEXT: vmovaps %ymm2, %ymm0 ; CHECK-NEXT: retq %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"() %2 = call <16 x i16> @llvm.x86.avx512bf16.cvtne2ps2bf16.256(<8 x float> %a0, <8 x float> %a1) @@ -361,9 +361,9 @@ define <8 x i16> @stack_fold_cvtne2ps2bf16_mask_xmm(<4 x float> %a0, <4 x float> ; CHECK-NEXT: nop ; CHECK-NEXT: #NO_APP ; CHECK-NEXT: kmovd %esi, %k1 -; CHECK-NEXT: vmovdqa (%rdi), %xmm2 +; CHECK-NEXT: vmovaps (%rdi), %xmm2 ; CHECK-NEXT: vcvtne2ps2bf16 {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 {%k1} # 16-byte Folded Reload -; CHECK-NEXT: vmovdqa %xmm2, %xmm0 +; CHECK-NEXT: vmovaps %xmm2, %xmm0 ; CHECK-NEXT: retq %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"() %2 = call <8 x i16> @llvm.x86.avx512bf16.cvtne2ps2bf16.128(<4 x float> %a0, <4 x float> %a1) diff --git a/llvm/test/CodeGen/X86/stack-guard-oob.ll b/llvm/test/CodeGen/X86/stack-guard-oob.ll new file mode 100644 index 00000000000000..74eb69328e6dda --- /dev/null +++ b/llvm/test/CodeGen/X86/stack-guard-oob.ll @@ -0,0 +1,415 @@ +; RUN: llc -mtriple=i686 -O0 < %s | FileCheck %s +; RUN: llc -mtriple=x86_64 -O0 < %s | FileCheck %s + +; CHECK-LABEL: in_bounds: +; CHECK-NOT: __stack_chk_guard +define i32 @in_bounds() #0 { + %var = alloca i32, align 4 + store i32 0, i32* %var, align 4 + %gep = getelementptr inbounds i32, i32* %var, i32 0 + %ret = load i32, i32* %gep, align 4 + ret i32 %ret +} + +; CHECK-LABEL: constant_out_of_bounds: +; CHECK: __stack_chk_guard +define i32 @constant_out_of_bounds() #0 { + %var = alloca i32, align 4 + store i32 0, i32* %var, align 4 + %gep = getelementptr inbounds i32, i32* %var, i32 1 + %ret = load i32, i32* %gep, align 4 + ret i32 %ret +} + +; CHECK-LABEL: nonconstant_out_of_bounds: +; CHECK: __stack_chk_guard +define i32 @nonconstant_out_of_bounds(i32 %n) #0 { + %var = alloca i32, align 4 + store i32 0, i32* %var, align 4 + %gep = getelementptr inbounds i32, i32* %var, i32 %n + %ret = load i32, i32* %gep, align 4 + ret i32 %ret +} + +; CHECK-LABEL: phi_before_gep_in_bounds: +; CHECK-NOT: __stack_chk_guard +define i32 @phi_before_gep_in_bounds(i32 %k) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i32, align 4 + store i32 0, i32* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %then + +if: + br label %then + +then: + %ptr = phi i32* [ %var1, %entry ], [ %var2, %if ] + %gep = getelementptr inbounds i32, i32* %ptr, i32 0 + %ret = load i32, i32* %gep, align 4 + ret i32 %ret +} + +; CHECK-LABEL: phi_before_gep_constant_out_of_bounds: +; CHECK: __stack_chk_guard +define i32 @phi_before_gep_constant_out_of_bounds(i32 %k) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i32, align 4 + store i32 0, i32* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %then + +if: + br label %then + +then: + %ptr = phi i32* [ %var1, %entry ], [ %var2, %if ] + %gep = getelementptr inbounds i32, i32* %ptr, i32 1 + %ret = load i32, i32* %gep, align 4 + ret i32 %ret +} + +; CHECK-LABEL: phi_before_gep_nonconstant_out_of_bounds: +; CHECK: __stack_chk_guard +define i32 @phi_before_gep_nonconstant_out_of_bounds(i32 %k, i32 %n) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i32, align 4 + store i32 0, i32* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %then + +if: + br label %then + +then: + %ptr = phi i32* [ %var1, %entry ], [ %var2, %if ] + %gep = getelementptr inbounds i32, i32* %ptr, i32 %n + %ret = load i32, i32* %gep, align 4 + ret i32 %ret +} + +; CHECK-LABEL: phi_after_gep_in_bounds: +; CHECK-NOT: __stack_chk_guard +define i32 @phi_after_gep_in_bounds(i32 %k) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i32, align 4 + store i32 0, i32* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %else + +if: + %gep1 = getelementptr inbounds i32, i32* %var1, i32 0 + br label %then + +else: + %gep2 = getelementptr inbounds i32, i32* %var2, i32 0 + br label %then + +then: + %ptr = phi i32* [ %gep1, %if ], [ %gep2, %else ] + %ret = load i32, i32* %ptr, align 4 + ret i32 %ret +} + +; CHECK-LABEL: phi_after_gep_constant_out_of_bounds_a: +; CHECK: __stack_chk_guard +define i32 @phi_after_gep_constant_out_of_bounds_a(i32 %k) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i32, align 4 + store i32 0, i32* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %else + +if: + %gep1 = getelementptr inbounds i32, i32* %var1, i32 0 + br label %then + +else: + %gep2 = getelementptr inbounds i32, i32* %var2, i32 1 + br label %then + +then: + %ptr = phi i32* [ %gep1, %if ], [ %gep2, %else ] + %ret = load i32, i32* %ptr, align 4 + ret i32 %ret +} + +; CHECK-LABEL: phi_after_gep_constant_out_of_bounds_b: +; CHECK: __stack_chk_guard +define i32 @phi_after_gep_constant_out_of_bounds_b(i32 %k) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i32, align 4 + store i32 0, i32* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %else + +if: + %gep1 = getelementptr inbounds i32, i32* %var1, i32 1 + br label %then + +else: + %gep2 = getelementptr inbounds i32, i32* %var2, i32 0 + br label %then + +then: + %ptr = phi i32* [ %gep1, %if ], [ %gep2, %else ] + %ret = load i32, i32* %ptr, align 4 + ret i32 %ret +} + +; CHECK-LABEL: phi_different_types_a: +; CHECK: __stack_chk_guard +define i64 @phi_different_types_a(i32 %k) #0 { +entry: + %var1 = alloca i64, align 4 + %var2 = alloca i32, align 4 + store i64 0, i64* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %then + +if: + %bitcast = bitcast i32* %var2 to i64* + br label %then + +then: + %ptr = phi i64* [ %var1, %entry ], [ %bitcast, %if ] + %ret = load i64, i64* %ptr, align 4 + ret i64 %ret +} + +; CHECK-LABEL: phi_different_types_b: +; CHECK: __stack_chk_guard +define i64 @phi_different_types_b(i32 %k) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i64, align 4 + store i32 0, i32* %var1, align 4 + store i64 0, i64* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %then + +if: + %bitcast = bitcast i32* %var1 to i64* + br label %then + +then: + %ptr = phi i64* [ %var2, %entry ], [ %bitcast, %if ] + %ret = load i64, i64* %ptr, align 4 + ret i64 %ret +} + +; CHECK-LABEL: phi_after_gep_nonconstant_out_of_bounds_a: +; CHECK: __stack_chk_guard +define i32 @phi_after_gep_nonconstant_out_of_bounds_a(i32 %k, i32 %n) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i32, align 4 + store i32 0, i32* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %else + +if: + %gep1 = getelementptr inbounds i32, i32* %var1, i32 0 + br label %then + +else: + %gep2 = getelementptr inbounds i32, i32* %var2, i32 %n + br label %then + +then: + %ptr = phi i32* [ %gep1, %if ], [ %gep2, %else ] + %ret = load i32, i32* %ptr, align 4 + ret i32 %ret +} + +; CHECK-LABEL: phi_after_gep_nonconstant_out_of_bounds_b: +; CHECK: __stack_chk_guard +define i32 @phi_after_gep_nonconstant_out_of_bounds_b(i32 %k, i32 %n) #0 { +entry: + %var1 = alloca i32, align 4 + %var2 = alloca i32, align 4 + store i32 0, i32* %var1, align 4 + store i32 0, i32* %var2, align 4 + %cmp = icmp ne i32 %k, 0 + br i1 %cmp, label %if, label %else + +if: + %gep1 = getelementptr inbounds i32, i32* %var1, i32 %n + br label %then + +else: + %gep2 = getelementptr inbounds i32, i32* %var2, i32 0 + br label %then + +then: + %ptr = phi i32* [ %gep1, %if ], [ %gep2, %else ] + %ret = load i32, i32* %ptr, align 4 + ret i32 %ret +} + +%struct.outer = type { %struct.inner, %struct.inner } +%struct.inner = type { i32, i32 } + +; CHECK-LABEL: struct_in_bounds: +; CHECK-NOT: __stack_chk_guard +define void @struct_in_bounds() #0 { + %var = alloca %struct.outer, align 4 + %outergep = getelementptr inbounds %struct.outer, %struct.outer* %var, i32 0, i32 1 + %innergep = getelementptr inbounds %struct.inner, %struct.inner* %outergep, i32 0, i32 1 + store i32 0, i32* %innergep, align 4 + ret void +} + +; CHECK-LABEL: struct_constant_out_of_bounds_a: +; CHECK: __stack_chk_guard +define void @struct_constant_out_of_bounds_a() #0 { + %var = alloca %struct.outer, align 4 + %outergep = getelementptr inbounds %struct.outer, %struct.outer* %var, i32 1, i32 0 + %innergep = getelementptr inbounds %struct.inner, %struct.inner* %outergep, i32 0, i32 0 + store i32 0, i32* %innergep, align 4 + ret void +} + +; CHECK-LABEL: struct_constant_out_of_bounds_b: +; Here the offset is out-of-bounds of the addressed struct.inner member, but +; still within bounds of the outer struct so no stack guard is needed. +; CHECK-NOT: __stack_chk_guard +define void @struct_constant_out_of_bounds_b() #0 { + %var = alloca %struct.outer, align 4 + %outergep = getelementptr inbounds %struct.outer, %struct.outer* %var, i32 0, i32 0 + %innergep = getelementptr inbounds %struct.inner, %struct.inner* %outergep, i32 1, i32 0 + store i32 0, i32* %innergep, align 4 + ret void +} + +; CHECK-LABEL: struct_constant_out_of_bounds_c: +; Here we are out-of-bounds of both the inner and outer struct. +; CHECK: __stack_chk_guard +define void @struct_constant_out_of_bounds_c() #0 { + %var = alloca %struct.outer, align 4 + %outergep = getelementptr inbounds %struct.outer, %struct.outer* %var, i32 0, i32 1 + %innergep = getelementptr inbounds %struct.inner, %struct.inner* %outergep, i32 1, i32 0 + store i32 0, i32* %innergep, align 4 + ret void +} + +; CHECK-LABEL: struct_nonconstant_out_of_bounds_a: +; CHECK: __stack_chk_guard +define void @struct_nonconstant_out_of_bounds_a(i32 %n) #0 { + %var = alloca %struct.outer, align 4 + %outergep = getelementptr inbounds %struct.outer, %struct.outer* %var, i32 %n, i32 0 + %innergep = getelementptr inbounds %struct.inner, %struct.inner* %outergep, i32 0, i32 0 + store i32 0, i32* %innergep, align 4 + ret void +} + +; CHECK-LABEL: struct_nonconstant_out_of_bounds_b: +; CHECK: __stack_chk_guard +define void @struct_nonconstant_out_of_bounds_b(i32 %n) #0 { + %var = alloca %struct.outer, align 4 + %outergep = getelementptr inbounds %struct.outer, %struct.outer* %var, i32 0, i32 0 + %innergep = getelementptr inbounds %struct.inner, %struct.inner* %outergep, i32 %n, i32 0 + store i32 0, i32* %innergep, align 4 + ret void +} + +; CHECK-LABEL: bitcast_smaller_load +; CHECK-NOT: __stack_chk_guard +define i32 @bitcast_smaller_load() #0 { + %var = alloca i64, align 4 + store i64 0, i64* %var, align 4 + %bitcast = bitcast i64* %var to i32* + %ret = load i32, i32* %bitcast, align 4 + ret i32 %ret +} + +; CHECK-LABEL: bitcast_same_size_load +; CHECK-NOT: __stack_chk_guard +define i32 @bitcast_same_size_load() #0 { + %var = alloca i64, align 4 + store i64 0, i64* %var, align 4 + %bitcast = bitcast i64* %var to %struct.inner* + %gep = getelementptr inbounds %struct.inner, %struct.inner* %bitcast, i32 0, i32 1 + %ret = load i32, i32* %gep, align 4 + ret i32 %ret +} + +; CHECK-LABEL: bitcast_larger_load +; CHECK: __stack_chk_guard +define i64 @bitcast_larger_load() #0 { + %var = alloca i32, align 4 + store i32 0, i32* %var, align 4 + %bitcast = bitcast i32* %var to i64* + %ret = load i64, i64* %bitcast, align 4 + ret i64 %ret +} + +; CHECK-LABEL: bitcast_larger_store +; CHECK: __stack_chk_guard +define i32 @bitcast_larger_store() #0 { + %var = alloca i32, align 4 + %bitcast = bitcast i32* %var to i64* + store i64 0, i64* %bitcast, align 4 + %ret = load i32, i32* %var, align 4 + ret i32 %ret +} + +; CHECK-LABEL: bitcast_larger_cmpxchg +; CHECK: __stack_chk_guard +define i64 @bitcast_larger_cmpxchg(i64 %desired, i64 %new) #0 { + %var = alloca i32, align 4 + %bitcast = bitcast i32* %var to i64* + %pair = cmpxchg i64* %bitcast, i64 %desired, i64 %new seq_cst monotonic + %ret = extractvalue { i64, i1 } %pair, 0 + ret i64 %ret +} + +; CHECK-LABEL: bitcast_larger_atomic_rmw +; CHECK: __stack_chk_guard +define i64 @bitcast_larger_atomic_rmw() #0 { + %var = alloca i32, align 4 + %bitcast = bitcast i32* %var to i64* + %ret = atomicrmw add i64* %bitcast, i64 1 monotonic + ret i64 %ret +} + +%struct.packed = type <{ i16, i32 }> + +; CHECK-LABEL: bitcast_overlap +; CHECK: __stack_chk_guard +define i32 @bitcast_overlap() #0 { + %var = alloca i32, align 4 + %bitcast = bitcast i32* %var to %struct.packed* + %gep = getelementptr inbounds %struct.packed, %struct.packed* %bitcast, i32 0, i32 1 + %ret = load i32, i32* %gep, align 2 + ret i32 %ret +} + +%struct.multi_dimensional = type { [10 x [10 x i32]], i32 } + +; CHECK-LABEL: multi_dimensional_array +; CHECK: __stack_chk_guard +define i32 @multi_dimensional_array() #0 { + %var = alloca %struct.multi_dimensional, align 4 + %gep1 = getelementptr inbounds %struct.multi_dimensional, %struct.multi_dimensional* %var, i32 0, i32 0 + %gep2 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %gep1, i32 0, i32 10 + %gep3 = getelementptr inbounds [10 x i32], [10 x i32]* %gep2, i32 0, i32 5 + %ret = load i32, i32* %gep3, align 4 + ret i32 %ret +} + +attributes #0 = { sspstrong } diff --git a/llvm/test/MC/X86/align-branch-64-hardcode.s b/llvm/test/MC/X86/align-branch-64-hardcode.s new file mode 100644 index 00000000000000..103e90534762d9 --- /dev/null +++ b/llvm/test/MC/X86/align-branch-64-hardcode.s @@ -0,0 +1,32 @@ + # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu --x86-align-branch-boundary=32 --x86-align-branch=jmp+call %s | llvm-objdump -d --no-show-raw-insn - | FileCheck %s + + # Exercise cases where instructions to be aligned is after hardcode + # and thus can't add a nop in between without changing semantic. + + .text + + # CHECK: 1d: int3 + # CHECK: 1e: jmp + # CHECK: 24: int3 + .p2align 5 + .rept 30 + int3 + .endr + .byte 0x2e + jmp baz + int3 + + # CHECK: 5d: int3 + # CHECK: 5e: call + # CHECK: 66: int3 + .p2align 5 + .rept 30 + int3 + .endr + .byte 0x66 + call *___tls_get_addr@GOT(%ecx) + int3 + + .section ".text.other" +bar: + retq diff --git a/llvm/test/MC/X86/prefix-padding-32.s b/llvm/test/MC/X86/prefix-padding-32.s new file mode 100644 index 00000000000000..b975bd5783c085 --- /dev/null +++ b/llvm/test/MC/X86/prefix-padding-32.s @@ -0,0 +1,50 @@ +# RUN: llvm-mc -filetype=obj -triple i386-pc-linux-gnu %s -x86-pad-max-prefix-size=15 | llvm-objdump -d --section=.text - | FileCheck %s + +# Check prefix padding generation for all cases on 32 bit x86. + +# CHECK: 1: 3e 3e 3e 3e 3e 3e 3e 3e 3e 81 e1 01 00 00 00 andl $1, %ecx +# CHECK: 10: 3e 3e 3e 3e 3e 3e 3e 3e 3e 81 21 01 00 00 00 andl $1, %ds:(%ecx) +# CHECK: 1f: 2e 2e 2e 2e 2e 2e 2e 2e 2e 81 21 01 00 00 00 andl $1, %cs:(%ecx) +# CHECK: 2e: 3e 3e 3e 3e 3e 3e 3e 3e 3e 81 21 01 00 00 00 andl $1, %ds:(%ecx) +# CHECK: 3d: 26 26 26 26 26 26 26 26 26 81 21 01 00 00 00 andl $1, %es:(%ecx) +# CHECK: 4c: 64 64 64 64 64 64 64 64 64 81 21 01 00 00 00 andl $1, %fs:(%ecx) +# CHECK: 5b: 65 65 65 65 65 65 65 65 65 81 21 01 00 00 00 andl $1, %gs:(%ecx) +# CHECK: 6a: 36 36 36 36 36 36 36 36 36 81 21 01 00 00 00 andl $1, %ss:(%ecx) +# CHECK: 79: 3e 3e 3e 3e 3e 81 a1 00 00 00 00 01 00 00 00 andl $1, %ds:(%ecx) +# CHECK: 88: 3e 3e 3e 3e 3e 81 a1 00 00 00 00 01 00 00 00 andl $1, %ds:(%ecx) +# CHECK: 97: 36 36 36 36 36 36 36 36 81 24 24 01 00 00 00 andl $1, %ss:(%esp) +# CHECK: a6: 65 65 65 65 65 65 65 65 81 24 24 01 00 00 00 andl $1, %gs:(%esp) +# CHECK: b5: 36 36 36 36 81 a4 24 00 00 00 00 01 00 00 00 andl $1, %ss:(%esp) +# CHECK: c4: 36 36 36 36 36 36 36 36 81 65 00 01 00 00 00 andl $1, %ss:(%ebp) +# CHECK: d3: 65 65 65 65 65 65 65 65 81 65 00 01 00 00 00 andl $1, %gs:(%ebp) +# CHECK: e2: 36 36 36 36 36 81 a5 00 00 00 00 01 00 00 00 andl $1, %ss:(%ebp) + .text + .section .text + .p2align 8 +bar: + int3 +foo: + # non-memory + andl $foo, %ecx + # memory, non-esp/ebp + andl $foo, (%ecx) + andl $foo, %cs:(%ecx) + andl $foo, %ds:(%ecx) + andl $foo, %es:(%ecx) + andl $foo, %fs:(%ecx) + andl $foo, %gs:(%ecx) + andl $foo, %ss:(%ecx) + andl $foo, data16 (%ecx) + andl $foo, data32 (%ecx) + # esp w/o segment override + andl $foo, (%esp) + andl $foo, %gs:(%esp) + andl $foo, data32 (%esp) + # ebp w/o segment override + andl $foo, (%ebp) + andl $foo, %gs:(%ebp) + andl $foo, data32 (%ebp) + + # Request enough padding to justify padding all of the above + .p2align 8 + int3 diff --git a/llvm/test/MC/X86/prefix-padding-64.s b/llvm/test/MC/X86/prefix-padding-64.s new file mode 100644 index 00000000000000..fcffc772d25bc1 --- /dev/null +++ b/llvm/test/MC/X86/prefix-padding-64.s @@ -0,0 +1,53 @@ +# RUN: llvm-mc -mcpu=skylake -filetype=obj -triple x86_64-pc-linux-gnu %s -x86-pad-max-prefix-size=15 | llvm-objdump -d --section=.text - | FileCheck %s + +# Check prefix padding generation for all cases on 64 bit x86. + +# CHECK: 0: 2e 2e 2e 2e 2e 2e 2e 2e 48 81 e1 00 00 00 00 andq $0, %rcx +# CHECK: f: 2e 2e 2e 2e 2e 2e 2e 2e 48 81 21 00 00 00 00 andq $0, %cs:(%rcx) +# CHECK: 1e: 2e 2e 2e 2e 2e 2e 2e 2e 48 81 21 00 00 00 00 andq $0, %cs:(%rcx) +# CHECK: 2d: 3e 3e 3e 3e 3e 3e 3e 3e 48 81 21 00 00 00 00 andq $0, %ds:(%rcx) +# CHECK: 3c: 26 26 26 26 26 26 26 26 48 81 21 00 00 00 00 andq $0, %es:(%rcx) +# CHECK: 4b: 64 64 64 64 64 64 64 64 48 81 21 00 00 00 00 andq $0, %fs:(%rcx) +# CHECK: 5a: 65 65 65 65 65 65 65 65 48 81 21 00 00 00 00 andq $0, %gs:(%rcx) +# CHECK: 69: 36 36 36 36 36 36 36 36 48 81 21 00 00 00 00 andq $0, %ss:(%rcx) +# CHECK: 78: 2e 2e 2e 2e 48 81 a1 00 00 00 00 00 00 00 00 andq $0, %cs:(%rcx) +# CHECK: 87: 2e 2e 2e 2e 48 81 a1 00 00 00 00 00 00 00 00 andq $0, %cs:(%rcx) +# CHECK: 96: 2e 2e 2e 2e 2e 2e 2e 48 81 24 24 00 00 00 00 andq $0, %cs:(%rsp) +# CHECK: a5: 65 65 65 65 65 65 65 48 81 24 24 00 00 00 00 andq $0, %gs:(%rsp) +# CHECK: b4: 2e 2e 2e 48 81 a4 24 00 00 00 00 00 00 00 00 andq $0, %cs:(%rsp) +# CHECK: c3: 2e 2e 2e 2e 2e 2e 2e 48 81 65 00 00 00 00 00 andq $0, %cs:(%rbp) +# CHECK: d2: 65 65 65 65 65 65 65 48 81 65 00 00 00 00 00 andq $0, %gs:(%rbp) +# CHECK: e1: 2e 2e 2e 2e 48 81 a5 00 00 00 00 00 00 00 00 andq $0, %cs:(%rbp) + .text + .section .text + .p2align 8 + # non-memory + andq $foo, %rcx + # memory, non-esp/ebp + andq $foo, (%rcx) + andq $foo, %cs:(%rcx) + andq $foo, %ds:(%rcx) + andq $foo, %es:(%rcx) + andq $foo, %fs:(%rcx) + andq $foo, %gs:(%rcx) + andq $foo, %ss:(%rcx) + andq $foo, data16 (%rcx) + andq $foo, data32 (%rcx) + # esp w/o segment override + andq $foo, (%rsp) + andq $foo, %gs:(%rsp) + andq $foo, data32 (%rsp) + # ebp w/o segment override + andq $foo, (%rbp) + andq $foo, %gs:(%rbp) + andq $foo, data32 (%rbp) + + # Request enough padding to justify padding all of the above + .p2align 8 + int3 + + .section "other" +bar: + .p2align 3 + int3 +foo: diff --git a/llvm/test/Transforms/InstCombine/align-attr.ll b/llvm/test/Transforms/InstCombine/align-attr.ll index 2b004311cc8ea4..16782dba2effc8 100644 --- a/llvm/test/Transforms/InstCombine/align-attr.ll +++ b/llvm/test/Transforms/InstCombine/align-attr.ll @@ -20,7 +20,7 @@ define i32 @foo2(i32* align 32 %a) #0 { ; CHECK-LABEL: @foo2( ; CHECK-NEXT: entry: ; CHECK-NEXT: [[V:%.*]] = call i32* @func1(i32* [[A:%.*]]) -; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[A]], align 32 +; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[V]], align 32 ; CHECK-NEXT: ret i32 [[TMP0]] ; entry: diff --git a/llvm/test/Transforms/InstCombine/element-atomic-memintrins.ll b/llvm/test/Transforms/InstCombine/element-atomic-memintrins.ll index a49b4c7af7e395..42e2b131c0c05e 100644 --- a/llvm/test/Transforms/InstCombine/element-atomic-memintrins.ll +++ b/llvm/test/Transforms/InstCombine/element-atomic-memintrins.ll @@ -415,4 +415,23 @@ define void @test_memcpy_loadstore_16(i8* %dest, i8* %src) { ret void } +define void @test_undefined(i8* %dest, i8* %src) { +; CHECK-LABEL: @test_undefined( +entry: + br i1 undef, label %ok, label %undefined +undefined: +; CHECK: undefined: +; CHECK-NEXT: store i1 true, i1* undef +; CHECK-NEXT: br label %ok + call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 16 %dest, i8* align 16 %src, i32 7, i32 4) + call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 16 %dest, i8* align 16 %src, i32 -8, i32 4) + call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 16 %dest, i8* align 16 %src, i32 7, i32 4) + call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* align 16 %dest, i8* align 16 %src, i32 -8, i32 4) + call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 16 %dest, i8 1, i32 7, i32 4) + call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 16 %dest, i8 1, i32 -8, i32 4) + br label %ok +ok: + ret void +} + declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* nocapture writeonly, i8* nocapture readonly, i32, i32) nounwind argmemonly diff --git a/llvm/test/Transforms/InstCombine/expensive-combines.ll b/llvm/test/Transforms/InstCombine/expensive-combines.ll index 96a45b05cfb591..28acb773bfd50f 100644 --- a/llvm/test/Transforms/InstCombine/expensive-combines.ll +++ b/llvm/test/Transforms/InstCombine/expensive-combines.ll @@ -16,7 +16,7 @@ define void @test() { ; ; EXPENSIVE-OFF-LABEL: @test( ; EXPENSIVE-OFF-NEXT: [[CALL:%.*]] = call i32 @passthru(i32 0) -; EXPENSIVE-OFF-NEXT: call void @sink(i32 0) +; EXPENSIVE-OFF-NEXT: call void @sink(i32 [[CALL]]) ; EXPENSIVE-OFF-NEXT: ret void ; %call = call i32 @passthru(i32 0) diff --git a/llvm/test/Transforms/InstCombine/fortify-folding.ll b/llvm/test/Transforms/InstCombine/fortify-folding.ll index b2171a44f57ef8..ee81557615a543 100644 --- a/llvm/test/Transforms/InstCombine/fortify-folding.ll +++ b/llvm/test/Transforms/InstCombine/fortify-folding.ll @@ -82,7 +82,7 @@ define i32 @test_not_sprintf() { define i8* @test_strcat() { ; CHECK-LABEL: @test_strcat( ; CHECK-NEXT: [[STRCAT:%.*]] = call i8* @strcat(i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i64 0, i64 0), i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @b, i64 0, i64 0)) -; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i64 0, i64 0) +; CHECK-NEXT: ret i8* [[STRCAT]] ; %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0 @@ -126,7 +126,7 @@ define i64 @test_not_strlcat() { define i8* @test_strncat() { ; CHECK-LABEL: @test_strncat( ; CHECK-NEXT: [[STRNCAT:%.*]] = call i8* @strncat(i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i64 0, i64 0), i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @b, i64 0, i64 0), i64 22) -; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i64 0, i64 0) +; CHECK-NEXT: ret i8* [[STRNCAT]] ; %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0 diff --git a/llvm/test/Transforms/InstCombine/strcpy_chk-1.ll b/llvm/test/Transforms/InstCombine/strcpy_chk-1.ll index 67e393d1525be1..02a4b5cbdeac29 100644 --- a/llvm/test/Transforms/InstCombine/strcpy_chk-1.ll +++ b/llvm/test/Transforms/InstCombine/strcpy_chk-1.ll @@ -53,7 +53,7 @@ define i8* @test_simplify3() { define i8* @test_simplify4() { ; CHECK-LABEL: @test_simplify4( ; CHECK-NEXT: [[STRCPY:%.*]] = call i8* @strcpy(i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0)) -; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0) +; CHECK-NEXT: ret i8* [[STRCPY]] ; %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0 diff --git a/llvm/test/Transforms/InstCombine/strncpy_chk-1.ll b/llvm/test/Transforms/InstCombine/strncpy_chk-1.ll index 7601b16693599d..ed90303b280807 100644 --- a/llvm/test/Transforms/InstCombine/strncpy_chk-1.ll +++ b/llvm/test/Transforms/InstCombine/strncpy_chk-1.ll @@ -39,7 +39,7 @@ define i8* @test_simplify2() { define i8* @test_simplify3() { ; CHECK-LABEL: @test_simplify3( ; CHECK-NEXT: [[STRNCPY:%.*]] = call i8* @strncpy(i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0), i32 12) -; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0) +; CHECK-NEXT: ret i8* [[STRNCPY]] ; %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0 diff --git a/llvm/test/Transforms/InstCombine/unused-nonnull.ll b/llvm/test/Transforms/InstCombine/unused-nonnull.ll index 382d2634b86c53..0a1520ea73c20c 100644 --- a/llvm/test/Transforms/InstCombine/unused-nonnull.ll +++ b/llvm/test/Transforms/InstCombine/unused-nonnull.ll @@ -12,8 +12,13 @@ define i32 @main(i32 %argc, i8** %argv) #0 { ; CHECK-SAME: (i32 [[ARGC:%.*]], i8** nocapture readnone [[ARGV:%.*]]) local_unnamed_addr #0 ; CHECK-NEXT: entry: ; CHECK-NEXT: [[TMP0:%.*]] = icmp slt i32 [[ARGC]], 2 -; CHECK-NEXT: [[SPEC_SELECT:%.*]] = select i1 [[TMP0]], i32 0, i32 [[ARGC]] -; CHECK-NEXT: ret i32 [[SPEC_SELECT]] +; CHECK-NEXT: br i1 [[TMP0]], label [[DONE:%.*]], label [[DO_WORK:%.*]] +; CHECK: do_work: +; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @compute(i8* undef, i32 [[ARGC]]) +; CHECK-NEXT: br label [[DONE]] +; CHECK: done: +; CHECK-NEXT: [[RETVAL:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[TMP1]], [[DO_WORK]] ] +; CHECK-NEXT: ret i32 [[RETVAL]] ; entry: %0 = getelementptr inbounds i8*, i8** %argv, i32 0 diff --git a/llvm/test/Transforms/InstSimplify/call.ll b/llvm/test/Transforms/InstSimplify/call.ll index d744db6ddf7660..108de9082a700d 100644 --- a/llvm/test/Transforms/InstSimplify/call.ll +++ b/llvm/test/Transforms/InstSimplify/call.ll @@ -993,7 +993,7 @@ define i32 @returned_const_int_arg() { define i8* @returned_const_ptr_arg() { ; CHECK-LABEL: @returned_const_ptr_arg( ; CHECK-NEXT: [[X:%.*]] = call i8* @passthru_p8(i8* null) -; CHECK-NEXT: ret i8* null +; CHECK-NEXT: ret i8* [[X]] ; %x = call i8* @passthru_p8(i8* null) ret i8* %x @@ -1002,7 +1002,7 @@ define i8* @returned_const_ptr_arg() { define i32 @returned_var_arg(i32 %arg) { ; CHECK-LABEL: @returned_var_arg( ; CHECK-NEXT: [[X:%.*]] = call i32 @passthru_i32(i32 [[ARG:%.*]]) -; CHECK-NEXT: ret i32 [[ARG]] +; CHECK-NEXT: ret i32 [[X]] ; %x = call i32 @passthru_i32(i32 %arg) ret i32 %x diff --git a/llvm/test/Transforms/InstSimplify/vscale.ll b/llvm/test/Transforms/InstSimplify/vscale.ll index 5a6971c9e2929d..d112128042c205 100644 --- a/llvm/test/Transforms/InstSimplify/vscale.ll +++ b/llvm/test/Transforms/InstSimplify/vscale.ll @@ -94,3 +94,42 @@ define i32 @insert_extract_element_same_vec_idx_2( %a) { ret i32 %r } +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Memory Access and Addressing Operations +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; getelementptr + +define @getelementptr_constant_foldable_1() { +; CHECK-LABEL: @getelementptr_constant_foldable_1( +; CHECK-NEXT: ret zeroinitializer +; + %ptr = getelementptr i32, zeroinitializer, undef + ret %ptr +} + +define *> @getelementptr_constant_foldable_2() { +; CHECK-LABEL: @getelementptr_constant_foldable_2( +; CHECK-NEXT: ret *> zeroinitializer +; + %ptr = getelementptr , * null, undef + ret *> %ptr +} + +; fold getelementptr P, 0 -> P. +define * @getelementptr_constant_foldable_3() { +; CHECK-LABEL: @getelementptr_constant_foldable_3( +; CHECK-NEXT: ret * null +; + %ptr = getelementptr , * null, i64 0 + ret * %ptr +} + +define * @getelementptr_not_constant_foldable(i64 %x) { +; CHECK-LABEL: @getelementptr_not_constant_foldable( +; CHECK-NEXT: [[PTR:%.*]] = getelementptr , * null, i64 [[X:%.*]] +; CHECK-NEXT: ret * [[PTR]] +; + %ptr = getelementptr , * null, i64 %x + ret * %ptr +} diff --git a/llvm/test/Transforms/SCCP/ip-ranges-select.ll b/llvm/test/Transforms/SCCP/ip-ranges-select.ll new file mode 100644 index 00000000000000..b19dc43352625f --- /dev/null +++ b/llvm/test/Transforms/SCCP/ip-ranges-select.ll @@ -0,0 +1,37 @@ +; RUN: opt -ipsccp -S %s -o -| FileCheck %s + +define void @caller.1(i8* %arg) { +; CHECK-LABEL: define void @caller.1(i8* %arg) { +; CHECK-NEXT: %r.1 = tail call i32 @callee.1(i32 4) +; CHECK-NEXT: %r.2 = tail call i32 @callee.1(i32 2) +; CHECK-NEXT: call void @use(i32 20) +; CHECK-NEXT: ret void +; + %r.1 = tail call i32 @callee.1(i32 4) + %r.2 = tail call i32 @callee.1(i32 2) + %r.3 = add i32 %r.1, %r.2 + call void @use(i32 %r.3) + ret void +} + +define internal i32 @callee.1(i32 %arg) { +; CHECK-LABEL: define internal i32 @callee.1(i32 %arg) { +; CHECK-NEXT: %sel = select i1 false, i32 16, i32 %arg +; CHECK-NEXT: br label %bb10 +; +; CHECK-LABEL: bb10: +; CHECK-NEXT: ret i32 undef +; + %c.1 = icmp slt i32 %arg, 0 + %sel = select i1 %c.1, i32 16, i32 %arg + %c.2 = icmp eq i32 %sel, 0 + br i1 %c.2, label %bb12, label %bb10 + +bb10: ; preds = %bb8 + ret i32 10 + +bb12: ; preds = %bb8, %bb3, %bb + ret i32 12 +} + +declare void @use(i32) diff --git a/llvm/test/Transforms/SimplifyCFG/PowerPC/prefer-fma.ll b/llvm/test/Transforms/SimplifyCFG/PowerPC/prefer-fma.ll new file mode 100644 index 00000000000000..e72413e8b308ba --- /dev/null +++ b/llvm/test/Transforms/SimplifyCFG/PowerPC/prefer-fma.ll @@ -0,0 +1,102 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; RUN: opt < %s -mtriple=powerpc64le-unknown-linux-gnu -simplifycfg -enable-unsafe-fp-math -S | \ +; RUN: FileCheck %s + +; This case is copied from test/Transforms/SimplifyCFG/AArch64/ +; Function Attrs: nounwind +define double @_Z3fooRdS_S_S_(double* dereferenceable(8) %x, double* dereferenceable(8) %y, double* dereferenceable(8) %a) { +; CHECK-LABEL: @_Z3fooRdS_S_S_( +; CHECK-NEXT: entry: +; CHECK-NEXT: [[TMP0:%.*]] = load double, double* [[Y:%.*]], align 8 +; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[TMP0]], 0.000000e+00 +; CHECK-NEXT: [[TMP1:%.*]] = load double, double* [[X:%.*]], align 8 +; CHECK-NEXT: [[TMP2:%.*]] = load double, double* [[A:%.*]], align 8 +; CHECK-NEXT: [[TMP3:%.*]] = fmul fast double [[TMP1]], [[TMP2]] +; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] +; CHECK: if.then: +; CHECK-NEXT: [[MUL:%.*]] = fadd fast double 1.000000e+00, [[TMP3]] +; CHECK-NEXT: store double [[MUL]], double* [[Y]], align 8 +; CHECK-NEXT: br label [[IF_END:%.*]] +; CHECK: if.else: +; CHECK-NEXT: [[SUB1:%.*]] = fsub fast double [[TMP3]], [[TMP0]] +; CHECK-NEXT: [[GEP1:%.*]] = getelementptr double, double* [[Y]], i32 1 +; CHECK-NEXT: store double [[SUB1]], double* [[GEP1]], align 8 +; CHECK-NEXT: br label [[IF_END]] +; CHECK: if.end: +; CHECK-NEXT: [[TMP4:%.*]] = load double, double* [[Y]], align 8 +; CHECK-NEXT: [[CMP2:%.*]] = fcmp oeq double [[TMP4]], 2.000000e+00 +; CHECK-NEXT: [[TMP5:%.*]] = load double, double* [[X]], align 8 +; CHECK-NEXT: br i1 [[CMP2]], label [[IF_THEN2:%.*]], label [[IF_ELSE2:%.*]] +; CHECK: if.then2: +; CHECK-NEXT: [[TMP6:%.*]] = load double, double* [[A]], align 8 +; CHECK-NEXT: [[TMP7:%.*]] = fmul fast double [[TMP5]], 3.000000e+00 +; CHECK-NEXT: [[MUL2:%.*]] = fsub fast double [[TMP6]], [[TMP7]] +; CHECK-NEXT: store double [[MUL2]], double* [[Y]], align 8 +; CHECK-NEXT: br label [[IF_END2:%.*]] +; CHECK: if.else2: +; CHECK-NEXT: [[MUL3:%.*]] = fmul fast double [[TMP5]], 3.000000e+00 +; CHECK-NEXT: [[NEG:%.*]] = fsub fast double 0.000000e+00, [[MUL3]] +; CHECK-NEXT: [[SUB2:%.*]] = fsub fast double [[NEG]], 3.000000e+00 +; CHECK-NEXT: store double [[SUB2]], double* [[Y]], align 8 +; CHECK-NEXT: br label [[IF_END2]] +; CHECK: if.end2: +; CHECK-NEXT: [[TMP8:%.*]] = load double, double* [[X]], align 8 +; CHECK-NEXT: [[TMP9:%.*]] = load double, double* [[Y]], align 8 +; CHECK-NEXT: [[ADD:%.*]] = fadd fast double [[TMP8]], [[TMP9]] +; CHECK-NEXT: [[TMP10:%.*]] = load double, double* [[A]], align 8 +; CHECK-NEXT: [[ADD2:%.*]] = fadd fast double [[ADD]], [[TMP10]] +; CHECK-NEXT: ret double [[ADD2]] +; +entry: + %0 = load double, double* %y, align 8 + %cmp = fcmp oeq double %0, 0.000000e+00 + %1 = load double, double* %x, align 8 + br i1 %cmp, label %if.then, label %if.else + +; fadd (const, (fmul x, y)) +if.then: ; preds = %entry + %2 = load double, double* %a, align 8 + %3 = fmul fast double %1, %2 + %mul = fadd fast double 1.000000e+00, %3 + store double %mul, double* %y, align 8 + br label %if.end + +; fsub ((fmul x, y), z) +if.else: ; preds = %entry + %4 = load double, double* %a, align 8 + %mul1 = fmul fast double %1, %4 + %sub1 = fsub fast double %mul1, %0 + %gep1 = getelementptr double, double* %y, i32 1 + store double %sub1, double* %gep1, align 8 + br label %if.end + +if.end: ; preds = %if.else, %if.then + %5 = load double, double* %y, align 8 + %cmp2 = fcmp oeq double %5, 2.000000e+00 + %6 = load double, double* %x, align 8 + br i1 %cmp2, label %if.then2, label %if.else2 + +; fsub (x, (fmul y, z)) +if.then2: ; preds = %entry + %7 = load double, double* %a, align 8 + %8 = fmul fast double %6, 3.0000000e+00 + %mul2 = fsub fast double %7, %8 + store double %mul2, double* %y, align 8 + br label %if.end2 + +; fsub (fneg((fmul x, y)), const) +if.else2: ; preds = %entry + %mul3 = fmul fast double %6, 3.0000000e+00 + %neg = fsub fast double 0.0000000e+00, %mul3 + %sub2 = fsub fast double %neg, 3.0000000e+00 + store double %sub2, double* %y, align 8 + br label %if.end2 + +if.end2: ; preds = %if.else, %if.then + %9 = load double, double* %x, align 8 + %10 = load double, double* %y, align 8 + %add = fadd fast double %9, %10 + %11 = load double, double* %a, align 8 + %add2 = fadd fast double %add, %11 + ret double %add2 +} diff --git a/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c b/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c deleted file mode 100644 index 20c17f7d9762dc..00000000000000 --- a/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c +++ /dev/null @@ -1,10 +0,0 @@ -int foo(int a, int b, int c) { - int x = a + b; - int y = x + c; - return y; -} - -int bar(int a) { - a++; - return a; -} diff --git a/llvm/test/tools/llvm-objdump/ARM/Inputs/wide-char.c b/llvm/test/tools/llvm-objdump/ARM/Inputs/wide-char.c deleted file mode 100644 index 8d923be0132836..00000000000000 --- a/llvm/test/tools/llvm-objdump/ARM/Inputs/wide-char.c +++ /dev/null @@ -1,3 +0,0 @@ -int foo(int *å–µ) { - return *å–µ; -} diff --git a/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s b/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s deleted file mode 100644 index b3bfbe3f7d513f..00000000000000 --- a/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4-sections.s +++ /dev/null @@ -1,354 +0,0 @@ -## Check that the --debug-vars option works for simple register locations, when -## using DWARF4 debug info, with functions in multiple sections. - -## Generated with this compile command, with the source code in Inputs/debug.c: -## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-4 -S -o - -ffunction-sections - -## The unicode characters in this test cause test failures on Windows. -# UNSUPPORTED: system-windows - -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars --no-show-raw-insn | \ -# RUN: FileCheck %s - -# CHECK: Disassembly of section .text.foo: -# CHECK-EMPTY: -# CHECK-NEXT: 00000000 : -# CHECK-NEXT: ┠─ a = R0 -# CHECK-NEXT: ┃ ┠─ b = R1 -# CHECK-NEXT: ┃ ┃ ┠─ c = R2 -# CHECK-NEXT: ┃ ┃ ┃ ┌─ x = R0 -# CHECK-NEXT: 0: add r0, r1, r0 â”» ┃ ┃ ╈ -# CHECK-NEXT: ┌─ y = R0 -# CHECK-NEXT: 4: add r0, r0, r2 ╈ ┃ ┃ â”» -# CHECK-NEXT: 8: bx lr â”» â”» â”» -# CHECK-EMPTY: -# CHECK-NEXT: Disassembly of section .text.bar: -# CHECK-EMPTY: -# CHECK-NEXT: 00000000 : -# CHECK-NEXT: ┠─ a = R0 -# CHECK-NEXT: 0: add r0, r0, #1 ┃ -# CHECK-NEXT: 4: bx lr â”» - - .text - .syntax unified - .eabi_attribute 67, "2.09" - .eabi_attribute 6, 10 - .eabi_attribute 7, 65 - .eabi_attribute 8, 1 - .eabi_attribute 9, 2 - .fpu neon - .eabi_attribute 34, 0 - .eabi_attribute 17, 1 - .eabi_attribute 20, 1 - .eabi_attribute 21, 1 - .eabi_attribute 23, 3 - .eabi_attribute 24, 1 - .eabi_attribute 25, 1 - .eabi_attribute 38, 1 - .eabi_attribute 18, 4 - .eabi_attribute 26, 2 - .eabi_attribute 14, 0 - .file "debug.c" - .section .text.foo,"ax",%progbits - .globl foo - .p2align 2 - .type foo,%function - .code 32 -foo: -.Lfunc_begin0: - .file 1 "/work" "llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" - .loc 1 1 0 - .fnstart - .cfi_sections .debug_frame - .cfi_startproc - .loc 1 2 13 prologue_end - add r0, r1, r0 -.Ltmp0: - .loc 1 3 13 - add r0, r0, r2 -.Ltmp1: - .loc 1 4 3 - bx lr -.Ltmp2: -.Lfunc_end0: - .size foo, .Lfunc_end0-foo - .cfi_endproc - .cantunwind - .fnend - - .section .text.bar,"ax",%progbits - .globl bar - .p2align 2 - .type bar,%function - .code 32 -bar: -.Lfunc_begin1: - .loc 1 7 0 - .fnstart - .cfi_startproc - .loc 1 8 4 prologue_end - add r0, r0, #1 -.Ltmp3: - .loc 1 9 3 - bx lr -.Ltmp4: -.Lfunc_end1: - .size bar, .Lfunc_end1-bar - .cfi_endproc - .cantunwind - .fnend - - .section .debug_str,"MS",%progbits,1 -.Linfo_string0: - .asciz "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" -.Linfo_string1: - .asciz "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" -.Linfo_string2: - .asciz "/work/scratch" -.Linfo_string3: - .asciz "foo" -.Linfo_string4: - .asciz "int" -.Linfo_string5: - .asciz "bar" -.Linfo_string6: - .asciz "a" -.Linfo_string7: - .asciz "b" -.Linfo_string8: - .asciz "c" -.Linfo_string9: - .asciz "x" -.Linfo_string10: - .asciz "y" - .section .debug_loc,"",%progbits -.Ldebug_loc0: - .long -1 - .long .Lfunc_begin0 - .long .Lfunc_begin0-.Lfunc_begin0 - .long .Ltmp0-.Lfunc_begin0 - .short 1 - .byte 80 - .long 0 - .long 0 -.Ldebug_loc1: - .long -1 - .long .Lfunc_begin0 - .long .Ltmp0-.Lfunc_begin0 - .long .Ltmp1-.Lfunc_begin0 - .short 1 - .byte 80 - .long 0 - .long 0 -.Ldebug_loc2: - .long -1 - .long .Lfunc_begin0 - .long .Ltmp1-.Lfunc_begin0 - .long .Lfunc_end0-.Lfunc_begin0 - .short 1 - .byte 80 - .long 0 - .long 0 - .section .debug_abbrev,"",%progbits - .byte 1 - .byte 17 - .byte 1 - .byte 37 - .byte 14 - .byte 19 - .byte 5 - .byte 3 - .byte 14 - .byte 16 - .byte 23 - .byte 27 - .byte 14 - .byte 17 - .byte 1 - .byte 85 - .byte 23 - .byte 0 - .byte 0 - .byte 2 - .byte 46 - .byte 1 - .byte 17 - .byte 1 - .byte 18 - .byte 6 - .byte 64 - .byte 24 - .ascii "\227B" - .byte 25 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 39 - .byte 25 - .byte 73 - .byte 19 - .byte 63 - .byte 25 - .byte 0 - .byte 0 - .byte 3 - .byte 5 - .byte 0 - .byte 2 - .byte 23 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 4 - .byte 5 - .byte 0 - .byte 2 - .byte 24 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 5 - .byte 52 - .byte 0 - .byte 2 - .byte 23 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 6 - .byte 36 - .byte 0 - .byte 3 - .byte 14 - .byte 62 - .byte 11 - .byte 11 - .byte 11 - .byte 0 - .byte 0 - .byte 0 - .section .debug_info,"",%progbits -.Lcu_begin0: - .long .Ldebug_info_end0-.Ldebug_info_start0 -.Ldebug_info_start0: - .short 4 - .long .debug_abbrev - .byte 4 - .byte 1 - .long .Linfo_string0 - .short 12 - .long .Linfo_string1 - .long .Lline_table_start0 - .long .Linfo_string2 - .long 0 - .long .Ldebug_ranges0 - .byte 2 - .long .Lfunc_begin0 - .long .Lfunc_end0-.Lfunc_begin0 - .byte 1 - .byte 91 - - .long .Linfo_string3 - .byte 1 - .byte 1 - - .long 166 - - .byte 3 - .long .Ldebug_loc0 - .long .Linfo_string6 - .byte 1 - .byte 1 - .long 166 - .byte 4 - .byte 1 - .byte 81 - .long .Linfo_string7 - .byte 1 - .byte 1 - .long 166 - .byte 4 - .byte 1 - .byte 82 - .long .Linfo_string8 - .byte 1 - .byte 1 - .long 166 - .byte 5 - .long .Ldebug_loc1 - .long .Linfo_string9 - .byte 1 - .byte 2 - .long 166 - .byte 5 - .long .Ldebug_loc2 - .long .Linfo_string10 - .byte 1 - .byte 3 - .long 166 - .byte 0 - .byte 2 - .long .Lfunc_begin1 - .long .Lfunc_end1-.Lfunc_begin1 - .byte 1 - .byte 91 - - .long .Linfo_string5 - .byte 1 - .byte 7 - - .long 166 - - .byte 4 - .byte 1 - .byte 80 - .long .Linfo_string6 - .byte 1 - .byte 7 - .long 166 - .byte 0 - .byte 6 - .long .Linfo_string4 - .byte 5 - .byte 4 - .byte 0 -.Ldebug_info_end0: - .section .debug_ranges,"",%progbits -.Ldebug_ranges0: - .long .Lfunc_begin0 - .long .Lfunc_end0 - .long .Lfunc_begin1 - .long .Lfunc_end1 - .long 0 - .long 0 - .ident "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" - .section ".note.GNU-stack","",%progbits - .addrsig - .eabi_attribute 30, 1 - .section .debug_line,"",%progbits -.Lline_table_start0: diff --git a/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4.s b/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4.s deleted file mode 100644 index 59af4c40a5a644..00000000000000 --- a/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf4.s +++ /dev/null @@ -1,456 +0,0 @@ -## Check that the --debug-vars option works for simple register locations, when -## using DWARF4 debug info, with multiple functions in one section. Check that -## the live-range lines are rendered correctly when using the --no-show-raw-insn, -## --line-numbers and --source options. These do not affect the DWARF parsing -## used by --debug-vars, but do add extra lines or columns to the output, so we -## test to make sure the live ranges are still displayed correctly. - -## Generated with this compile command, with the source code in Inputs/debug.c: -## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-4 -S -o - - -## The unicode characters in this test cause test failures on Windows. -# UNSUPPORTED: system-windows - -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars | \ -# RUN: FileCheck %s --check-prefix=RAW --strict-whitespace - -## Check that passing the default value for --debug-vars-indent (40) makes no -## change to the output. -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars --debug-vars-indent=40 | \ -# RUN: FileCheck %s --check-prefix=RAW --strict-whitespace - -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars --debug-vars-indent=30 | \ -# RUN: FileCheck %s --check-prefix=INDENT --strict-whitespace - -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars --no-show-raw-insn | \ -# RUN: FileCheck %s --check-prefix=NO-RAW --strict-whitespace - -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars --no-show-raw-insn --line-numbers | \ -# RUN: FileCheck %s --check-prefix=LINE-NUMS --strict-whitespace - -# RUN: mkdir -p %t/a -# RUN: cp %p/Inputs/debug.c %t/a/debug.c -# RUN: sed -e "s,SRC_COMPDIR,%/t/a,g" %s > %t.s -# RUN: llvm-mc -triple armv8a--none-eabi < %t.s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars --no-show-raw-insn --source | \ -# RUN: FileCheck %s --check-prefix=SOURCE --strict-whitespace - -## An optional argument to the --debug-vars= option can be used to switch -## between unicode and ascii output (with unicode being the default). -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars=unicode | \ -# RUN: FileCheck %s --check-prefix=RAW --strict-whitespace -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars=ascii | \ -# RUN: FileCheck %s --check-prefix=ASCII --strict-whitespace - -## Note that llvm-objdump emits tab characters in the disassembly, assuming an -## 8-byte tab stop, so these might not look aligned in a text editor. - -# RAW: 00000000 : -# RAW-NEXT: ┠─ a = R0 -# RAW-NEXT: ┃ ┠─ b = R1 -# RAW-NEXT: ┃ ┃ ┠─ c = R2 -# RAW-NEXT: ┃ ┃ ┃ ┌─ x = R0 -# RAW-NEXT: 0: 00 00 81 e0 add r0, r1, r0 â”» ┃ ┃ ╈ -# RAW-NEXT: ┌─ y = R0 -# RAW-NEXT: 4: 02 00 80 e0 add r0, r0, r2 ╈ ┃ ┃ â”» -# RAW-NEXT: 8: 1e ff 2f e1 bx lr â”» â”» â”» -# RAW-EMPTY: -# RAW-NEXT: 0000000c : -# RAW-NEXT: ┠─ a = R0 -# RAW-NEXT: c: 01 00 80 e2 add r0, r0, #1 ┃ -# RAW-NEXT: 10: 1e ff 2f e1 bx lr â”» - -# INDENT: 00000000 : -# INDENT-NEXT: ┠─ a = R0 -# INDENT-NEXT: ┃ ┠─ b = R1 -# INDENT-NEXT: ┃ ┃ ┠─ c = R2 -# INDENT-NEXT: ┃ ┃ ┃ ┌─ x = R0 -# INDENT-NEXT: 0: 00 00 81 e0 add r0, r1, r0 â”» ┃ ┃ ╈ -# INDENT-NEXT: ┌─ y = R0 -# INDENT-NEXT: 4: 02 00 80 e0 add r0, r0, r2 ╈ ┃ ┃ â”» -# INDENT-NEXT: 8: 1e ff 2f e1 bx lr â”» â”» â”» -# INDENT-EMPTY: -# INDENT-NEXT: 0000000c : -# INDENT-NEXT: ┠─ a = R0 -# INDENT-NEXT: c: 01 00 80 e2 add r0, r0, #1 ┃ -# INDENT-NEXT: 10: 1e ff 2f e1 bx lr â”» - -# NO-RAW: 00000000 : -# NO-RAW-NEXT: ┠─ a = R0 -# NO-RAW-NEXT: ┃ ┠─ b = R1 -# NO-RAW-NEXT: ┃ ┃ ┠─ c = R2 -# NO-RAW-NEXT: ┃ ┃ ┃ ┌─ x = R0 -# NO-RAW-NEXT: 0: add r0, r1, r0 â”» ┃ ┃ ╈ -# NO-RAW-NEXT: ┌─ y = R0 -# NO-RAW-NEXT: 4: add r0, r0, r2 ╈ ┃ ┃ â”» -# NO-RAW-NEXT: 8: bx lr â”» â”» â”» -# NO-RAW-EMPTY: -# NO-RAW-NEXT: 0000000c : -# NO-RAW-NEXT: ┠─ a = R0 -# NO-RAW-NEXT: c: add r0, r0, #1 ┃ -# NO-RAW-NEXT: 10: bx lr â”» - -# LINE-NUMS: 00000000 : -# LINE-NUMS-NEXT: ; foo(): -# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:2 ┠─ a = R0 -# LINE-NUMS-NEXT: ┃ ┠─ b = R1 -# LINE-NUMS-NEXT: ┃ ┃ ┠─ c = R2 -# LINE-NUMS-NEXT: ┃ ┃ ┃ ┌─ x = R0 -# LINE-NUMS-NEXT: 0: add r0, r1, r0 â”» ┃ ┃ ╈ -# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:3 ┌─ y = R0 -# LINE-NUMS-NEXT: 4: add r0, r0, r2 ╈ ┃ ┃ â”» -# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:4 ┃ ┃ ┃ -# LINE-NUMS-NEXT: 8: bx lr â”» â”» â”» -# LINE-NUMS-EMPTY: -# LINE-NUMS-NEXT: 0000000c : -# LINE-NUMS-NEXT: ; bar(): -# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:8 ┠─ a = R0 -# LINE-NUMS-NEXT: c: add r0, r0, #1 ┃ -# LINE-NUMS-NEXT: ; SRC_COMPDIR{{[\\/]}}debug.c:9 ┃ -# LINE-NUMS-NEXT: 10: bx lr â”» - -# SOURCE: 00000000 : -# SOURCE-NEXT: ; int x = a + b; ┠─ a = R0 -# SOURCE-NEXT: ┃ ┠─ b = R1 -# SOURCE-NEXT: ┃ ┃ ┠─ c = R2 -# SOURCE-NEXT: ┃ ┃ ┃ ┌─ x = R0 -# SOURCE-NEXT: 0: add r0, r1, r0 â”» ┃ ┃ ╈ -# SOURCE-NEXT: ; int y = x + c; ┌─ y = R0 -# SOURCE-NEXT: 4: add r0, r0, r2 ╈ ┃ ┃ â”» -# SOURCE-NEXT: ; return y; ┃ ┃ ┃ -# SOURCE-NEXT: 8: bx lr â”» â”» â”» -# SOURCE-EMPTY: -# SOURCE-NEXT: 0000000c : -# SOURCE-NEXT: ; a++; ┠─ a = R0 -# SOURCE-NEXT: c: add r0, r0, #1 ┃ -# SOURCE-NEXT: ; return a; ┃ -# SOURCE-NEXT: 10: bx lr â”» - -# ASCII: 00000000 : -# ASCII-NEXT: |- a = R0 -# ASCII-NEXT: | |- b = R1 -# ASCII-NEXT: | | |- c = R2 -# ASCII-NEXT: | | | /- x = R0 -# ASCII-NEXT: 0: 00 00 81 e0 add r0, r1, r0 v | | ^ -# ASCII-NEXT: /- y = R0 -# ASCII-NEXT: 4: 02 00 80 e0 add r0, r0, r2 ^ | | v -# ASCII-NEXT: 8: 1e ff 2f e1 bx lr v v v -# ASCII-EMPTY: -# ASCII-NEXT: 0000000c : -# ASCII-NEXT: |- a = R0 -# ASCII-NEXT: c: 01 00 80 e2 add r0, r0, #1 | -# ASCII-NEXT: 10: 1e ff 2f e1 bx lr v - - .text - .syntax unified - .eabi_attribute 67, "2.09" - .eabi_attribute 6, 10 - .eabi_attribute 7, 65 - .eabi_attribute 8, 1 - .eabi_attribute 9, 2 - .fpu neon - .eabi_attribute 34, 0 - .eabi_attribute 17, 1 - .eabi_attribute 20, 1 - .eabi_attribute 21, 1 - .eabi_attribute 23, 3 - .eabi_attribute 24, 1 - .eabi_attribute 25, 1 - .eabi_attribute 38, 1 - .eabi_attribute 18, 4 - .eabi_attribute 26, 2 - .eabi_attribute 14, 0 - .file "debug.c" - .globl foo - .p2align 2 - .type foo,%function - .code 32 -foo: -.Lfunc_begin0: - .file 1 "" "SRC_COMPDIR/debug.c" - .loc 1 1 0 - .fnstart - .cfi_sections .debug_frame - .cfi_startproc - .loc 1 2 13 prologue_end - add r0, r1, r0 -.Ltmp0: - .loc 1 3 13 - add r0, r0, r2 -.Ltmp1: - .loc 1 4 3 - bx lr -.Ltmp2: -.Lfunc_end0: - .size foo, .Lfunc_end0-foo - .cfi_endproc - .cantunwind - .fnend - - .globl bar - .p2align 2 - .type bar,%function - .code 32 -bar: -.Lfunc_begin1: - .loc 1 7 0 - .fnstart - .cfi_startproc - .loc 1 8 4 prologue_end - add r0, r0, #1 -.Ltmp3: - .loc 1 9 3 - bx lr -.Ltmp4: -.Lfunc_end1: - .size bar, .Lfunc_end1-bar - .cfi_endproc - .cantunwind - .fnend - - .section .debug_str,"MS",%progbits,1 -.Linfo_string0: - .asciz "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" -.Linfo_string1: - .asciz "SRC_COMPDIR/debug.c" -.Linfo_string2: - .asciz "" -.Linfo_string3: - .asciz "foo" -.Linfo_string4: - .asciz "int" -.Linfo_string5: - .asciz "bar" -.Linfo_string6: - .asciz "a" -.Linfo_string7: - .asciz "b" -.Linfo_string8: - .asciz "c" -.Linfo_string9: - .asciz "x" -.Linfo_string10: - .asciz "y" - .section .debug_loc,"",%progbits -.Ldebug_loc0: - .long .Lfunc_begin0-.Lfunc_begin0 - .long .Ltmp0-.Lfunc_begin0 - .short 1 - .byte 80 - .long 0 - .long 0 -.Ldebug_loc1: - .long .Ltmp0-.Lfunc_begin0 - .long .Ltmp1-.Lfunc_begin0 - .short 1 - .byte 80 - .long 0 - .long 0 -.Ldebug_loc2: - .long .Ltmp1-.Lfunc_begin0 - .long .Lfunc_end0-.Lfunc_begin0 - .short 1 - .byte 80 - .long 0 - .long 0 - .section .debug_abbrev,"",%progbits - .byte 1 - .byte 17 - .byte 1 - .byte 37 - .byte 14 - .byte 19 - .byte 5 - .byte 3 - .byte 14 - .byte 16 - .byte 23 - .byte 27 - .byte 14 - .byte 17 - .byte 1 - .byte 18 - .byte 6 - .byte 0 - .byte 0 - .byte 2 - .byte 46 - .byte 1 - .byte 17 - .byte 1 - .byte 18 - .byte 6 - .byte 64 - .byte 24 - .ascii "\227B" - .byte 25 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 39 - .byte 25 - .byte 73 - .byte 19 - .byte 63 - .byte 25 - .byte 0 - .byte 0 - .byte 3 - .byte 5 - .byte 0 - .byte 2 - .byte 23 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 4 - .byte 5 - .byte 0 - .byte 2 - .byte 24 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 5 - .byte 52 - .byte 0 - .byte 2 - .byte 23 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 6 - .byte 36 - .byte 0 - .byte 3 - .byte 14 - .byte 62 - .byte 11 - .byte 11 - .byte 11 - .byte 0 - .byte 0 - .byte 0 - .section .debug_info,"",%progbits -.Lcu_begin0: - .long .Ldebug_info_end0-.Ldebug_info_start0 -.Ldebug_info_start0: - .short 4 - .long .debug_abbrev - .byte 4 - .byte 1 - .long .Linfo_string0 - .short 12 - .long .Linfo_string1 - .long .Lline_table_start0 - .long .Linfo_string2 - .long .Lfunc_begin0 - .long .Lfunc_end1-.Lfunc_begin0 - .byte 2 - .long .Lfunc_begin0 - .long .Lfunc_end0-.Lfunc_begin0 - .byte 1 - .byte 91 - - .long .Linfo_string3 - .byte 1 - .byte 1 - - .long 166 - - .byte 3 - .long .Ldebug_loc0 - .long .Linfo_string6 - .byte 1 - .byte 1 - .long 166 - .byte 4 - .byte 1 - .byte 81 - .long .Linfo_string7 - .byte 1 - .byte 1 - .long 166 - .byte 4 - .byte 1 - .byte 82 - .long .Linfo_string8 - .byte 1 - .byte 1 - .long 166 - .byte 5 - .long .Ldebug_loc1 - .long .Linfo_string9 - .byte 1 - .byte 2 - .long 166 - .byte 5 - .long .Ldebug_loc2 - .long .Linfo_string10 - .byte 1 - .byte 3 - .long 166 - .byte 0 - .byte 2 - .long .Lfunc_begin1 - .long .Lfunc_end1-.Lfunc_begin1 - .byte 1 - .byte 91 - - .long .Linfo_string5 - .byte 1 - .byte 7 - - .long 166 - - .byte 4 - .byte 1 - .byte 80 - .long .Linfo_string6 - .byte 1 - .byte 7 - .long 166 - .byte 0 - .byte 6 - .long .Linfo_string4 - .byte 5 - .byte 4 - .byte 0 -.Ldebug_info_end0: - .ident "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" - .section ".note.GNU-stack","",%progbits - .addrsig - .eabi_attribute 30, 1 - .section .debug_line,"",%progbits -.Lline_table_start0: diff --git a/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5-sections.s b/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5-sections.s deleted file mode 100644 index 1594ec9f0085f2..00000000000000 --- a/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5-sections.s +++ /dev/null @@ -1,414 +0,0 @@ -## Check that the --debug-vars option works for simple register locations, when -## using DWARF4 debug info, with functions in multiple sections. - -## Generated with this compile command, with the source code in Inputs/debug.c: -## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-5 -S -o - -ffunction-sections - -## The unicode characters in this test cause test failures on Windows. -# UNSUPPORTED: system-windows - -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj --dwarf-version=5 | \ -# RUN: llvm-objdump - -d --debug-vars --no-show-raw-insn | \ -# RUN: FileCheck %s - -# CHECK: Disassembly of section .text.foo: -# CHECK-EMPTY: -# CHECK-NEXT: 00000000 : -# CHECK-NEXT: ┠─ a = R0 -# CHECK-NEXT: ┃ ┠─ b = R1 -# CHECK-NEXT: ┃ ┃ ┠─ c = R2 -# CHECK-NEXT: ┃ ┃ ┃ ┌─ x = R0 -# CHECK-NEXT: 0: add r0, r1, r0 â”» ┃ ┃ ╈ -# CHECK-NEXT: ┌─ y = R0 -# CHECK-NEXT: 4: add r0, r0, r2 ╈ ┃ ┃ â”» -# CHECK-NEXT: 8: bx lr â”» â”» â”» -# CHECK-EMPTY: -# CHECK-NEXT: Disassembly of section .text.bar: -# CHECK-EMPTY: -# CHECK-NEXT: 00000000 : -# CHECK-NEXT: ┠─ a = R0 -# CHECK-NEXT: 0: add r0, r0, #1 ┃ -# CHECK-NEXT: 4: bx lr â”» - - .text - .syntax unified - .eabi_attribute 67, "2.09" - .eabi_attribute 6, 10 - .eabi_attribute 7, 65 - .eabi_attribute 8, 1 - .eabi_attribute 9, 2 - .fpu neon - .eabi_attribute 34, 0 - .eabi_attribute 17, 1 - .eabi_attribute 20, 1 - .eabi_attribute 21, 1 - .eabi_attribute 23, 3 - .eabi_attribute 24, 1 - .eabi_attribute 25, 1 - .eabi_attribute 38, 1 - .eabi_attribute 18, 4 - .eabi_attribute 26, 2 - .eabi_attribute 14, 0 - .file "debug.c" - .section .text.foo,"ax",%progbits - .globl foo - .p2align 2 - .type foo,%function - .code 32 -foo: -.Lfunc_begin0: - .file 0 "/work/scratch" "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" md5 0x07374f01ab24ec7c07db73bc13bd778e - .file 1 "/work" "llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" md5 0x07374f01ab24ec7c07db73bc13bd778e - .loc 1 1 0 - .fnstart - .cfi_sections .debug_frame - .cfi_startproc - .loc 1 2 13 prologue_end - add r0, r1, r0 -.Ltmp0: - .loc 1 3 13 - add r0, r0, r2 -.Ltmp1: - .loc 1 4 3 - bx lr -.Ltmp2: -.Lfunc_end0: - .size foo, .Lfunc_end0-foo - .cfi_endproc - .cantunwind - .fnend - - .section .text.bar,"ax",%progbits - .globl bar - .p2align 2 - .type bar,%function - .code 32 -bar: -.Lfunc_begin1: - .loc 1 7 0 - .fnstart - .cfi_startproc - .loc 1 8 4 prologue_end - add r0, r0, #1 -.Ltmp3: - .loc 1 9 3 - bx lr -.Ltmp4: -.Lfunc_end1: - .size bar, .Lfunc_end1-bar - .cfi_endproc - .cantunwind - .fnend - - .section .debug_str_offsets,"",%progbits - .long 48 - .short 5 - .short 0 -.Lstr_offsets_base0: - .section .debug_str,"MS",%progbits,1 -.Linfo_string0: - .asciz "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" -.Linfo_string1: - .asciz "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" -.Linfo_string2: - .asciz "/work/scratch" -.Linfo_string3: - .asciz "foo" -.Linfo_string4: - .asciz "int" -.Linfo_string5: - .asciz "bar" -.Linfo_string6: - .asciz "a" -.Linfo_string7: - .asciz "b" -.Linfo_string8: - .asciz "c" -.Linfo_string9: - .asciz "x" -.Linfo_string10: - .asciz "y" - .section .debug_str_offsets,"",%progbits - .long .Linfo_string0 - .long .Linfo_string1 - .long .Linfo_string2 - .long .Linfo_string3 - .long .Linfo_string4 - .long .Linfo_string5 - .long .Linfo_string6 - .long .Linfo_string7 - .long .Linfo_string8 - .long .Linfo_string9 - .long .Linfo_string10 - .section .debug_loclists,"",%progbits - .long .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0 -.Ldebug_loclist_table_start0: - .short 5 - .byte 4 - .byte 0 - .long 3 -.Lloclists_table_base0: - .long .Ldebug_loc0-.Lloclists_table_base0 - .long .Ldebug_loc1-.Lloclists_table_base0 - .long .Ldebug_loc2-.Lloclists_table_base0 -.Ldebug_loc0: - .byte 3 - .byte 0 - .uleb128 .Ltmp0-.Lfunc_begin0 - .byte 1 - .byte 80 - .byte 0 -.Ldebug_loc1: - .byte 1 - .byte 0 - .byte 4 - .uleb128 .Ltmp0-.Lfunc_begin0 - .uleb128 .Ltmp1-.Lfunc_begin0 - .byte 1 - .byte 80 - .byte 0 -.Ldebug_loc2: - .byte 1 - .byte 0 - .byte 4 - .uleb128 .Ltmp1-.Lfunc_begin0 - .uleb128 .Lfunc_end0-.Lfunc_begin0 - .byte 1 - .byte 80 - .byte 0 -.Ldebug_loclist_table_end0: - .section .debug_abbrev,"",%progbits - .byte 1 - .byte 17 - .byte 1 - .byte 37 - .byte 37 - .byte 19 - .byte 5 - .byte 3 - .byte 37 - .byte 114 - .byte 23 - .byte 16 - .byte 23 - .byte 27 - .byte 37 - .byte 17 - .byte 1 - .byte 85 - .byte 35 - .byte 115 - .byte 23 - .byte 116 - .byte 23 - .ascii "\214\001" - .byte 23 - .byte 0 - .byte 0 - .byte 2 - .byte 46 - .byte 1 - .byte 17 - .byte 27 - .byte 18 - .byte 6 - .byte 64 - .byte 24 - .byte 122 - .byte 25 - .byte 3 - .byte 37 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 39 - .byte 25 - .byte 73 - .byte 19 - .byte 63 - .byte 25 - .byte 0 - .byte 0 - .byte 3 - .byte 5 - .byte 0 - .byte 2 - .byte 34 - .byte 3 - .byte 37 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 4 - .byte 5 - .byte 0 - .byte 2 - .byte 24 - .byte 3 - .byte 37 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 5 - .byte 52 - .byte 0 - .byte 2 - .byte 34 - .byte 3 - .byte 37 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 6 - .byte 36 - .byte 0 - .byte 3 - .byte 37 - .byte 62 - .byte 11 - .byte 11 - .byte 11 - .byte 0 - .byte 0 - .byte 0 - .section .debug_info,"",%progbits -.Lcu_begin0: - .long .Ldebug_info_end0-.Ldebug_info_start0 -.Ldebug_info_start0: - .short 5 - .byte 1 - .byte 4 - .long .debug_abbrev - .byte 1 - .byte 0 - .short 12 - .byte 1 - .long .Lstr_offsets_base0 - .long .Lline_table_start0 - .byte 2 - .long 0 - .byte 0 - .long .Laddr_table_base0 - .long .Lrnglists_table_base0 - .long .Lloclists_table_base0 - .byte 2 - .byte 0 - .long .Lfunc_end0-.Lfunc_begin0 - .byte 1 - .byte 91 - - .byte 3 - .byte 1 - .byte 1 - - .long 132 - - .byte 3 - .byte 0 - .byte 6 - .byte 1 - .byte 1 - .long 132 - .byte 4 - .byte 1 - .byte 81 - .byte 7 - .byte 1 - .byte 1 - .long 132 - .byte 4 - .byte 1 - .byte 82 - .byte 8 - .byte 1 - .byte 1 - .long 132 - .byte 5 - .byte 1 - .byte 9 - .byte 1 - .byte 2 - .long 132 - .byte 5 - .byte 2 - .byte 10 - .byte 1 - .byte 3 - .long 132 - .byte 0 - .byte 2 - .byte 1 - .long .Lfunc_end1-.Lfunc_begin1 - .byte 1 - .byte 91 - - .byte 5 - .byte 1 - .byte 7 - - .long 132 - - .byte 4 - .byte 1 - .byte 80 - .byte 6 - .byte 1 - .byte 7 - .long 132 - .byte 0 - .byte 6 - .byte 4 - .byte 5 - .byte 4 - .byte 0 -.Ldebug_info_end0: - .section .debug_rnglists,"",%progbits - .long .Ldebug_rnglist_table_end0-.Ldebug_rnglist_table_start0 -.Ldebug_rnglist_table_start0: - .short 5 - .byte 4 - .byte 0 - .long 1 -.Lrnglists_table_base0: - .long .Ldebug_ranges0-.Lrnglists_table_base0 -.Ldebug_ranges0: - .byte 3 - .byte 0 - .uleb128 .Lfunc_end0-.Lfunc_begin0 - .byte 3 - .byte 1 - .uleb128 .Lfunc_end1-.Lfunc_begin1 - .byte 0 -.Ldebug_rnglist_table_end0: - .section .debug_addr,"",%progbits - .long .Ldebug_addr_end0-.Ldebug_addr_start0 -.Ldebug_addr_start0: - .short 5 - .byte 4 - .byte 0 -.Laddr_table_base0: - .long .Lfunc_begin0 - .long .Lfunc_begin1 -.Ldebug_addr_end0: - .ident "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" - .section ".note.GNU-stack","",%progbits - .addrsig - .eabi_attribute 30, 1 - .section .debug_line,"",%progbits -.Lline_table_start0: diff --git a/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5.s b/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5.s deleted file mode 100644 index 90310870ab98f0..00000000000000 --- a/llvm/test/tools/llvm-objdump/ARM/debug-vars-dwarf5.s +++ /dev/null @@ -1,385 +0,0 @@ -## Check that the --debug-vars option works for simple register locations, when -## using DWARF5 debug info, with multiple functions in one section. - -## Generated with this compile command, with the source code in Inputs/debug.c: -## clang --target=arm--none-eabi -march=armv7-a -c debug.c -O1 -gdwarf-3 -S -o - - -## The unicode characters in this test cause test failures on Windows. -# UNSUPPORTED: system-windows - -# RUN: llvm-mc -triple armv8a--none-eabi < %s -filetype=obj --dwarf-version=5 | \ -# RUN: llvm-objdump - -d --debug-vars --no-show-raw-insn | \ -# RUN: FileCheck %s - -# CHECK: Disassembly of section .text: -# CHECK-EMPTY: -# CHECK-NEXT: 00000000 : -# CHECK-NEXT: ┠─ a = R0 -# CHECK-NEXT: ┃ ┠─ b = R1 -# CHECK-NEXT: ┃ ┃ ┠─ c = R2 -# CHECK-NEXT: ┃ ┃ ┃ ┌─ x = R0 -# CHECK-NEXT: 0: add r0, r1, r0 â”» ┃ ┃ ╈ -# CHECK-NEXT: ┌─ y = R0 -# CHECK-NEXT: 4: add r0, r0, r2 ╈ ┃ ┃ â”» -# CHECK-NEXT: 8: bx lr â”» â”» â”» -# CHECK-EMPTY: -# CHECK-NEXT: 0000000c : -# CHECK-NEXT: ┠─ a = R0 -# CHECK-NEXT: c: add r0, r0, #1 ┃ -# CHECK-NEXT: 10: bx lr â”» - - .text - .syntax unified - .eabi_attribute 67, "2.09" - .eabi_attribute 6, 10 - .eabi_attribute 7, 65 - .eabi_attribute 8, 1 - .eabi_attribute 9, 2 - .fpu neon - .eabi_attribute 34, 0 - .eabi_attribute 17, 1 - .eabi_attribute 20, 1 - .eabi_attribute 21, 1 - .eabi_attribute 23, 3 - .eabi_attribute 24, 1 - .eabi_attribute 25, 1 - .eabi_attribute 38, 1 - .eabi_attribute 18, 4 - .eabi_attribute 26, 2 - .eabi_attribute 14, 0 - .file "debug.c" - .globl foo - .p2align 2 - .type foo,%function - .code 32 -foo: -.Lfunc_begin0: - .file 0 "/work/scratch" "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" md5 0x07374f01ab24ec7c07db73bc13bd778e - .file 1 "/work" "llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" md5 0x07374f01ab24ec7c07db73bc13bd778e - .loc 1 1 0 - .fnstart - .cfi_sections .debug_frame - .cfi_startproc - .loc 1 2 13 prologue_end - add r0, r1, r0 -.Ltmp0: - .loc 1 3 13 - add r0, r0, r2 -.Ltmp1: - .loc 1 4 3 - bx lr -.Ltmp2: -.Lfunc_end0: - .size foo, .Lfunc_end0-foo - .cfi_endproc - .cantunwind - .fnend - - .globl bar - .p2align 2 - .type bar,%function - .code 32 -bar: -.Lfunc_begin1: - .loc 1 7 0 - .fnstart - .cfi_startproc - .loc 1 8 4 prologue_end - add r0, r0, #1 -.Ltmp3: - .loc 1 9 3 - bx lr -.Ltmp4: -.Lfunc_end1: - .size bar, .Lfunc_end1-bar - .cfi_endproc - .cantunwind - .fnend - - .section .debug_str_offsets,"",%progbits - .long 48 - .short 5 - .short 0 -.Lstr_offsets_base0: - .section .debug_str,"MS",%progbits,1 -.Linfo_string0: - .asciz "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" -.Linfo_string1: - .asciz "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" -.Linfo_string2: - .asciz "/work/scratch" -.Linfo_string3: - .asciz "foo" -.Linfo_string4: - .asciz "int" -.Linfo_string5: - .asciz "bar" -.Linfo_string6: - .asciz "a" -.Linfo_string7: - .asciz "b" -.Linfo_string8: - .asciz "c" -.Linfo_string9: - .asciz "x" -.Linfo_string10: - .asciz "y" - .section .debug_str_offsets,"",%progbits - .long .Linfo_string0 - .long .Linfo_string1 - .long .Linfo_string2 - .long .Linfo_string3 - .long .Linfo_string4 - .long .Linfo_string5 - .long .Linfo_string6 - .long .Linfo_string7 - .long .Linfo_string8 - .long .Linfo_string9 - .long .Linfo_string10 - .section .debug_loclists,"",%progbits - .long .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0 -.Ldebug_loclist_table_start0: - .short 5 - .byte 4 - .byte 0 - .long 3 -.Lloclists_table_base0: - .long .Ldebug_loc0-.Lloclists_table_base0 - .long .Ldebug_loc1-.Lloclists_table_base0 - .long .Ldebug_loc2-.Lloclists_table_base0 -.Ldebug_loc0: - .byte 4 - .uleb128 .Lfunc_begin0-.Lfunc_begin0 - .uleb128 .Ltmp0-.Lfunc_begin0 - .byte 1 - .byte 80 - .byte 0 -.Ldebug_loc1: - .byte 4 - .uleb128 .Ltmp0-.Lfunc_begin0 - .uleb128 .Ltmp1-.Lfunc_begin0 - .byte 1 - .byte 80 - .byte 0 -.Ldebug_loc2: - .byte 4 - .uleb128 .Ltmp1-.Lfunc_begin0 - .uleb128 .Lfunc_end0-.Lfunc_begin0 - .byte 1 - .byte 80 - .byte 0 -.Ldebug_loclist_table_end0: - .section .debug_abbrev,"",%progbits - .byte 1 - .byte 17 - .byte 1 - .byte 37 - .byte 37 - .byte 19 - .byte 5 - .byte 3 - .byte 37 - .byte 114 - .byte 23 - .byte 16 - .byte 23 - .byte 27 - .byte 37 - .byte 17 - .byte 27 - .byte 18 - .byte 6 - .byte 115 - .byte 23 - .ascii "\214\001" - .byte 23 - .byte 0 - .byte 0 - .byte 2 - .byte 46 - .byte 1 - .byte 17 - .byte 27 - .byte 18 - .byte 6 - .byte 64 - .byte 24 - .byte 122 - .byte 25 - .byte 3 - .byte 37 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 39 - .byte 25 - .byte 73 - .byte 19 - .byte 63 - .byte 25 - .byte 0 - .byte 0 - .byte 3 - .byte 5 - .byte 0 - .byte 2 - .byte 34 - .byte 3 - .byte 37 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 4 - .byte 5 - .byte 0 - .byte 2 - .byte 24 - .byte 3 - .byte 37 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 5 - .byte 52 - .byte 0 - .byte 2 - .byte 34 - .byte 3 - .byte 37 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 6 - .byte 36 - .byte 0 - .byte 3 - .byte 37 - .byte 62 - .byte 11 - .byte 11 - .byte 11 - .byte 0 - .byte 0 - .byte 0 - .section .debug_info,"",%progbits -.Lcu_begin0: - .long .Ldebug_info_end0-.Ldebug_info_start0 -.Ldebug_info_start0: - .short 5 - .byte 1 - .byte 4 - .long .debug_abbrev - .byte 1 - .byte 0 - .short 12 - .byte 1 - .long .Lstr_offsets_base0 - .long .Lline_table_start0 - .byte 2 - .byte 0 - .long .Lfunc_end1-.Lfunc_begin0 - .long .Laddr_table_base0 - .long .Lloclists_table_base0 - .byte 2 - .byte 0 - .long .Lfunc_end0-.Lfunc_begin0 - .byte 1 - .byte 91 - - .byte 3 - .byte 1 - .byte 1 - - .long 128 - - .byte 3 - .byte 0 - .byte 6 - .byte 1 - .byte 1 - .long 128 - .byte 4 - .byte 1 - .byte 81 - .byte 7 - .byte 1 - .byte 1 - .long 128 - .byte 4 - .byte 1 - .byte 82 - .byte 8 - .byte 1 - .byte 1 - .long 128 - .byte 5 - .byte 1 - .byte 9 - .byte 1 - .byte 2 - .long 128 - .byte 5 - .byte 2 - .byte 10 - .byte 1 - .byte 3 - .long 128 - .byte 0 - .byte 2 - .byte 1 - .long .Lfunc_end1-.Lfunc_begin1 - .byte 1 - .byte 91 - - .byte 5 - .byte 1 - .byte 7 - - .long 128 - - .byte 4 - .byte 1 - .byte 80 - .byte 6 - .byte 1 - .byte 7 - .long 128 - .byte 0 - .byte 6 - .byte 4 - .byte 5 - .byte 4 - .byte 0 -.Ldebug_info_end0: - .section .debug_addr,"",%progbits - .long .Ldebug_addr_end0-.Ldebug_addr_start0 -.Ldebug_addr_start0: - .short 5 - .byte 4 - .byte 0 -.Laddr_table_base0: - .long .Lfunc_begin0 - .long .Lfunc_begin1 -.Ldebug_addr_end0: - .ident "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" - .section ".note.GNU-stack","",%progbits - .addrsig - .eabi_attribute 30, 1 - .section .debug_line,"",%progbits -.Lline_table_start0: diff --git a/llvm/test/tools/llvm-objdump/ARM/debug-vars-wide-chars.s b/llvm/test/tools/llvm-objdump/ARM/debug-vars-wide-chars.s deleted file mode 100644 index 4085bd3cbd73af..00000000000000 --- a/llvm/test/tools/llvm-objdump/ARM/debug-vars-wide-chars.s +++ /dev/null @@ -1,232 +0,0 @@ -# RUN: mkdir -p %t/a -# RUN: cp %p/Inputs/wide-char.c %t/a/wide-char.c -# RUN: sed -e "s,SRC_COMPDIR,%/t/a,g" %s > %t.s -# RUN: llvm-mc -triple armv8a--none-eabi < %t.s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars --source | \ -# RUN: FileCheck %s --strict-whitespace - -## The Chinese character in the source does not print correctly on Windows. -# UNSUPPORTED: system-windows - -## Check that the --debug-vars option correctly aligns the variable display when -## the source code (printed by the -S option) includes East Asian wide -## characters. - -# CHECK: 00000000 : -# CHECK-NEXT: ; return *å–µ; ┠─ å–µ = R0 -# CHECK-NEXT: 0: 00 00 90 e5 ldr r0, [r0] â”» -# CHECK-NEXT: 4: 1e ff 2f e1 bx lr - - .text - .syntax unified - .eabi_attribute 67, "2.09" - .eabi_attribute 6, 10 - .eabi_attribute 7, 65 - .eabi_attribute 8, 1 - .eabi_attribute 9, 2 - .fpu vfpv3 - .eabi_attribute 34, 0 - .eabi_attribute 17, 1 - .eabi_attribute 20, 1 - .eabi_attribute 21, 1 - .eabi_attribute 23, 3 - .eabi_attribute 24, 1 - .eabi_attribute 25, 1 - .eabi_attribute 38, 1 - .eabi_attribute 18, 4 - .eabi_attribute 26, 2 - .eabi_attribute 14, 0 - .file "wide.c" - .globl foo - .p2align 2 - .type foo,%function - .code 32 -foo: -.Lfunc_begin0: - .file 1 "SRC_COMPDIR/wide-char.c" - .loc 1 1 0 - .fnstart - .cfi_sections .debug_frame - .cfi_startproc - .loc 1 2 10 prologue_end - ldr r0, [r0] -.Ltmp0: - .loc 1 2 3 is_stmt 0 - bx lr -.Ltmp1: -.Lfunc_end0: - .size foo, .Lfunc_end0-foo - .cfi_endproc - .cantunwind - .fnend - - .section .debug_str,"MS",%progbits,1 -.Linfo_string0: - .asciz "clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)" -.Linfo_string1: - .asciz "wide-char.c" -.Linfo_string2: - .asciz "SRC_COMPDIR" -.Linfo_string3: - .asciz "foo" -.Linfo_string4: - .asciz "int" -.Linfo_string5: - .asciz "\345\226\265" - .section .debug_loc,"",%progbits -.Ldebug_loc0: - .long .Lfunc_begin0-.Lfunc_begin0 - .long .Ltmp0-.Lfunc_begin0 - .short 1 - .byte 80 - .long 0 - .long 0 - .section .debug_abbrev,"",%progbits - .byte 1 - .byte 17 - .byte 1 - .byte 37 - .byte 14 - .byte 19 - .byte 5 - .byte 3 - .byte 14 - .byte 16 - .byte 23 - .byte 27 - .byte 14 - .ascii "\264B" - .byte 25 - .byte 17 - .byte 1 - .byte 18 - .byte 6 - .byte 0 - .byte 0 - .byte 2 - .byte 46 - .byte 1 - .byte 17 - .byte 1 - .byte 18 - .byte 6 - .byte 64 - .byte 24 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 39 - .byte 25 - .byte 73 - .byte 19 - .byte 63 - .byte 25 - .byte 0 - .byte 0 - .byte 3 - .byte 5 - .byte 0 - .byte 2 - .byte 23 - .byte 3 - .byte 14 - .byte 58 - .byte 11 - .byte 59 - .byte 11 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 4 - .byte 36 - .byte 0 - .byte 3 - .byte 14 - .byte 62 - .byte 11 - .byte 11 - .byte 11 - .byte 0 - .byte 0 - .byte 5 - .byte 15 - .byte 0 - .byte 73 - .byte 19 - .byte 0 - .byte 0 - .byte 0 - .section .debug_info,"",%progbits -.Lcu_begin0: - .long 84 - .short 4 - .long .debug_abbrev - .byte 4 - .byte 1 - .long .Linfo_string0 - .short 12 - .long .Linfo_string1 - .long .Lline_table_start0 - .long .Linfo_string2 - - .long .Lfunc_begin0 - .long .Lfunc_end0-.Lfunc_begin0 - .byte 2 - .long .Lfunc_begin0 - .long .Lfunc_end0-.Lfunc_begin0 - .byte 1 - .byte 91 - .long .Linfo_string3 - .byte 1 - .byte 1 - - .long 75 - - .byte 3 - .long .Ldebug_loc0 - .long .Linfo_string5 - .byte 1 - .byte 1 - .long 82 - .byte 0 - .byte 4 - .long .Linfo_string4 - .byte 5 - .byte 4 - .byte 5 - .long 75 - .byte 0 - .section .debug_ranges,"",%progbits - .section .debug_macinfo,"",%progbits -.Lcu_macro_begin0: - .byte 0 - .section .debug_pubnames,"",%progbits - .long .LpubNames_end0-.LpubNames_begin0 -.LpubNames_begin0: - .short 2 - .long .Lcu_begin0 - .long 88 - .long 38 - .asciz "foo" - .long 0 -.LpubNames_end0: - .section .debug_pubtypes,"",%progbits - .long .LpubTypes_end0-.LpubTypes_begin0 -.LpubTypes_begin0: - .short 2 - .long .Lcu_begin0 - .long 88 - .long 75 - .asciz "int" - .long 0 -.LpubTypes_end0: - - .ident "clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)" - .section ".note.GNU-stack","",%progbits - .eabi_attribute 30, 1 - .section .debug_line,"",%progbits -.Lline_table_start0: diff --git a/llvm/test/tools/llvm-objdump/PowerPC/debug-vars.s b/llvm/test/tools/llvm-objdump/PowerPC/debug-vars.s deleted file mode 100644 index cdd3a265b38159..00000000000000 --- a/llvm/test/tools/llvm-objdump/PowerPC/debug-vars.s +++ /dev/null @@ -1,373 +0,0 @@ -## Check that the --debug-vars option works for simple register locations, when -## using DWARF4 debug info, with multiple functions in one section. - -## Generated with this compile command and source code: -## clang --target=powerpc64-unknown-linux -c debug.c -O1 -S -o - - -## The unicode characters in this test cause test failures on Windows. -# UNSUPPORTED: system-windows - -## int foo(int a, int b, int c) { -## int x = a + b; -## int y = x + c; -## return y; -## } -## -## int bar(int a) { -## a++; -## return a; -## } - -# RUN: llvm-mc -triple powerpc64-unknown-linux < %s -filetype=obj | \ -# RUN: llvm-objdump - -d --debug-vars --no-show-raw-insn | \ -# RUN: FileCheck %s - -# CHECK: Disassembly of section .text: -# CHECK-EMPTY: -# CHECK-NEXT: 0000000000000000 <.text>: -# CHECK-NEXT: ┠─ a = S3 -# CHECK-NEXT: ┃ ┠─ b = S4 -# CHECK-NEXT: ┃ ┃ ┠─ c = S5 -# CHECK-NEXT: ┃ ┃ ┃ ┌─ x = S3 -# CHECK-NEXT: 0: add 3, 4, 3 â”» ┃ ┃ ╈ -# CHECK-NEXT: ┌─ y = S3 -# CHECK-NEXT: 4: add 3, 3, 5 ╈ ┃ ┃ â”» -# CHECK-NEXT: 8: extsw 3, 3 â”» ┃ ┃ -# CHECK-NEXT: c: blr ┃ ┃ -# CHECK-NEXT: ... -# CHECK-NEXT: ┠─ a = S3 -# CHECK-NEXT: 1c: addi 3, 3, 1 ┃ -# CHECK-NEXT: 20: extsw 3, 3 â”» -# CHECK-NEXT: 24: blr -# CHECK-NEXT: ... - - .text - .file "debug.c" - .globl foo # -- Begin function foo - .p2align 2 - .type foo,@function - .section .opd,"aw",@progbits -foo: # @foo - .p2align 3 - .quad .Lfunc_begin0 - .quad .TOC.@tocbase - .quad 0 - .text -.Lfunc_begin0: - .file 1 "/work" "llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" - .loc 1 1 0 # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:1:0 - .cfi_sections .debug_frame - .cfi_startproc -# %bb.0: # %entry - #DEBUG_VALUE: foo:a <- $x3 - #DEBUG_VALUE: foo:a <- $r3 - #DEBUG_VALUE: foo:b <- $x4 - #DEBUG_VALUE: foo:b <- $x4 - #DEBUG_VALUE: foo:b <- $r4 - #DEBUG_VALUE: foo:c <- $x5 - #DEBUG_VALUE: foo:c <- $x5 - #DEBUG_VALUE: foo:c <- $r5 - .loc 1 2 13 prologue_end # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:2:13 - add 3, 4, 3 -.Ltmp0: - #DEBUG_VALUE: foo:x <- $r3 - .loc 1 3 13 # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:3:13 - add 3, 3, 5 -.Ltmp1: - #DEBUG_VALUE: foo:y <- $r3 - .loc 1 4 3 # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:4:3 - extsw 3, 3 -.Ltmp2: - blr -.Ltmp3: - .long 0 - .quad 0 -.Lfunc_end0: - .size foo, .Lfunc_end0-.Lfunc_begin0 - .cfi_endproc - # -- End function - .globl bar # -- Begin function bar - .p2align 2 - .type bar,@function - .section .opd,"aw",@progbits -bar: # @bar - .p2align 3 - .quad .Lfunc_begin1 - .quad .TOC.@tocbase - .quad 0 - .text -.Lfunc_begin1: - .loc 1 7 0 # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:7:0 - .cfi_startproc -# %bb.0: # %entry - #DEBUG_VALUE: bar:a <- $x3 - #DEBUG_VALUE: bar:a <- $r3 - .loc 1 8 4 prologue_end # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:8:4 - addi 3, 3, 1 -.Ltmp4: - #DEBUG_VALUE: bar:a <- $r3 - .loc 1 9 3 # llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c:9:3 - extsw 3, 3 -.Ltmp5: - blr -.Ltmp6: - .long 0 - .quad 0 -.Lfunc_end1: - .size bar, .Lfunc_end1-.Lfunc_begin1 - .cfi_endproc - # -- End function - .section .debug_str,"MS",@progbits,1 -.Linfo_string0: - .asciz "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" # string offset=0 -.Linfo_string1: - .asciz "/work/llvm/src/llvm/test/tools/llvm-objdump/ARM/Inputs/debug.c" # string offset=101 -.Linfo_string2: - .asciz "/work/scratch" # string offset=164 -.Linfo_string3: - .asciz "foo" # string offset=178 -.Linfo_string4: - .asciz "int" # string offset=182 -.Linfo_string5: - .asciz "bar" # string offset=186 -.Linfo_string6: - .asciz "a" # string offset=190 -.Linfo_string7: - .asciz "b" # string offset=192 -.Linfo_string8: - .asciz "c" # string offset=194 -.Linfo_string9: - .asciz "x" # string offset=196 -.Linfo_string10: - .asciz "y" # string offset=198 - .section .debug_loc,"",@progbits -.Ldebug_loc0: - .quad .Lfunc_begin0-.Lfunc_begin0 - .quad .Ltmp0-.Lfunc_begin0 - .short 3 # Loc expr size - .byte 144 # super-register DW_OP_regx - .byte 179 # 1203 - .byte 9 # - .quad 0 - .quad 0 -.Ldebug_loc1: - .quad .Ltmp0-.Lfunc_begin0 - .quad .Ltmp1-.Lfunc_begin0 - .short 3 # Loc expr size - .byte 144 # super-register DW_OP_regx - .byte 179 # 1203 - .byte 9 # - .quad 0 - .quad 0 -.Ldebug_loc2: - .quad .Ltmp1-.Lfunc_begin0 - .quad .Ltmp2-.Lfunc_begin0 - .short 3 # Loc expr size - .byte 144 # super-register DW_OP_regx - .byte 179 # 1203 - .byte 9 # - .quad 0 - .quad 0 -.Ldebug_loc3: - .quad .Lfunc_begin1-.Lfunc_begin0 - .quad .Ltmp5-.Lfunc_begin0 - .short 3 # Loc expr size - .byte 144 # super-register DW_OP_regx - .byte 179 # 1203 - .byte 9 # - .quad 0 - .quad 0 - .section .debug_abbrev,"",@progbits - .byte 1 # Abbreviation Code - .byte 17 # DW_TAG_compile_unit - .byte 1 # DW_CHILDREN_yes - .byte 37 # DW_AT_producer - .byte 14 # DW_FORM_strp - .byte 19 # DW_AT_language - .byte 5 # DW_FORM_data2 - .byte 3 # DW_AT_name - .byte 14 # DW_FORM_strp - .byte 16 # DW_AT_stmt_list - .byte 23 # DW_FORM_sec_offset - .byte 27 # DW_AT_comp_dir - .byte 14 # DW_FORM_strp - .byte 17 # DW_AT_low_pc - .byte 1 # DW_FORM_addr - .byte 18 # DW_AT_high_pc - .byte 6 # DW_FORM_data4 - .byte 0 # EOM(1) - .byte 0 # EOM(2) - .byte 2 # Abbreviation Code - .byte 46 # DW_TAG_subprogram - .byte 1 # DW_CHILDREN_yes - .byte 17 # DW_AT_low_pc - .byte 1 # DW_FORM_addr - .byte 18 # DW_AT_high_pc - .byte 6 # DW_FORM_data4 - .byte 64 # DW_AT_frame_base - .byte 24 # DW_FORM_exprloc - .ascii "\227B" # DW_AT_GNU_all_call_sites - .byte 25 # DW_FORM_flag_present - .byte 3 # DW_AT_name - .byte 14 # DW_FORM_strp - .byte 58 # DW_AT_decl_file - .byte 11 # DW_FORM_data1 - .byte 59 # DW_AT_decl_line - .byte 11 # DW_FORM_data1 - .byte 39 # DW_AT_prototyped - .byte 25 # DW_FORM_flag_present - .byte 73 # DW_AT_type - .byte 19 # DW_FORM_ref4 - .byte 63 # DW_AT_external - .byte 25 # DW_FORM_flag_present - .byte 0 # EOM(1) - .byte 0 # EOM(2) - .byte 3 # Abbreviation Code - .byte 5 # DW_TAG_formal_parameter - .byte 0 # DW_CHILDREN_no - .byte 2 # DW_AT_location - .byte 23 # DW_FORM_sec_offset - .byte 3 # DW_AT_name - .byte 14 # DW_FORM_strp - .byte 58 # DW_AT_decl_file - .byte 11 # DW_FORM_data1 - .byte 59 # DW_AT_decl_line - .byte 11 # DW_FORM_data1 - .byte 73 # DW_AT_type - .byte 19 # DW_FORM_ref4 - .byte 0 # EOM(1) - .byte 0 # EOM(2) - .byte 4 # Abbreviation Code - .byte 5 # DW_TAG_formal_parameter - .byte 0 # DW_CHILDREN_no - .byte 2 # DW_AT_location - .byte 24 # DW_FORM_exprloc - .byte 3 # DW_AT_name - .byte 14 # DW_FORM_strp - .byte 58 # DW_AT_decl_file - .byte 11 # DW_FORM_data1 - .byte 59 # DW_AT_decl_line - .byte 11 # DW_FORM_data1 - .byte 73 # DW_AT_type - .byte 19 # DW_FORM_ref4 - .byte 0 # EOM(1) - .byte 0 # EOM(2) - .byte 5 # Abbreviation Code - .byte 52 # DW_TAG_variable - .byte 0 # DW_CHILDREN_no - .byte 2 # DW_AT_location - .byte 23 # DW_FORM_sec_offset - .byte 3 # DW_AT_name - .byte 14 # DW_FORM_strp - .byte 58 # DW_AT_decl_file - .byte 11 # DW_FORM_data1 - .byte 59 # DW_AT_decl_line - .byte 11 # DW_FORM_data1 - .byte 73 # DW_AT_type - .byte 19 # DW_FORM_ref4 - .byte 0 # EOM(1) - .byte 0 # EOM(2) - .byte 6 # Abbreviation Code - .byte 36 # DW_TAG_base_type - .byte 0 # DW_CHILDREN_no - .byte 3 # DW_AT_name - .byte 14 # DW_FORM_strp - .byte 62 # DW_AT_encoding - .byte 11 # DW_FORM_data1 - .byte 11 # DW_AT_byte_size - .byte 11 # DW_FORM_data1 - .byte 0 # EOM(1) - .byte 0 # EOM(2) - .byte 0 # EOM(3) - .section .debug_info,"",@progbits -.Lcu_begin0: - .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit -.Ldebug_info_start0: - .short 4 # DWARF version number - .long .debug_abbrev # Offset Into Abbrev. Section - .byte 8 # Address Size (in bytes) - .byte 1 # Abbrev [1] 0xb:0xb5 DW_TAG_compile_unit - .long .Linfo_string0 # DW_AT_producer - .short 12 # DW_AT_language - .long .Linfo_string1 # DW_AT_name - .long .Lline_table_start0 # DW_AT_stmt_list - .long .Linfo_string2 # DW_AT_comp_dir - .quad .Lfunc_begin0 # DW_AT_low_pc - .long .Lfunc_end1-.Lfunc_begin0 # DW_AT_high_pc - .byte 2 # Abbrev [2] 0x2a:0x65 DW_TAG_subprogram - .quad .Lfunc_begin0 # DW_AT_low_pc - .long .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc - .byte 1 # DW_AT_frame_base - .byte 81 - # DW_AT_GNU_all_call_sites - .long .Linfo_string3 # DW_AT_name - .byte 1 # DW_AT_decl_file - .byte 1 # DW_AT_decl_line - # DW_AT_prototyped - .long 184 # DW_AT_type - # DW_AT_external - .byte 3 # Abbrev [3] 0x43:0xf DW_TAG_formal_parameter - .long .Ldebug_loc0 # DW_AT_location - .long .Linfo_string6 # DW_AT_name - .byte 1 # DW_AT_decl_file - .byte 1 # DW_AT_decl_line - .long 184 # DW_AT_type - .byte 4 # Abbrev [4] 0x52:0xf DW_TAG_formal_parameter - .byte 3 # DW_AT_location - .byte 144 - .ascii "\264\t" - .long .Linfo_string7 # DW_AT_name - .byte 1 # DW_AT_decl_file - .byte 1 # DW_AT_decl_line - .long 184 # DW_AT_type - .byte 4 # Abbrev [4] 0x61:0xf DW_TAG_formal_parameter - .byte 3 # DW_AT_location - .byte 144 - .ascii "\265\t" - .long .Linfo_string8 # DW_AT_name - .byte 1 # DW_AT_decl_file - .byte 1 # DW_AT_decl_line - .long 184 # DW_AT_type - .byte 5 # Abbrev [5] 0x70:0xf DW_TAG_variable - .long .Ldebug_loc1 # DW_AT_location - .long .Linfo_string9 # DW_AT_name - .byte 1 # DW_AT_decl_file - .byte 2 # DW_AT_decl_line - .long 184 # DW_AT_type - .byte 5 # Abbrev [5] 0x7f:0xf DW_TAG_variable - .long .Ldebug_loc2 # DW_AT_location - .long .Linfo_string10 # DW_AT_name - .byte 1 # DW_AT_decl_file - .byte 3 # DW_AT_decl_line - .long 184 # DW_AT_type - .byte 0 # End Of Children Mark - .byte 2 # Abbrev [2] 0x8f:0x29 DW_TAG_subprogram - .quad .Lfunc_begin1 # DW_AT_low_pc - .long .Lfunc_end1-.Lfunc_begin1 # DW_AT_high_pc - .byte 1 # DW_AT_frame_base - .byte 81 - # DW_AT_GNU_all_call_sites - .long .Linfo_string5 # DW_AT_name - .byte 1 # DW_AT_decl_file - .byte 7 # DW_AT_decl_line - # DW_AT_prototyped - .long 184 # DW_AT_type - # DW_AT_external - .byte 3 # Abbrev [3] 0xa8:0xf DW_TAG_formal_parameter - .long .Ldebug_loc3 # DW_AT_location - .long .Linfo_string6 # DW_AT_name - .byte 1 # DW_AT_decl_file - .byte 7 # DW_AT_decl_line - .long 184 # DW_AT_type - .byte 0 # End Of Children Mark - .byte 6 # Abbrev [6] 0xb8:0x7 DW_TAG_base_type - .long .Linfo_string4 # DW_AT_name - .byte 5 # DW_AT_encoding - .byte 4 # DW_AT_byte_size - .byte 0 # End Of Children Mark -.Ldebug_info_end0: - .ident "clang version 10.0.0 (git@github.com:llvm/llvm-project.git e73f78acd34360f7450b81167d9dc858ccddc262)" - .section ".note.GNU-stack","",@progbits - .addrsig - .section .debug_line,"",@progbits -.Lline_table_start0: diff --git a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-aarch64.test b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-aarch64.test index 8245a1564c11ce..c95265d520a17a 100644 --- a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-aarch64.test +++ b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-aarch64.test @@ -144,248 +144,126 @@ Sections: EntSize: 0x0000000000000018 Info: .text Relocations: - - Type: R_AARCH64_NONE - - Offset: 0x0000000000000004 - Type: R_AARCH64_ABS64 - - Offset: 0x0000000000000008 - Type: R_AARCH64_ABS32 - - Offset: 0x000000000000000C - Type: R_AARCH64_ABS16 - - Offset: 0x0000000000000010 - Type: R_AARCH64_PREL64 - - Offset: 0x0000000000000014 - Type: R_AARCH64_PREL32 - - Offset: 0x0000000000000018 - Type: R_AARCH64_PREL16 - - Offset: 0x000000000000001C - Type: R_AARCH64_MOVW_UABS_G0 - - Offset: 0x0000000000000020 - Type: R_AARCH64_MOVW_UABS_G0_NC - - Offset: 0x0000000000000024 - Type: R_AARCH64_MOVW_UABS_G1 - - Offset: 0x0000000000000028 - Type: R_AARCH64_MOVW_UABS_G1_NC - - Offset: 0x000000000000002C - Type: R_AARCH64_MOVW_UABS_G2 - - Offset: 0x0000000000000030 - Type: R_AARCH64_MOVW_UABS_G2_NC - - Offset: 0x0000000000000034 - Type: R_AARCH64_MOVW_UABS_G3 - - Offset: 0x0000000000000038 - Type: R_AARCH64_MOVW_SABS_G0 - - Offset: 0x000000000000003C - Type: R_AARCH64_MOVW_SABS_G1 - - Offset: 0x0000000000000040 - Type: R_AARCH64_MOVW_SABS_G2 - - Offset: 0x0000000000000044 - Type: R_AARCH64_LD_PREL_LO19 - - Offset: 0x0000000000000048 - Type: R_AARCH64_ADR_PREL_LO21 - - Offset: 0x000000000000004C - Type: R_AARCH64_ADR_PREL_PG_HI21 - - Offset: 0x0000000000000050 - Type: R_AARCH64_ADR_PREL_PG_HI21_NC - - Offset: 0x0000000000000054 - Type: R_AARCH64_ADD_ABS_LO12_NC - - Offset: 0x0000000000000058 - Type: R_AARCH64_LDST8_ABS_LO12_NC - - Offset: 0x000000000000005C - Type: R_AARCH64_TSTBR14 - - Offset: 0x0000000000000060 - Type: R_AARCH64_CONDBR19 - - Offset: 0x0000000000000064 - Type: R_AARCH64_JUMP26 - - Offset: 0x0000000000000068 - Type: R_AARCH64_CALL26 - - Offset: 0x000000000000006C - Type: R_AARCH64_LDST16_ABS_LO12_NC - - Offset: 0x0000000000000070 - Type: R_AARCH64_LDST32_ABS_LO12_NC - - Offset: 0x0000000000000074 - Type: R_AARCH64_LDST64_ABS_LO12_NC - - Offset: 0x0000000000000078 - Type: R_AARCH64_MOVW_PREL_G0 - - Offset: 0x000000000000007C - Type: R_AARCH64_MOVW_PREL_G0_NC - - Offset: 0x0000000000000080 - Type: R_AARCH64_MOVW_PREL_G1 - - Offset: 0x0000000000000084 - Type: R_AARCH64_MOVW_PREL_G1_NC - - Offset: 0x0000000000000088 - Type: R_AARCH64_MOVW_PREL_G2 - - Offset: 0x000000000000008C - Type: R_AARCH64_MOVW_PREL_G2_NC - - Offset: 0x0000000000000090 - Type: R_AARCH64_MOVW_PREL_G3 - - Offset: 0x0000000000000094 - Type: R_AARCH64_LDST128_ABS_LO12_NC - - Offset: 0x0000000000000098 - Type: R_AARCH64_MOVW_GOTOFF_G0 - - Offset: 0x000000000000009C - Type: R_AARCH64_MOVW_GOTOFF_G0_NC - - Offset: 0x00000000000000A0 - Type: R_AARCH64_MOVW_GOTOFF_G1 - - Offset: 0x00000000000000A4 - Type: R_AARCH64_MOVW_GOTOFF_G1_NC - - Offset: 0x00000000000000A8 - Type: R_AARCH64_MOVW_GOTOFF_G2 - - Offset: 0x00000000000000AC - Type: R_AARCH64_MOVW_GOTOFF_G2_NC - - Offset: 0x00000000000000B0 - Type: R_AARCH64_MOVW_GOTOFF_G3 - - Offset: 0x00000000000000B4 - Type: R_AARCH64_GOTREL64 - - Offset: 0x00000000000000B8 - Type: R_AARCH64_GOTREL32 - - Offset: 0x00000000000000BC - Type: R_AARCH64_GOT_LD_PREL19 - - Offset: 0x00000000000000C0 - Type: R_AARCH64_LD64_GOTOFF_LO15 - - Offset: 0x00000000000000C4 - Type: R_AARCH64_ADR_GOT_PAGE - - Offset: 0x00000000000000C8 - Type: R_AARCH64_LD64_GOT_LO12_NC - - Offset: 0x00000000000000CC - Type: R_AARCH64_LD64_GOTPAGE_LO15 - - Offset: 0x00000000000000D0 - Type: R_AARCH64_TLSGD_ADR_PREL21 - - Offset: 0x00000000000000D4 - Type: R_AARCH64_TLSGD_ADR_PAGE21 - - Offset: 0x00000000000000D8 - Type: R_AARCH64_TLSGD_ADD_LO12_NC - - Offset: 0x00000000000000DC - Type: R_AARCH64_TLSGD_MOVW_G1 - - Offset: 0x00000000000000E0 - Type: R_AARCH64_TLSGD_MOVW_G0_NC - - Offset: 0x00000000000000E4 - Type: R_AARCH64_TLSLD_ADR_PREL21 - - Offset: 0x00000000000000E8 - Type: R_AARCH64_TLSLD_ADR_PAGE21 - - Offset: 0x00000000000000EC - Type: R_AARCH64_TLSLD_ADD_LO12_NC - - Offset: 0x00000000000000F0 - Type: R_AARCH64_TLSLD_MOVW_G1 - - Offset: 0x00000000000000F4 - Type: R_AARCH64_TLSLD_MOVW_G0_NC - - Offset: 0x00000000000000F8 - Type: R_AARCH64_TLSLD_LD_PREL19 - - Offset: 0x00000000000000FC - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G2 - - Offset: 0x0000000000000100 - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G1 - - Offset: 0x0000000000000104 - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC - - Offset: 0x0000000000000108 - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G0 - - Offset: 0x000000000000010C - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC - - Offset: 0x0000000000000110 - Type: R_AARCH64_TLSLD_ADD_DTPREL_HI12 - - Offset: 0x0000000000000114 - Type: R_AARCH64_TLSLD_ADD_DTPREL_LO12 - - Offset: 0x0000000000000118 - Type: R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC - - Offset: 0x000000000000011C - Type: R_AARCH64_TLSLD_LDST8_DTPREL_LO12 - - Offset: 0x0000000000000120 - Type: R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC - - Offset: 0x0000000000000124 - Type: R_AARCH64_TLSLD_LDST16_DTPREL_LO12 - - Offset: 0x0000000000000128 - Type: R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC - - Offset: 0x000000000000012C - Type: R_AARCH64_TLSLD_LDST32_DTPREL_LO12 - - Offset: 0x0000000000000130 - Type: R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC - - Offset: 0x0000000000000134 - Type: R_AARCH64_TLSLD_LDST64_DTPREL_LO12 - - Offset: 0x0000000000000138 - Type: R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC - - Offset: 0x000000000000013C - Type: R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 - - Offset: 0x0000000000000140 - Type: R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC - - Offset: 0x0000000000000144 - Type: R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 - - Offset: 0x0000000000000148 - Type: R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC - - Offset: 0x000000000000014C - Type: R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 - - Offset: 0x0000000000000150 - Type: R_AARCH64_TLSLE_MOVW_TPREL_G2 - - Offset: 0x0000000000000154 - Type: R_AARCH64_TLSLE_MOVW_TPREL_G1 - - Offset: 0x0000000000000158 - Type: R_AARCH64_TLSLE_MOVW_TPREL_G1_NC - - Offset: 0x000000000000015C - Type: R_AARCH64_TLSLE_MOVW_TPREL_G0 - - Offset: 0x0000000000000160 - Type: R_AARCH64_TLSLE_MOVW_TPREL_G0_NC - - Offset: 0x0000000000000164 - Type: R_AARCH64_TLSLE_ADD_TPREL_HI12 - - Offset: 0x0000000000000168 - Type: R_AARCH64_TLSLE_ADD_TPREL_LO12 - - Offset: 0x000000000000016C - Type: R_AARCH64_TLSLE_ADD_TPREL_LO12_NC - - Offset: 0x0000000000000170 - Type: R_AARCH64_TLSLE_LDST8_TPREL_LO12 - - Offset: 0x0000000000000174 - Type: R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC - - Offset: 0x0000000000000178 - Type: R_AARCH64_TLSLE_LDST16_TPREL_LO12 - - Offset: 0x000000000000017C - Type: R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC - - Offset: 0x0000000000000180 - Type: R_AARCH64_TLSLE_LDST32_TPREL_LO12 - - Offset: 0x0000000000000184 - Type: R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC - - Offset: 0x0000000000000188 - Type: R_AARCH64_TLSLE_LDST64_TPREL_LO12 - - Offset: 0x000000000000018C - Type: R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC - - Offset: 0x0000000000000190 - Type: R_AARCH64_TLSDESC_LD_PREL19 - - Offset: 0x0000000000000194 - Type: R_AARCH64_TLSDESC_ADR_PREL21 - - Offset: 0x0000000000000198 - Type: R_AARCH64_TLSDESC_ADR_PAGE21 - - Offset: 0x000000000000019C - Type: R_AARCH64_TLSDESC_LD64_LO12 - - Offset: 0x00000000000001A0 - Type: R_AARCH64_TLSDESC_ADD_LO12 - - Offset: 0x00000000000001A4 - Type: R_AARCH64_TLSDESC_OFF_G1 - - Offset: 0x00000000000001A8 - Type: R_AARCH64_TLSDESC_OFF_G0_NC - - Offset: 0x00000000000001AC - Type: R_AARCH64_TLSDESC_LDR - - Offset: 0x00000000000001B0 - Type: R_AARCH64_TLSDESC_ADD - - Offset: 0x00000000000001B4 - Type: R_AARCH64_TLSDESC_CALL - - Offset: 0x00000000000001B8 - Type: R_AARCH64_TLSLE_LDST128_TPREL_LO12 - - Offset: 0x00000000000001BC - Type: R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC - - Offset: 0x00000000000001C0 - Type: R_AARCH64_TLSLD_LDST128_DTPREL_LO12 - - Offset: 0x00000000000001C4 - Type: R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC - - Offset: 0x00000000000001C8 - Type: R_AARCH64_COPY - - Offset: 0x00000000000001CC - Type: R_AARCH64_GLOB_DAT - - Offset: 0x00000000000001D0 - Type: R_AARCH64_JUMP_SLOT - - Offset: 0x00000000000001D4 - Type: R_AARCH64_RELATIVE - - Offset: 0x00000000000001D8 - Type: R_AARCH64_TLS_DTPMOD64 - - Offset: 0x00000000000001DC - Type: R_AARCH64_TLS_DTPREL64 - - Offset: 0x00000000000001E0 - Type: R_AARCH64_TLS_TPREL64 - - Offset: 0x00000000000001E4 - Type: R_AARCH64_TLSDESC - - Offset: 0x00000000000001E8 - Type: R_AARCH64_IRELATIVE + - Type: R_AARCH64_NONE + - Type: R_AARCH64_ABS64 + - Type: R_AARCH64_ABS32 + - Type: R_AARCH64_ABS16 + - Type: R_AARCH64_PREL64 + - Type: R_AARCH64_PREL32 + - Type: R_AARCH64_PREL16 + - Type: R_AARCH64_MOVW_UABS_G0 + - Type: R_AARCH64_MOVW_UABS_G0_NC + - Type: R_AARCH64_MOVW_UABS_G1 + - Type: R_AARCH64_MOVW_UABS_G1_NC + - Type: R_AARCH64_MOVW_UABS_G2 + - Type: R_AARCH64_MOVW_UABS_G2_NC + - Type: R_AARCH64_MOVW_UABS_G3 + - Type: R_AARCH64_MOVW_SABS_G0 + - Type: R_AARCH64_MOVW_SABS_G1 + - Type: R_AARCH64_MOVW_SABS_G2 + - Type: R_AARCH64_LD_PREL_LO19 + - Type: R_AARCH64_ADR_PREL_LO21 + - Type: R_AARCH64_ADR_PREL_PG_HI21 + - Type: R_AARCH64_ADR_PREL_PG_HI21_NC + - Type: R_AARCH64_ADD_ABS_LO12_NC + - Type: R_AARCH64_LDST8_ABS_LO12_NC + - Type: R_AARCH64_TSTBR14 + - Type: R_AARCH64_CONDBR19 + - Type: R_AARCH64_JUMP26 + - Type: R_AARCH64_CALL26 + - Type: R_AARCH64_LDST16_ABS_LO12_NC + - Type: R_AARCH64_LDST32_ABS_LO12_NC + - Type: R_AARCH64_LDST64_ABS_LO12_NC + - Type: R_AARCH64_MOVW_PREL_G0 + - Type: R_AARCH64_MOVW_PREL_G0_NC + - Type: R_AARCH64_MOVW_PREL_G1 + - Type: R_AARCH64_MOVW_PREL_G1_NC + - Type: R_AARCH64_MOVW_PREL_G2 + - Type: R_AARCH64_MOVW_PREL_G2_NC + - Type: R_AARCH64_MOVW_PREL_G3 + - Type: R_AARCH64_LDST128_ABS_LO12_NC + - Type: R_AARCH64_MOVW_GOTOFF_G0 + - Type: R_AARCH64_MOVW_GOTOFF_G0_NC + - Type: R_AARCH64_MOVW_GOTOFF_G1 + - Type: R_AARCH64_MOVW_GOTOFF_G1_NC + - Type: R_AARCH64_MOVW_GOTOFF_G2 + - Type: R_AARCH64_MOVW_GOTOFF_G2_NC + - Type: R_AARCH64_MOVW_GOTOFF_G3 + - Type: R_AARCH64_GOTREL64 + - Type: R_AARCH64_GOTREL32 + - Type: R_AARCH64_GOT_LD_PREL19 + - Type: R_AARCH64_LD64_GOTOFF_LO15 + - Type: R_AARCH64_ADR_GOT_PAGE + - Type: R_AARCH64_LD64_GOT_LO12_NC + - Type: R_AARCH64_LD64_GOTPAGE_LO15 + - Type: R_AARCH64_TLSGD_ADR_PREL21 + - Type: R_AARCH64_TLSGD_ADR_PAGE21 + - Type: R_AARCH64_TLSGD_ADD_LO12_NC + - Type: R_AARCH64_TLSGD_MOVW_G1 + - Type: R_AARCH64_TLSGD_MOVW_G0_NC + - Type: R_AARCH64_TLSLD_ADR_PREL21 + - Type: R_AARCH64_TLSLD_ADR_PAGE21 + - Type: R_AARCH64_TLSLD_ADD_LO12_NC + - Type: R_AARCH64_TLSLD_MOVW_G1 + - Type: R_AARCH64_TLSLD_MOVW_G0_NC + - Type: R_AARCH64_TLSLD_LD_PREL19 + - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G2 + - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G1 + - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC + - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G0 + - Type: R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC + - Type: R_AARCH64_TLSLD_ADD_DTPREL_HI12 + - Type: R_AARCH64_TLSLD_ADD_DTPREL_LO12 + - Type: R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC + - Type: R_AARCH64_TLSLD_LDST8_DTPREL_LO12 + - Type: R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC + - Type: R_AARCH64_TLSLD_LDST16_DTPREL_LO12 + - Type: R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC + - Type: R_AARCH64_TLSLD_LDST32_DTPREL_LO12 + - Type: R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC + - Type: R_AARCH64_TLSLD_LDST64_DTPREL_LO12 + - Type: R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC + - Type: R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 + - Type: R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC + - Type: R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 + - Type: R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC + - Type: R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 + - Type: R_AARCH64_TLSLE_MOVW_TPREL_G2 + - Type: R_AARCH64_TLSLE_MOVW_TPREL_G1 + - Type: R_AARCH64_TLSLE_MOVW_TPREL_G1_NC + - Type: R_AARCH64_TLSLE_MOVW_TPREL_G0 + - Type: R_AARCH64_TLSLE_MOVW_TPREL_G0_NC + - Type: R_AARCH64_TLSLE_ADD_TPREL_HI12 + - Type: R_AARCH64_TLSLE_ADD_TPREL_LO12 + - Type: R_AARCH64_TLSLE_ADD_TPREL_LO12_NC + - Type: R_AARCH64_TLSLE_LDST8_TPREL_LO12 + - Type: R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC + - Type: R_AARCH64_TLSLE_LDST16_TPREL_LO12 + - Type: R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC + - Type: R_AARCH64_TLSLE_LDST32_TPREL_LO12 + - Type: R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC + - Type: R_AARCH64_TLSLE_LDST64_TPREL_LO12 + - Type: R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC + - Type: R_AARCH64_TLSDESC_LD_PREL19 + - Type: R_AARCH64_TLSDESC_ADR_PREL21 + - Type: R_AARCH64_TLSDESC_ADR_PAGE21 + - Type: R_AARCH64_TLSDESC_LD64_LO12 + - Type: R_AARCH64_TLSDESC_ADD_LO12 + - Type: R_AARCH64_TLSDESC_OFF_G1 + - Type: R_AARCH64_TLSDESC_OFF_G0_NC + - Type: R_AARCH64_TLSDESC_LDR + - Type: R_AARCH64_TLSDESC_ADD + - Type: R_AARCH64_TLSDESC_CALL + - Type: R_AARCH64_TLSLE_LDST128_TPREL_LO12 + - Type: R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC + - Type: R_AARCH64_TLSLD_LDST128_DTPREL_LO12 + - Type: R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC + - Type: R_AARCH64_COPY + - Type: R_AARCH64_GLOB_DAT + - Type: R_AARCH64_JUMP_SLOT + - Type: R_AARCH64_RELATIVE + - Type: R_AARCH64_TLS_DTPMOD64 + - Type: R_AARCH64_TLS_DTPREL64 + - Type: R_AARCH64_TLS_TPREL64 + - Type: R_AARCH64_TLSDESC + - Type: R_AARCH64_IRELATIVE diff --git a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-arm.test b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-arm.test index 2bd08c9f7f6e8f..f72d7cdd891386 100644 --- a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-arm.test +++ b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-arm.test @@ -153,266 +153,135 @@ Sections: EntSize: 0x0000000000000008 Info: .text Relocations: - - Type: R_ARM_NONE - - Offset: 0x0000000000000004 - Type: R_ARM_PC24 - - Offset: 0x0000000000000008 - Type: R_ARM_ABS32 - - Offset: 0x000000000000000C - Type: R_ARM_REL32 - - Offset: 0x0000000000000010 - Type: R_ARM_LDR_PC_G0 - - Offset: 0x0000000000000014 - Type: R_ARM_ABS16 - - Offset: 0x0000000000000018 - Type: R_ARM_ABS12 - - Offset: 0x000000000000001C - Type: R_ARM_THM_ABS5 - - Offset: 0x0000000000000020 - Type: R_ARM_ABS8 - - Offset: 0x0000000000000024 - Type: R_ARM_SBREL32 - - Offset: 0x0000000000000028 - Type: R_ARM_THM_CALL - - Offset: 0x000000000000002C - Type: R_ARM_THM_PC8 - - Offset: 0x0000000000000030 - Type: R_ARM_BREL_ADJ - - Offset: 0x0000000000000034 - Type: R_ARM_TLS_DESC - - Offset: 0x0000000000000038 - Type: R_ARM_THM_SWI8 - - Offset: 0x000000000000003C - Type: R_ARM_XPC25 - - Offset: 0x0000000000000040 - Type: R_ARM_THM_XPC22 - - Offset: 0x0000000000000044 - Type: R_ARM_TLS_DTPMOD32 - - Offset: 0x0000000000000048 - Type: R_ARM_TLS_DTPOFF32 - - Offset: 0x000000000000004C - Type: R_ARM_TLS_TPOFF32 - - Offset: 0x0000000000000050 - Type: R_ARM_COPY - - Offset: 0x0000000000000054 - Type: R_ARM_GLOB_DAT - - Offset: 0x0000000000000058 - Type: R_ARM_JUMP_SLOT - - Offset: 0x000000000000005C - Type: R_ARM_RELATIVE - - Offset: 0x0000000000000060 - Type: R_ARM_GOTOFF32 - - Offset: 0x0000000000000064 - Type: R_ARM_BASE_PREL - - Offset: 0x0000000000000068 - Type: R_ARM_GOT_BREL - - Offset: 0x000000000000006C - Type: R_ARM_PLT32 - - Offset: 0x0000000000000070 - Type: R_ARM_CALL - - Offset: 0x0000000000000074 - Type: R_ARM_JUMP24 - - Offset: 0x0000000000000078 - Type: R_ARM_THM_JUMP24 - - Offset: 0x000000000000007C - Type: R_ARM_BASE_ABS - - Offset: 0x0000000000000080 - Type: R_ARM_ALU_PCREL_7_0 - - Offset: 0x0000000000000084 - Type: R_ARM_ALU_PCREL_15_8 - - Offset: 0x0000000000000088 - Type: R_ARM_ALU_PCREL_23_15 - - Offset: 0x000000000000008C - Type: R_ARM_LDR_SBREL_11_0_NC - - Offset: 0x0000000000000090 - Type: R_ARM_ALU_SBREL_19_12_NC - - Offset: 0x0000000000000094 - Type: R_ARM_ALU_SBREL_27_20_CK - - Offset: 0x0000000000000098 - Type: R_ARM_TARGET1 - - Offset: 0x000000000000009C - Type: R_ARM_SBREL31 - - Offset: 0x00000000000000A0 - Type: R_ARM_V4BX - - Offset: 0x00000000000000A4 - Type: R_ARM_TARGET2 - - Offset: 0x00000000000000A8 - Type: R_ARM_PREL31 - - Offset: 0x00000000000000AC - Type: R_ARM_MOVW_ABS_NC - - Offset: 0x00000000000000B0 - Type: R_ARM_MOVT_ABS - - Offset: 0x00000000000000B4 - Type: R_ARM_MOVW_PREL_NC - - Offset: 0x00000000000000B8 - Type: R_ARM_MOVT_PREL - - Offset: 0x00000000000000BC - Type: R_ARM_THM_MOVW_ABS_NC - - Offset: 0x00000000000000C0 - Type: R_ARM_THM_MOVT_ABS - - Offset: 0x00000000000000C4 - Type: R_ARM_THM_MOVW_PREL_NC - - Offset: 0x00000000000000C8 - Type: R_ARM_THM_MOVT_PREL - - Offset: 0x00000000000000CC - Type: R_ARM_THM_JUMP19 - - Offset: 0x00000000000000D0 - Type: R_ARM_THM_JUMP6 - - Offset: 0x00000000000000D4 - Type: R_ARM_THM_ALU_PREL_11_0 - - Offset: 0x00000000000000D8 - Type: R_ARM_THM_PC12 - - Offset: 0x00000000000000DC - Type: R_ARM_ABS32_NOI - - Offset: 0x00000000000000E0 - Type: R_ARM_REL32_NOI - - Offset: 0x00000000000000E4 - Type: R_ARM_ALU_PC_G0_NC - - Offset: 0x00000000000000E8 - Type: R_ARM_ALU_PC_G0 - - Offset: 0x00000000000000EC - Type: R_ARM_ALU_PC_G1_NC - - Offset: 0x00000000000000F0 - Type: R_ARM_ALU_PC_G1 - - Offset: 0x00000000000000F4 - Type: R_ARM_ALU_PC_G2 - - Offset: 0x00000000000000F8 - Type: R_ARM_LDR_PC_G1 - - Offset: 0x00000000000000FC - Type: R_ARM_LDR_PC_G2 - - Offset: 0x0000000000000100 - Type: R_ARM_LDRS_PC_G0 - - Offset: 0x0000000000000104 - Type: R_ARM_LDRS_PC_G1 - - Offset: 0x0000000000000108 - Type: R_ARM_LDRS_PC_G2 - - Offset: 0x000000000000010C - Type: R_ARM_LDC_PC_G0 - - Offset: 0x0000000000000110 - Type: R_ARM_LDC_PC_G1 - - Offset: 0x0000000000000114 - Type: R_ARM_LDC_PC_G2 - - Offset: 0x0000000000000118 - Type: R_ARM_ALU_SB_G0_NC - - Offset: 0x000000000000011C - Type: R_ARM_ALU_SB_G0 - - Offset: 0x0000000000000120 - Type: R_ARM_ALU_SB_G1_NC - - Offset: 0x0000000000000124 - Type: R_ARM_ALU_SB_G1 - - Offset: 0x0000000000000128 - Type: R_ARM_ALU_SB_G2 - - Offset: 0x000000000000012C - Type: R_ARM_LDR_SB_G0 - - Offset: 0x0000000000000130 - Type: R_ARM_LDR_SB_G1 - - Offset: 0x0000000000000134 - Type: R_ARM_LDR_SB_G2 - - Offset: 0x0000000000000138 - Type: R_ARM_LDRS_SB_G0 - - Offset: 0x000000000000013C - Type: R_ARM_LDRS_SB_G1 - - Offset: 0x0000000000000140 - Type: R_ARM_LDRS_SB_G2 - - Offset: 0x0000000000000144 - Type: R_ARM_LDC_SB_G0 - - Offset: 0x0000000000000148 - Type: R_ARM_LDC_SB_G1 - - Offset: 0x000000000000014C - Type: R_ARM_LDC_SB_G2 - - Offset: 0x0000000000000150 - Type: R_ARM_MOVW_BREL_NC - - Offset: 0x0000000000000154 - Type: R_ARM_MOVT_BREL - - Offset: 0x0000000000000158 - Type: R_ARM_MOVW_BREL - - Offset: 0x000000000000015C - Type: R_ARM_THM_MOVW_BREL_NC - - Offset: 0x0000000000000160 - Type: R_ARM_THM_MOVT_BREL - - Offset: 0x0000000000000164 - Type: R_ARM_THM_MOVW_BREL - - Offset: 0x0000000000000168 - Type: R_ARM_TLS_GOTDESC - - Offset: 0x000000000000016C - Type: R_ARM_TLS_CALL - - Offset: 0x0000000000000170 - Type: R_ARM_TLS_DESCSEQ - - Offset: 0x0000000000000174 - Type: R_ARM_THM_TLS_CALL - - Offset: 0x0000000000000178 - Type: R_ARM_PLT32_ABS - - Offset: 0x000000000000017C - Type: R_ARM_GOT_ABS - - Offset: 0x0000000000000180 - Type: R_ARM_GOT_PREL - - Offset: 0x0000000000000184 - Type: R_ARM_GOT_BREL12 - - Offset: 0x0000000000000188 - Type: R_ARM_GOTOFF12 - - Offset: 0x000000000000018C - Type: R_ARM_GOTRELAX - - Offset: 0x0000000000000190 - Type: R_ARM_GNU_VTENTRY - - Offset: 0x0000000000000194 - Type: R_ARM_GNU_VTINHERIT - - Offset: 0x0000000000000198 - Type: R_ARM_THM_JUMP11 - - Offset: 0x000000000000019C - Type: R_ARM_THM_JUMP8 - - Offset: 0x00000000000001A0 - Type: R_ARM_TLS_GD32 - - Offset: 0x00000000000001A4 - Type: R_ARM_TLS_LDM32 - - Offset: 0x00000000000001A8 - Type: R_ARM_TLS_LDO32 - - Offset: 0x00000000000001AC - Type: R_ARM_TLS_IE32 - - Offset: 0x00000000000001B0 - Type: R_ARM_TLS_LE32 - - Offset: 0x00000000000001B4 - Type: R_ARM_TLS_LDO12 - - Offset: 0x00000000000001B8 - Type: R_ARM_TLS_LE12 - - Offset: 0x00000000000001BC - Type: R_ARM_TLS_IE12GP - - Offset: 0x00000000000001C0 - Type: R_ARM_PRIVATE_0 - - Offset: 0x00000000000001C4 - Type: R_ARM_PRIVATE_1 - - Offset: 0x00000000000001C8 - Type: R_ARM_PRIVATE_2 - - Offset: 0x00000000000001CC - Type: R_ARM_PRIVATE_3 - - Offset: 0x00000000000001D0 - Type: R_ARM_PRIVATE_4 - - Offset: 0x00000000000001D4 - Type: R_ARM_PRIVATE_5 - - Offset: 0x00000000000001D8 - Type: R_ARM_PRIVATE_6 - - Offset: 0x00000000000001DC - Type: R_ARM_PRIVATE_7 - - Offset: 0x00000000000001E0 - Type: R_ARM_PRIVATE_8 - - Offset: 0x00000000000001E4 - Type: R_ARM_PRIVATE_9 - - Offset: 0x00000000000001E8 - Type: R_ARM_PRIVATE_10 - - Offset: 0x00000000000001EC - Type: R_ARM_PRIVATE_11 - - Offset: 0x00000000000001F0 - Type: R_ARM_PRIVATE_12 - - Offset: 0x00000000000001F4 - Type: R_ARM_PRIVATE_13 - - Offset: 0x00000000000001F8 - Type: R_ARM_PRIVATE_14 - - Offset: 0x00000000000001FC - Type: R_ARM_PRIVATE_15 - - Offset: 0x0000000000000200 - Type: R_ARM_ME_TOO - - Offset: 0x0000000000000204 - Type: R_ARM_THM_TLS_DESCSEQ16 - - Offset: 0x0000000000000208 - Type: R_ARM_THM_TLS_DESCSEQ32 - - Offset: 0x000000000000020C - Type: R_ARM_IRELATIVE + - Type: R_ARM_NONE + - Type: R_ARM_PC24 + - Type: R_ARM_ABS32 + - Type: R_ARM_REL32 + - Type: R_ARM_LDR_PC_G0 + - Type: R_ARM_ABS16 + - Type: R_ARM_ABS12 + - Type: R_ARM_THM_ABS5 + - Type: R_ARM_ABS8 + - Type: R_ARM_SBREL32 + - Type: R_ARM_THM_CALL + - Type: R_ARM_THM_PC8 + - Type: R_ARM_BREL_ADJ + - Type: R_ARM_TLS_DESC + - Type: R_ARM_THM_SWI8 + - Type: R_ARM_XPC25 + - Type: R_ARM_THM_XPC22 + - Type: R_ARM_TLS_DTPMOD32 + - Type: R_ARM_TLS_DTPOFF32 + - Type: R_ARM_TLS_TPOFF32 + - Type: R_ARM_COPY + - Type: R_ARM_GLOB_DAT + - Type: R_ARM_JUMP_SLOT + - Type: R_ARM_RELATIVE + - Type: R_ARM_GOTOFF32 + - Type: R_ARM_BASE_PREL + - Type: R_ARM_GOT_BREL + - Type: R_ARM_PLT32 + - Type: R_ARM_CALL + - Type: R_ARM_JUMP24 + - Type: R_ARM_THM_JUMP24 + - Type: R_ARM_BASE_ABS + - Type: R_ARM_ALU_PCREL_7_0 + - Type: R_ARM_ALU_PCREL_15_8 + - Type: R_ARM_ALU_PCREL_23_15 + - Type: R_ARM_LDR_SBREL_11_0_NC + - Type: R_ARM_ALU_SBREL_19_12_NC + - Type: R_ARM_ALU_SBREL_27_20_CK + - Type: R_ARM_TARGET1 + - Type: R_ARM_SBREL31 + - Type: R_ARM_V4BX + - Type: R_ARM_TARGET2 + - Type: R_ARM_PREL31 + - Type: R_ARM_MOVW_ABS_NC + - Type: R_ARM_MOVT_ABS + - Type: R_ARM_MOVW_PREL_NC + - Type: R_ARM_MOVT_PREL + - Type: R_ARM_THM_MOVW_ABS_NC + - Type: R_ARM_THM_MOVT_ABS + - Type: R_ARM_THM_MOVW_PREL_NC + - Type: R_ARM_THM_MOVT_PREL + - Type: R_ARM_THM_JUMP19 + - Type: R_ARM_THM_JUMP6 + - Type: R_ARM_THM_ALU_PREL_11_0 + - Type: R_ARM_THM_PC12 + - Type: R_ARM_ABS32_NOI + - Type: R_ARM_REL32_NOI + - Type: R_ARM_ALU_PC_G0_NC + - Type: R_ARM_ALU_PC_G0 + - Type: R_ARM_ALU_PC_G1_NC + - Type: R_ARM_ALU_PC_G1 + - Type: R_ARM_ALU_PC_G2 + - Type: R_ARM_LDR_PC_G1 + - Type: R_ARM_LDR_PC_G2 + - Type: R_ARM_LDRS_PC_G0 + - Type: R_ARM_LDRS_PC_G1 + - Type: R_ARM_LDRS_PC_G2 + - Type: R_ARM_LDC_PC_G0 + - Type: R_ARM_LDC_PC_G1 + - Type: R_ARM_LDC_PC_G2 + - Type: R_ARM_ALU_SB_G0_NC + - Type: R_ARM_ALU_SB_G0 + - Type: R_ARM_ALU_SB_G1_NC + - Type: R_ARM_ALU_SB_G1 + - Type: R_ARM_ALU_SB_G2 + - Type: R_ARM_LDR_SB_G0 + - Type: R_ARM_LDR_SB_G1 + - Type: R_ARM_LDR_SB_G2 + - Type: R_ARM_LDRS_SB_G0 + - Type: R_ARM_LDRS_SB_G1 + - Type: R_ARM_LDRS_SB_G2 + - Type: R_ARM_LDC_SB_G0 + - Type: R_ARM_LDC_SB_G1 + - Type: R_ARM_LDC_SB_G2 + - Type: R_ARM_MOVW_BREL_NC + - Type: R_ARM_MOVT_BREL + - Type: R_ARM_MOVW_BREL + - Type: R_ARM_THM_MOVW_BREL_NC + - Type: R_ARM_THM_MOVT_BREL + - Type: R_ARM_THM_MOVW_BREL + - Type: R_ARM_TLS_GOTDESC + - Type: R_ARM_TLS_CALL + - Type: R_ARM_TLS_DESCSEQ + - Type: R_ARM_THM_TLS_CALL + - Type: R_ARM_PLT32_ABS + - Type: R_ARM_GOT_ABS + - Type: R_ARM_GOT_PREL + - Type: R_ARM_GOT_BREL12 + - Type: R_ARM_GOTOFF12 + - Type: R_ARM_GOTRELAX + - Type: R_ARM_GNU_VTENTRY + - Type: R_ARM_GNU_VTINHERIT + - Type: R_ARM_THM_JUMP11 + - Type: R_ARM_THM_JUMP8 + - Type: R_ARM_TLS_GD32 + - Type: R_ARM_TLS_LDM32 + - Type: R_ARM_TLS_LDO32 + - Type: R_ARM_TLS_IE32 + - Type: R_ARM_TLS_LE32 + - Type: R_ARM_TLS_LDO12 + - Type: R_ARM_TLS_LE12 + - Type: R_ARM_TLS_IE12GP + - Type: R_ARM_PRIVATE_0 + - Type: R_ARM_PRIVATE_1 + - Type: R_ARM_PRIVATE_2 + - Type: R_ARM_PRIVATE_3 + - Type: R_ARM_PRIVATE_4 + - Type: R_ARM_PRIVATE_5 + - Type: R_ARM_PRIVATE_6 + - Type: R_ARM_PRIVATE_7 + - Type: R_ARM_PRIVATE_8 + - Type: R_ARM_PRIVATE_9 + - Type: R_ARM_PRIVATE_10 + - Type: R_ARM_PRIVATE_11 + - Type: R_ARM_PRIVATE_12 + - Type: R_ARM_PRIVATE_13 + - Type: R_ARM_PRIVATE_14 + - Type: R_ARM_PRIVATE_15 + - Type: R_ARM_ME_TOO + - Type: R_ARM_THM_TLS_DESCSEQ16 + - Type: R_ARM_THM_TLS_DESCSEQ32 + - Type: R_ARM_IRELATIVE diff --git a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-lanai.test b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-lanai.test index 101c0a8e7a97e1..6bbe1a839b5097 100644 --- a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-lanai.test +++ b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-lanai.test @@ -30,16 +30,10 @@ Sections: EntSize: 0x000000000000000C Info: .text Relocations: - - Type: R_LANAI_NONE - - Offset: 0x0000000000000004 - Type: R_LANAI_21 - - Offset: 0x0000000000000008 - Type: R_LANAI_21_F - - Offset: 0x000000000000000C - Type: R_LANAI_25 - - Offset: 0x0000000000000010 - Type: R_LANAI_32 - - Offset: 0x0000000000000014 - Type: R_LANAI_HI16 - - Offset: 0x0000000000000018 - Type: R_LANAI_LO16 + - Type: R_LANAI_NONE + - Type: R_LANAI_21 + - Type: R_LANAI_21_F + - Type: R_LANAI_25 + - Type: R_LANAI_32 + - Type: R_LANAI_HI16 + - Type: R_LANAI_LO16 diff --git a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-mips.test b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-mips.test index 1bfe2f4aba72f6..59793c512b35a4 100644 --- a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-mips.test +++ b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-mips.test @@ -74,106 +74,55 @@ Sections: EntSize: 0x0000000000000008 Info: .text Relocations: - - Type: R_MIPS_NONE - - Offset: 0x0000000000000004 - Type: R_MIPS_16 - - Offset: 0x0000000000000008 - Type: R_MIPS_32 - - Offset: 0x000000000000000C - Type: R_MIPS_REL32 - - Offset: 0x0000000000000010 - Type: R_MIPS_26 - - Offset: 0x0000000000000014 - Type: R_MIPS_HI16 - - Offset: 0x0000000000000018 - Type: R_MIPS_LO16 - - Offset: 0x000000000000001C - Type: R_MIPS_GPREL16 - - Offset: 0x0000000000000020 - Type: R_MIPS_LITERAL - - Offset: 0x0000000000000024 - Type: R_MIPS_GOT16 - - Offset: 0x0000000000000028 - Type: R_MIPS_PC16 - - Offset: 0x000000000000002C - Type: R_MIPS_CALL16 - - Offset: 0x0000000000000030 - Type: R_MIPS_GPREL32 - - Offset: 0x0000000000000034 - Type: R_MIPS_SHIFT5 - - Offset: 0x0000000000000038 - Type: R_MIPS_SHIFT6 - - Offset: 0x000000000000003C - Type: R_MIPS_64 - - Offset: 0x0000000000000040 - Type: R_MIPS_GOT_DISP - - Offset: 0x0000000000000044 - Type: R_MIPS_GOT_PAGE - - Offset: 0x0000000000000048 - Type: R_MIPS_GOT_OFST - - Offset: 0x000000000000004C - Type: R_MIPS_GOT_HI16 - - Offset: 0x0000000000000050 - Type: R_MIPS_GOT_LO16 - - Offset: 0x0000000000000054 - Type: R_MIPS_SUB - - Offset: 0x0000000000000058 - Type: R_MIPS_INSERT_A - - Offset: 0x000000000000005C - Type: R_MIPS_INSERT_B - - Offset: 0x0000000000000060 - Type: R_MIPS_DELETE - - Offset: 0x0000000000000064 - Type: R_MIPS_HIGHER - - Offset: 0x0000000000000068 - Type: R_MIPS_HIGHEST - - Offset: 0x000000000000006C - Type: R_MIPS_CALL_HI16 - - Offset: 0x0000000000000070 - Type: R_MIPS_CALL_LO16 - - Offset: 0x0000000000000074 - Type: R_MIPS_SCN_DISP - - Offset: 0x0000000000000078 - Type: R_MIPS_REL16 - - Offset: 0x000000000000007C - Type: R_MIPS_ADD_IMMEDIATE - - Offset: 0x0000000000000080 - Type: R_MIPS_PJUMP - - Offset: 0x0000000000000084 - Type: R_MIPS_RELGOT - - Offset: 0x0000000000000088 - Type: R_MIPS_JALR - - Offset: 0x000000000000008C - Type: R_MIPS_TLS_DTPMOD32 - - Offset: 0x0000000000000090 - Type: R_MIPS_TLS_DTPREL32 - - Offset: 0x0000000000000094 - Type: R_MIPS_TLS_DTPMOD64 - - Offset: 0x0000000000000098 - Type: R_MIPS_TLS_DTPREL64 - - Offset: 0x000000000000009C - Type: R_MIPS_TLS_GD - - Offset: 0x00000000000000A0 - Type: R_MIPS_TLS_LDM - - Offset: 0x00000000000000A4 - Type: R_MIPS_TLS_DTPREL_HI16 - - Offset: 0x00000000000000A8 - Type: R_MIPS_TLS_DTPREL_LO16 - - Offset: 0x00000000000000AC - Type: R_MIPS_TLS_GOTTPREL - - Offset: 0x00000000000000B0 - Type: R_MIPS_TLS_TPREL32 - - Offset: 0x00000000000000B4 - Type: R_MIPS_TLS_TPREL64 - - Offset: 0x00000000000000B8 - Type: R_MIPS_TLS_TPREL_HI16 - - Offset: 0x00000000000000BC - Type: R_MIPS_TLS_TPREL_LO16 - - Offset: 0x00000000000000C0 - Type: R_MIPS_GLOB_DAT - - Offset: 0x00000000000000C4 - Type: R_MIPS_COPY - - Offset: 0x00000000000000C8 - Type: R_MIPS_JUMP_SLOT - - Offset: 0x00000000000000CC - Type: R_MIPS_NUM + - Type: R_MIPS_NONE + - Type: R_MIPS_16 + - Type: R_MIPS_32 + - Type: R_MIPS_REL32 + - Type: R_MIPS_26 + - Type: R_MIPS_HI16 + - Type: R_MIPS_LO16 + - Type: R_MIPS_GPREL16 + - Type: R_MIPS_LITERAL + - Type: R_MIPS_GOT16 + - Type: R_MIPS_PC16 + - Type: R_MIPS_CALL16 + - Type: R_MIPS_GPREL32 + - Type: R_MIPS_SHIFT5 + - Type: R_MIPS_SHIFT6 + - Type: R_MIPS_64 + - Type: R_MIPS_GOT_DISP + - Type: R_MIPS_GOT_PAGE + - Type: R_MIPS_GOT_OFST + - Type: R_MIPS_GOT_HI16 + - Type: R_MIPS_GOT_LO16 + - Type: R_MIPS_SUB + - Type: R_MIPS_INSERT_A + - Type: R_MIPS_INSERT_B + - Type: R_MIPS_DELETE + - Type: R_MIPS_HIGHER + - Type: R_MIPS_HIGHEST + - Type: R_MIPS_CALL_HI16 + - Type: R_MIPS_CALL_LO16 + - Type: R_MIPS_SCN_DISP + - Type: R_MIPS_REL16 + - Type: R_MIPS_ADD_IMMEDIATE + - Type: R_MIPS_PJUMP + - Type: R_MIPS_RELGOT + - Type: R_MIPS_JALR + - Type: R_MIPS_TLS_DTPMOD32 + - Type: R_MIPS_TLS_DTPREL32 + - Type: R_MIPS_TLS_DTPMOD64 + - Type: R_MIPS_TLS_DTPREL64 + - Type: R_MIPS_TLS_GD + - Type: R_MIPS_TLS_LDM + - Type: R_MIPS_TLS_DTPREL_HI16 + - Type: R_MIPS_TLS_DTPREL_LO16 + - Type: R_MIPS_TLS_GOTTPREL + - Type: R_MIPS_TLS_TPREL32 + - Type: R_MIPS_TLS_TPREL64 + - Type: R_MIPS_TLS_TPREL_HI16 + - Type: R_MIPS_TLS_TPREL_LO16 + - Type: R_MIPS_GLOB_DAT + - Type: R_MIPS_COPY + - Type: R_MIPS_JUMP_SLOT + - Type: R_MIPS_NUM diff --git a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-mips64.test b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-mips64.test index 8c303d46b728de..fc72edd29d2c03 100644 --- a/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-mips64.test +++ b/llvm/test/tools/llvm-readobj/ELF/reloc-types-elf-mips64.test @@ -74,208 +74,157 @@ Sections: EntSize: 0x0000000000000018 Info: .text Relocations: - - Type: R_MIPS_NONE - - Offset: 0x0000000000000004 - Type: R_MIPS_16 - Type2: R_MIPS_16 - Type3: R_MIPS_16 - - Offset: 0x0000000000000008 - Type: R_MIPS_32 - Type2: R_MIPS_32 - Type3: R_MIPS_32 - - Offset: 0x000000000000000C - Type: R_MIPS_REL32 - Type2: R_MIPS_REL32 - Type3: R_MIPS_REL32 - - Offset: 0x0000000000000010 - Type: R_MIPS_26 - Type2: R_MIPS_26 - Type3: R_MIPS_26 - - Offset: 0x0000000000000014 - Type: R_MIPS_HI16 - Type2: R_MIPS_HI16 - Type3: R_MIPS_HI16 - - Offset: 0x0000000000000018 - Type: R_MIPS_LO16 - Type2: R_MIPS_LO16 - Type3: R_MIPS_LO16 - - Offset: 0x000000000000001C - Type: R_MIPS_GPREL16 - Type2: R_MIPS_GPREL16 - Type3: R_MIPS_GPREL16 - - Offset: 0x0000000000000020 - Type: R_MIPS_LITERAL - Type2: R_MIPS_LITERAL - Type3: R_MIPS_LITERAL - - Offset: 0x0000000000000024 - Type: R_MIPS_GOT16 - Type2: R_MIPS_GOT16 - Type3: R_MIPS_GOT16 - - Offset: 0x0000000000000028 - Type: R_MIPS_PC16 - Type2: R_MIPS_PC16 - Type3: R_MIPS_PC16 - - Offset: 0x000000000000002C - Type: R_MIPS_CALL16 - Type2: R_MIPS_CALL16 - Type3: R_MIPS_CALL16 - - Offset: 0x0000000000000030 - Type: R_MIPS_GPREL32 - Type2: R_MIPS_GPREL32 - Type3: R_MIPS_GPREL32 - - Offset: 0x0000000000000034 - Type: R_MIPS_SHIFT5 - Type2: R_MIPS_SHIFT5 - Type3: R_MIPS_SHIFT5 - - Offset: 0x0000000000000038 - Type: R_MIPS_SHIFT6 - Type2: R_MIPS_SHIFT6 - Type3: R_MIPS_SHIFT6 - - Offset: 0x000000000000003C - Type: R_MIPS_64 - Type2: R_MIPS_64 - Type3: R_MIPS_64 - - Offset: 0x0000000000000040 - Type: R_MIPS_GOT_DISP - Type2: R_MIPS_GOT_DISP - Type3: R_MIPS_GOT_DISP - - Offset: 0x0000000000000044 - Type: R_MIPS_GOT_PAGE - Type2: R_MIPS_GOT_PAGE - Type3: R_MIPS_GOT_PAGE - - Offset: 0x0000000000000048 - Type: R_MIPS_GOT_OFST - Type2: R_MIPS_GOT_OFST - Type3: R_MIPS_GOT_OFST - - Offset: 0x000000000000004C - Type: R_MIPS_GOT_HI16 - Type2: R_MIPS_GOT_HI16 - Type3: R_MIPS_GOT_HI16 - - Offset: 0x0000000000000050 - Type: R_MIPS_GOT_LO16 - Type2: R_MIPS_GOT_LO16 - Type3: R_MIPS_GOT_LO16 - - Offset: 0x0000000000000054 - Type: R_MIPS_SUB - Type2: R_MIPS_SUB - Type3: R_MIPS_SUB - - Offset: 0x0000000000000058 - Type: R_MIPS_INSERT_A - Type2: R_MIPS_INSERT_A - Type3: R_MIPS_INSERT_A - - Offset: 0x000000000000005C - Type: R_MIPS_INSERT_B - Type2: R_MIPS_INSERT_B - Type3: R_MIPS_INSERT_B - - Offset: 0x0000000000000060 - Type: R_MIPS_DELETE - Type2: R_MIPS_DELETE - Type3: R_MIPS_DELETE - - Offset: 0x0000000000000064 - Type: R_MIPS_HIGHER - Type2: R_MIPS_HIGHER - Type3: R_MIPS_HIGHER - - Offset: 0x0000000000000068 - Type: R_MIPS_HIGHEST - Type2: R_MIPS_HIGHEST - Type3: R_MIPS_HIGHEST - - Offset: 0x000000000000006C - Type: R_MIPS_CALL_HI16 - Type2: R_MIPS_CALL_HI16 - Type3: R_MIPS_CALL_HI16 - - Offset: 0x0000000000000070 - Type: R_MIPS_CALL_LO16 - Type2: R_MIPS_CALL_LO16 - Type3: R_MIPS_CALL_LO16 - - Offset: 0x0000000000000074 - Type: R_MIPS_SCN_DISP - Type2: R_MIPS_SCN_DISP - Type3: R_MIPS_SCN_DISP - - Offset: 0x0000000000000078 - Type: R_MIPS_REL16 - Type2: R_MIPS_REL16 - Type3: R_MIPS_REL16 - - Offset: 0x000000000000007C - Type: R_MIPS_ADD_IMMEDIATE - Type2: R_MIPS_ADD_IMMEDIATE - Type3: R_MIPS_ADD_IMMEDIATE - - Offset: 0x0000000000000080 - Type: R_MIPS_PJUMP - Type2: R_MIPS_PJUMP - Type3: R_MIPS_PJUMP - - Offset: 0x0000000000000084 - Type: R_MIPS_RELGOT - Type2: R_MIPS_RELGOT - Type3: R_MIPS_RELGOT - - Offset: 0x0000000000000088 - Type: R_MIPS_JALR - Type2: R_MIPS_JALR - Type3: R_MIPS_JALR - - Offset: 0x000000000000008C - Type: R_MIPS_TLS_DTPMOD32 - Type2: R_MIPS_TLS_DTPMOD32 - Type3: R_MIPS_TLS_DTPMOD32 - - Offset: 0x0000000000000090 - Type: R_MIPS_TLS_DTPREL32 - Type2: R_MIPS_TLS_DTPREL32 - Type3: R_MIPS_TLS_DTPREL32 - - Offset: 0x0000000000000094 - Type: R_MIPS_TLS_DTPMOD64 - Type2: R_MIPS_TLS_DTPMOD64 - Type3: R_MIPS_TLS_DTPMOD64 - - Offset: 0x0000000000000098 - Type: R_MIPS_TLS_DTPREL64 - Type2: R_MIPS_TLS_DTPREL64 - Type3: R_MIPS_TLS_DTPREL64 - - Offset: 0x000000000000009C - Type: R_MIPS_TLS_GD - Type2: R_MIPS_TLS_GD - Type3: R_MIPS_TLS_GD - - Offset: 0x00000000000000A0 - Type: R_MIPS_TLS_LDM - Type2: R_MIPS_TLS_LDM - Type3: R_MIPS_TLS_LDM - - Offset: 0x00000000000000A4 - Type: R_MIPS_TLS_DTPREL_HI16 - Type2: R_MIPS_TLS_DTPREL_HI16 - Type3: R_MIPS_TLS_DTPREL_HI16 - - Offset: 0x00000000000000A8 - Type: R_MIPS_TLS_DTPREL_LO16 - Type2: R_MIPS_TLS_DTPREL_LO16 - Type3: R_MIPS_TLS_DTPREL_LO16 - - Offset: 0x00000000000000AC - Type: R_MIPS_TLS_GOTTPREL - Type2: R_MIPS_TLS_GOTTPREL - Type3: R_MIPS_TLS_GOTTPREL - - Offset: 0x00000000000000B0 - Type: R_MIPS_TLS_TPREL32 - Type2: R_MIPS_TLS_TPREL32 - Type3: R_MIPS_TLS_TPREL32 - - Offset: 0x00000000000000B4 - Type: R_MIPS_TLS_TPREL64 - Type2: R_MIPS_TLS_TPREL64 - Type3: R_MIPS_TLS_TPREL64 - - Offset: 0x00000000000000B8 - Type: R_MIPS_TLS_TPREL_HI16 - Type2: R_MIPS_TLS_TPREL_HI16 - Type3: R_MIPS_TLS_TPREL_HI16 - - Offset: 0x00000000000000BC - Type: R_MIPS_TLS_TPREL_LO16 - Type2: R_MIPS_TLS_TPREL_LO16 - Type3: R_MIPS_TLS_TPREL_LO16 - - Offset: 0x00000000000000C0 - Type: R_MIPS_GLOB_DAT - Type2: R_MIPS_GLOB_DAT - Type3: R_MIPS_GLOB_DAT - - Offset: 0x00000000000000C4 - Type: R_MIPS_COPY - Type2: R_MIPS_COPY - Type3: R_MIPS_COPY - - Offset: 0x00000000000000C8 - Type: R_MIPS_JUMP_SLOT - Type2: R_MIPS_JUMP_SLOT - Type3: R_MIPS_JUMP_SLOT - - Offset: 0x00000000000000CC - Type: R_MIPS_NUM - Type2: R_MIPS_NUM - Type3: R_MIPS_NUM + - Type: R_MIPS_NONE + - Type: R_MIPS_16 + Type2: R_MIPS_16 + Type3: R_MIPS_16 + - Type: R_MIPS_32 + Type2: R_MIPS_32 + Type3: R_MIPS_32 + - Type: R_MIPS_REL32 + Type2: R_MIPS_REL32 + Type3: R_MIPS_REL32 + - Type: R_MIPS_26 + Type2: R_MIPS_26 + Type3: R_MIPS_26 + - Type: R_MIPS_HI16 + Type2: R_MIPS_HI16 + Type3: R_MIPS_HI16 + - Type: R_MIPS_LO16 + Type2: R_MIPS_LO16 + Type3: R_MIPS_LO16 + - Type: R_MIPS_GPREL16 + Type2: R_MIPS_GPREL16 + Type3: R_MIPS_GPREL16 + - Type: R_MIPS_LITERAL + Type2: R_MIPS_LITERAL + Type3: R_MIPS_LITERAL + - Type: R_MIPS_GOT16 + Type2: R_MIPS_GOT16 + Type3: R_MIPS_GOT16 + - Type: R_MIPS_PC16 + Type2: R_MIPS_PC16 + Type3: R_MIPS_PC16 + - Type: R_MIPS_CALL16 + Type2: R_MIPS_CALL16 + Type3: R_MIPS_CALL16 + - Type: R_MIPS_GPREL32 + Type2: R_MIPS_GPREL32 + Type3: R_MIPS_GPREL32 + - Type: R_MIPS_SHIFT5 + Type2: R_MIPS_SHIFT5 + Type3: R_MIPS_SHIFT5 + - Type: R_MIPS_SHIFT6 + Type2: R_MIPS_SHIFT6 + Type3: R_MIPS_SHIFT6 + - Type: R_MIPS_64 + Type2: R_MIPS_64 + Type3: R_MIPS_64 + - Type: R_MIPS_GOT_DISP + Type2: R_MIPS_GOT_DISP + Type3: R_MIPS_GOT_DISP + - Type: R_MIPS_GOT_PAGE + Type2: R_MIPS_GOT_PAGE + Type3: R_MIPS_GOT_PAGE + - Type: R_MIPS_GOT_OFST + Type2: R_MIPS_GOT_OFST + Type3: R_MIPS_GOT_OFST + - Type: R_MIPS_GOT_HI16 + Type2: R_MIPS_GOT_HI16 + Type3: R_MIPS_GOT_HI16 + - Type: R_MIPS_GOT_LO16 + Type2: R_MIPS_GOT_LO16 + Type3: R_MIPS_GOT_LO16 + - Type: R_MIPS_SUB + Type2: R_MIPS_SUB + Type3: R_MIPS_SUB + - Type: R_MIPS_INSERT_A + Type2: R_MIPS_INSERT_A + Type3: R_MIPS_INSERT_A + - Type: R_MIPS_INSERT_B + Type2: R_MIPS_INSERT_B + Type3: R_MIPS_INSERT_B + - Type: R_MIPS_DELETE + Type2: R_MIPS_DELETE + Type3: R_MIPS_DELETE + - Type: R_MIPS_HIGHER + Type2: R_MIPS_HIGHER + Type3: R_MIPS_HIGHER + - Type: R_MIPS_HIGHEST + Type2: R_MIPS_HIGHEST + Type3: R_MIPS_HIGHEST + - Type: R_MIPS_CALL_HI16 + Type2: R_MIPS_CALL_HI16 + Type3: R_MIPS_CALL_HI16 + - Type: R_MIPS_CALL_LO16 + Type2: R_MIPS_CALL_LO16 + Type3: R_MIPS_CALL_LO16 + - Type: R_MIPS_SCN_DISP + Type2: R_MIPS_SCN_DISP + Type3: R_MIPS_SCN_DISP + - Type: R_MIPS_REL16 + Type2: R_MIPS_REL16 + Type3: R_MIPS_REL16 + - Type: R_MIPS_ADD_IMMEDIATE + Type2: R_MIPS_ADD_IMMEDIATE + Type3: R_MIPS_ADD_IMMEDIATE + - Type: R_MIPS_PJUMP + Type2: R_MIPS_PJUMP + Type3: R_MIPS_PJUMP + - Type: R_MIPS_RELGOT + Type2: R_MIPS_RELGOT + Type3: R_MIPS_RELGOT + - Type: R_MIPS_JALR + Type2: R_MIPS_JALR + Type3: R_MIPS_JALR + - Type: R_MIPS_TLS_DTPMOD32 + Type2: R_MIPS_TLS_DTPMOD32 + Type3: R_MIPS_TLS_DTPMOD32 + - Type: R_MIPS_TLS_DTPREL32 + Type2: R_MIPS_TLS_DTPREL32 + Type3: R_MIPS_TLS_DTPREL32 + - Type: R_MIPS_TLS_DTPMOD64 + Type2: R_MIPS_TLS_DTPMOD64 + Type3: R_MIPS_TLS_DTPMOD64 + - Type: R_MIPS_TLS_DTPREL64 + Type2: R_MIPS_TLS_DTPREL64 + Type3: R_MIPS_TLS_DTPREL64 + - Type: R_MIPS_TLS_GD + Type2: R_MIPS_TLS_GD + Type3: R_MIPS_TLS_GD + - Type: R_MIPS_TLS_LDM + Type2: R_MIPS_TLS_LDM + Type3: R_MIPS_TLS_LDM + - Type: R_MIPS_TLS_DTPREL_HI16 + Type2: R_MIPS_TLS_DTPREL_HI16 + Type3: R_MIPS_TLS_DTPREL_HI16 + - Type: R_MIPS_TLS_DTPREL_LO16 + Type2: R_MIPS_TLS_DTPREL_LO16 + Type3: R_MIPS_TLS_DTPREL_LO16 + - Type: R_MIPS_TLS_GOTTPREL + Type2: R_MIPS_TLS_GOTTPREL + Type3: R_MIPS_TLS_GOTTPREL + - Type: R_MIPS_TLS_TPREL32 + Type2: R_MIPS_TLS_TPREL32 + Type3: R_MIPS_TLS_TPREL32 + - Type: R_MIPS_TLS_TPREL64 + Type2: R_MIPS_TLS_TPREL64 + Type3: R_MIPS_TLS_TPREL64 + - Type: R_MIPS_TLS_TPREL_HI16 + Type2: R_MIPS_TLS_TPREL_HI16 + Type3: R_MIPS_TLS_TPREL_HI16 + - Type: R_MIPS_TLS_TPREL_LO16 + Type2: R_MIPS_TLS_TPREL_LO16 + Type3: R_MIPS_TLS_TPREL_LO16 + - Type: R_MIPS_GLOB_DAT + Type2: R_MIPS_GLOB_DAT + Type3: R_MIPS_GLOB_DAT + - Type: R_MIPS_COPY + Type2: R_MIPS_COPY + Type3: R_MIPS_COPY + - Type: R_MIPS_JUMP_SLOT + Type2: R_MIPS_JUMP_SLOT + Type3: R_MIPS_JUMP_SLOT + - Type: R_MIPS_NUM + Type2: R_MIPS_NUM + Type3: R_MIPS_NUM diff --git a/llvm/test/tools/obj2yaml/Inputs/crt1.o b/llvm/test/tools/obj2yaml/Inputs/crt1.o deleted file mode 100755 index 2b000ab9ae836e..00000000000000 Binary files a/llvm/test/tools/obj2yaml/Inputs/crt1.o and /dev/null differ diff --git a/llvm/test/tools/obj2yaml/missing_symtab.test b/llvm/test/tools/obj2yaml/missing_symtab.test deleted file mode 100644 index f61712c9b2afb3..00000000000000 --- a/llvm/test/tools/obj2yaml/missing_symtab.test +++ /dev/null @@ -1,5 +0,0 @@ -# RUN: obj2yaml %S/Inputs/crt1.o | FileCheck %s -# test that we don't crash when passed object files without a symbol table -# CHECK-LABEL: FileHeader: -# CHECK-LABEL: Sections: -# CHECK-NOT: Symbols: diff --git a/llvm/test/tools/yaml2obj/ELF/dynamic-section.yaml b/llvm/test/tools/yaml2obj/ELF/dynamic-section.yaml index 035d97094dfef9..9dadf63b16f009 100644 --- a/llvm/test/tools/yaml2obj/ELF/dynamic-section.yaml +++ b/llvm/test/tools/yaml2obj/ELF/dynamic-section.yaml @@ -1,18 +1,29 @@ ## Ensures that dynamic section has sh_entsize correctly set. -# RUN: yaml2obj %s -o %t -# RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=SECTION +# RUN: yaml2obj -DBITS=64 %s -o %t.64 +# RUN: llvm-readobj --sections %t.64 | FileCheck %s -DENTSIZE=16 +# RUN: yaml2obj -DBITS=32 %s -o %t.32 +# RUN: llvm-readobj --sections %t.32 | FileCheck %s -DENTSIZE=8 !ELF FileHeader: - Class: ELFCLASS64 - Data: ELFDATA2LSB - Type: ET_DYN - Machine: EM_X86_64 + Class: ELFCLASS[[BITS]] + Data: ELFDATA2LSB + Type: ET_DYN + Machine: EM_X86_64 Sections: - - Name: .dynamic - Type: SHT_DYNAMIC +## Test default values set by yaml2obj. + - Name: .dynamic + Type: SHT_DYNAMIC Flags: [ SHF_ALLOC, SHF_WRITE ] +## Test we can use an arbitrary value for sh_entsize. + - Name: .mydynamic + Type: SHT_DYNAMIC + EntSize: 0xFE -# SECTION: Name: .dynamic -# SECTION: EntrySize: 16 +# CHECK: Name: .dynamic +# CHECK: EntrySize: +# CHECK-SAME: {{^}} [[ENTSIZE]]{{$}} +# CHECK: Name: .mydynamic +# CHECK: EntrySize: +# CHECK-SAME: {{^}} 254{{$}} diff --git a/llvm/test/tools/yaml2obj/ELF/relocation-addend.yaml b/llvm/test/tools/yaml2obj/ELF/relocation-addend.yaml index 53396765fb59a5..f4ed870357f46f 100644 --- a/llvm/test/tools/yaml2obj/ELF/relocation-addend.yaml +++ b/llvm/test/tools/yaml2obj/ELF/relocation-addend.yaml @@ -2,36 +2,50 @@ ## Case 1: Check a 64-bit object. -## Case 1.1: Document we accept an addend with the -## value INT64_MAX = 2^63-1 = 0x7FFFFFFFFFFFFFFF = 9223372036854775807. +## Case 1.1: Document we accept any hex/decimal addends in [INT64_MIN, UINT64_MAX]. -# RUN: yaml2obj %s -o %t1 -D ADDEND=9223372036854775807 -# RUN: llvm-readobj -r %t1 | FileCheck %s --check-prefix=MAX64 -# RUN: yaml2obj %s -o %t2 -D ADDEND=0x7FFFFFFFFFFFFFFF -# RUN: llvm-readobj -r %t2 | FileCheck %s --check-prefix=MAX64 +## INT64_MIN == -9223372036854775808 +## UINT64_MAX == 0xffffffffffffffff -# MAX64: 0x0 R_X86_64_PC32 foo 0x7FFFFFFFFFFFFFFF +## Addend == UINT64_MAX. +# RUN: yaml2obj %s -o %t64.decimal.max -DADDEND=18446744073709551615 +# RUN: llvm-readobj -r %t64.decimal.max | FileCheck %s --check-prefix=TEST -DADDEND=0xFFFFFFFFFFFFFFFF +# RUN: yaml2obj %s -o %t64.hex.max -DADDEND=0xFFFFFFFFFFFFFFFF +# RUN: llvm-readobj -r %t64.hex.max | FileCheck %s --check-prefix=TEST -DADDEND=0xFFFFFFFFFFFFFFFF -## Case 1.2: Check we report an error when an addend is greater than INT64_MAX and -## it is in decimal form. We use (INT64_MAX + 1). -# RUN: not yaml2obj %s -o %t3 -D ADDEND=9223372036854775808 2>&1 | FileCheck %s --check-prefix=OVERFLOW64 +## Addend == first positive integer. +# RUN: yaml2obj %s -o %t64.decimal.first.pos -DADDEND=1 +# RUN: llvm-readobj -r %t64.decimal.first.pos | FileCheck %s --check-prefix=TEST -DADDEND=0x1 +# RUN: yaml2obj %s -o %t64.hex.first.pos -DADDEND=0x1 +# RUN: llvm-readobj -r %t64.hex.first.pos | FileCheck %s --check-prefix=TEST -DADDEND=0x1 -# OVERFLOW64: error: invalid number +## Addend == 0. +# RUN: yaml2obj %s -o %t64.decimal.null -DADDEND=0 +# RUN: llvm-readobj -r %t64.decimal.null | FileCheck %s --check-prefix=TEST -DADDEND=0x0 +# RUN: yaml2obj %s -o %t64.hex.null -DADDEND=0x0 +# RUN: llvm-readobj -r %t64.hex.null | FileCheck %s --check-prefix=TEST -DADDEND=0x0 -## Case 1.3: Document we accept an addend with the -## value INT64_MIN = -2^63 = 0x8000000000000000 = -9223372036854775808. +## Addend == first negative integer. +# RUN: yaml2obj %s -o %t64.decimal.first.neg -DADDEND=-1 +# RUN: llvm-readobj -r %t64.decimal.first.neg | FileCheck %s --check-prefix=TEST -DADDEND=0xFFFFFFFFFFFFFFFF +## We do not accept negative hex addends. +# RUN: not yaml2obj %s -o /dev/null -DADDEND=-0x1 2>&1 | FileCheck %s --check-prefix=ERR -# RUN: yaml2obj %s -o %t3 -D ADDEND=-9223372036854775808 -# RUN: llvm-readobj -r %t3 | FileCheck %s --check-prefix=MIN64 +## Addend == INT64_MIN. +# RUN: yaml2obj %s -o %t64.decimal.min -DADDEND=-9223372036854775808 +# RUN: llvm-readobj -r %t64.decimal.min | FileCheck %s --check-prefix=TEST -DADDEND=0x8000000000000000 +# TEST: 0x0 R_{{.*}}_PC32 foo [[ADDEND]] -# MIN64: 0x0 R_X86_64_PC32 foo 0x8000000000000000 +# Case 1.2: Document we do not accept any hex/decimal addends outside of the range specified. -## FIXME: We should support the following case instead. -# RUN: not yaml2obj %s -o /dev/null -D ADDEND=0x8000000000000000 2>&1 | FileCheck %s --check-prefix=OVERFLOW64 +## Addend == 2^64. +# RUN: not yaml2obj %s -o /dev/null -DADDEND=18446744073709551616 2>&1 | FileCheck %s --check-prefix=ERR +# RUN: not yaml2obj %s -o /dev/null -DADDEND=0x10000000000000000 2>&1 | FileCheck %s --check-prefix=ERR -## Case 1.4: Check we report an error when an addend is less than INT64_MIN and -## it is in decimal form. We use (INT64_MIN - 1). -# RUN: not yaml2obj %s -o /dev/null -D ADDEND=-9223372036854775809 2>&1 | FileCheck %s --check-prefix=OVERFLOW64 +## Addend == INT64_MIN - 1. +# RUN: not yaml2obj %s -o /dev/null -DADDEND=-9223372036854775809 2>&1 | FileCheck %s --check-prefix=ERR + +# ERR: invalid number --- !ELF FileHeader: @@ -55,43 +69,47 @@ Symbols: ## Case 2: Check a 32-bit object. -## Case 2.1: Document we accept an addend with the -## value INT32_MAX = 2^31-1 = 0x7FFFFFFF = 2,147,483,647. - -# RUN: yaml2obj --docnum=2 %s -o %t4 -D ADDEND=2147483647 -# RUN: llvm-readobj -r %t4 | FileCheck %s --check-prefix=MAX32 -# RUN: yaml2obj --docnum=2 %s -o %t5 -D ADDEND=0x7FFFFFFF -# RUN: cmp %t4 %t5 +## INT32_MIN == -2147483648 +## UINT32_MAX == 0xffffffff -# MAX32: 0x0 R_386_PC32 foo 0x7FFFFFFF{{$}} +## Case 2.1: Document we accept any hex/decimal addends in [INT32_MIN, UINT32_MAX]. -## Case 2.2: Check we report an error when an addend is greater than INT32_MAX and -## it is specified in decimal form. We use (INT32_MAX + 1). +## Addend == UINT32_MAX. +# RUN: yaml2obj --docnum=2 %s -o %t32.decimal.max -DADDEND=4294967295 +# RUN: llvm-readobj -r %t32.decimal.max | FileCheck %s --check-prefix=TEST -DADDEND=0xFFFFFFFF +# RUN: yaml2obj --docnum=2 %s -o %t32.hex.max -DADDEND=0xFFFFFFFF +# RUN: llvm-readobj -r %t32.hex.max | FileCheck %s --check-prefix=TEST -DADDEND=0xFFFFFFFF -## FIXME: The following case should fail, see OVERFLOW64. -# RUN: yaml2obj --docnum=2 %s -o %t6 -D ADDEND=2147483648 -# RUN: llvm-readobj -r %t6 | FileCheck %s --check-prefix=OVERFLOW32-1 +## Addend == first positive integer. +# RUN: yaml2obj --docnum=2 %s -o %t32.decimal.first.pos -DADDEND=1 +# RUN: llvm-readobj -r %t32.decimal.first.pos | FileCheck %s --check-prefix=TEST -DADDEND=0x1 +# RUN: yaml2obj --docnum=2 %s -o %t32.hex.first.pos -DADDEND=0x1 +# RUN: llvm-readobj -r %t32.hex.first.pos | FileCheck %s --check-prefix=TEST -DADDEND=0x1 -# OVERFLOW32-1: 0x0 R_386_PC32 foo 0x80000000{{$}} +## Addend == 0. +# RUN: yaml2obj --docnum=2 %s -o %t32.decimal.null -DADDEND=0 +# RUN: llvm-readobj -r %t32.decimal.null | FileCheck %s --check-prefix=TEST -DADDEND=0x0 +# RUN: yaml2obj --docnum=2 %s -o %t32.hex.null -DADDEND=0x0 +# RUN: llvm-readobj -r %t32.hex.null | FileCheck %s --check-prefix=TEST -DADDEND=0x0 -## Case 2.3: Document we accept an addend with the -## value INT32_MIN = -2^31 = 0x80000000 = -2,147,483,648. +## Addend == first negative integer. +# RUN: yaml2obj --docnum=2 %s -o %t32.decimal.first.neg -DADDEND=-1 +# RUN: llvm-readobj -r %t32.decimal.first.neg | FileCheck %s --check-prefix=TEST -DADDEND=0xFFFFFFFF +## We do not accept negative hex addends. +# RUN: not yaml2obj --docnum=2 %s -o /dev/null -DADDEND=-0x1 2>&1 | FileCheck %s --check-prefix=ERR -# RUN: yaml2obj --docnum=2 %s -o %t7 -D ADDEND=-2147483648 -# RUN: llvm-readobj -r %t7 | FileCheck %s --check-prefix=MIN32 -# RUN: yaml2obj --docnum=2 %s -o %t8 -D ADDEND=0x80000000 -# RUN: cmp %t7 %t8 +## Addend == INT32_MIN +# RUN: yaml2obj --docnum=2 %s -o %t32.decimal.min -DADDEND=-2147483648 +# RUN: llvm-readobj -r %t32.decimal.min | FileCheck %s --check-prefix=TEST -DADDEND=0x80000000 -# MIN32: 0x0 R_386_PC32 foo 0x80000000{{$}} +# Case 2.2: Document we do not accept any hex/decimal addends outside of the range specified. -## Case 2.4: Check we report an error when an addend is less than INT32_MIN and -## it is in decimal form. We use (INT32_MIN - 1). +## Addend == 2^32. +# RUN: not yaml2obj --docnum=2 %s -o /dev/null -DADDEND=4294967296 2>&1 | FileCheck %s --check-prefix=ERR +# RUN: not yaml2obj --docnum=2 %s -o /dev/null -DADDEND=0x100000000 2>&1 | FileCheck %s --check-prefix=ERR -## FIXME: The following case should fail, see OVERFLOW64. -# RUN: yaml2obj --docnum=2 %s -o %t9 -D ADDEND=-2147483649 -# RUN: llvm-readobj -r %t9 | FileCheck %s --check-prefix=OVERFLOW32-2 - -# OVERFLOW32-2: 0x0 R_386_PC32 foo 0x7FFFFFFF{{$}} +## Addend == INT32_MIN - 1. +# RUN: not yaml2obj --docnum=2 %s -o /dev/null -DADDEND=-2147483649 2>&1 | FileCheck %s --check-prefix=ERR --- !ELF FileHeader: @@ -112,3 +130,12 @@ Sections: Addend: [[ADDEND]] Symbols: - Name: foo + +## Case 3: Check we do not allow invalid values. +# RUN: not yaml2obj %s -D ADDEND=0x1122GGEE 2>&1 | FileCheck %s --check-prefix=ERR +# RUN: not yaml2obj %s -D ADDEND=-0x1122GGEE 2>&1 | FileCheck %s --check-prefix=ERR +# RUN: not yaml2obj %s -D ADDEND=1234G5 2>&1 | FileCheck %s --check-prefix=ERR +# RUN: not yaml2obj %s -D ADDEND=-1234G5 2>&1 | FileCheck %s --check-prefix=ERR +# RUN: not yaml2obj %s -D ADDEND=foo 2>&1 | FileCheck %s --check-prefix=ERR +# RUN: not yaml2obj %s -D ADDEND=- 2>&1 | FileCheck %s --check-prefix=ERR +# RUN: not yaml2obj %s -D ADDEND=--1234 2>&1 | FileCheck %s --check-prefix=ERR diff --git a/llvm/tools/llvm-objdump/llvm-objdump.cpp b/llvm/tools/llvm-objdump/llvm-objdump.cpp index 866fb53774913c..1cfd06d2cef5e6 100644 --- a/llvm/tools/llvm-objdump/llvm-objdump.cpp +++ b/llvm/tools/llvm-objdump/llvm-objdump.cpp @@ -16,9 +16,7 @@ //===----------------------------------------------------------------------===// #include "llvm-objdump.h" -#include "llvm/ADT/IndexedMap.h" #include "llvm/ADT/Optional.h" -#include "llvm/ADT/SmallSet.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SetOperations.h" #include "llvm/ADT/StringExtras.h" @@ -72,8 +70,6 @@ #include #include -#define DEBUG_TYPE "objdump" - using namespace llvm::object; namespace llvm { @@ -338,28 +334,6 @@ static cl::opt cl::cat(ObjdumpCat)); static cl::alias WideShort("w", cl::Grouping, cl::aliasopt(Wide)); -enum DebugVarsFormat { - DVDisabled, - DVUnicode, - DVASCII, -}; - -static cl::opt DbgVariables( - "debug-vars", cl::init(DVDisabled), - cl::desc("Print the locations (in registers or memory) of " - "source-level variables alongside disassembly"), - cl::ValueOptional, - cl::values(clEnumValN(DVUnicode, "", "unicode"), - clEnumValN(DVUnicode, "unicode", "unicode"), - clEnumValN(DVASCII, "ascii", "unicode")), - cl::cat(ObjdumpCat)); - -static cl::opt - DbgIndent("debug-vars-indent", cl::init(40), - cl::desc("Distance to indent the source-level variable display, " - "relative to the start of the disassembly"), - cl::cat(ObjdumpCat)); - static cl::extrahelp HelpResponse("\nPass @FILE as argument to read options from FILE.\n"); @@ -562,357 +536,6 @@ static bool getHidden(RelocationRef RelRef) { } namespace { - -/// Get the column at which we want to start printing the instruction -/// disassembly, taking into account anything which appears to the left of it. -unsigned getInstStartColumn() { - return NoShowRawInsn ? 16 : 40; -} - -/// Stores a single expression representing the location of a source-level -/// variable, along with the PC range for which that expression is valid. -struct LiveVariable { - DWARFLocationExpression LocExpr; - const char *VarName; - DWARFUnit *Unit; - const DWARFDie FuncDie; - - LiveVariable(const DWARFLocationExpression &LocExpr, const char *VarName, - DWARFUnit *Unit, const DWARFDie FuncDie) - : LocExpr(LocExpr), VarName(VarName), Unit(Unit), FuncDie(FuncDie) {} - - bool liveAtAddress(object::SectionedAddress Addr) { - if (LocExpr.Range == None) - return false; - return LocExpr.Range->SectionIndex == Addr.SectionIndex && - LocExpr.Range->LowPC <= Addr.Address && - LocExpr.Range->HighPC > Addr.Address; - } - - void print(raw_ostream &OS, const MCRegisterInfo &MRI) const { - DataExtractor Data({LocExpr.Expr.data(), LocExpr.Expr.size()}, - Unit->getContext().isLittleEndian(), 0); - DWARFExpression Expression(Data, Unit->getAddressByteSize()); - Expression.printCompact(OS, MRI); - } -}; - -/// Helper class for printing source variable locations alongside disassembly. -class LiveVariablePrinter { - // Information we want to track about one column in which we are printing a - // variable live range. - struct Column { - unsigned VarIdx = NullVarIdx; - bool LiveIn = false; - bool LiveOut = false; - bool MustDrawLabel = false; - - bool isActive() const { return VarIdx != NullVarIdx; } - - static constexpr unsigned NullVarIdx = std::numeric_limits::max(); - }; - - // All live variables we know about in the object/image file. - std::vector LiveVariables; - - // The columns we are currently drawing. - IndexedMap ActiveCols; - - const MCRegisterInfo &MRI; - - void addVariable(DWARFDie FuncDie, DWARFDie VarDie) { - uint64_t FuncLowPC, FuncHighPC, SectionIndex; - FuncDie.getLowAndHighPC(FuncLowPC, FuncHighPC, SectionIndex); - const char *VarName = VarDie.getName(DINameKind::ShortName); - DWARFUnit *U = VarDie.getDwarfUnit(); - - Expected Locs = - VarDie.getLocations(dwarf::DW_AT_location); - if (!Locs) { - // If the variable doesn't have any locations, just ignore it. We don't - // report an error or warning here as that could be noisy on optimised - // code. - consumeError(Locs.takeError()); - return; - } - - for (const DWARFLocationExpression &LocExpr : *Locs) { - if (LocExpr.Range) { - LiveVariables.emplace_back(LocExpr, VarName, U, FuncDie); - } else { - // If the LocExpr does not have an associated range, it is valid for - // the whole of the function. - // TODO: technically it is not valid for any range covered by another - // LocExpr, does that happen in reality? - DWARFLocationExpression WholeFuncExpr{ - DWARFAddressRange(FuncLowPC, FuncHighPC, SectionIndex), - LocExpr.Expr}; - LiveVariables.emplace_back(WholeFuncExpr, VarName, U, FuncDie); - } - } - } - - void addFunction(DWARFDie D) { - for (const DWARFDie &Child : D.children()) { - if (Child.getTag() == dwarf::DW_TAG_variable || - Child.getTag() == dwarf::DW_TAG_formal_parameter) - addVariable(D, Child); - else - addFunction(Child); - } - } - - // Get the column number (in characters) at which the first live variable - // line should be printed. - unsigned getIndentLevel() const { - return DbgIndent + getInstStartColumn(); - } - - // Indent to the first live-range column to the right of the currently - // printed line, and return the index of that column. - // TODO: formatted_raw_ostream uses "column" to mean a number of characters - // since the last \n, and we use it to mean the number of slots in which we - // put live variable lines. Pick a less overloaded word. - unsigned moveToFirstVarColumn(formatted_raw_ostream &OS) { - // Logical column number: column zero is the first column we print in, each - // logical column is 2 physical columns wide. - unsigned FirstUnprintedLogicalColumn = - std::max((int)(OS.getColumn() - getIndentLevel() + 1) / 2, 0); - // Physical column number: the actual column number in characters, with - // zero being the left-most side of the screen. - unsigned FirstUnprintedPhysicalColumn = - getIndentLevel() + FirstUnprintedLogicalColumn * 2; - - if (FirstUnprintedPhysicalColumn > OS.getColumn()) - OS.PadToColumn(FirstUnprintedPhysicalColumn); - - return FirstUnprintedLogicalColumn; - } - - unsigned findFreeColumn() { - for (unsigned ColIdx = 0; ColIdx < ActiveCols.size(); ++ColIdx) - if (!ActiveCols[ColIdx].isActive()) - return ColIdx; - - size_t OldSize = ActiveCols.size(); - ActiveCols.grow(std::max(OldSize * 2, 1)); - return OldSize; - } - -public: - LiveVariablePrinter(const MCRegisterInfo &MRI) - : LiveVariables(), ActiveCols(Column()), MRI(MRI) {} - - void dump() const { - for (const LiveVariable &LV : LiveVariables) { - dbgs() << LV.VarName << " @ " << LV.LocExpr.Range << ": "; - LV.print(dbgs(), MRI); - dbgs() << "\n"; - } - } - - void addCompileUnit(DWARFDie D) { - if (D.getTag() == dwarf::DW_TAG_subprogram) - addFunction(D); - else - for (const DWARFDie &Child : D.children()) - addFunction(Child); - } - - /// Update to match the state of the instruction between ThisAddr and - /// NextAddr. In the common case, any live range active at ThisAddr is - /// live-in to the instruction, and any live range active at NextAddr is - /// live-out of the instruction. If IncludeDefinedVars is false, then live - /// ranges starting at NextAddr will be ignored. - void update(object::SectionedAddress ThisAddr, - object::SectionedAddress NextAddr, bool IncludeDefinedVars) { - // First, check variables which have already been assigned a column, so - // that we don't change their order. - SmallSet CheckedVarIdxs; - for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) { - if (!ActiveCols[ColIdx].isActive()) - continue; - CheckedVarIdxs.insert(ActiveCols[ColIdx].VarIdx); - LiveVariable &LV = LiveVariables[ActiveCols[ColIdx].VarIdx]; - ActiveCols[ColIdx].LiveIn = LV.liveAtAddress(ThisAddr); - ActiveCols[ColIdx].LiveOut = LV.liveAtAddress(NextAddr); - LLVM_DEBUG(dbgs() << "pass 1, " << ThisAddr.Address << "-" - << NextAddr.Address << ", " << LV.VarName << ", Col " - << ColIdx << ": LiveIn=" << ActiveCols[ColIdx].LiveIn - << ", LiveOut=" << ActiveCols[ColIdx].LiveOut << "\n"); - - if (!ActiveCols[ColIdx].LiveIn && !ActiveCols[ColIdx].LiveOut) - ActiveCols[ColIdx].VarIdx = Column::NullVarIdx; - } - - // Next, look for variables which don't already have a column, but which - // are now live. - if (IncludeDefinedVars) { - for (unsigned VarIdx = 0, End = LiveVariables.size(); VarIdx < End; - ++VarIdx) { - if (CheckedVarIdxs.count(VarIdx)) - continue; - LiveVariable &LV = LiveVariables[VarIdx]; - bool LiveIn = LV.liveAtAddress(ThisAddr); - bool LiveOut = LV.liveAtAddress(NextAddr); - if (!LiveIn && !LiveOut) - continue; - - unsigned ColIdx = findFreeColumn(); - LLVM_DEBUG(dbgs() << "pass 2, " << ThisAddr.Address << "-" - << NextAddr.Address << ", " << LV.VarName << ", Col " - << ColIdx << ": LiveIn=" << LiveIn - << ", LiveOut=" << LiveOut << "\n"); - ActiveCols[ColIdx].VarIdx = VarIdx; - ActiveCols[ColIdx].LiveIn = LiveIn; - ActiveCols[ColIdx].LiveOut = LiveOut; - ActiveCols[ColIdx].MustDrawLabel = true; - } - } - } - - enum class LineChar { - RangeStart, - RangeMid, - RangeEnd, - LabelVert, - LabelCornerNew, - LabelCornerActive, - LabelHoriz, - }; - const char *getLineChar(LineChar C) const { - bool IsASCII = DbgVariables == DVASCII; - switch (C) { - case LineChar::RangeStart: - return IsASCII ? "^" : "╈"; - case LineChar::RangeMid: - return IsASCII ? "|" : "┃"; - case LineChar::RangeEnd: - return IsASCII ? "v" : "â”»"; - case LineChar::LabelVert: - return IsASCII ? "|" : "│"; - case LineChar::LabelCornerNew: - return IsASCII ? "/" : "┌"; - case LineChar::LabelCornerActive: - return IsASCII ? "|" : "â” "; - case LineChar::LabelHoriz: - return IsASCII ? "-" : "─"; - } - llvm_unreachable("Unexpected LineChar"); - } - - /// Print live ranges to the right of an existing line. This assumes the - /// line is not an instruction, so doesn't start or end any live ranges, so - /// we only need to print active ranges or empty columns. If AfterInst is - /// true, this is being printed after the last instruction fed to update(), - /// otherwise this is being printed before it. - void printAfterOtherLine(formatted_raw_ostream &OS, bool AfterInst) { - if (ActiveCols.size()) { - unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS); - for (size_t ColIdx = FirstUnprintedColumn, End = ActiveCols.size(); - ColIdx < End; ++ColIdx) { - if (ActiveCols[ColIdx].isActive()) { - if ((AfterInst && ActiveCols[ColIdx].LiveOut) || - (!AfterInst && ActiveCols[ColIdx].LiveIn)) - OS << getLineChar(LineChar::RangeMid); - else if (!AfterInst && ActiveCols[ColIdx].LiveOut) - OS << getLineChar(LineChar::LabelVert); - else - OS << " "; - } - OS << " "; - } - } - OS << "\n"; - } - - /// Print any live variable range info needed to the right of a - /// non-instruction line of disassembly. This is where we print the variable - /// names and expressions, with thin line-drawing characters connecting them - /// to the live range which starts at the next instruction. If MustPrint is - /// true, we have to print at least one line (with the continuation of any - /// already-active live ranges) because something has already been printed - /// earlier on this line. - void printBetweenInsts(formatted_raw_ostream &OS, bool MustPrint) { - bool PrintedSomething = false; - for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) { - if (ActiveCols[ColIdx].isActive() && ActiveCols[ColIdx].MustDrawLabel) { - // First we need to print the live range markers for any active - // columns to the left of this one. - OS.PadToColumn(getIndentLevel()); - for (unsigned ColIdx2 = 0; ColIdx2 < ColIdx; ++ColIdx2) { - if (ActiveCols[ColIdx2].isActive()) { - if (ActiveCols[ColIdx2].MustDrawLabel && - !ActiveCols[ColIdx2].LiveIn) - OS << getLineChar(LineChar::LabelVert) << " "; - else - OS << getLineChar(LineChar::RangeMid) << " "; - } else - OS << " "; - } - - // Then print the variable name and location of the new live range, - // with box drawing characters joining it to the live range line. - OS << getLineChar(ActiveCols[ColIdx].LiveIn - ? LineChar::LabelCornerActive - : LineChar::LabelCornerNew) - << getLineChar(LineChar::LabelHoriz) << " "; - WithColor(OS, raw_ostream::GREEN) - << LiveVariables[ActiveCols[ColIdx].VarIdx].VarName; - OS << " = "; - { - WithColor ExprColor(OS, raw_ostream::CYAN); - LiveVariables[ActiveCols[ColIdx].VarIdx].print(OS, MRI); - } - - // If there are any columns to the right of the expression we just - // printed, then continue their live range lines. - unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS); - for (unsigned ColIdx2 = FirstUnprintedColumn, End = ActiveCols.size(); - ColIdx2 < End; ++ColIdx2) { - if (ActiveCols[ColIdx2].isActive() && ActiveCols[ColIdx2].LiveIn) - OS << getLineChar(LineChar::RangeMid) << " "; - else - OS << " "; - } - - OS << "\n"; - PrintedSomething = true; - } - } - - for (unsigned ColIdx = 0, End = ActiveCols.size(); ColIdx < End; ++ColIdx) - if (ActiveCols[ColIdx].isActive()) - ActiveCols[ColIdx].MustDrawLabel = false; - - // If we must print something (because we printed a line/column number), - // but don't have any new variables to print, then print a line which - // just continues any existing live ranges. - if (MustPrint && !PrintedSomething) - printAfterOtherLine(OS, false); - } - - /// Print the live variable ranges to the right of a disassembled instruction. - void printAfterInst(formatted_raw_ostream &OS) { - if (!ActiveCols.size()) - return; - unsigned FirstUnprintedColumn = moveToFirstVarColumn(OS); - for (unsigned ColIdx = FirstUnprintedColumn, End = ActiveCols.size(); - ColIdx < End; ++ColIdx) { - if (!ActiveCols[ColIdx].isActive()) - OS << " "; - else if (ActiveCols[ColIdx].LiveIn && ActiveCols[ColIdx].LiveOut) - OS << getLineChar(LineChar::RangeMid) << " "; - else if (ActiveCols[ColIdx].LiveOut) - OS << getLineChar(LineChar::RangeStart) << " "; - else if (ActiveCols[ColIdx].LiveIn) - OS << getLineChar(LineChar::RangeEnd) << " "; - else - llvm_unreachable("var must be live in or out!"); - } - } -}; - class SourcePrinter { protected: DILineInfo OldLineInfo; @@ -930,12 +553,11 @@ class SourcePrinter { private: bool cacheSource(const DILineInfo& LineInfoFile); - void printLines(formatted_raw_ostream &OS, const DILineInfo &LineInfo, - StringRef Delimiter, LiveVariablePrinter &LVP); + void printLines(raw_ostream &OS, const DILineInfo &LineInfo, + StringRef Delimiter); - void printSources(formatted_raw_ostream &OS, const DILineInfo &LineInfo, - StringRef ObjectFilename, StringRef Delimiter, - LiveVariablePrinter &LVP); + void printSources(raw_ostream &OS, const DILineInfo &LineInfo, + StringRef ObjectFilename, StringRef Delimiter); public: SourcePrinter() = default; @@ -949,10 +571,9 @@ class SourcePrinter { Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts)); } virtual ~SourcePrinter() = default; - virtual void printSourceLine(formatted_raw_ostream &OS, + virtual void printSourceLine(raw_ostream &OS, object::SectionedAddress Address, StringRef ObjectFilename, - LiveVariablePrinter &LVP, StringRef Delimiter = "; "); }; @@ -986,10 +607,9 @@ bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) { return true; } -void SourcePrinter::printSourceLine(formatted_raw_ostream &OS, +void SourcePrinter::printSourceLine(raw_ostream &OS, object::SectionedAddress Address, StringRef ObjectFilename, - LiveVariablePrinter &LVP, StringRef Delimiter) { if (!Symbolizer) return; @@ -1014,15 +634,14 @@ void SourcePrinter::printSourceLine(formatted_raw_ostream &OS, } if (PrintLines) - printLines(OS, LineInfo, Delimiter, LVP); + printLines(OS, LineInfo, Delimiter); if (PrintSource) - printSources(OS, LineInfo, ObjectFilename, Delimiter, LVP); + printSources(OS, LineInfo, ObjectFilename, Delimiter); OldLineInfo = LineInfo; } -void SourcePrinter::printLines(formatted_raw_ostream &OS, - const DILineInfo &LineInfo, StringRef Delimiter, - LiveVariablePrinter &LVP) { +void SourcePrinter::printLines(raw_ostream &OS, const DILineInfo &LineInfo, + StringRef Delimiter) { bool PrintFunctionName = LineInfo.FunctionName != DILineInfo::BadString && LineInfo.FunctionName != OldLineInfo.FunctionName; if (PrintFunctionName) { @@ -1035,16 +654,13 @@ void SourcePrinter::printLines(formatted_raw_ostream &OS, } if (LineInfo.FileName != DILineInfo::BadString && LineInfo.Line != 0 && (OldLineInfo.Line != LineInfo.Line || - OldLineInfo.FileName != LineInfo.FileName || PrintFunctionName)) { - OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line; - LVP.printBetweenInsts(OS, true); - } + OldLineInfo.FileName != LineInfo.FileName || PrintFunctionName)) + OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line << "\n"; } -void SourcePrinter::printSources(formatted_raw_ostream &OS, - const DILineInfo &LineInfo, - StringRef ObjectFilename, StringRef Delimiter, - LiveVariablePrinter &LVP) { +void SourcePrinter::printSources(raw_ostream &OS, const DILineInfo &LineInfo, + StringRef ObjectFilename, + StringRef Delimiter) { if (LineInfo.FileName == DILineInfo::BadString || LineInfo.Line == 0 || (OldLineInfo.Line == LineInfo.Line && OldLineInfo.FileName == LineInfo.FileName)) @@ -1064,8 +680,7 @@ void SourcePrinter::printSources(formatted_raw_ostream &OS, return; } // Vector begins at 0, line numbers are non-zero - OS << Delimiter << LineBuffer->second[LineInfo.Line - 1]; - LVP.printBetweenInsts(OS, true); + OS << Delimiter << LineBuffer->second[LineInfo.Line - 1] << '\n'; } } @@ -1083,30 +698,28 @@ static bool hasMappingSymbols(const ObjectFile *Obj) { return isArmElf(Obj) || isAArch64Elf(Obj); } -static void printRelocation(formatted_raw_ostream &OS, StringRef FileName, - const RelocationRef &Rel, uint64_t Address, - bool Is64Bits) { +static void printRelocation(StringRef FileName, const RelocationRef &Rel, + uint64_t Address, bool Is64Bits) { StringRef Fmt = Is64Bits ? "\t\t%016" PRIx64 ": " : "\t\t\t%08" PRIx64 ": "; SmallString<16> Name; SmallString<32> Val; Rel.getTypeName(Name); if (Error E = getRelocationValueString(Rel, Val)) reportError(std::move(E), FileName); - OS << format(Fmt.data(), Address) << Name << "\t" << Val; + outs() << format(Fmt.data(), Address) << Name << "\t" << Val << "\n"; } class PrettyPrinter { public: virtual ~PrettyPrinter() = default; - virtual void - printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef Bytes, - object::SectionedAddress Address, formatted_raw_ostream &OS, - StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP, - StringRef ObjectFilename, std::vector *Rels, - LiveVariablePrinter &LVP) { + virtual void printInst(MCInstPrinter &IP, const MCInst *MI, + ArrayRef Bytes, + object::SectionedAddress Address, raw_ostream &OS, + StringRef Annot, MCSubtargetInfo const &STI, + SourcePrinter *SP, StringRef ObjectFilename, + std::vector *Rels = nullptr) { if (SP && (PrintSource || PrintLines)) - SP->printSourceLine(OS, Address, ObjectFilename, LVP); - LVP.printBetweenInsts(OS, false); + SP->printSourceLine(OS, Address, ObjectFilename); size_t Start = OS.tell(); if (!NoLeadingAddr) @@ -1118,7 +731,7 @@ class PrettyPrinter { // The output of printInst starts with a tab. Print some spaces so that // the tab has 1 column and advances to the target tab stop. - unsigned TabStop = getInstStartColumn(); + unsigned TabStop = NoShowRawInsn ? 16 : 40; unsigned Column = OS.tell() - Start; OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8); @@ -1133,7 +746,7 @@ PrettyPrinter PrettyPrinterInst; class HexagonPrettyPrinter : public PrettyPrinter { public: void printLead(ArrayRef Bytes, uint64_t Address, - formatted_raw_ostream &OS) { + raw_ostream &OS) { uint32_t opcode = (Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | Bytes[0]; if (!NoLeadingAddr) @@ -1145,12 +758,12 @@ class HexagonPrettyPrinter : public PrettyPrinter { } } void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef Bytes, - object::SectionedAddress Address, formatted_raw_ostream &OS, + object::SectionedAddress Address, raw_ostream &OS, StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP, - StringRef ObjectFilename, std::vector *Rels, - LiveVariablePrinter &LVP) override { + StringRef ObjectFilename, + std::vector *Rels) override { if (SP && (PrintSource || PrintLines)) - SP->printSourceLine(OS, Address, ObjectFilename, LVP, ""); + SP->printSourceLine(OS, Address, ObjectFilename, ""); if (!MI) { printLead(Bytes, Address.Address, OS); OS << " "; @@ -1176,7 +789,7 @@ class HexagonPrettyPrinter : public PrettyPrinter { auto PrintReloc = [&]() -> void { while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address.Address)) { if (RelCur->getOffset() == Address.Address) { - printRelocation(OS, ObjectFilename, *RelCur, Address.Address, false); + printRelocation(ObjectFilename, *RelCur, Address.Address, false); return; } ++RelCur; @@ -1187,7 +800,7 @@ class HexagonPrettyPrinter : public PrettyPrinter { OS << Separator; Separator = "\n"; if (SP && (PrintSource || PrintLines)) - SP->printSourceLine(OS, Address, ObjectFilename, LVP, ""); + SP->printSourceLine(OS, Address, ObjectFilename, ""); printLead(Bytes, Address.Address, OS); OS << Preamble; Preamble = " "; @@ -1215,12 +828,12 @@ HexagonPrettyPrinter HexagonPrettyPrinterInst; class AMDGCNPrettyPrinter : public PrettyPrinter { public: void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef Bytes, - object::SectionedAddress Address, formatted_raw_ostream &OS, + object::SectionedAddress Address, raw_ostream &OS, StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP, - StringRef ObjectFilename, std::vector *Rels, - LiveVariablePrinter &LVP) override { + StringRef ObjectFilename, + std::vector *Rels) override { if (SP && (PrintSource || PrintLines)) - SP->printSourceLine(OS, Address, ObjectFilename, LVP); + SP->printSourceLine(OS, Address, ObjectFilename); if (MI) { SmallString<40> InstStr; @@ -1267,12 +880,12 @@ AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst; class BPFPrettyPrinter : public PrettyPrinter { public: void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef Bytes, - object::SectionedAddress Address, formatted_raw_ostream &OS, + object::SectionedAddress Address, raw_ostream &OS, StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP, - StringRef ObjectFilename, std::vector *Rels, - LiveVariablePrinter &LVP) override { + StringRef ObjectFilename, + std::vector *Rels) override { if (SP && (PrintSource || PrintLines)) - SP->printSourceLine(OS, Address, ObjectFilename, LVP); + SP->printSourceLine(OS, Address, ObjectFilename); if (!NoLeadingAddr) OS << format("%8" PRId64 ":", Address.Address / 8); if (!NoShowRawInsn) { @@ -1458,34 +1071,33 @@ static char getMappingSymbolKind(ArrayRef MappingSymbols, return (It - 1)->second; } -static uint64_t dumpARMELFData(uint64_t SectionAddr, uint64_t Index, - uint64_t End, const ObjectFile *Obj, - ArrayRef Bytes, - ArrayRef MappingSymbols, - raw_ostream &OS) { +static uint64_t +dumpARMELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End, + const ObjectFile *Obj, ArrayRef Bytes, + ArrayRef MappingSymbols) { support::endianness Endian = Obj->isLittleEndian() ? support::little : support::big; while (Index < End) { - OS << format("%8" PRIx64 ":", SectionAddr + Index); - OS << "\t"; + outs() << format("%8" PRIx64 ":", SectionAddr + Index); + outs() << "\t"; if (Index + 4 <= End) { - dumpBytes(Bytes.slice(Index, 4), OS); - OS << "\t.word\t" + dumpBytes(Bytes.slice(Index, 4), outs()); + outs() << "\t.word\t" << format_hex( support::endian::read32(Bytes.data() + Index, Endian), 10); Index += 4; } else if (Index + 2 <= End) { - dumpBytes(Bytes.slice(Index, 2), OS); - OS << "\t\t.short\t" + dumpBytes(Bytes.slice(Index, 2), outs()); + outs() << "\t\t.short\t" << format_hex( support::endian::read16(Bytes.data() + Index, Endian), 6); Index += 2; } else { - dumpBytes(Bytes.slice(Index, 1), OS); - OS << "\t\t.byte\t" << format_hex(Bytes[0], 4); + dumpBytes(Bytes.slice(Index, 1), outs()); + outs() << "\t\t.byte\t" << format_hex(Bytes[0], 4); ++Index; } - OS << "\n"; + outs() << "\n"; if (getMappingSymbolKind(MappingSymbols, Index) != 'd') break; } @@ -1630,17 +1242,6 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, array_pod_sort(SecSyms.second.begin(), SecSyms.second.end()); array_pod_sort(AbsoluteSymbols.begin(), AbsoluteSymbols.end()); - std::unique_ptr DICtx; - LiveVariablePrinter LVP(*Ctx.getRegisterInfo()); - - if (DbgVariables != DVDisabled) { - DICtx = DWARFContext::create(*Obj); - for (const std::unique_ptr &CU : DICtx->compile_units()) - LVP.addCompileUnit(CU->getUnitDIE(false)); - } - - LLVM_DEBUG(LVP.dump()); - for (const SectionRef &Section : ToolSectionFilter(*Obj)) { if (FilterSections.empty() && !DisassembleAll && (!Section.isText() || Section.isVirtual())) @@ -1804,7 +1405,6 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, bool CheckARMELFData = hasMappingSymbols(Obj) && Symbols[SI].Type != ELF::STT_OBJECT && !DisassembleAll; - formatted_raw_ostream FOS(outs()); while (Index < End) { // ARM and AArch64 ELF binaries can interleave data and text in the // same section. We rely on the markers introduced to understand what @@ -1813,7 +1413,7 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, if (CheckARMELFData && getMappingSymbolKind(MappingSymbols, Index) == 'd') { Index = dumpARMELFData(SectionAddr, Index, End, Obj, Bytes, - MappingSymbols, FOS); + MappingSymbols); continue; } @@ -1828,7 +1428,7 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, if (size_t N = countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) { - FOS << "\t\t..." << '\n'; + outs() << "\t\t..." << '\n'; Index += N; continue; } @@ -1852,20 +1452,17 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, if (Size == 0) Size = 1; - LVP.update({Index, Section.getIndex()}, - {Index + Size, Section.getIndex()}, Index + Size != End); - PIP.printInst(*IP, Disassembled ? &Inst : nullptr, Bytes.slice(Index, Size), {SectionAddr + Index + VMAAdjustment, Section.getIndex()}, - FOS, "", *STI, &SP, Obj->getFileName(), &Rels, LVP); - FOS << CommentStream.str(); + outs(), "", *STI, &SP, Obj->getFileName(), &Rels); + outs() << CommentStream.str(); Comments.clear(); // If disassembly has failed, continue with the next instruction, to // avoid analysing invalid/incomplete instruction information. if (!Disassembled) { - FOS << "\n"; + outs() << "\n"; Index += Size; continue; } @@ -1918,17 +1515,15 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, --TargetSym; uint64_t TargetAddress = TargetSym->Addr; StringRef TargetName = TargetSym->Name; - FOS << " <" << TargetName; + outs() << " <" << TargetName; uint64_t Disp = Target - TargetAddress; if (Disp) - FOS << "+0x" << Twine::utohexstr(Disp); - FOS << '>'; + outs() << "+0x" << Twine::utohexstr(Disp); + outs() << '>'; } } } - - LVP.printAfterInst(FOS); - FOS << "\n"; + outs() << "\n"; // Hexagon does this in pretty printer if (Obj->getArch() != Triple::hexagon) { @@ -1954,9 +1549,8 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, Offset += AdjustVMA; } - printRelocation(FOS, Obj->getFileName(), *RelCur, - SectionAddr + Offset, Is64Bits); - LVP.printAfterOtherLine(FOS, true); + printRelocation(Obj->getFileName(), *RelCur, SectionAddr + Offset, + Is64Bits); ++RelCur; } } diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp b/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp index d359ab203a78ca..9407a9437bcc99 100644 --- a/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp +++ b/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp @@ -2341,4 +2341,179 @@ TEST_F(GISelMITest, NarrowScalarExtract) { // Check EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF; } + +TEST_F(GISelMITest, LowerInsert) { + setUp(); + if (!TM) + return; + + // Declare your legalization info + DefineLegalizerInfo(A, { getActionDefinitionsBuilder(G_INSERT).lower(); }); + + LLT S32{LLT::scalar(32)}; + LLT S64{LLT::scalar(64)}; + LLT P0{LLT::pointer(0, 64)}; + LLT P1{LLT::pointer(1, 32)}; + LLT V2S32{LLT::vector(2, 32)}; + + auto TruncS32 = B.buildTrunc(S32, Copies[0]); + auto IntToPtrP0 = B.buildIntToPtr(P0, Copies[0]); + auto IntToPtrP1 = B.buildIntToPtr(P1, TruncS32); + auto BitcastV2S32 = B.buildBitcast(V2S32, Copies[0]); + + auto InsertS64S32 = B.buildInsert(S64, Copies[0], TruncS32, 0); + auto InsertS64P1 = B.buildInsert(S64, Copies[0], IntToPtrP1, 8); + auto InsertP0S32 = B.buildInsert(P0, IntToPtrP0, TruncS32, 16); + auto InsertP0P1 = B.buildInsert(P0, IntToPtrP0, IntToPtrP1, 4); + auto InsertV2S32S32 = B.buildInsert(V2S32, BitcastV2S32, TruncS32, 32); + auto InsertV2S32P1 = B.buildInsert(V2S32, BitcastV2S32, IntToPtrP1, 0); + + AInfo Info(MF->getSubtarget()); + DummyGISelObserver Observer; + LegalizerHelper Helper(*MF, Info, Observer, B); + + EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized, + Helper.lower(*InsertS64S32, 0, LLT{})); + + EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized, + Helper.lower(*InsertS64P1, 0, LLT{})); + + EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized, + Helper.lower(*InsertP0S32, 0, LLT{})); + + EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized, + Helper.lower(*InsertP0P1, 0, LLT{})); + + EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized, + Helper.lower(*InsertV2S32S32, 0, LLT{})); + + EXPECT_EQ(LegalizerHelper::LegalizeResult::UnableToLegalize, + Helper.lower(*InsertV2S32P1, 0, LLT{})); + + const auto *CheckStr = R"( + CHECK: [[S64:%[0-9]+]]:_(s64) = COPY + CHECK: [[S32:%[0-9]+]]:_(s32) = G_TRUNC [[S64]] + CHECK: [[P0:%[0-9]+]]:_(p0) = G_INTTOPTR [[S64]] + CHECK: [[P1:%[0-9]+]]:_(p1) = G_INTTOPTR [[S32]] + CHECK: [[V2S32:%[0-9]+]]:_(<2 x s32>) = G_BITCAST [[S64]] + CHECK: [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[S32]] + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[AND:%[0-9]+]]:_(s64) = G_AND [[S64]]:_, [[C]]:_ + CHECK: [[OR:%[0-9]+]]:_(s64) = G_OR [[AND]]:_, [[ZEXT]]:_ + + CHECK: [[PTRTOINT:%[0-9]+]]:_(s32) = G_PTRTOINT [[P1]] + CHECK: [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[PTRTOINT]] + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[SHL:%[0-9]+]]:_(s64) = G_SHL [[ZEXT]]:_, [[C]]:_(s64) + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[AND:%[0-9]+]]:_(s64) = G_AND [[S64]]:_, [[C]]:_ + CHECK: [[OR:%[0-9]+]]:_(s64) = G_OR [[AND]]:_, [[SHL]]:_ + + CHECK: [[PTRTOINT:%[0-9]+]]:_(s64) = G_PTRTOINT [[P0]] + CHECK: [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[S32]] + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[SHL:%[0-9]+]]:_(s64) = G_SHL [[ZEXT]]:_, [[C]]:_(s64) + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[AND:%[0-9]+]]:_(s64) = G_AND [[PTRTOINT]]:_, [[C]]:_ + CHECK: [[OR:%[0-9]+]]:_(s64) = G_OR [[AND]]:_, [[SHL]]:_ + CHECK: [[INTTOPTR:%[0-9]+]]:_(p0) = G_INTTOPTR [[OR]] + + CHECK: [[PTRTOINT:%[0-9]+]]:_(s64) = G_PTRTOINT [[P0]] + CHECK: [[PTRTOINT1:%[0-9]+]]:_(s32) = G_PTRTOINT [[P1]] + CHECK: [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[PTRTOINT1]] + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[SHL:%[0-9]+]]:_(s64) = G_SHL [[ZEXT]]:_, [[C]]:_(s64) + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[AND:%[0-9]+]]:_(s64) = G_AND [[PTRTOINT]]:_, [[C]]:_ + CHECK: [[OR:%[0-9]+]]:_(s64) = G_OR [[AND]]:_, [[SHL]]:_ + CHECK: [[INTTOPTR:%[0-9]+]]:_(p0) = G_INTTOPTR [[OR]] + + CHECK: [[BITCAST:%[0-9]+]]:_(s64) = G_BITCAST [[V2S32]] + CHECK: [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[S32]] + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[SHL:%[0-9]+]]:_(s64) = G_SHL [[ZEXT]]:_, [[C]]:_(s64) + CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT + CHECK: [[AND:%[0-9]+]]:_(s64) = G_AND [[BITCAST]]:_, [[C]]:_ + CHECK: [[OR:%[0-9]+]]:_(s64) = G_OR [[AND]]:_, [[SHL]]:_ + CHECK: [[BITCAST:%[0-9]+]]:_(<2 x s32>) = G_BITCAST [[OR]] + )"; + + // Check + EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF; +} + +// Test lowering of G_FFLOOR +TEST_F(GISelMITest, LowerFFloor) { + setUp(); + if (!TM) + return; + + // Declare your legalization info + DefineLegalizerInfo(A, {}); + // Build Instr + auto Floor = B.buildFFloor(LLT::scalar(64), Copies[0], MachineInstr::MIFlag::FmNoInfs); + AInfo Info(MF->getSubtarget()); + DummyGISelObserver Observer; + LegalizerHelper Helper(*MF, Info, Observer, B); + // Perform Legalization + EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized, + Helper.lower(*Floor, 0, LLT())); + + auto CheckStr = R"( + CHECK: [[COPY:%[0-9]+]]:_(s64) = COPY + CHECK: [[TRUNC:%[0-9]+]]:_(s64) = ninf G_INTRINSIC_TRUNC [[COPY]] + CHECK: [[ZERO:%[0-9]+]]:_(s64) = G_FCONSTANT double 0.000000e+00 + CHECK: [[CMP0:%[0-9]+]]:_(s1) = ninf G_FCMP floatpred(olt), [[COPY]]:_(s64), [[ZERO]]:_ + CHECK: [[CMP1:%[0-9]+]]:_(s1) = ninf G_FCMP floatpred(one), [[COPY]]:_(s64), [[TRUNC]]:_ + CHECK: [[AND:%[0-9]+]]:_(s1) = G_AND [[CMP0]]:_, [[CMP1]]:_ + CHECK: [[ITOFP:%[0-9]+]]:_(s64) = G_SITOFP [[AND]] + = ninf G_FADD [[TRUNC]]:_, [[ITOFP]]:_ + )"; + + // Check + EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF; +} + +// Test lowering of G_BSWAP +TEST_F(GISelMITest, LowerBSWAP) { + setUp(); + if (!TM) + return; + + DefineLegalizerInfo(A, {}); + + // Make sure vector lowering doesn't assert. + auto Cast = B.buildBitcast(LLT::vector(2, 32), Copies[0]); + auto BSwap = B.buildBSwap(LLT::vector(2, 32), Cast); + AInfo Info(MF->getSubtarget()); + DummyGISelObserver Observer; + LegalizerHelper Helper(*MF, Info, Observer, B); + // Perform Legalization + EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized, + Helper.lower(*BSwap, 0, LLT())); + + auto CheckStr = R"( + CHECK: [[COPY:%[0-9]+]]:_(s64) = COPY + CHECK: [[VEC:%[0-9]+]]:_(<2 x s32>) = G_BITCAST [[COPY]] + CHECK: [[K24:%[0-9]+]]:_(s32) = G_CONSTANT i32 24 + CHECK: [[SPLAT24:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[K24]]:_(s32), [[K24]]:_(s32) + CHECK: [[SHL0:%[0-9]+]]:_(<2 x s32>) = G_SHL [[VEC]]:_, [[SPLAT24]] + CHECK: [[SHR0:%[0-9]+]]:_(<2 x s32>) = G_LSHR [[VEC]]:_, [[SPLAT24]] + CHECK: [[OR0:%[0-9]+]]:_(<2 x s32>) = G_OR [[SHR0]]:_, [[SHL0]]:_ + CHECK: [[KMASK:%[0-9]+]]:_(s32) = G_CONSTANT i32 65280 + CHECK: [[SPLATMASK:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[KMASK]]:_(s32), [[KMASK]]:_(s32) + CHECK: [[K8:%[0-9]+]]:_(s32) = G_CONSTANT i32 8 + CHECK: [[SPLAT8:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[K8]]:_(s32), [[K8]]:_(s32) + CHECK: [[AND0:%[0-9]+]]:_(<2 x s32>) = G_AND [[VEC]]:_, [[SPLATMASK]]:_ + CHECK: [[SHL1:%[0-9]+]]:_(<2 x s32>) = G_SHL [[AND0]]:_, [[SPLAT8]] + CHECK: [[OR1:%[0-9]+]]:_(<2 x s32>) = G_OR [[OR0]]:_, [[SHL1]]:_ + CHECK: [[SHR1:%[0-9]+]]:_(<2 x s32>) = G_LSHR [[VEC]]:_, [[SPLAT8]] + CHECK: [[AND1:%[0-9]+]]:_(<2 x s32>) = G_AND [[SHR1]]:_, [[SPLATMASK]]:_ + CHECK: [[BSWAP:%[0-9]+]]:_(<2 x s32>) = G_OR [[OR1]]:_, [[AND1]]:_ + )"; + + // Check + EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF; +} + } // namespace diff --git a/llvm/unittests/DebugInfo/DWARF/CMakeLists.txt b/llvm/unittests/DebugInfo/DWARF/CMakeLists.txt index 00acb383386182..d7e7ed204d38ae 100644 --- a/llvm/unittests/DebugInfo/DWARF/CMakeLists.txt +++ b/llvm/unittests/DebugInfo/DWARF/CMakeLists.txt @@ -18,7 +18,6 @@ add_llvm_unittest(DebugInfoDWARFTests DWARFDebugInfoTest.cpp DWARFDebugLineTest.cpp DWARFDieTest.cpp - DWARFExpressionCompactPrinterTest.cpp DWARFFormValueTest.cpp DWARFLocationExpressionTest.cpp ) diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp deleted file mode 100644 index 6fa97794218c4d..00000000000000 --- a/llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp +++ /dev/null @@ -1,115 +0,0 @@ -//===- llvm/unittest/DebugInfo/DWARFExpressionCompactPrinterTest.cpp ------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/ArrayRef.h" -#include "llvm/DebugInfo/DWARF/DWARFContext.h" -#include "llvm/DebugInfo/DWARF/DWARFDie.h" -#include "llvm/DebugInfo/DWARF/DWARFExpression.h" -#include "llvm/MC/MCInstrInfo.h" -#include "llvm/Support/DataExtractor.h" -#include "llvm/Support/TargetRegistry.h" -#include "llvm/Support/TargetSelect.h" -#include "llvm/Testing/Support/Error.h" -#include "gtest/gtest.h" -#include "DwarfGenerator.h" - -using namespace llvm; -using namespace dwarf; - -namespace { -class DWARFExpressionCompactPrinterTest : public ::testing::Test { -public: - std::unique_ptr MRI; - - DWARFExpressionCompactPrinterTest() { - InitializeAllTargets(); - InitializeAllTargetMCs(); - InitializeAllAsmPrinters(); - - std::string TripleName = "armv8a-linux-gnueabi"; - std::string ErrorStr; - - const Target *TheTarget = - TargetRegistry::lookupTarget(TripleName, ErrorStr); - - if (!TheTarget) - return; - - MRI.reset(TheTarget->createMCRegInfo(TripleName)); - } - - void TestExprPrinter(ArrayRef ExprData, StringRef Expected); -}; -} // namespace - -void DWARFExpressionCompactPrinterTest::TestExprPrinter( - ArrayRef ExprData, StringRef Expected) { - // If we didn't build ARM, do not run the test. - if (!MRI) - return; - - // Print the expression, passing in the subprogram DIE, and check that the - // result is as expected. - std::string Result; - raw_string_ostream OS(Result); - DataExtractor DE(ExprData, true, 8); - DWARFExpression Expr(DE, 8); - Expr.printCompact(OS, *MRI); - EXPECT_EQ(OS.str(), Expected); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_reg0) { - TestExprPrinter({DW_OP_reg0}, "R0"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_reg10) { - TestExprPrinter({DW_OP_reg10}, "R10"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_regx) { - TestExprPrinter({DW_OP_regx, 0x80, 0x02}, "D0"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg0) { - TestExprPrinter({DW_OP_breg0, 0x04}, "[R0+4]"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg0_large_offset) { - TestExprPrinter({DW_OP_breg0, 0x80, 0x02}, "[R0+256]"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg13) { - TestExprPrinter({DW_OP_breg13, 0x10}, "[SP+16]"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg13_zero_offset) { - TestExprPrinter({DW_OP_breg13, 0x00}, "[SP]"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_breg0_negative) { - TestExprPrinter({DW_OP_breg0, 0x70}, "[R0-16]"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_bregx) { - TestExprPrinter({DW_OP_bregx, 0x0d, 0x28}, "[SP+40]"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_stack_value) { - TestExprPrinter({DW_OP_breg13, 0x04, DW_OP_stack_value}, "SP+4"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_entry_value) { - TestExprPrinter({DW_OP_entry_value, 0x01, DW_OP_reg0, DW_OP_stack_value}, - "entry(R0)"); -} - -TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_entry_value_mem) { - TestExprPrinter( - {DW_OP_entry_value, 0x02, DW_OP_breg13, 0x10, DW_OP_stack_value}, - "entry([SP+16])"); -} diff --git a/llvm/utils/gn/secondary/clang/include/clang/Basic/BUILD.gn b/llvm/utils/gn/secondary/clang/include/clang/Basic/BUILD.gn index 06e8644cb4928a..1a96d603de47e5 100644 --- a/llvm/utils/gn/secondary/clang/include/clang/Basic/BUILD.gn +++ b/llvm/utils/gn/secondary/clang/include/clang/Basic/BUILD.gn @@ -119,16 +119,6 @@ clang_tablegen("arm_mve_builtin_aliases") { td_file = "arm_mve.td" } -clang_tablegen("arm_sve_builtins") { - args = [ "-gen-arm-sve-builtins" ] - td_file = "arm_sve.td" -} - -clang_tablegen("arm_sve_codegenmap") { - args = [ "-gen-arm-sve-codegenmap" ] - td_file = "arm_sve.td" -} - clang_tablegen("arm_cde_builtins") { args = [ "-gen-arm-cde-builtin-def" ] td_file = "arm_cde.td" diff --git a/llvm/utils/gn/secondary/clang/lib/AST/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/AST/BUILD.gn index eb635fa453d852..4d645799dbf655 100644 --- a/llvm/utils/gn/secondary/clang/lib/AST/BUILD.gn +++ b/llvm/utils/gn/secondary/clang/lib/AST/BUILD.gn @@ -60,6 +60,7 @@ static_library("AST") { "CommentParser.cpp", "CommentSema.cpp", "ComparisonCategories.cpp", + "ComputeDependence.cpp", "DataCollection.cpp", "Decl.cpp", "DeclBase.cpp", diff --git a/llvm/utils/gn/secondary/clang/lib/Basic/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/Basic/BUILD.gn index 7267286d4898cf..c505a698052a89 100644 --- a/llvm/utils/gn/secondary/clang/lib/Basic/BUILD.gn +++ b/llvm/utils/gn/secondary/clang/lib/Basic/BUILD.gn @@ -26,7 +26,6 @@ static_library("Basic") { "//clang/include/clang/Basic:DiagnosticGroups", "//clang/include/clang/Basic:arm_cde_builtins", "//clang/include/clang/Basic:arm_mve_builtins", - "//clang/include/clang/Basic:arm_sve_builtins", "//clang/include/clang/Basic:diags_tablegen", "//clang/include/clang/Basic:version", ] diff --git a/llvm/utils/gn/secondary/clang/lib/CodeGen/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/CodeGen/BUILD.gn index c9097d5f2a5199..f4e275b25305bf 100644 --- a/llvm/utils/gn/secondary/clang/lib/CodeGen/BUILD.gn +++ b/llvm/utils/gn/secondary/clang/lib/CodeGen/BUILD.gn @@ -4,7 +4,6 @@ static_library("CodeGen") { deps = [ "//clang/include/clang/Basic:arm_cde_builtin_cg", "//clang/include/clang/Basic:arm_mve_builtin_cg", - "//clang/include/clang/Basic:arm_sve_codegenmap", "//clang/lib/AST", "//clang/lib/Analysis", "//clang/lib/Basic", diff --git a/llvm/utils/gn/secondary/clang/utils/TableGen/BUILD.gn b/llvm/utils/gn/secondary/clang/utils/TableGen/BUILD.gn index 34297ecf3b142c..a0e35cc11ef6c0 100644 --- a/llvm/utils/gn/secondary/clang/utils/TableGen/BUILD.gn +++ b/llvm/utils/gn/secondary/clang/utils/TableGen/BUILD.gn @@ -3,11 +3,6 @@ executable("clang-tblgen") { "//llvm/lib/Support", "//llvm/lib/TableGen", ] - - # FIXME: This is incorrect, see https://reviews.llvm.org/D75470#inline-695187 - # Remoe again once that's rectified. - include_dirs = [ "//clang/include" ] - sources = [ "ASTTableGen.cpp", "ClangASTNodesEmitter.cpp", diff --git a/llvm/utils/gn/secondary/llvm/lib/CodeGen/BUILD.gn b/llvm/utils/gn/secondary/llvm/lib/CodeGen/BUILD.gn index 2663df98170f8e..64ad6d4c154400 100644 --- a/llvm/utils/gn/secondary/llvm/lib/CodeGen/BUILD.gn +++ b/llvm/utils/gn/secondary/llvm/lib/CodeGen/BUILD.gn @@ -21,6 +21,7 @@ static_library("CodeGen") { "AllocationOrder.cpp", "Analysis.cpp", "AtomicExpandPass.cpp", + "BBSectionsPrepare.cpp", "BasicTargetTransformInfo.cpp", "BranchFolding.cpp", "BranchRelaxation.cpp", diff --git a/llvm/utils/gn/secondary/llvm/unittests/DebugInfo/DWARF/BUILD.gn b/llvm/utils/gn/secondary/llvm/unittests/DebugInfo/DWARF/BUILD.gn index 2d795760a46518..e2b9f325ea76f8 100644 --- a/llvm/utils/gn/secondary/llvm/unittests/DebugInfo/DWARF/BUILD.gn +++ b/llvm/utils/gn/secondary/llvm/unittests/DebugInfo/DWARF/BUILD.gn @@ -19,7 +19,6 @@ unittest("DebugInfoDWARFTests") { "DWARFDebugInfoTest.cpp", "DWARFDebugLineTest.cpp", "DWARFDieTest.cpp", - "DWARFExpressionCompactPrinterTest.cpp", "DWARFFormValueTest.cpp", "DWARFLocationExpressionTest.cpp", "DwarfGenerator.cpp", diff --git a/mlir/include/mlir/Dialect/GPU/GPUOps.td b/mlir/include/mlir/Dialect/GPU/GPUOps.td index 1ff0a8b57f5d26..659c10142e8155 100644 --- a/mlir/include/mlir/Dialect/GPU/GPUOps.td +++ b/mlir/include/mlir/Dialect/GPU/GPUOps.td @@ -28,6 +28,8 @@ def IntLikeOrLLVMInt : TypeConstraint< def GPU_Dialect : Dialect { let name = "gpu"; + let hasOperationAttrVerify = 1; + let extraClassDeclaration = [{ /// Get the name of the attribute used to annotate the modules that contain /// kernel modules. @@ -57,9 +59,6 @@ def GPU_Dialect : Dialect { /// Returns the numeric value used to identify the private memory address /// space. static unsigned getPrivateAddressSpace() { return 5; } - - LogicalResult verifyOperationAttribute(Operation *op, - NamedAttribute attr) override; }]; } diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td index b2d1e57c0f110b..20ed573ab8bdaa 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td @@ -19,17 +19,12 @@ include "mlir/IR/OpBase.td" def LLVM_Dialect : Dialect { let name = "llvm"; let cppNamespace = "LLVM"; + let hasRegionArgAttrVerify = 1; let extraClassDeclaration = [{ ~LLVMDialect(); llvm::LLVMContext &getLLVMContext(); llvm::Module &getLLVMModule(); - /// Verify a region argument attribute registered to this dialect. - /// Returns failure if the verification failed, success otherwise. - LogicalResult verifyRegionArgAttribute(Operation *op, unsigned regionIdx, - unsigned argIdx, - NamedAttribute argAttr) override; - private: friend LLVMType; diff --git a/mlir/include/mlir/Dialect/QuantOps/QuantOps.td b/mlir/include/mlir/Dialect/QuantOps/QuantOps.td index 92e1e1d813edd2..0047b41efd607d 100644 --- a/mlir/include/mlir/Dialect/QuantOps/QuantOps.td +++ b/mlir/include/mlir/Dialect/QuantOps/QuantOps.td @@ -83,6 +83,36 @@ def quant_StorageCastOp : quant_Op<"scast", [NoSideEffect]> { let hasFolder = 1; } +// A QuantizeRegion (region) represents a quantization unit which wraps +// high-precision ops with quantization specifications for all the inputs +// and outputs. Some quantization specifications can be undetermined and +// derived from other ports by the target specification of the kernel. +def quant_QuantizeRegionOp : quant_Op<"region", [ + NoSideEffect, + IsolatedFromAbove, + SingleBlockImplicitTerminator<"ReturnOp">]> { + let summary = [{ + The `region operation wraps high-precision ops as a logical low-precision + quantized kernel. + }]; + + let arguments = (ins Variadic:$inputs, + TypeArrayAttr:$input_specs, + TypeArrayAttr:$output_specs, + StrAttr:$logical_kernel); + let results = (outs Variadic:$outputs); + let regions = (region SizedRegion<1>:$body); + let verifier = [{ return verifyRegionOp(*this); }]; +} + +def quant_ReturnOp : quant_Op<"return", [Terminator]> { + let summary = [{ + The `return` operation terminates a quantize region and returns values. + }]; + + let arguments = (ins Variadic:$results); +} + //===----------------------------------------------------------------------===// // Training integration and instrumentation ops //===----------------------------------------------------------------------===// diff --git a/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td b/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td index 4dc1886fae2d76..26d8f1401c32eb 100644 --- a/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td +++ b/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td @@ -47,6 +47,10 @@ def SPIRV_Dialect : Dialect { let cppNamespace = "spirv"; let hasConstantMaterializer = 1; + let hasOperationAttrVerify = 1; + let hasRegionArgAttrVerify = 1; + let hasRegionResultAttrVerify = 1; + let extraClassDeclaration = [{ //===------------------------------------------------------------------===// // Type @@ -65,23 +69,6 @@ def SPIRV_Dialect : Dialect { /// Returns the attribute name to use when specifying decorations on results /// of operations. static std::string getAttributeName(Decoration decoration); - - /// Provides a hook for verifying SPIR-V dialect attributes attached to the - /// given op. - LogicalResult verifyOperationAttribute(Operation *op, - NamedAttribute attribute) override; - - /// Provides a hook for verifying SPIR-V dialect attributes attached to the - /// given op's region argument. - LogicalResult verifyRegionArgAttribute(Operation *op, unsigned regionIndex, - unsigned argIndex, - NamedAttribute attribute) override; - - /// Provides a hook for verifying SPIR-V dialect attributes attached to the - /// given op's region result. - LogicalResult verifyRegionResultAttribute( - Operation *op, unsigned regionIndex, unsigned resultIndex, - NamedAttribute attribute) override; }]; } diff --git a/mlir/include/mlir/IR/AffineExpr.h b/mlir/include/mlir/IR/AffineExpr.h index 21318114d4ca32..5d3e86bc9ba180 100644 --- a/mlir/include/mlir/IR/AffineExpr.h +++ b/mlir/include/mlir/IR/AffineExpr.h @@ -187,7 +187,7 @@ class AffineSymbolExpr : public AffineExpr { class AffineConstantExpr : public AffineExpr { public: using ImplType = detail::AffineConstantExprStorage; - /* implicit */ AffineConstantExpr(AffineExpr::ImplType *ptr); + /* implicit */ AffineConstantExpr(AffineExpr::ImplType *ptr = nullptr); int64_t getValue() const; }; diff --git a/mlir/include/mlir/IR/OpBase.td b/mlir/include/mlir/IR/OpBase.td index 159a3c5eae54a3..d76c9d5476ef85 100644 --- a/mlir/include/mlir/IR/OpBase.td +++ b/mlir/include/mlir/IR/OpBase.td @@ -260,6 +260,16 @@ class Dialect { // If this dialect overrides the hook for materializing constants. bit hasConstantMaterializer = 0; + + // If this dialect overrides the hook for verifying operation attributes. + bit hasOperationAttrVerify = 0; + + // If this dialect overrides the hook for verifying region argument + // attributes. + bit hasRegionArgAttrVerify = 0; + + // If this dialect overrides the hook for verifying region result attributes. + bit hasRegionResultAttrVerify = 0; } //===----------------------------------------------------------------------===// diff --git a/mlir/include/mlir/IR/PatternMatch.h b/mlir/include/mlir/IR/PatternMatch.h index aa17952b79c43f..48f58199814657 100644 --- a/mlir/include/mlir/IR/PatternMatch.h +++ b/mlir/include/mlir/IR/PatternMatch.h @@ -54,22 +54,9 @@ class PatternBenefit { unsigned short representation; }; -/// Pattern state is used by patterns that want to maintain state between their -/// match and rewrite phases. Patterns can define a pattern-specific subclass -/// of this. -class PatternState { -public: - virtual ~PatternState() {} - -protected: - // Must be subclassed. - PatternState() {} -}; - -/// This is the type returned by a pattern match. A match failure returns a -/// None value. A match success returns a Some value with any state the pattern -/// may need to maintain (but may also be null). -using PatternMatchResult = Optional>; +/// This is the type returned by a pattern match. +/// TODO: Replace usages with LogicalResult directly. +using PatternMatchResult = LogicalResult; //===----------------------------------------------------------------------===// // Pattern class @@ -97,9 +84,7 @@ class Pattern { //===--------------------------------------------------------------------===// /// Attempt to match against code rooted at the specified operation, - /// which is the same operation code as getRootKind(). On failure, this - /// returns a None value. On success it returns a (possibly null) - /// pattern-specific state wrapped in an Optional. + /// which is the same operation code as getRootKind(). virtual PatternMatchResult match(Operation *op) const = 0; virtual ~Pattern() {} @@ -108,14 +93,11 @@ class Pattern { // Helper methods to simplify pattern implementations //===--------------------------------------------------------------------===// - /// This method indicates that no match was found. - static PatternMatchResult matchFailure() { return None; } + /// Return a result, indicating that no match was found. + PatternMatchResult matchFailure() const { return failure(); } - /// This method indicates that a match was found and has the specified cost. - PatternMatchResult - matchSuccess(std::unique_ptr state = {}) const { - return PatternMatchResult(std::move(state)); - } + /// This method indicates that a match was found. + PatternMatchResult matchSuccess() const { return success(); } protected: /// Patterns must specify the root operation name they match against, and can @@ -136,19 +118,10 @@ class Pattern { /// separate the concerns of matching and rewriting. /// * Single-step RewritePattern with "matchAndRewrite" /// - By overloading the "matchAndRewrite" function, the user can perform -/// the rewrite in the same call as the match. This removes the need for -/// any PatternState. +/// the rewrite in the same call as the match. /// class RewritePattern : public Pattern { public: - /// Rewrite the IR rooted at the specified operation with the result of - /// this pattern, generating any new operations with the specified - /// rewriter. If an unexpected error is encountered (an internal - /// compiler error), it is emitted through the normal MLIR diagnostic - /// hooks and the IR is left in a valid state. - virtual void rewrite(Operation *op, std::unique_ptr state, - PatternRewriter &rewriter) const; - /// Rewrite the IR rooted at the specified operation with the result of /// this pattern, generating any new operations with the specified /// builder. If an unexpected error is encountered (an internal @@ -168,8 +141,8 @@ class RewritePattern : public Pattern { /// function will automatically perform the rewrite. virtual PatternMatchResult matchAndRewrite(Operation *op, PatternRewriter &rewriter) const { - if (auto matchResult = match(op)) { - rewrite(op, std::move(*matchResult), rewriter); + if (succeeded(match(op))) { + rewrite(op, rewriter); return matchSuccess(); } return matchFailure(); @@ -206,10 +179,6 @@ template struct OpRewritePattern : public RewritePattern { : RewritePattern(SourceOp::getOperationName(), benefit, context) {} /// Wrappers around the RewritePattern methods that pass the derived op type. - void rewrite(Operation *op, std::unique_ptr state, - PatternRewriter &rewriter) const final { - rewrite(cast(op), std::move(state), rewriter); - } void rewrite(Operation *op, PatternRewriter &rewriter) const final { rewrite(cast(op), rewriter); } @@ -223,20 +192,16 @@ template struct OpRewritePattern : public RewritePattern { /// Rewrite and Match methods that operate on the SourceOp type. These must be /// overridden by the derived pattern class. - virtual void rewrite(SourceOp op, std::unique_ptr state, - PatternRewriter &rewriter) const { - rewrite(op, rewriter); - } virtual void rewrite(SourceOp op, PatternRewriter &rewriter) const { - llvm_unreachable("must override matchAndRewrite or a rewrite method"); + llvm_unreachable("must override rewrite or matchAndRewrite"); } virtual PatternMatchResult match(SourceOp op) const { llvm_unreachable("must override match or matchAndRewrite"); } virtual PatternMatchResult matchAndRewrite(SourceOp op, PatternRewriter &rewriter) const { - if (auto matchResult = match(op)) { - rewrite(op, std::move(*matchResult), rewriter); + if (succeeded(match(op))) { + rewrite(op, rewriter); return matchSuccess(); } return matchFailure(); diff --git a/mlir/include/mlir/TableGen/Dialect.h b/mlir/include/mlir/TableGen/Dialect.h index 7cf5760b6817b7..5e85806f377f4f 100644 --- a/mlir/include/mlir/TableGen/Dialect.h +++ b/mlir/include/mlir/TableGen/Dialect.h @@ -13,6 +13,7 @@ #define MLIR_TABLEGEN_DIALECT_H_ #include "mlir/Support/LLVM.h" +#include namespace llvm { class Record; @@ -48,6 +49,15 @@ class Dialect { // Returns if this dialect has a constant materializer or not. bool hasConstantMaterializer() const; + /// Returns if this dialect has an operation attribute verifier. + bool hasOperationAttrVerify() const; + + /// Returns if this dialect has a region argument attribute verifier. + bool hasRegionArgAttrVerify() const; + + /// Returns if this dialect has a region result attribute verifier. + bool hasRegionResultAttrVerify() const; + // Returns whether two dialects are equal by checking the equality of the // underlying record. bool operator==(const Dialect &other) const; diff --git a/mlir/include/mlir/Transforms/DialectConversion.h b/mlir/include/mlir/Transforms/DialectConversion.h index 48ce470b88dd5a..a58c85499d634d 100644 --- a/mlir/include/mlir/Transforms/DialectConversion.h +++ b/mlir/include/mlir/Transforms/DialectConversion.h @@ -238,7 +238,7 @@ class ConversionPattern : public RewritePattern { virtual PatternMatchResult matchAndRewrite(Operation *op, ArrayRef operands, ConversionPatternRewriter &rewriter) const { - if (!match(op)) + if (failed(match(op))) return matchFailure(); rewrite(op, operands, rewriter); return matchSuccess(); @@ -285,7 +285,7 @@ struct OpConversionPattern : public ConversionPattern { virtual PatternMatchResult matchAndRewrite(SourceOp op, ArrayRef operands, ConversionPatternRewriter &rewriter) const { - if (!match(op)) + if (failed(match(op))) return matchFailure(); rewrite(op, operands, rewriter); return matchSuccess(); diff --git a/mlir/include/mlir/Transforms/LoopUtils.h b/mlir/include/mlir/Transforms/LoopUtils.h index 72db5e625aa2f9..479b7ce81a42ce 100644 --- a/mlir/include/mlir/Transforms/LoopUtils.h +++ b/mlir/include/mlir/Transforms/LoopUtils.h @@ -79,13 +79,14 @@ void getCleanupLoopLowerBound(AffineForOp forOp, unsigned unrollFactor, AffineMap *map, SmallVectorImpl *operands, OpBuilder &builder); -/// Skew the operations in the body of a 'affine.for' operation with the +/// Skew the operations in the body of an affine.for operation with the /// specified operation-wise shifts. The shifts are with respect to the /// original execution order, and are multiplied by the loop 'step' before being -/// applied. +/// applied. If `unrollPrologueEpilogue` is set, fully unroll the prologue and +/// epilogue loops when possible. LLVM_NODISCARD -LogicalResult instBodySkew(AffineForOp forOp, ArrayRef shifts, - bool unrollPrologueEpilogue = false); +LogicalResult affineForOpBodySkew(AffineForOp forOp, ArrayRef shifts, + bool unrollPrologueEpilogue = false); /// Tiles the specified band of perfectly nested loops creating tile-space loops /// and intra-tile loops. A band is a contiguous set of loops. diff --git a/mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp b/mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp index fcfae4563778d5..26833fd4daa757 100644 --- a/mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp +++ b/mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp @@ -33,10 +33,10 @@ static constexpr const char *kVulkanLaunch = "vulkanLaunch"; namespace { -// A pass to convert gpu launch op to vulkan launch call op, by creating a -// SPIR-V binary shader from `spirv::ModuleOp` using `spirv::serialize` -// function and attaching binary data and entry point name as an attributes to -// created vulkan launch call op. +/// A pass to convert gpu launch op to vulkan launch call op, by creating a +/// SPIR-V binary shader from `spirv::ModuleOp` using `spirv::serialize` +/// function and attaching binary data and entry point name as an attributes to +/// created vulkan launch call op. class ConvertGpuLaunchFuncToVulkanLaunchFunc : public ModulePass { public: diff --git a/mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp b/mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp index 92c376e1978865..f1dc52e5f85631 100644 --- a/mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp +++ b/mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp @@ -15,6 +15,7 @@ //===----------------------------------------------------------------------===// #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h" +#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/IR/Attributes.h" #include "mlir/IR/Builders.h" @@ -26,7 +27,9 @@ using namespace mlir; -static constexpr const char *kBindResource = "bindResource"; +static constexpr const char *kBindMemRef1DFloat = "bindMemRef1DFloat"; +static constexpr const char *kCInterfaceVulkanLaunch = + "_mlir_ciface_vulkanLaunch"; static constexpr const char *kDeinitVulkan = "deinitVulkan"; static constexpr const char *kRunOnVulkan = "runOnVulkan"; static constexpr const char *kInitVulkan = "initVulkan"; @@ -40,11 +43,11 @@ static constexpr const char *kVulkanLaunch = "vulkanLaunch"; namespace { -/// A pass to convert vulkan launch func into a sequence of Vulkan +/// A pass to convert vulkan launch call op into a sequence of Vulkan /// runtime calls in the following order: /// /// * initVulkan -- initializes vulkan runtime -/// * bindResource -- binds resource +/// * bindMemRef -- binds memref /// * setBinaryShader -- sets the binary shader data /// * setEntryPoint -- sets the entry point name /// * setNumWorkGroups -- sets the number of a local workgroups @@ -67,6 +70,29 @@ class VulkanLaunchFuncToVulkanCallsPass llvmPointerType = LLVM::LLVMType::getInt8PtrTy(llvmDialect); llvmInt32Type = LLVM::LLVMType::getInt32Ty(llvmDialect); llvmInt64Type = LLVM::LLVMType::getInt64Ty(llvmDialect); + initializeMemRefTypes(); + } + + void initializeMemRefTypes() { + // According to the MLIR doc memref argument is converted into a + // pointer-to-struct argument of type: + // template + // struct { + // Elem *allocated; + // Elem *aligned; + // int64_t offset; + // int64_t sizes[Rank]; // omitted when rank == 0 + // int64_t strides[Rank]; // omitted when rank == 0 + // }; + auto llvmPtrToFloatType = getFloatType().getPointerTo(); + auto llvmArrayOneElementSizeType = + LLVM::LLVMType::getArrayTy(getInt64Type(), 1); + + // Create a type `!llvm<"{ float*, float*, i64, [1 x i64], [1 x i64]}">`. + llvmMemRef1DFloat = LLVM::LLVMType::getStructTy( + llvmDialect, + {llvmPtrToFloatType, llvmPtrToFloatType, getInt64Type(), + llvmArrayOneElementSizeType, llvmArrayOneElementSizeType}); } LLVM::LLVMType getFloatType() { return llvmFloatType; } @@ -74,6 +100,7 @@ class VulkanLaunchFuncToVulkanCallsPass LLVM::LLVMType getPointerType() { return llvmPointerType; } LLVM::LLVMType getInt32Type() { return llvmInt32Type; } LLVM::LLVMType getInt64Type() { return llvmInt64Type; } + LLVM::LLVMType getMemRef1DFloat() { return llvmMemRef1DFloat; } /// Creates a LLVM global for the given `name`. Value createEntryPointNameConstant(StringRef name, Location loc, @@ -85,16 +112,27 @@ class VulkanLaunchFuncToVulkanCallsPass /// Checks whether the given LLVM::CallOp is a vulkan launch call op. bool isVulkanLaunchCallOp(LLVM::CallOp callOp) { return (callOp.callee() && callOp.callee().getValue() == kVulkanLaunch && - callOp.getNumOperands() >= 6); + callOp.getNumOperands() >= gpu::LaunchOp::kNumConfigOperands); + } + + /// Checks whether the given LLVM::CallOp is a "ci_face" vulkan launch call + /// op. + bool isCInterfaceVulkanLaunchCallOp(LLVM::CallOp callOp) { + return (callOp.callee() && + callOp.callee().getValue() == kCInterfaceVulkanLaunch && + callOp.getNumOperands() >= gpu::LaunchOp::kNumConfigOperands); } /// Translates the given `vulkanLaunchCallOp` to the sequence of Vulkan /// runtime calls. void translateVulkanLaunchCall(LLVM::CallOp vulkanLaunchCallOp); - /// Creates call to `bindResource` for each resource operand. - void createBindResourceCalls(LLVM::CallOp vulkanLaunchCallOp, - Value vulkanRuntiem); + /// Creates call to `bindMemRef` for each memref operand. + void createBindMemRefCalls(LLVM::CallOp vulkanLaunchCallOp, + Value vulkanRuntime); + + /// Collects SPIRV attributes from the given `vulkanLaunchCallOp`. + void collectSPIRVAttributes(LLVM::CallOp vulkanLaunchCallOp); public: void runOnModule() override; @@ -106,89 +144,81 @@ class VulkanLaunchFuncToVulkanCallsPass LLVM::LLVMType llvmPointerType; LLVM::LLVMType llvmInt32Type; LLVM::LLVMType llvmInt64Type; -}; - -/// Represents operand adaptor for vulkan launch call operation, to simplify an -/// access to the lowered memref. -// TODO: We should use 'emit-c-wrappers' option to lower memref type: -// https://mlir.llvm.org/docs/ConversionToLLVMDialect/#c-compatible-wrapper-emission. -struct VulkanLaunchOpOperandAdaptor { - VulkanLaunchOpOperandAdaptor(ArrayRef values) { operands = values; } - VulkanLaunchOpOperandAdaptor(const VulkanLaunchOpOperandAdaptor &) = delete; - VulkanLaunchOpOperandAdaptor - operator=(const VulkanLaunchOpOperandAdaptor &) = delete; - - /// Returns a tuple with a pointer to the memory and the size for the index-th - /// resource. - std::tuple getResourceDescriptor1D(uint32_t index) { - assert(index < getResourceCount1D()); - // 1D memref calling convention according to "ConversionToLLVMDialect.md": - // 0. Allocated pointer. - // 1. Aligned pointer. - // 2. Offset. - // 3. Size in dim 0. - // 4. Stride in dim 0. - auto offset = numConfigOps + index * loweredMemRefNumOps1D; - return std::make_tuple(operands[offset], operands[offset + 3]); - } + LLVM::LLVMType llvmMemRef1DFloat; - /// Returns the number of resources assuming all operands lowered from - /// 1D memref. - uint32_t getResourceCount1D() { - return (operands.size() - numConfigOps) / loweredMemRefNumOps1D; - } - -private: - /// The number of operands of lowered 1D memref. - static constexpr const uint32_t loweredMemRefNumOps1D = 5; - /// The number of the first config operands. - static constexpr const uint32_t numConfigOps = 6; - ArrayRef operands; + // TODO: Use an associative array to support multiple vulkan launch calls. + std::pair spirvAttributes; }; } // anonymous namespace void VulkanLaunchFuncToVulkanCallsPass::runOnModule() { initializeCachedTypes(); + + // Collect SPIR-V attributes such as `spirv_blob` and + // `spirv_entry_point_name`. getModule().walk([this](LLVM::CallOp op) { if (isVulkanLaunchCallOp(op)) + collectSPIRVAttributes(op); + }); + + // Convert vulkan launch call op into a sequence of Vulkan runtime calls. + getModule().walk([this](LLVM::CallOp op) { + if (isCInterfaceVulkanLaunchCallOp(op)) translateVulkanLaunchCall(op); }); } -void VulkanLaunchFuncToVulkanCallsPass::createBindResourceCalls( - LLVM::CallOp vulkanLaunchCallOp, Value vulkanRuntime) { - if (vulkanLaunchCallOp.getNumOperands() == 6) +void VulkanLaunchFuncToVulkanCallsPass::collectSPIRVAttributes( + LLVM::CallOp vulkanLaunchCallOp) { + // Check that `kSPIRVBinary` and `kSPIRVEntryPoint` are present in attributes + // for the given vulkan launch call. + auto spirvBlobAttr = + vulkanLaunchCallOp.getAttrOfType(kSPIRVBlobAttrName); + if (!spirvBlobAttr) { + vulkanLaunchCallOp.emitError() + << "missing " << kSPIRVBlobAttrName << " attribute"; + return signalPassFailure(); + } + + auto spirvEntryPointNameAttr = + vulkanLaunchCallOp.getAttrOfType(kSPIRVEntryPointAttrName); + if (!spirvEntryPointNameAttr) { + vulkanLaunchCallOp.emitError() + << "missing " << kSPIRVEntryPointAttrName << " attribute"; + return signalPassFailure(); + } + + spirvAttributes = std::make_pair(spirvBlobAttr, spirvEntryPointNameAttr); +} + +void VulkanLaunchFuncToVulkanCallsPass::createBindMemRefCalls( + LLVM::CallOp cInterfaceVulkanLaunchCallOp, Value vulkanRuntime) { + if (cInterfaceVulkanLaunchCallOp.getNumOperands() == + gpu::LaunchOp::kNumConfigOperands) return; - OpBuilder builder(vulkanLaunchCallOp); - Location loc = vulkanLaunchCallOp.getLoc(); + OpBuilder builder(cInterfaceVulkanLaunchCallOp); + Location loc = cInterfaceVulkanLaunchCallOp.getLoc(); // Create LLVM constant for the descriptor set index. - // Bind all resources to the `0` descriptor set, the same way as `GPUToSPIRV` + // Bind all memrefs to the `0` descriptor set, the same way as `GPUToSPIRV` // pass does. Value descriptorSet = builder.create( loc, getInt32Type(), builder.getI32IntegerAttr(0)); - auto operands = SmallVector{vulkanLaunchCallOp.getOperands()}; - VulkanLaunchOpOperandAdaptor vkLaunchOperandAdaptor(operands); - - for (auto resourceIdx : - llvm::seq(0, vkLaunchOperandAdaptor.getResourceCount1D())) { + for (auto en : + llvm::enumerate(cInterfaceVulkanLaunchCallOp.getOperands().drop_front( + gpu::LaunchOp::kNumConfigOperands))) { // Create LLVM constant for the descriptor binding index. Value descriptorBinding = builder.create( - loc, getInt32Type(), builder.getI32IntegerAttr(resourceIdx)); - // Get a pointer to the memory and size of that memory. - auto resourceDescriptor = - vkLaunchOperandAdaptor.getResourceDescriptor1D(resourceIdx); - // Create call to `bindResource`. + loc, getInt32Type(), builder.getI32IntegerAttr(en.index())); + // Create call to `bindMemRef`. builder.create( loc, ArrayRef{getVoidType()}, - builder.getSymbolRefAttr(kBindResource), + // TODO: Add support for memref with other ranks. + builder.getSymbolRefAttr(kBindMemRef1DFloat), ArrayRef{vulkanRuntime, descriptorSet, descriptorBinding, - // Pointer to the memory. - std::get<0>(resourceDescriptor), - // Size of the memory. - std::get<1>(resourceDescriptor)}); + en.value()}); } } @@ -228,14 +258,14 @@ void VulkanLaunchFuncToVulkanCallsPass::declareVulkanFunctions(Location loc) { /*isVarArg=*/false)); } - if (!module.lookupSymbol(kBindResource)) { + if (!module.lookupSymbol(kBindMemRef1DFloat)) { builder.create( - loc, kBindResource, - LLVM::LLVMType::getFunctionTy( - getVoidType(), - {getPointerType(), getInt32Type(), getInt32Type(), - getFloatType().getPointerTo(), getInt64Type()}, - /*isVarArg=*/false)); + loc, kBindMemRef1DFloat, + LLVM::LLVMType::getFunctionTy(getVoidType(), + {getPointerType(), getInt32Type(), + getInt32Type(), + getMemRef1DFloat().getPointerTo()}, + /*isVarArg=*/false)); } if (!module.lookupSymbol(kInitVulkan)) { @@ -267,28 +297,9 @@ Value VulkanLaunchFuncToVulkanCallsPass::createEntryPointNameConstant( } void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall( - LLVM::CallOp vulkanLaunchCallOp) { - OpBuilder builder(vulkanLaunchCallOp); - Location loc = vulkanLaunchCallOp.getLoc(); - - // Check that `kSPIRVBinary` and `kSPIRVEntryPoint` are present in attributes - // for the given vulkan launch call. - auto spirvBlobAttr = - vulkanLaunchCallOp.getAttrOfType(kSPIRVBlobAttrName); - if (!spirvBlobAttr) { - vulkanLaunchCallOp.emitError() - << "missing " << kSPIRVBlobAttrName << " attribute"; - return signalPassFailure(); - } - - auto entryPointNameAttr = - vulkanLaunchCallOp.getAttrOfType(kSPIRVEntryPointAttrName); - if (!entryPointNameAttr) { - vulkanLaunchCallOp.emitError() - << "missing " << kSPIRVEntryPointAttrName << " attribute"; - return signalPassFailure(); - } - + LLVM::CallOp cInterfaceVulkanLaunchCallOp) { + OpBuilder builder(cInterfaceVulkanLaunchCallOp); + Location loc = cInterfaceVulkanLaunchCallOp.getLoc(); // Create call to `initVulkan`. auto initVulkanCall = builder.create( loc, ArrayRef{getPointerType()}, @@ -300,16 +311,16 @@ void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall( // Create LLVM global with SPIR-V binary data, so we can pass a pointer with // that data to runtime call. Value ptrToSPIRVBinary = LLVM::createGlobalString( - loc, builder, kSPIRVBinary, spirvBlobAttr.getValue(), + loc, builder, kSPIRVBinary, spirvAttributes.first.getValue(), LLVM::Linkage::Internal, getLLVMDialect()); // Create LLVM constant for the size of SPIR-V binary shader. Value binarySize = builder.create( loc, getInt32Type(), - builder.getI32IntegerAttr(spirvBlobAttr.getValue().size())); + builder.getI32IntegerAttr(spirvAttributes.first.getValue().size())); - // Create call to `bindResource` for each resource operand. - createBindResourceCalls(vulkanLaunchCallOp, vulkanRuntime); + // Create call to `bindMemRef` for each memref operand. + createBindMemRefCalls(cInterfaceVulkanLaunchCallOp, vulkanRuntime); // Create call to `setBinaryShader` runtime function with the given pointer to // SPIR-V binary and binary size. @@ -318,8 +329,8 @@ void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall( builder.getSymbolRefAttr(kSetBinaryShader), ArrayRef{vulkanRuntime, ptrToSPIRVBinary, binarySize}); // Create LLVM global with entry point name. - Value entryPointName = - createEntryPointNameConstant(entryPointNameAttr.getValue(), loc, builder); + Value entryPointName = createEntryPointNameConstant( + spirvAttributes.second.getValue(), loc, builder); // Create call to `setEntryPoint` runtime function with the given pointer to // entry point name. builder.create(loc, ArrayRef{getVoidType()}, @@ -330,9 +341,9 @@ void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall( builder.create( loc, ArrayRef{getVoidType()}, builder.getSymbolRefAttr(kSetNumWorkGroups), - ArrayRef{vulkanRuntime, vulkanLaunchCallOp.getOperand(0), - vulkanLaunchCallOp.getOperand(1), - vulkanLaunchCallOp.getOperand(2)}); + ArrayRef{vulkanRuntime, cInterfaceVulkanLaunchCallOp.getOperand(0), + cInterfaceVulkanLaunchCallOp.getOperand(1), + cInterfaceVulkanLaunchCallOp.getOperand(2)}); // Create call to `runOnVulkan` runtime function. builder.create(loc, ArrayRef{getVoidType()}, @@ -347,7 +358,7 @@ void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall( // Declare runtime functions. declareVulkanFunctions(loc); - vulkanLaunchCallOp.erase(); + cInterfaceVulkanLaunchCallOp.erase(); } std::unique_ptr> diff --git a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp index d295870d09ab37..f967793c36f09e 100644 --- a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp +++ b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp @@ -805,7 +805,7 @@ class VectorInsertStridedSliceOpSameRankRewritePattern // multiple times. auto success = matchAndRewrite(insertStridedSliceOp, rewriter); (void)success; - assert(success && "Unexpected failure"); + assert(succeeded(success) && "Unexpected failure"); extractedSource = insertStridedSliceOp; } // 4. Insert the extractedSource into the res vector. @@ -1083,7 +1083,7 @@ class VectorStridedSliceOpConversion : public OpRewritePattern { // multiple times. auto success = matchAndRewrite(stridedSliceOp, rewriter); (void)success; - assert(success && "Unexpected failure"); + assert(succeeded(success) && "Unexpected failure"); extracted = stridedSliceOp; } res = insertOne(rewriter, loc, extracted, res, idx); diff --git a/mlir/lib/Dialect/QuantOps/IR/QuantOps.cpp b/mlir/lib/Dialect/QuantOps/IR/QuantOps.cpp index 9a678260415a89..f87330cff01663 100644 --- a/mlir/lib/Dialect/QuantOps/IR/QuantOps.cpp +++ b/mlir/lib/Dialect/QuantOps/IR/QuantOps.cpp @@ -34,13 +34,63 @@ QuantizationDialect::QuantizationDialect(MLIRContext *context) } OpFoldResult StorageCastOp::fold(ArrayRef operands) { - /// Matches x -> [scast -> scast] -> y, replacing the second scast with the - /// value of x if the casts invert each other. + // Matches x -> [scast -> scast] -> y, replacing the second scast with the + // value of x if the casts invert each other. auto srcScastOp = dyn_cast_or_null(arg().getDefiningOp()); if (!srcScastOp || srcScastOp.arg().getType() != getType()) return OpFoldResult(); return srcScastOp.arg(); } +/// The quantization specification should match the expressed type. +static bool isValidQuantizationSpec(Attribute quantSpec, Type expressed) { + if (auto typeAttr = quantSpec.dyn_cast()) { + Type spec = typeAttr.getValue(); + if (spec.isa() || spec.isa()) + return false; + + // The spec should be either a quantized type which is compatible to the + // expressed type, or a primitive type which is as same as the + // (element type of) the expressed type. + if (auto quantizedType = spec.dyn_cast()) + return quantizedType.isCompatibleExpressedType(expressed); + + if (auto tensorType = expressed.dyn_cast()) + return spec == tensorType.getElementType(); + + if (auto vectorType = expressed.dyn_cast()) + return spec == vectorType.getElementType(); + } + return false; +} + +static LogicalResult verifyRegionOp(QuantizeRegionOp op) { + // There are specifications for both inputs and outputs. + if (op.getNumOperands() != op.input_specs().size() || + op.getNumResults() != op.output_specs().size()) + return op.emitOpError( + "has unmatched operands/results number and spec attributes number"); + + // Verify that quantization specifications are valid. + for (auto input : llvm::zip(op.getOperandTypes(), op.input_specs())) { + Type inputType = std::get<0>(input); + Attribute inputSpec = std::get<1>(input); + if (!isValidQuantizationSpec(inputSpec, inputType)) { + return op.emitOpError() << "has incompatible specification " << inputSpec + << " and input type " << inputType; + } + } + + for (auto result : llvm::zip(op.getResultTypes(), op.output_specs())) { + Type outputType = std::get<0>(result); + Attribute outputSpec = std::get<1>(result); + if (!isValidQuantizationSpec(outputSpec, outputType)) { + return op.emitOpError() << "has incompatible specification " << outputSpec + << " and output type " << outputType; + } + } + return success(); +} + #define GET_OP_CLASSES #include "mlir/Dialect/QuantOps/QuantOps.cpp.inc" diff --git a/mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp b/mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp index c705dc87bfa8ad..68c7c018b58466 100644 --- a/mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp +++ b/mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp @@ -318,9 +318,8 @@ struct ConvertSelectionOpToSelect auto *falseBlock = brConditionalOp.getSuccessor(1); auto *mergeBlock = selectionOp.getMergeBlock(); - if (!canCanonicalizeSelection(trueBlock, falseBlock, mergeBlock)) { + if (failed(canCanonicalizeSelection(trueBlock, falseBlock, mergeBlock))) return matchFailure(); - } auto trueValue = getSrcValue(trueBlock); auto falseValue = getSrcValue(falseBlock); diff --git a/mlir/lib/IR/AffineExpr.cpp b/mlir/lib/IR/AffineExpr.cpp index 921538b4edc335..295b5155c29b4f 100644 --- a/mlir/lib/IR/AffineExpr.cpp +++ b/mlir/lib/IR/AffineExpr.cpp @@ -314,6 +314,39 @@ static AffineExpr simplifyAdd(AffineExpr lhs, AffineExpr rhs) { return lBin.getLHS() + (lrhs.getValue() + rhsConst.getValue()); } + // Detect "c1 * expr + c_2 * expr" as "(c1 + c2) * expr". + // c1 is rRhsConst, c2 is rLhsConst; firstExpr, secondExpr are their + // respective multiplicands. + Optional rLhsConst, rRhsConst; + AffineExpr firstExpr, secondExpr; + AffineConstantExpr rLhsConstExpr; + auto lBinOpExpr = lhs.dyn_cast(); + if (lBinOpExpr && lBinOpExpr.getKind() == AffineExprKind::Mul && + (rLhsConstExpr = lBinOpExpr.getRHS().dyn_cast())) { + rLhsConst = rLhsConstExpr.getValue(); + firstExpr = lBinOpExpr.getLHS(); + } else { + rLhsConst = 1; + firstExpr = lhs; + } + + auto rBinOpExpr = rhs.dyn_cast(); + AffineConstantExpr rRhsConstExpr; + if (rBinOpExpr && rBinOpExpr.getKind() == AffineExprKind::Mul && + (rRhsConstExpr = rBinOpExpr.getRHS().dyn_cast())) { + rRhsConst = rRhsConstExpr.getValue(); + secondExpr = rBinOpExpr.getLHS(); + } else { + rRhsConst = 1; + secondExpr = rhs; + } + + if (rLhsConst && rRhsConst && firstExpr == secondExpr) + return getAffineBinaryOpExpr( + AffineExprKind::Mul, firstExpr, + getAffineConstantExpr(rLhsConst.getValue() + rRhsConst.getValue(), + lhs.getContext())); + // When doing successive additions, bring constant to the right: turn (d0 + 2) // + d1 into (d0 + d1) + 2. if (lBin && lBin.getKind() == AffineExprKind::Add) { @@ -327,7 +360,6 @@ static AffineExpr simplifyAdd(AffineExpr lhs, AffineExpr rhs) { // general a more compact and readable form. // Process '(expr floordiv c) * (-c)'. - AffineBinaryOpExpr rBinOpExpr = rhs.dyn_cast(); if (!rBinOpExpr) return nullptr; diff --git a/mlir/lib/IR/PatternMatch.cpp b/mlir/lib/IR/PatternMatch.cpp index b111137e736aa8..bf1cd3c29b3efa 100644 --- a/mlir/lib/IR/PatternMatch.cpp +++ b/mlir/lib/IR/PatternMatch.cpp @@ -39,11 +39,6 @@ void Pattern::anchor() {} // RewritePattern and PatternRewriter implementation //===----------------------------------------------------------------------===// -void RewritePattern::rewrite(Operation *op, std::unique_ptr state, - PatternRewriter &rewriter) const { - rewrite(op, rewriter); -} - void RewritePattern::rewrite(Operation *op, PatternRewriter &rewriter) const { llvm_unreachable("need to implement either matchAndRewrite or one of the " "rewrite functions!"); @@ -191,7 +186,7 @@ bool RewritePatternMatcher::matchAndRewrite(Operation *op, // Try to match and rewrite this pattern. The patterns are sorted by // benefit, so if we match we can immediately rewrite and return. - if (pattern->matchAndRewrite(op, rewriter)) + if (succeeded(pattern->matchAndRewrite(op, rewriter))) return true; } return false; diff --git a/mlir/lib/Quantizer/Configurations/FxpMathConfig.cpp b/mlir/lib/Quantizer/Configurations/FxpMathConfig.cpp index 1dc9a0596a8bee..d4b3b74047737c 100644 --- a/mlir/lib/Quantizer/Configurations/FxpMathConfig.cpp +++ b/mlir/lib/Quantizer/Configurations/FxpMathConfig.cpp @@ -60,7 +60,7 @@ struct FxpMathTargetConfigImpl : public FxpMathTargetConfig { // Op handlers. addOpHandler( std::bind(&FxpMathTargetConfigImpl::handleConstant, this, _1, _2)); - addOpHandler( + addOpHandler( std::bind(&FxpMathTargetConfigImpl::handleTerminal, this, _1, _2)); addOpHandler( std::bind(&FxpMathTargetConfigImpl::handleStats, this, _1, _2)); diff --git a/mlir/lib/TableGen/Dialect.cpp b/mlir/lib/TableGen/Dialect.cpp index 7e757eaeae4f4b..db68ed43593f95 100644 --- a/mlir/lib/TableGen/Dialect.cpp +++ b/mlir/lib/TableGen/Dialect.cpp @@ -58,6 +58,18 @@ bool tblgen::Dialect::hasConstantMaterializer() const { return def->getValueAsBit("hasConstantMaterializer"); } +bool tblgen::Dialect::hasOperationAttrVerify() const { + return def->getValueAsBit("hasOperationAttrVerify"); +} + +bool tblgen::Dialect::hasRegionArgAttrVerify() const { + return def->getValueAsBit("hasRegionArgAttrVerify"); +} + +bool tblgen::Dialect::hasRegionResultAttrVerify() const { + return def->getValueAsBit("hasRegionResultAttrVerify"); +} + bool Dialect::operator==(const Dialect &other) const { return def == other.def; } diff --git a/mlir/lib/Transforms/DialectConversion.cpp b/mlir/lib/Transforms/DialectConversion.cpp index a58dd05d081264..5c0c0625c392c9 100644 --- a/mlir/lib/Transforms/DialectConversion.cpp +++ b/mlir/lib/Transforms/DialectConversion.cpp @@ -1237,12 +1237,12 @@ OperationLegalizer::legalizePattern(Operation *op, RewritePattern *pattern, // Try to rewrite with the given pattern. rewriter.setInsertionPoint(op); - auto matchedPattern = pattern->matchAndRewrite(op, rewriter); + LogicalResult matchedPattern = pattern->matchAndRewrite(op, rewriter); #ifndef NDEBUG assert(rewriterImpl.pendingRootUpdates.empty() && "dangling root updates"); #endif - if (!matchedPattern) { + if (failed(matchedPattern)) { LLVM_DEBUG(logFailure(rewriterImpl.logger, "pattern failed to match")); return cleanupFailure(); } diff --git a/mlir/lib/Transforms/PipelineDataTransfer.cpp b/mlir/lib/Transforms/PipelineDataTransfer.cpp index 7057ecb853835f..39874b1bc44a02 100644 --- a/mlir/lib/Transforms/PipelineDataTransfer.cpp +++ b/mlir/lib/Transforms/PipelineDataTransfer.cpp @@ -22,6 +22,7 @@ #include "mlir/Transforms/Utils.h" #include "llvm/ADT/DenseMap.h" #include "llvm/Support/Debug.h" + #define DEBUG_TYPE "affine-pipeline-data-transfer" using namespace mlir; @@ -46,9 +47,9 @@ std::unique_ptr> mlir::createPipelineDataTransferPass() { // Returns the position of the tag memref operand given a DMA operation. // Temporary utility: will be replaced when DmaStart/DmaFinish abstract op's are // added. TODO(b/117228571) -static unsigned getTagMemRefPos(Operation &dmaInst) { - assert(isa(dmaInst) || isa(dmaInst)); - if (auto dmaStartOp = dyn_cast(dmaInst)) { +static unsigned getTagMemRefPos(Operation &dmaOp) { + assert(isa(dmaOp) || isa(dmaOp)); + if (auto dmaStartOp = dyn_cast(dmaOp)) { return dmaStartOp.getTagMemRefOperandIndex(); } // First operand for a dma finish operation. @@ -79,21 +80,20 @@ static bool doubleBuffer(Value oldMemRef, AffineForOp forOp) { auto oldMemRefType = oldMemRef.getType().cast(); auto newMemRefType = doubleShape(oldMemRefType); - // The double buffer is allocated right before 'forInst'. - auto *forInst = forOp.getOperation(); - OpBuilder bOuter(forInst); + // The double buffer is allocated right before 'forOp'. + OpBuilder bOuter(forOp); // Put together alloc operands for any dynamic dimensions of the memref. SmallVector allocOperands; unsigned dynamicDimCount = 0; for (auto dimSize : oldMemRefType.getShape()) { if (dimSize == -1) - allocOperands.push_back(bOuter.create(forInst->getLoc(), oldMemRef, - dynamicDimCount++)); + allocOperands.push_back( + bOuter.create(forOp.getLoc(), oldMemRef, dynamicDimCount++)); } // Create and place the alloc right before the 'affine.for' operation. Value newMemRef = - bOuter.create(forInst->getLoc(), newMemRefType, allocOperands); + bOuter.create(forOp.getLoc(), newMemRefType, allocOperands); // Create 'iv mod 2' value to index the leading dimension. auto d0 = bInner.getAffineDimExpr(0); @@ -118,8 +118,8 @@ static bool doubleBuffer(Value oldMemRef, AffineForOp forOp) { return false; } // Insert the dealloc op right after the for loop. - bOuter.setInsertionPointAfter(forInst); - bOuter.create(forInst->getLoc(), newMemRef); + bOuter.setInsertionPointAfter(forOp); + bOuter.create(forOp.getLoc(), newMemRef); return true; } @@ -219,11 +219,11 @@ static void findMatchingStartFinishInsts( } // For each start operation, we look for a matching finish operation. - for (auto *dmaStartInst : dmaStartInsts) { - for (auto *dmaFinishInst : dmaFinishInsts) { - if (checkTagMatch(cast(dmaStartInst), - cast(dmaFinishInst))) { - startWaitPairs.push_back({dmaStartInst, dmaFinishInst}); + for (auto *dmaStartOp : dmaStartInsts) { + for (auto *dmaFinishOp : dmaFinishInsts) { + if (checkTagMatch(cast(dmaStartOp), + cast(dmaFinishOp))) { + startWaitPairs.push_back({dmaStartOp, dmaFinishOp}); break; } } @@ -236,8 +236,7 @@ static void findMatchingStartFinishInsts( void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) { auto mayBeConstTripCount = getConstantTripCount(forOp); if (!mayBeConstTripCount.hasValue()) { - LLVM_DEBUG( - forOp.emitRemark("won't pipeline due to unknown trip count loop")); + LLVM_DEBUG(forOp.emitRemark("won't pipeline due to unknown trip count")); return; } @@ -258,14 +257,14 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) { // the dimension we are adding here for the double buffering is the outermost // dimension. for (auto &pair : startWaitPairs) { - auto *dmaStartInst = pair.first; - Value oldMemRef = dmaStartInst->getOperand( - cast(dmaStartInst).getFasterMemPos()); + auto *dmaStartOp = pair.first; + Value oldMemRef = dmaStartOp->getOperand( + cast(dmaStartOp).getFasterMemPos()); if (!doubleBuffer(oldMemRef, forOp)) { // Normally, double buffering should not fail because we already checked // that there are no uses outside. LLVM_DEBUG(llvm::dbgs() - << "double buffering failed for" << dmaStartInst << "\n";); + << "double buffering failed for" << dmaStartOp << "\n";); // IR still valid and semantically correct. return; } @@ -275,13 +274,13 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) { // order to create the double buffer above.) // '-canonicalize' does this in a more general way, but we'll anyway do the // simple/common case so that the output / test cases looks clear. - if (auto *allocInst = oldMemRef.getDefiningOp()) { + if (auto *allocOp = oldMemRef.getDefiningOp()) { if (oldMemRef.use_empty()) { - allocInst->erase(); + allocOp->erase(); } else if (oldMemRef.hasOneUse()) { if (auto dealloc = dyn_cast(*oldMemRef.user_begin())) { dealloc.erase(); - allocInst->erase(); + allocOp->erase(); } } } @@ -289,22 +288,21 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) { // Double the buffers for tag memrefs. for (auto &pair : startWaitPairs) { - auto *dmaFinishInst = pair.second; - Value oldTagMemRef = - dmaFinishInst->getOperand(getTagMemRefPos(*dmaFinishInst)); + auto *dmaFinishOp = pair.second; + Value oldTagMemRef = dmaFinishOp->getOperand(getTagMemRefPos(*dmaFinishOp)); if (!doubleBuffer(oldTagMemRef, forOp)) { LLVM_DEBUG(llvm::dbgs() << "tag double buffering failed\n";); return; } // If the old tag has no uses or a single dealloc use, remove it. // (canonicalization handles more complex cases). - if (auto *tagAllocInst = oldTagMemRef.getDefiningOp()) { + if (auto *tagAllocOp = oldTagMemRef.getDefiningOp()) { if (oldTagMemRef.use_empty()) { - tagAllocInst->erase(); + tagAllocOp->erase(); } else if (oldTagMemRef.hasOneUse()) { if (auto dealloc = dyn_cast(*oldTagMemRef.user_begin())) { dealloc.erase(); - tagAllocInst->erase(); + tagAllocOp->erase(); } } } @@ -317,12 +315,12 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) { // Store shift for operation for later lookup for AffineApplyOp's. DenseMap instShiftMap; for (auto &pair : startWaitPairs) { - auto *dmaStartInst = pair.first; - assert(isa(dmaStartInst)); - instShiftMap[dmaStartInst] = 0; + auto *dmaStartOp = pair.first; + assert(isa(dmaStartOp)); + instShiftMap[dmaStartOp] = 0; // Set shifts for DMA start op's affine operand computation slices to 0. SmallVector sliceOps; - mlir::createAffineComputationSlice(dmaStartInst, &sliceOps); + mlir::createAffineComputationSlice(dmaStartOp, &sliceOps); if (!sliceOps.empty()) { for (auto sliceOp : sliceOps) { instShiftMap[sliceOp.getOperation()] = 0; @@ -331,7 +329,7 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) { // If a slice wasn't created, the reachable affine.apply op's from its // operands are the ones that go with it. SmallVector affineApplyInsts; - SmallVector operands(dmaStartInst->getOperands()); + SmallVector operands(dmaStartOp->getOperands()); getReachableAffineApplyOps(operands, affineApplyInsts); for (auto *op : affineApplyInsts) { instShiftMap[op] = 0; @@ -339,16 +337,14 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) { } } // Everything else (including compute ops and dma finish) are shifted by one. - for (auto &op : *forOp.getBody()) { - if (instShiftMap.find(&op) == instShiftMap.end()) { + for (auto &op : forOp.getBody()->without_terminator()) + if (instShiftMap.find(&op) == instShiftMap.end()) instShiftMap[&op] = 1; - } - } // Get shifts stored in map. std::vector shifts(forOp.getBody()->getOperations().size()); unsigned s = 0; - for (auto &op : *forOp.getBody()) { + for (auto &op : forOp.getBody()->without_terminator()) { assert(instShiftMap.find(&op) != instShiftMap.end()); shifts[s++] = instShiftMap[&op]; @@ -365,7 +361,7 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) { return; } - if (failed(instBodySkew(forOp, shifts))) { + if (failed(affineForOpBodySkew(forOp, shifts))) { LLVM_DEBUG(llvm::dbgs() << "op body skewing failed - unexpected\n";); return; } diff --git a/mlir/lib/Transforms/Utils/LoopUtils.cpp b/mlir/lib/Transforms/Utils/LoopUtils.cpp index 0df8837503d79d..96b4e72eff488f 100644 --- a/mlir/lib/Transforms/Utils/LoopUtils.cpp +++ b/mlir/lib/Transforms/Utils/LoopUtils.cpp @@ -156,65 +156,57 @@ void mlir::promoteSingleIterationLoops(FuncOp f) { f.walk([](AffineForOp forOp) { promoteIfSingleIteration(forOp); }); } -/// Generates a 'affine.for' op with the specified lower and upper bounds -/// while generating the right IV remappings for the shifted operations. The -/// operation blocks that go into the loop are specified in instGroupQueue -/// starting from the specified offset, and in that order; the first element of -/// the pair specifies the shift applied to that group of operations; note -/// that the shift is multiplied by the loop step before being applied. Returns -/// nullptr if the generated loop simplifies to a single iteration one. -static AffineForOp -generateLoop(AffineMap lbMap, AffineMap ubMap, - const std::vector>> - &instGroupQueue, - unsigned offset, AffineForOp srcForInst, OpBuilder b) { - auto lbOperands = srcForInst.getLowerBoundOperands(); - auto ubOperands = srcForInst.getUpperBoundOperands(); +/// Generates an affine.for op with the specified lower and upper bounds +/// while generating the right IV remappings to realize shifts for operations in +/// its body. The operations that go into the loop body are specified in +/// opGroupQueue starting from the specified offset, and in that order. The +/// first element of the pair specifies the shift applied to that group of +/// operations; the shift is multiplied by the loop step before being applied. +/// Returns nullptr if the generated loop simplifies to a single iteration one. +static AffineForOp generateShiftedLoop( + AffineMap lbMap, AffineMap ubMap, + const std::vector>> &opGroupQueue, + unsigned offset, AffineForOp srcForOp, OpBuilder b) { + auto lbOperands = srcForOp.getLowerBoundOperands(); + auto ubOperands = srcForOp.getUpperBoundOperands(); assert(lbMap.getNumInputs() == lbOperands.size()); assert(ubMap.getNumInputs() == ubOperands.size()); - auto loopChunk = - b.create(srcForInst.getLoc(), lbOperands, lbMap, ubOperands, - ubMap, srcForInst.getStep()); + auto loopChunk = b.create(srcForOp.getLoc(), lbOperands, lbMap, + ubOperands, ubMap, srcForOp.getStep()); auto loopChunkIV = loopChunk.getInductionVar(); - auto srcIV = srcForInst.getInductionVar(); + auto srcIV = srcForOp.getInductionVar(); BlockAndValueMapping operandMap; OpBuilder bodyBuilder = loopChunk.getBodyBuilder(); - for (auto it = instGroupQueue.begin() + offset, e = instGroupQueue.end(); - it != e; ++it) { + for (auto it = opGroupQueue.begin() + offset, e = opGroupQueue.end(); it != e; + ++it) { uint64_t shift = it->first; - auto insts = it->second; + auto ops = it->second; // All 'same shift' operations get added with their operands being // remapped to results of cloned operations, and their IV used remapped. // Generate the remapping if the shift is not zero: remappedIV = newIV - // shift. if (!srcIV.use_empty() && shift != 0) { auto ivRemap = bodyBuilder.create( - srcForInst.getLoc(), + srcForOp.getLoc(), bodyBuilder.getSingleDimShiftAffineMap( - -static_cast(srcForInst.getStep() * shift)), + -static_cast(srcForOp.getStep() * shift)), loopChunkIV); operandMap.map(srcIV, ivRemap); } else { operandMap.map(srcIV, loopChunkIV); } - for (auto *op : insts) { - if (!isa(op)) - bodyBuilder.clone(*op, operandMap); - } + for (auto *op : ops) + bodyBuilder.clone(*op, operandMap); }; if (succeeded(promoteIfSingleIteration(loopChunk))) return AffineForOp(); return loopChunk; } -/// Skew the operations in the body of a 'affine.for' operation with the -/// specified operation-wise shifts. The shifts are with respect to the -/// original execution order, and are multiplied by the loop 'step' before being -/// applied. A shift of zero for each operation will lead to no change. // The skewing of operations with respect to one another can be used for // example to allow overlap of asynchronous operations (such as DMA // communication) with computation, or just relative shifting of operations @@ -226,8 +218,9 @@ generateLoop(AffineMap lbMap, AffineMap ubMap, // asserts preservation of SSA dominance. A check for that as well as that for // memory-based dependence preservation check rests with the users of this // method. -LogicalResult mlir::instBodySkew(AffineForOp forOp, ArrayRef shifts, - bool unrollPrologueEpilogue) { +LogicalResult mlir::affineForOpBodySkew(AffineForOp forOp, + ArrayRef shifts, + bool unrollPrologueEpilogue) { if (forOp.getBody()->begin() == std::prev(forOp.getBody()->end())) return success(); @@ -263,11 +256,11 @@ LogicalResult mlir::instBodySkew(AffineForOp forOp, ArrayRef shifts, // An array of operation groups sorted by shift amount; each group has all // operations with the same shift in the order in which they appear in the // body of the 'affine.for' op. - std::vector> sortedInstGroups(maxShift + 1); + std::vector> sortedOpGroups(maxShift + 1); unsigned pos = 0; - for (auto &op : *forOp.getBody()) { + for (auto &op : forOp.getBody()->without_terminator()) { auto shift = shifts[pos++]; - sortedInstGroups[shift].push_back(&op); + sortedOpGroups[shift].push_back(&op); } // Unless the shifts have a specific pattern (which actually would be the @@ -275,40 +268,39 @@ LogicalResult mlir::instBodySkew(AffineForOp forOp, ArrayRef shifts, // Nevertheless, if 'unrollPrologueEpilogue' is set, we will treat the first // loop generated as the prologue and the last as epilogue and unroll these // fully. - AffineForOp prologue; - AffineForOp epilogue; + AffineForOp prologue, epilogue; // Do a sweep over the sorted shifts while storing open groups in a // vector, and generating loop portions as necessary during the sweep. A block // of operations is paired with its shift. - std::vector>> instGroupQueue; + std::vector>> opGroupQueue; auto origLbMap = forOp.getLowerBoundMap(); uint64_t lbShift = 0; OpBuilder b(forOp.getOperation()); - for (uint64_t d = 0, e = sortedInstGroups.size(); d < e; ++d) { + for (uint64_t d = 0, e = sortedOpGroups.size(); d < e; ++d) { // If nothing is shifted by d, continue. - if (sortedInstGroups[d].empty()) + if (sortedOpGroups[d].empty()) continue; - if (!instGroupQueue.empty()) { + if (!opGroupQueue.empty()) { assert(d >= 1 && "Queue expected to be empty when the first block is found"); // The interval for which the loop needs to be generated here is: // [lbShift, min(lbShift + tripCount, d)) and the body of the - // loop needs to have all operations in instQueue in that order. + // loop needs to have all operations in opQueue in that order. AffineForOp res; if (lbShift + tripCount * step < d * step) { - res = generateLoop( + res = generateShiftedLoop( b.getShiftedAffineMap(origLbMap, lbShift), b.getShiftedAffineMap(origLbMap, lbShift + tripCount * step), - instGroupQueue, 0, forOp, b); + opGroupQueue, /*offset=*/0, forOp, b); // Entire loop for the queued op groups generated, empty it. - instGroupQueue.clear(); + opGroupQueue.clear(); lbShift += tripCount * step; } else { - res = generateLoop(b.getShiftedAffineMap(origLbMap, lbShift), - b.getShiftedAffineMap(origLbMap, d), instGroupQueue, - 0, forOp, b); + res = generateShiftedLoop(b.getShiftedAffineMap(origLbMap, lbShift), + b.getShiftedAffineMap(origLbMap, d), + opGroupQueue, /*offset=*/0, forOp, b); lbShift = d * step; } if (!prologue && res) @@ -319,16 +311,16 @@ LogicalResult mlir::instBodySkew(AffineForOp forOp, ArrayRef shifts, lbShift = d * step; } // Augment the list of operations that get into the current open interval. - instGroupQueue.push_back({d, sortedInstGroups[d]}); + opGroupQueue.push_back({d, sortedOpGroups[d]}); } // Those operations groups left in the queue now need to be processed (FIFO) // and their loops completed. - for (unsigned i = 0, e = instGroupQueue.size(); i < e; ++i) { - uint64_t ubShift = (instGroupQueue[i].first + tripCount) * step; - epilogue = generateLoop(b.getShiftedAffineMap(origLbMap, lbShift), - b.getShiftedAffineMap(origLbMap, ubShift), - instGroupQueue, i, forOp, b); + for (unsigned i = 0, e = opGroupQueue.size(); i < e; ++i) { + uint64_t ubShift = (opGroupQueue[i].first + tripCount) * step; + epilogue = generateShiftedLoop(b.getShiftedAffineMap(origLbMap, lbShift), + b.getShiftedAffineMap(origLbMap, ubShift), + opGroupQueue, /*offset=*/i, forOp, b); lbShift = ubShift; if (!prologue) prologue = epilogue; diff --git a/mlir/test/Conversion/GPUToVulkan/invoke-vulkan.mlir b/mlir/test/Conversion/GPUToVulkan/invoke-vulkan.mlir index 060e2b3c93db6d..4313eb5548535e 100644 --- a/mlir/test/Conversion/GPUToVulkan/invoke-vulkan.mlir +++ b/mlir/test/Conversion/GPUToVulkan/invoke-vulkan.mlir @@ -6,7 +6,7 @@ // CHECK: %[[addressof_SPIRV_BIN:.*]] = llvm.mlir.addressof @SPIRV_BIN // CHECK: %[[SPIRV_BIN_ptr:.*]] = llvm.getelementptr %[[addressof_SPIRV_BIN]] // CHECK: %[[SPIRV_BIN_size:.*]] = llvm.mlir.constant -// CHECK: llvm.call @bindResource(%[[Vulkan_Runtime_ptr]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm<"i8*">, !llvm.i32, !llvm.i32, !llvm<"float*">, !llvm.i64) -> !llvm.void +// CHECK: llvm.call @bindMemRef1DFloat(%[[Vulkan_Runtime_ptr]], %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm<"i8*">, !llvm.i32, !llvm.i32, !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">) -> !llvm.void // CHECK: llvm.call @setBinaryShader(%[[Vulkan_Runtime_ptr]], %[[SPIRV_BIN_ptr]], %[[SPIRV_BIN_size]]) : (!llvm<"i8*">, !llvm<"i8*">, !llvm.i32) -> !llvm.void // CHECK: %[[addressof_entry_point:.*]] = llvm.mlir.addressof @kernel_spv_entry_point_name // CHECK: %[[entry_point_ptr:.*]] = llvm.getelementptr %[[addressof_entry_point]] @@ -44,5 +44,18 @@ module attributes {gpu.container_module} { : (!llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm<"float*">, !llvm<"float*">, !llvm.i64, !llvm.i64, !llvm.i64) -> () llvm.return } - llvm.func @vulkanLaunch(!llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm<"float*">, !llvm<"float*">, !llvm.i64, !llvm.i64, !llvm.i64) + llvm.func @vulkanLaunch(%arg0: !llvm.i64, %arg1: !llvm.i64, %arg2: !llvm.i64, %arg3: !llvm.i64, %arg4: !llvm.i64, %arg5: !llvm.i64, %arg6: !llvm<"float*">, %arg7: !llvm<"float*">, %arg8: !llvm.i64, %arg9: !llvm.i64, %arg10: !llvm.i64) { + %0 = llvm.mlir.undef : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }"> + %1 = llvm.insertvalue %arg6, %0[0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }"> + %2 = llvm.insertvalue %arg7, %1[1] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }"> + %3 = llvm.insertvalue %arg8, %2[2] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }"> + %4 = llvm.insertvalue %arg9, %3[3, 0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }"> + %5 = llvm.insertvalue %arg10, %4[4, 0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }"> + %6 = llvm.mlir.constant(1 : index) : !llvm.i64 + %7 = llvm.alloca %6 x !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }"> : (!llvm.i64) -> !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*"> + llvm.store %5, %7 : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*"> + llvm.call @_mlir_ciface_vulkanLaunch(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5, %7) : (!llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">) -> () + llvm.return + } + llvm.func @_mlir_ciface_vulkanLaunch(!llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">) } diff --git a/mlir/test/Dialect/AffineOps/canonicalize.mlir b/mlir/test/Dialect/AffineOps/canonicalize.mlir index 26220925bfb31a..ede438eb0bd4d2 100644 --- a/mlir/test/Dialect/AffineOps/canonicalize.mlir +++ b/mlir/test/Dialect/AffineOps/canonicalize.mlir @@ -448,7 +448,7 @@ func @canonicalize_affine_if(%M : index, %N : index) { // ----- // CHECK-DAG: [[LBMAP:#map[0-9]+]] = affine_map<()[s0] -> (0, s0)> -// CHECK-DAG: [[UBMAP:#map[0-9]+]] = affine_map<()[s0] -> (1024, s0 + s0)> +// CHECK-DAG: [[UBMAP:#map[0-9]+]] = affine_map<()[s0] -> (1024, s0 * 2)> // CHECK-LABEL: func @canonicalize_bounds // CHECK-SAME: [[M:%.*]]: index, diff --git a/mlir/test/Dialect/QuantOps/quant_region.mlir b/mlir/test/Dialect/QuantOps/quant_region.mlir new file mode 100644 index 00000000000000..ee874211a7acbe --- /dev/null +++ b/mlir/test/Dialect/QuantOps/quant_region.mlir @@ -0,0 +1,101 @@ +// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s + +// CHECK-LABEL: @source +func @source(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>, %arg2: tensor<4xf32>) -> (tensor<4xf32>) { + %0 = "quant.region"(%arg0, %arg1, %arg2) ({ + ^bb0(%10: tensor<4xf32>, %11: tensor<4xf32>, %12: tensor<4xf32>): + %13 = "foo"(%10, %11) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + %14 = "bar"(%13, %12) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + "quant.return"(%14) : (tensor<4xf32>) -> () + }) {input_specs = [f32, f32, f32], output_specs = [f32], logical_kernel = "xyz"} + : (tensor<4xf32>, tensor<4xf32>, tensor<4xf32>) -> (tensor<4xf32>) + return %0 : tensor<4xf32> +} + +// CHECK-LABEL: @annotated +func @annotated(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>, %arg2: tensor<4xf32>) -> (tensor<4xf32>) { + %0 = "quant.region"(%arg0, %arg1, %arg2) ({ + ^bb0(%10: tensor<4xf32>, %11: tensor<4xf32>, %12: tensor<4xf32>): + %13 = "foo"(%10, %11) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + %14 = "bar"(%13, %12) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + "quant.return"(%14) : (tensor<4xf32>) -> () + }) {input_specs = [!quant.uniform, !quant.uniform, f32], + output_specs = [!quant.uniform], logical_kernel = "xyz"} + : (tensor<4xf32>, tensor<4xf32>, tensor<4xf32>) -> (tensor<4xf32>) + return %0 : tensor<4xf32> +} + +// CHECK-LABEL: @quantized +func @quantized(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>, %arg2: tensor<4xf32>) -> (tensor<4xf32>) { + %0 = "quant.region"(%arg0, %arg1, %arg2) ({ + ^bb0(%10: tensor<4xf32>, %11: tensor<4xf32>, %12: tensor<4xf32>): + %13 = "foo"(%10, %11) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + %14 = "bar"(%13, %12) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + "quant.return"(%14) : (tensor<4xf32>) -> () + }) {input_specs = [!quant.uniform, !quant.uniform, !quant.uniform], + output_specs = [!quant.uniform], logical_kernel = "xyz"} + : (tensor<4xf32>, tensor<4xf32>, tensor<4xf32>) -> (tensor<4xf32>) + return %0 : tensor<4xf32> +} + +// ----- + +func @unmatched_quantize(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>, %arg2: tensor<4xf32>) -> (tensor<4xf32>) { + // @expected-error @+1 {{'quant.region' op has incompatible specification !quant.uniform and input type 'tensor<4xf32>'}} + %0 = "quant.region"(%arg0, %arg1, %arg2) ({ + ^bb0(%10: tensor<4xf32>, %11: tensor<4xf32>, %12: tensor<4xf32>): + %13 = "foo"(%10, %11) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + %14 = "bar"(%13, %12) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + "quant.return"(%14) : (tensor<4xf32>) -> () + }) {input_specs = [!quant.uniform, !quant.uniform, !quant.uniform], + output_specs = [!quant.uniform], logical_kernel = "xyz"} + : (tensor<4xf32>, tensor<4xf32>, tensor<4xf32>) -> (tensor<4xf32>) + return %0 : tensor<4xf32> +} + +// ----- + +func @unmatched_primitive(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>, %arg2: tensor<4xf32>) -> (tensor<4xf32>) { + // @expected-error @+1 {{'quant.region' op has incompatible specification i32 and input type 'tensor<4xf32>'}} + %0 = "quant.region"(%arg0, %arg1, %arg2) ({ + ^bb0(%10: tensor<4xf32>, %11: tensor<4xf32>, %12: tensor<4xf32>): + %13 = "foo"(%10, %11) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + %14 = "bar"(%13, %12) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + "quant.return"(%14) : (tensor<4xf32>) -> () + }) {input_specs = [!quant.uniform, !quant.uniform, i32], + output_specs = [!quant.uniform], logical_kernel = "xyz"} + : (tensor<4xf32>, tensor<4xf32>, tensor<4xf32>) -> (tensor<4xf32>) + return %0 : tensor<4xf32> +} + +// ----- + +func @unmatched_number(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>, %arg2: tensor<4xf32>) -> (tensor<4xf32>) { + // @expected-error @+1 {{'quant.region' op has unmatched operands/results number and spec attributes number}} + %0 = "quant.region"(%arg0, %arg1, %arg2) ({ + ^bb0(%10: tensor<4xf32>, %11: tensor<4xf32>, %12: tensor<4xf32>): + %13 = "foo"(%10, %11) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + %14 = "bar"(%13, %12) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + "quant.return"(%14) : (tensor<4xf32>) -> () + }) {input_specs = [!quant.uniform, !quant.uniform], + output_specs = [!quant.uniform], logical_kernel = "xyz"} + : (tensor<4xf32>, tensor<4xf32>, tensor<4xf32>) -> (tensor<4xf32>) + return %0 : tensor<4xf32> +} + +// ----- + +func @isolated(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>, %arg2: tensor<4xf32>) -> (tensor<4xf32>) { + // @expected-note @+1 {{required by region isolation constraints}} + %0 = "quant.region"(%arg0, %arg1) ({ + ^bb0(%10: tensor<4xf32>, %11: tensor<4xf32>): + %13 = "foo"(%10, %11) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + // @expected-error @+1 {{'bar' op using value defined outside the region}} + %14 = "bar"(%13, %arg2) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> + "quant.return"(%14) : (tensor<4xf32>) -> () + }) {input_specs = [!quant.uniform, !quant.uniform], + output_specs = [!quant.uniform], logical_kernel = "xyz"} + : (tensor<4xf32>, tensor<4xf32>) -> (tensor<4xf32>) + return %0 : tensor<4xf32> +} + diff --git a/mlir/test/IR/affine-map.mlir b/mlir/test/IR/affine-map.mlir index 9ce4d8c0bfc74b..d4c80049b7423f 100644 --- a/mlir/test/IR/affine-map.mlir +++ b/mlir/test/IR/affine-map.mlir @@ -33,7 +33,7 @@ // The following reduction should be unique'd out too but such expression // simplification is not performed for IR parsing, but only through analyses // and transforms. -// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d1 - d0 + (d0 - d1 + 1) * 2 + d1 - 1, d1 + d1 + d1 + d1 + 2)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d1 - d0 + (d0 - d1 + 1) * 2 + d1 - 1, d1 * 4 + 2)> #map3l = affine_map<(i, j) -> ((j - i) + 2*(i - j + 1) + j - 1 + 0, j + j + 1 + j + j + 1)> // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 + 2, d1)> @@ -183,6 +183,12 @@ // CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0, d0 * 2 + d1 * 4 + 2, 1, 2, (d0 * 4) mod 8)> #map56 = affine_map<(d0, d1) -> ((4*d0 + 2) floordiv 4, (4*d0 + 8*d1 + 5) floordiv 2, (2*d0 + 4*d1 + 3) mod 2, (3*d0 - 4) mod 3, (4*d0 + 8*d1) mod 8)> +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d1, d0, 0)> +#map57 = affine_map<(d0, d1) -> (d0 - d0 + d1, -d0 + d0 + d0, (1 + d0 + d1 floordiv 4) - (d0 + d1 floordiv 4 + 1))> + +// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 * 3, (d0 + d1) * 2, d0 mod 2)> +#map58 = affine_map<(d0, d1) -> (4*d0 - 2*d0 + d0, (d0 + d1) + (d0 + d1), 2 * (d0 mod 2) - d0 mod 2)> + // Single identity maps are removed. // CHECK: func @f0(memref<2x4xi8, 1>) func @f0(memref<2x4xi8, #map0, 1>) @@ -361,3 +367,9 @@ func @f54(memref<10xi32, #map54>) // CHECK: func @f56(memref<1x1xi8, #map{{[0-9]+}}>) func @f56(memref<1x1xi8, #map56>) + +// CHECK: "f57"() {map = #map{{[0-9]+}}} : () -> () +"f57"() {map = #map57} : () -> () + +// CHECK: "f58"() {map = #map{{[0-9]+}}} : () -> () +"f58"() {map = #map58} : () -> () diff --git a/mlir/test/Transforms/pipeline-data-transfer.mlir b/mlir/test/Transforms/pipeline-data-transfer.mlir index 8293120d50e8f6..a2ff1262552096 100644 --- a/mlir/test/Transforms/pipeline-data-transfer.mlir +++ b/mlir/test/Transforms/pipeline-data-transfer.mlir @@ -36,23 +36,23 @@ func @loop_nest_dma() { // CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}} mod 2, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32> // CHECK-NEXT: affine.for %{{.*}} = 1 to 8 { // CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}} mod 2, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32> -// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_MINUS_1]](%{{.*}}) -// CHECK-NEXT: %{{.*}} = affine.apply [[MOD_2]](%{{.*}}) -// CHECK-NEXT: %{{.*}} = affine.apply [[MOD_2]](%{{.*}}) +// CHECK-NEXT: affine.apply [[MAP_MINUS_1]](%{{.*}}) +// CHECK-NEXT: affine.apply [[MOD_2]](%{{.*}}) +// CHECK-NEXT: affine.apply [[MOD_2]](%{{.*}}) // CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<2x1xf32> -// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1> -// CHECK-NEXT: %{{.*}} = "compute"(%{{.*}}) : (f32) -> f32 +// CHECK-NEXT: affine.load %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1> +// CHECK-NEXT: "compute"(%{{.*}}) : (f32) -> f32 // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1> // CHECK-NEXT: affine.for %{{.*}} = 0 to 32 { // CHECK-NEXT: "do_more_compute"(%{{.*}}, %{{.*}}) : (index, index) -> () // CHECK-NEXT: } // CHECK-NEXT: } -// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_MINUS_1]](%{{.*}}) -// CHECK-NEXT: %{{.*}} = affine.apply [[MOD_2]](%{{.*}}) -// CHECK-NEXT: %{{.*}} = affine.apply [[MOD_2]](%{{.*}}) +// CHECK-NEXT: affine.apply [[MAP_MINUS_1]](%{{.*}}) +// CHECK-NEXT: affine.apply [[MOD_2]](%{{.*}}) +// CHECK-NEXT: affine.apply [[MOD_2]](%{{.*}}) // CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<2x1xf32> -// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1> -// CHECK-NEXT: %{{.*}} = "compute"(%{{.*}}) : (f32) -> f32 +// CHECK-NEXT: affine.load %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1> +// CHECK-NEXT: "compute"(%{{.*}}) : (f32) -> f32 // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1> // CHECK-NEXT: affine.for %{{.*}} = 0 to 32 { // CHECK-NEXT: "do_more_compute"(%{{.*}}, %{{.*}}) : (index, index) -> () @@ -89,8 +89,8 @@ func @loop_step(%arg0: memref<512xf32>, // CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[(%{{.*}} floordiv 4) mod 2, 0], [[TAG]][(%{{.*}} floordiv 4) mod 2, 0], %{{.*}} : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32> // CHECK-NEXT: affine.for %{{.*}} = 4 to 512 step 4 { // CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[(%{{.*}} floordiv 4) mod 2, 0], [[TAG]][(%{{.*}} floordiv 4) mod 2, 0], %{{.*}} : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32> -// CHECK-NEXT: %{{.*}} = affine.apply [[REMAP_SHIFT_MINUS_4]](%{{.*}}) -// CHECK-NEXT: %{{.*}} = affine.apply [[FLOOR_MOD_2]](%{{.*}}) +// CHECK-NEXT: affine.apply [[REMAP_SHIFT_MINUS_4]](%{{.*}}) +// CHECK-NEXT: affine.apply [[FLOOR_MOD_2]](%{{.*}}) // CHECK: affine.dma_wait [[TAG]][(%{{.*}} floordiv 4) mod 2, 0], %{{.*}} : memref<2x1xi32> // CHECK-NEXT: "compute"(%{{.*}}) : (index) -> () // CHECK-NEXT: } @@ -313,7 +313,7 @@ func @live_out_use(%arg0: memref<512 x 32 x f32>) -> f32 { dealloc %tag : memref<1 x i32> dealloc %Av : memref<32 x 32 x f32, 2> return %v : f32 -// CHECK: %{{[0-9]+}} = affine.load %{{[0-9]+}}[%{{.*}}, %{{.*}}] : memref<32x32xf32, 2> +// CHECK: affine.load %{{[0-9]+}}[%{{.*}}, %{{.*}}] : memref<32x32xf32, 2> // CHECK: return } @@ -329,10 +329,10 @@ func @dynamic_shape_dma_buffer(%arg0: memref<512 x 32 x f32>) { %tag = alloc() : memref<1 x i32> // Double buffering for dynamic shaped buffer. -// CHECK: %{{.*}} = alloc(%{{.*}}, %{{.*}}) : memref -// CHECK-NEXT: %{{.*}} = dim %{{.*}}, 0 : memref -// CHECK-NEXT: %{{.*}} = dim %{{.*}}, 1 : memref -// CHECK-NEXT: %{{.*}} = alloc(%{{.*}}, %{{.*}}) : memref<2x?x?xf32, 2> +// CHECK: alloc(%{{.*}}, %{{.*}}) : memref +// CHECK-NEXT: dim %{{.*}}, 0 : memref +// CHECK-NEXT: dim %{{.*}}, 1 : memref +// CHECK-NEXT: alloc(%{{.*}}, %{{.*}}) : memref<2x?x?xf32, 2> // CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0, 0], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} affine.for %kTT = 0 to 16 { affine.dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %tag[%zero], %num_elt : diff --git a/mlir/test/lib/TestDialect/CMakeLists.txt b/mlir/test/lib/TestDialect/CMakeLists.txt index 6424d5ab23e1fc..d625a58190965e 100644 --- a/mlir/test/lib/TestDialect/CMakeLists.txt +++ b/mlir/test/lib/TestDialect/CMakeLists.txt @@ -6,6 +6,7 @@ set(LLVM_OPTIONAL_SOURCES set(LLVM_TARGET_DEFINITIONS TestOps.td) mlir_tablegen(TestOps.h.inc -gen-op-decls) mlir_tablegen(TestOps.cpp.inc -gen-op-defs) +mlir_tablegen(TestOpsDialect.h.inc -gen-dialect-decls) mlir_tablegen(TestOpEnums.h.inc -gen-enum-decls) mlir_tablegen(TestOpEnums.cpp.inc -gen-enum-defs) mlir_tablegen(TestPatterns.inc -gen-rewriters) diff --git a/mlir/test/lib/TestDialect/TestDialect.cpp b/mlir/test/lib/TestDialect/TestDialect.cpp index 94b5017978a09f..da15486ef1171b 100644 --- a/mlir/test/lib/TestDialect/TestDialect.cpp +++ b/mlir/test/lib/TestDialect/TestDialect.cpp @@ -128,7 +128,7 @@ struct TestInlinerInterface : public DialectInlinerInterface { //===----------------------------------------------------------------------===// TestDialect::TestDialect(MLIRContext *context) - : Dialect(getDialectName(), context) { + : Dialect(getDialectNamespace(), context) { addOperations< #define GET_OP_LIST #include "TestOps.cpp.inc" diff --git a/mlir/test/lib/TestDialect/TestDialect.h b/mlir/test/lib/TestDialect/TestDialect.h index f751918bb1b3ad..9b4dfee2daaa3d 100644 --- a/mlir/test/lib/TestDialect/TestDialect.h +++ b/mlir/test/lib/TestDialect/TestDialect.h @@ -29,23 +29,7 @@ namespace mlir { -class TestDialect : public Dialect { -public: - /// Create the dialect in the given `context`. - TestDialect(MLIRContext *context); - - /// Get the canonical string name of the dialect. - static StringRef getDialectName() { return "test"; } - - LogicalResult verifyOperationAttribute(Operation *op, - NamedAttribute namedAttr) override; - LogicalResult verifyRegionArgAttribute(Operation *op, unsigned regionIndex, - unsigned argIndex, - NamedAttribute namedAttr) override; - LogicalResult verifyRegionResultAttribute(Operation *op, unsigned regionIndex, - unsigned resultIndex, - NamedAttribute namedAttr) override; -}; +#include "TestOpsDialect.h.inc" #define GET_OP_CLASSES #include "TestOps.h.inc" diff --git a/mlir/test/lib/TestDialect/TestOps.td b/mlir/test/lib/TestDialect/TestOps.td index d9710ba03961b6..cf0ec63fe6c595 100644 --- a/mlir/test/lib/TestDialect/TestOps.td +++ b/mlir/test/lib/TestDialect/TestOps.td @@ -17,13 +17,16 @@ include "mlir/Interfaces/ControlFlowInterfaces.td" include "mlir/Interfaces/InferTypeOpInterface.td" include "mlir/Interfaces/SideEffects.td" -def TEST_Dialect : Dialect { +def Test_Dialect : Dialect { let name = "test"; let cppNamespace = ""; + let hasOperationAttrVerify = 1; + let hasRegionArgAttrVerify = 1; + let hasRegionResultAttrVerify = 1; } class TEST_Op traits = []> : - Op; + Op; //===----------------------------------------------------------------------===// // Test Types diff --git a/mlir/tools/mlir-tblgen/DialectGen.cpp b/mlir/tools/mlir-tblgen/DialectGen.cpp index c0009d6e1231b1..a662f6273b9dd5 100644 --- a/mlir/tools/mlir-tblgen/DialectGen.cpp +++ b/mlir/tools/mlir-tblgen/DialectGen.cpp @@ -36,14 +36,23 @@ static llvm::cl::opt selectedDialect("dialect", llvm::cl::desc("The dialect to gen for"), llvm::cl::cat(dialectGenCat), llvm::cl::CommaSeparated); +/// Utility iterator used for filtering records for a specific dialect. +namespace { +using DialectFilterIterator = + llvm::filter_iterator::iterator, + std::function>; +} // end anonymous namespace + /// Given a set of records for a T, filter the ones that correspond to /// the given dialect. template -static auto filterForDialect(ArrayRef records, - Dialect &dialect) { - return llvm::make_filter_range(records, [&](const llvm::Record *record) { +static iterator_range +filterForDialect(ArrayRef records, Dialect &dialect) { + auto filterFn = [&](const llvm::Record *record) { return T(record).getDialect() == dialect; - }); + }; + return {DialectFilterIterator(records.begin(), records.end(), filterFn), + DialectFilterIterator(records.end(), records.end(), filterFn)}; } //===----------------------------------------------------------------------===// @@ -92,13 +101,37 @@ static const char *const constantMaterializerDecl = R"( ::mlir::Location loc) override; )"; +/// The code block for the operation attribute verifier hook. +static const char *const opAttrVerifierDecl = R"( + /// Provides a hook for verifying dialect attributes attached to the given + /// op. + ::mlir::LogicalResult verifyOperationAttribute( + ::mlir::Operation *op, ::mlir::NamedAttribute attribute) override; +)"; + +/// The code block for the region argument attribute verifier hook. +static const char *const regionArgAttrVerifierDecl = R"( + /// Provides a hook for verifying dialect attributes attached to the given + /// op's region argument. + ::mlir::LogicalResult verifyRegionArgAttribute( + ::mlir::Operation *op, unsigned regionIndex, unsigned argIndex, + ::mlir::NamedAttribute attribute) override; +)"; + +/// The code block for the region result attribute verifier hook. +static const char *const regionResultAttrVerifierDecl = R"( + /// Provides a hook for verifying dialect attributes attached to the given + /// op's region result. + ::mlir::LogicalResult verifyRegionResultAttribute( + ::mlir::Operation *op, unsigned regionIndex, unsigned resultIndex, + ::mlir::NamedAttribute attribute) override; +)"; + /// Generate the declaration for the given dialect class. -static void emitDialectDecl( - Dialect &dialect, - FunctionTraits)>::result_t - dialectAttrs, - FunctionTraits)>::result_t dialectTypes, - raw_ostream &os) { +static void emitDialectDecl(Dialect &dialect, + iterator_range dialectAttrs, + iterator_range dialectTypes, + raw_ostream &os) { // Emit the start of the decl. std::string cppName = dialect.getCppClassName(); os << llvm::formatv(dialectDeclBeginStr, cppName, dialect.getName()); @@ -113,6 +146,12 @@ static void emitDialectDecl( // Add the decls for the various features of the dialect. if (dialect.hasConstantMaterializer()) os << constantMaterializerDecl; + if (dialect.hasOperationAttrVerify()) + os << opAttrVerifierDecl; + if (dialect.hasRegionArgAttrVerify()) + os << regionArgAttrVerifierDecl; + if (dialect.hasRegionResultAttrVerify()) + os << regionResultAttrVerifierDecl; if (llvm::Optional extraDecl = dialect.getExtraClassDeclaration()) os << *extraDecl; diff --git a/mlir/tools/mlir-vulkan-runner/VulkanRuntime.h b/mlir/tools/mlir-vulkan-runner/VulkanRuntime.h index 91f234007f74bd..9c63714306b977 100644 --- a/mlir/tools/mlir-vulkan-runner/VulkanRuntime.h +++ b/mlir/tools/mlir-vulkan-runner/VulkanRuntime.h @@ -22,7 +22,7 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/Support/ToolOutputFile.h" -#include // NOLINT +#include using namespace mlir; diff --git a/mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp b/mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp index f91bc71e8713ef..10987f6939cab6 100644 --- a/mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp +++ b/mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp @@ -40,7 +40,9 @@ static LogicalResult runMLIRPasses(ModuleOp module) { modulePM.addPass(spirv::createLowerABIAttributesPass()); modulePM.addPass(spirv::createUpdateVersionCapabilityExtensionPass()); passManager.addPass(createConvertGpuLaunchFuncToVulkanLaunchFuncPass()); - passManager.addPass(createLowerToLLVMPass()); + passManager.addPass(createLowerToLLVMPass(/*useAlloca=*/false, + /*useBarePtrCallConv=*/false, + /*emitCWrappers=*/true)); passManager.addPass(createConvertVulkanLaunchFuncToVulkanCallsPass()); return passManager.run(module); } diff --git a/mlir/tools/mlir-vulkan-runner/vulkan-runtime-wrappers.cpp b/mlir/tools/mlir-vulkan-runner/vulkan-runtime-wrappers.cpp index eb9a682da30001..52c11dad8c7e05 100644 --- a/mlir/tools/mlir-vulkan-runner/vulkan-runtime-wrappers.cpp +++ b/mlir/tools/mlir-vulkan-runner/vulkan-runtime-wrappers.cpp @@ -62,34 +62,28 @@ class VulkanRuntimeManager { } // namespace +template +struct MemRefDescriptor { + T *allocated; + T *aligned; + int64_t offset; + int64_t sizes[N]; + int64_t strides[N]; +}; + extern "C" { -// Initializes `VulkanRuntimeManager` and returns a pointer to it. +/// Initializes `VulkanRuntimeManager` and returns a pointer to it. void *initVulkan() { return new VulkanRuntimeManager(); } -// Deinitializes `VulkanRuntimeManager` by the given pointer. +/// Deinitializes `VulkanRuntimeManager` by the given pointer. void deinitVulkan(void *vkRuntimeManager) { delete reinterpret_cast(vkRuntimeManager); } -/// Binds the given memref to the given descriptor set and descriptor index. -void bindResource(void *vkRuntimeManager, DescriptorSetIndex setIndex, - BindingIndex bindIndex, float *ptr, int64_t size) { - VulkanHostMemoryBuffer memBuffer{ptr, - static_cast(size * sizeof(float))}; - reinterpret_cast(vkRuntimeManager) - ->setResourceData(setIndex, bindIndex, memBuffer); -} - void runOnVulkan(void *vkRuntimeManager) { reinterpret_cast(vkRuntimeManager)->runOnVulkan(); } -/// Fills the given 1D float memref with the given float value. -void fillResource1DFloat(float *allocated, float *aligned, int64_t offset, - int64_t size, int64_t stride, float value) { - std::fill_n(allocated, size, value); -} - void setEntryPoint(void *vkRuntimeManager, const char *entryPoint) { reinterpret_cast(vkRuntimeManager) ->setEntryPoint(entryPoint); @@ -105,4 +99,21 @@ void setBinaryShader(void *vkRuntimeManager, uint8_t *shader, uint32_t size) { reinterpret_cast(vkRuntimeManager) ->setShaderModule(shader, size); } + +/// Binds the given 1D float memref to the given descriptor set and descriptor +/// index. +void bindMemRef1DFloat(void *vkRuntimeManager, DescriptorSetIndex setIndex, + BindingIndex bindIndex, + MemRefDescriptor *ptr) { + VulkanHostMemoryBuffer memBuffer{ + ptr->allocated, static_cast(ptr->sizes[0] * sizeof(float))}; + reinterpret_cast(vkRuntimeManager) + ->setResourceData(setIndex, bindIndex, memBuffer); +} + +/// Fills the given 1D float memref with the given float value. +void _mlir_ciface_fillResource1DFloat(MemRefDescriptor *ptr, // NOLINT + float value) { + std::fill_n(ptr->allocated, ptr->sizes[0], value); +} }