This is an archive of the discontinued LLVM Phabricator instance.

Differential D59881

Initial support for vectorization using MASSV (IBM MASS vector library)
ClosedPublic

Authored by pjeeva01 on Mar 27 2019, 8:04 AM.

Details

Reviewers
nemanjai
jsji
hfinkel
mmasten
mzolotukhin
Commits
rG6321c6806591: Initial support for vectorization using MASSV (IBM MASS vector library)
rC362571: Initial support for vectorization using MASSV (IBM MASS vector library)
rL362571: Initial support for vectorization using MASSV (IBM MASS vector library)
Summary

This patch (first of two patches) enables the vectorizer to recognize the IBM MASS vector library routines. This patch specifically adds support for recognizing the “-vector-library=MASSV” option, and defines mappings from IEEE standard scalar math functions to generic PowerPC MASS vector counterparts.
For instance, the generic PowerPC MASS vector entry for double-precision “cbrt” function is “__cbrtd2_massv”

The second patch will further lower the generic PowerPC vector entries to PowerPC subtarget-specific entries.
For instance, the PowerPC generic entry “cbrtd2_massv” is lowered to “cbrtd2_P9” or Power9 subtarget.

The overall support for MASS vector library is presented as such in two patches for ease of review.

Diff Detail

Repository
rL LLVM

Event Timeline

pjeeva01 created this revision.Mar 27 2019, 8:04 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 27 2019, 8:04 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
jsji added a child revision: D59883: Lower generic MASSV entries to PowerPC subtarget-specific entries.Mar 28 2019, 2:10 PM
jsji added inline comments.Mar 28 2019, 2:16 PM
llvm/lib/Analysis/TargetLibraryInfo.cpp
1467–1468

Can we split the refactoring of these definitions into llvm/Analysis/VecFuncs.def into a NFC patch first?
And leave only the MASSV related change in this patch ?

pjeeva01 added inline comments.Mar 29 2019, 6:32 AM
llvm/lib/Analysis/TargetLibraryInfo.cpp
1467–1468

@jsji Thank you for looking into this.

@mmasten @mzolotukhin If you agree with this refactoring suggestion, I will go ahead and create an NFC patch for the same.

pjeeva01 marked an inline comment as done.Apr 3 2019, 9:27 AM
pjeeva01 added inline comments.
llvm/lib/Analysis/TargetLibraryInfo.cpp
1467–1468

NFC patch that simply factors out these definitions into llvm/Analysis/VecFuncs.def is posted [[ llvm/Analysis/VecFuncs.def | here ]]

pjeeva01 added a comment.Apr 5 2019, 12:22 PM

ping

hubert.reinterpretcast added a subscriber: hubert.reinterpretcast.Apr 5 2019, 2:24 PM

@pjeeva01, please post the delta assuming a base that has D60211 incorporated.

llvm/lib/Analysis/TargetLibraryInfo.cpp
1467–1468

You mean, posted as D60211?

pjeeva01 updated this revision to Diff 194193.Apr 8 2019, 12:40 PM

Updated the patch assuming a base that has D60211 incorporated.

jsji added inline comments.Apr 12 2019, 2:53 PM
llvm/include/llvm/Analysis/VecFuncs.def
76

How about the finite versions? eg: __expf_finite

llvm/test/Transforms/LoopVectorize/PowerPC/massv-calls.ll
1

do we require any attr? eg: vsx? what happen to ppc without altivec or vsx?

4

How about powerpc (32 bit) or powerpc64?

93

It would be better if we check all the key elements of call , not only the name .
eg: call <2 x double> @__cbrtd2_massv(<2 x double> %2)

282

Missing some intrinsics test? @sqrt_f64_intrinsic?@sqrt_f32_intrinsic?

1524

Shall we add some negative tests to make sure that we don't vectorize functions not in the list, eg: arbitrary functions, function in ACCELERATE/SVML but not in MASSV?

1525

Maybe add a negative test where the nobuiltin attribute is present too.

nemanjai added a comment.Apr 22 2019, 7:17 AM

@pjeeva01 Can you address Jinsong's comments? It would be good to add the negative tests for sure:

  • No vectorization with -mattr=-altivec
  • No vectorization with the nobuiltin attribute
  • A couple of calls to functions that MASSV doesn't have a vector equivalent for

Also, it would be good to add a run line for big endian.

pjeeva01 updated this revision to Diff 198475.EditedMay 7 2019, 8:23 AM

Thank you for your comments @jsji
This patch includes following updates:

  • negative tests for math functions lacking vector counterparts, for altivec targets, and for nobuiltin attributes.

I have left the CHECK for *_massv function calls as-is because they are intended to check whether the massv suffixed calls are generated. The subsequent patch that further lowers such *_massv calls to PowerPC subtarget-specific entries will have checks with the full function signatures.

MASS vector library is currently supported only for 64-bit Linux LE. Since the use of this vector library is option controlled, I think it's fair for users to experience link errors if and when used with 32-bit Linux, for instance.

jsji added a subscriber: chandlerc.May 14 2019, 7:59 AM

Some more nit-picker, other than that, mostly good to me.

However, as Chandler mentioned in similar patch for AArch64 in https://reviews.llvm.org/D53927,

In D53927#1307196, @chandlerc wrote:

Adding new support for a vector math library seems worth getting reviewed / approved by someone reasonably deeply familiar w/ our vectorization infra.

I would be good to have @hfinkel or @nemanjai or someone more familiar with vectorization infra to double confirm and approve it.

llvm/test/Transforms/LoopVectorize/PowerPC/massv-altivec.ll
2 ↗(On Diff #198475)

I would be great if we can add some comments to describe the overall test points, eg: this is for negative test of massv without altivec support. This apply to all testcases in this patch.

llvm/test/Transforms/LoopVectorize/PowerPC/massv-calls.ll
282

Still missing in latest patch?

pjeeva01 updated this revision to Diff 199822.EditedMay 16 2019, 7:12 AM

This patch includes following updates:

  1. sqrt (f32 and f64) intrinsics are lowered to their vector intrinsic counterparts; lowering them to massv entries is beyond the scope of this patch. Relevant tests for the sqrt intrinsics are added to massv-unsupported.ll
  2. The test files include comments to portray their intent.
nemanjai accepted this revision.May 16 2019, 2:31 PM

LGTM. Thanks for getting this done.

This revision is now accepted and ready to land.May 16 2019, 2:31 PM
nemanjai added a comment.Jun 4 2019, 5:00 PM

I'll commit this for you soon Jeeva.

Closed by commit rL362571: Initial support for vectorization using MASSV (IBM MASS vector library) (authored by nemanjai). · Explain WhyJun 4 2019, 6:54 PM
This revision was automatically updated to reflect the committed changes.
nemanjai mentioned this in rL362571: Initial support for vectorization using MASSV (IBM MASS vector library).
nemanjai mentioned this in rG6321c6806591: Initial support for vectorization using MASSV (IBM MASS vector library).
nemanjai added a comment.Jun 4 2019, 6:57 PM

The LLVM portion of this patch committed in https://reviews.llvm.org/rL362568.

pjeeva01 added a comment.Jun 5 2019, 6:08 AM
In D59881#1530258, @nemanjai wrote:

The LLVM portion of this patch committed in https://reviews.llvm.org/rL362568.

Thank you @nemanjai.

Revision Contents

PathSize
clang/
include/
clang/
Basic/
1 line
Driver/
2 lines
lib/
CodeGen/
3 lines
Frontend/
2 lines
test/
Driver/
1 line
2 lines
llvm/
include/
llvm/
Analysis/
1 line
78 lines
lib/
Analysis/
10 lines
test/
Transforms/
LoopVectorize/
PowerPC/
1526 lines

Diff 194193

clang/include/clang/Basic/CodeGenOptions.h

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines enum InliningMethod {
NormalInlining, // Use the standard function inlining pass. NormalInlining, // Use the standard function inlining pass.
OnlyHintInlining, // Inline only (implicitly) hinted functions. OnlyHintInlining, // Inline only (implicitly) hinted functions.
OnlyAlwaysInlining // Only run the always inlining pass. OnlyAlwaysInlining // Only run the always inlining pass.
}; };
enum VectorLibrary { enum VectorLibrary {
NoLibrary, // Don't use any vector library. NoLibrary, // Don't use any vector library.
Accelerate, // Use the Accelerate framework. Accelerate, // Use the Accelerate framework.
MASSV, // IBM MASS vector library.
SVML // Intel short vector math library. SVML // Intel short vector math library.
}; };
enum ObjCDispatchMethodKind { enum ObjCDispatchMethodKind {
Legacy = 0, Legacy = 0,
NonLegacy = 1, NonLegacy = 1,
Mixed = 2 Mixed = 2
▲ Show 20 Lines • Show All 285 Lines • Show Last 20 Lines

clang/include/clang/Driver/Options.td

Show First 20 Lines • Show All 1,410 Lines • ▼ Show 20 Lines
def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>; def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>; def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>;
def fno_experimental_isel : Flag<["-"], "fno-experimental-isel">, Group<f_clang_Group>, def fno_experimental_isel : Flag<["-"], "fno-experimental-isel">, Group<f_clang_Group>,
HelpText<"Disables the experimental global instruction selector">; HelpText<"Disables the experimental global instruction selector">;
def fno_experimental_new_pass_manager : Flag<["-"], "fno-experimental-new-pass-manager">, def fno_experimental_new_pass_manager : Flag<["-"], "fno-experimental-new-pass-manager">,
Group<f_clang_Group>, Flags<[CC1Option]>, Group<f_clang_Group>, Flags<[CC1Option]>,
HelpText<"Disables an experimental new pass manager in LLVM.">; HelpText<"Disables an experimental new pass manager in LLVM.">;
def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>, def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Use the given vector functions library">, Values<"Accelerate,SVML,none">; HelpText<"Use the given vector functions library">, Values<"Accelerate,MASSV,SVML,none">;
def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>, def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
HelpText<"Disallow implicit conversions between vectors with a different number of elements or different element types">, Flags<[CC1Option]>; HelpText<"Disallow implicit conversions between vectors with a different number of elements or different element types">, Flags<[CC1Option]>;
def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>, def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
HelpText<"Disallow merging of constants">; HelpText<"Disallow merging of constants">;
def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>, def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
Flags<[DriverOption]>; Flags<[DriverOption]>;
def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>, def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>,
Flags<[DriverOption]>; Flags<[DriverOption]>;
▲ Show 20 Lines • Show All 1,749 Lines • Show Last 20 Lines

clang/lib/CodeGen/BackendUtil.cpp

Show First 20 Lines • Show All 330 Lines • ▼ Show 20 Lines for (auto &FuncName : CodeGenOpts.getNoBuiltinFuncs())
if (TLII->getLibFunc(FuncName, F)) if (TLII->getLibFunc(FuncName, F))
TLII->setUnavailable(F); TLII->setUnavailable(F);
} }
switch (CodeGenOpts.getVecLib()) { switch (CodeGenOpts.getVecLib()) {
case CodeGenOptions::Accelerate: case CodeGenOptions::Accelerate:
TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate); TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate);
break; break;
case CodeGenOptions::MASSV:
TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::MASSV);
break;
case CodeGenOptions::SVML: case CodeGenOptions::SVML:
TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML); TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML);
break; break;
default: default:
break; break;
} }
return TLII; return TLII;
} }
▲ Show 20 Lines • Show All 1,221 Lines • Show Last 20 Lines

clang/lib/Frontend/CompilerInvocation.cpp

Show First 20 Lines • Show All 666 Lines • ▼ Show 20 Linesstatic bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
Opts.DebugPassManager = Opts.DebugPassManager =
Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager, Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager,
/* Default */ false); /* Default */ false);
if (Arg *A = Args.getLastArg(OPT_fveclib)) { if (Arg *A = Args.getLastArg(OPT_fveclib)) {
StringRef Name = A->getValue(); StringRef Name = A->getValue();
if (Name == "Accelerate") if (Name == "Accelerate")
Opts.setVecLib(CodeGenOptions::Accelerate); Opts.setVecLib(CodeGenOptions::Accelerate);
else if (Name == "MASSV")
Opts.setVecLib(CodeGenOptions::MASSV);
else if (Name == "SVML") else if (Name == "SVML")
Opts.setVecLib(CodeGenOptions::SVML); Opts.setVecLib(CodeGenOptions::SVML);
else if (Name == "none") else if (Name == "none")
Opts.setVecLib(CodeGenOptions::NoLibrary); Opts.setVecLib(CodeGenOptions::NoLibrary);
else else
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name; Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
} }
▲ Show 20 Lines • Show All 2,827 Lines • Show Last 20 Lines

clang/test/Driver/autocomplete.c

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
// FFPALL: fast // FFPALL: fast
// FFPALL-NEXT: off // FFPALL-NEXT: off
// FFPALL-NEXT: on // FFPALL-NEXT: on
// RUN: %clang --autocomplete=-flto= | FileCheck %s -check-prefix=FLTOALL // RUN: %clang --autocomplete=-flto= | FileCheck %s -check-prefix=FLTOALL
// FLTOALL: full // FLTOALL: full
// FLTOALL-NEXT: thin // FLTOALL-NEXT: thin
// RUN: %clang --autocomplete=-fveclib= | FileCheck %s -check-prefix=FVECLIBALL // RUN: %clang --autocomplete=-fveclib= | FileCheck %s -check-prefix=FVECLIBALL
// FVECLIBALL: Accelerate // FVECLIBALL: Accelerate
// FVECLIBALL-NEXT: MASSV
// FVECLIBALL-NEXT: none // FVECLIBALL-NEXT: none
// FVECLIBALL-NEXT: SVML // FVECLIBALL-NEXT: SVML
// RUN: %clang --autocomplete=-fshow-overloads= | FileCheck %s -check-prefix=FSOVERALL // RUN: %clang --autocomplete=-fshow-overloads= | FileCheck %s -check-prefix=FSOVERALL
// FSOVERALL: all // FSOVERALL: all
// FSOVERALL-NEXT: best // FSOVERALL-NEXT: best
// RUN: %clang --autocomplete=-fvisibility= | FileCheck %s -check-prefix=FVISIBILITYALL // RUN: %clang --autocomplete=-fvisibility= | FileCheck %s -check-prefix=FVISIBILITYALL
// FVISIBILITYALL: default // FVISIBILITYALL: default
// FVISIBILITYALL-NEXT: hidden // FVISIBILITYALL-NEXT: hidden
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

clang/test/Driver/fveclib.c

// RUN: %clang -### -c -fveclib=none %s 2>&1 | FileCheck -check-prefix CHECK-NOLIB %s // RUN: %clang -### -c -fveclib=none %s 2>&1 | FileCheck -check-prefix CHECK-NOLIB %s
// RUN: %clang -### -c -fveclib=Accelerate %s 2>&1 | FileCheck -check-prefix CHECK-ACCELERATE %s // RUN: %clang -### -c -fveclib=Accelerate %s 2>&1 | FileCheck -check-prefix CHECK-ACCELERATE %s
// RUN: %clang -### -c -fveclib=MASSV %s 2>&1 | FileCheck -check-prefix CHECK-MASSV %s
// RUN: not %clang -c -fveclib=something %s 2>&1 | FileCheck -check-prefix CHECK-INVALID %s // RUN: not %clang -c -fveclib=something %s 2>&1 | FileCheck -check-prefix CHECK-INVALID %s
// CHECK-NOLIB: "-fveclib=none" // CHECK-NOLIB: "-fveclib=none"
// CHECK-ACCELERATE: "-fveclib=Accelerate" // CHECK-ACCELERATE: "-fveclib=Accelerate"
// CHECK-MASSV: "-fveclib=MASSV"
// CHECK-INVALID: error: invalid value 'something' in '-fveclib=something' // CHECK-INVALID: error: invalid value 'something' in '-fveclib=something'
// RUN: %clang -fveclib=Accelerate %s -target arm64-apple-ios8.0.0 -### 2>&1 | FileCheck --check-prefix=CHECK-LINK %s // RUN: %clang -fveclib=Accelerate %s -target arm64-apple-ios8.0.0 -### 2>&1 | FileCheck --check-prefix=CHECK-LINK %s
// CHECK-LINK: "-framework" "Accelerate" // CHECK-LINK: "-framework" "Accelerate"
// RUN: %clang -fveclib=Accelerate %s -nostdlib -target arm64-apple-ios8.0.0 -### 2>&1 | FileCheck --check-prefix=CHECK-LINK-NOSTDLIB %s // RUN: %clang -fveclib=Accelerate %s -nostdlib -target arm64-apple-ios8.0.0 -### 2>&1 | FileCheck --check-prefix=CHECK-LINK-NOSTDLIB %s
// CHECK-LINK-NOSTDLIB-NOT: "-framework" "Accelerate" // CHECK-LINK-NOSTDLIB-NOT: "-framework" "Accelerate"
// RUN: %clang -fveclib=Accelerate %s -nodefaultlibs -target arm64-apple-ios8.0.0 -### 2>&1 | FileCheck --check-prefix=CHECK-LINK-NODEFAULTLIBS %s // RUN: %clang -fveclib=Accelerate %s -nodefaultlibs -target arm64-apple-ios8.0.0 -### 2>&1 | FileCheck --check-prefix=CHECK-LINK-NODEFAULTLIBS %s
// CHECK-LINK-NODEFAULTLIBS-NOT: "-framework" "Accelerate" // CHECK-LINK-NODEFAULTLIBS-NOT: "-framework" "Accelerate"

llvm/include/llvm/Analysis/TargetLibraryInfo.h

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Linespublic:
/// The vector-functions library defines, which functions are vectorizable /// The vector-functions library defines, which functions are vectorizable
/// and with which factor. The library can be specified by either frontend, /// and with which factor. The library can be specified by either frontend,
/// or a commandline option, and then used by /// or a commandline option, and then used by
/// addVectorizableFunctionsFromVecLib for filling up the tables of /// addVectorizableFunctionsFromVecLib for filling up the tables of
/// vectorizable functions. /// vectorizable functions.
enum VectorLibrary { enum VectorLibrary {
NoLibrary, // Don't use any vector library. NoLibrary, // Don't use any vector library.
Accelerate, // Use Accelerate framework. Accelerate, // Use Accelerate framework.
MASSV, // IBM MASS vector library.
SVML // Intel short vector math library. SVML // Intel short vector math library.
}; };
TargetLibraryInfoImpl(); TargetLibraryInfoImpl();
explicit TargetLibraryInfoImpl(const Triple &T); explicit TargetLibraryInfoImpl(const Triple &T);
// Provide value semantics. // Provide value semantics.
TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI); TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI);
▲ Show 20 Lines • Show All 297 Lines • Show Last 20 Lines

llvm/include/llvm/Analysis/VecFuncs.def

//===-- VecFuncs.def - Library information -------------*- C++ -*-----------===// //===-- VecFuncs.def - Library information -------------*- C++ -*-----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// This .def file will create mappings from scalar math functions to vector // This .def file will create mappings from scalar math functions to vector
// functions along with their vectorization factor. The current support includes // functions along with their vectorization factor. The current support includes
// such mappings for Accelerate framework and SVML library. // such mappings for Accelerate framework, MASS vector library, and SVML library.
#if !(defined(TLI_DEFINE_VECFUNC)) #if !(defined(TLI_DEFINE_VECFUNC))
#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF}, #define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF},
#endif #endif
#if defined(TLI_DEFINE_ACCELERATE_VECFUNCS) #if defined(TLI_DEFINE_ACCELERATE_VECFUNCS)
// Accelerate framework's Vector Functions // Accelerate framework's Vector Functions
Show All 30 Lines
TLI_DEFINE_VECFUNC("sinhf", "vsinhf", 4) TLI_DEFINE_VECFUNC("sinhf", "vsinhf", 4)
TLI_DEFINE_VECFUNC("coshf", "vcoshf", 4) TLI_DEFINE_VECFUNC("coshf", "vcoshf", 4)
TLI_DEFINE_VECFUNC("tanhf", "vtanhf", 4) TLI_DEFINE_VECFUNC("tanhf", "vtanhf", 4)
TLI_DEFINE_VECFUNC("asinhf", "vasinhf", 4) TLI_DEFINE_VECFUNC("asinhf", "vasinhf", 4)
TLI_DEFINE_VECFUNC("acoshf", "vacoshf", 4) TLI_DEFINE_VECFUNC("acoshf", "vacoshf", 4)
TLI_DEFINE_VECFUNC("atanhf", "vatanhf", 4) TLI_DEFINE_VECFUNC("atanhf", "vatanhf", 4)
#elif defined(TLI_DEFINE_MASSV_VECFUNCS)
// IBM MASS library's vector Functions
// Floating-Point Arithmetic and Auxiliary Functions
TLI_DEFINE_VECFUNC("cbrt", "__cbrtd2_massv", 2)
TLI_DEFINE_VECFUNC("cbrtf", "__cbrtf4_massv", 4)
TLI_DEFINE_VECFUNC("pow", "__powd2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.pow.f64", "__powd2_massv", 2)
TLI_DEFINE_VECFUNC("powf", "__powf4_massv", 4)
TLI_DEFINE_VECFUNC("llvm.pow.f32", "__powf4_massv", 4)
TLI_DEFINE_VECFUNC("sqrt", "__sqrtd2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.sqrt.f64", "__sqrtd2_massv", 2)
TLI_DEFINE_VECFUNC("sqrtf", "__sqrtf4_massv", 4)
TLI_DEFINE_VECFUNC("llvm.sqrt.f32", "__sqrtf4_massv", 4)
// Exponential and Logarithmic Functions
TLI_DEFINE_VECFUNC("exp", "__expd2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.exp.f64", "__expd2_massv", 2)
TLI_DEFINE_VECFUNC("expf", "__expf4_massv", 4)
jsjiUnsubmitted
Not Done
ReplyInline Actions

How about the finite versions? eg: __expf_finite

jsji: How about the finite versions? eg: __expf_finite
TLI_DEFINE_VECFUNC("llvm.exp.f32", "__expf4_massv", 4)
TLI_DEFINE_VECFUNC("exp2", "__exp2d2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.exp2.f64", "__exp2d2_massv", 2)
TLI_DEFINE_VECFUNC("exp2f", "__exp2f4_massv", 4)
TLI_DEFINE_VECFUNC("llvm.exp2.f32", "__exp2f4_massv", 4)
TLI_DEFINE_VECFUNC("expm1", "__expm1d2_massv", 2)
TLI_DEFINE_VECFUNC("expm1f", "__expm1f4_massv", 4)
TLI_DEFINE_VECFUNC("log", "__logd2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.log.f64", "__logd2_massv", 2)
TLI_DEFINE_VECFUNC("logf", "__logf4_massv", 4)
TLI_DEFINE_VECFUNC("llvm.log.f32", "__logf4_massv", 4)
TLI_DEFINE_VECFUNC("log1p", "__log1pd2_massv", 2)
TLI_DEFINE_VECFUNC("log1pf", "__log1pf4_massv", 4)
TLI_DEFINE_VECFUNC("log10", "__log10d2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.log10.f64", "__log10d2_massv", 2)
TLI_DEFINE_VECFUNC("log10f", "__log10f4_massv", 4)
TLI_DEFINE_VECFUNC("llvm.log10.f32", "__log10f4_massv", 4)
TLI_DEFINE_VECFUNC("log2", "__log2d2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.log2.f64", "__log2d2_massv", 2)
TLI_DEFINE_VECFUNC("log2f", "__log2f4_massv", 4)
TLI_DEFINE_VECFUNC("llvm.log2.f32", "__log2f4_massv", 4)
// Trigonometric Functions
TLI_DEFINE_VECFUNC("sin", "__sind2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.sin.f64", "__sind2_massv", 2)
TLI_DEFINE_VECFUNC("sinf", "__sinf4_massv", 4)
TLI_DEFINE_VECFUNC("llvm.sin.f32", "__sinf4_massv", 4)
TLI_DEFINE_VECFUNC("cos", "__cosd2_massv", 2)
TLI_DEFINE_VECFUNC("llvm.cos.f64", "__cosd2_massv", 2)
TLI_DEFINE_VECFUNC("cosf", "__cosf4_massv", 4)
TLI_DEFINE_VECFUNC("llvm.cos.f32", "__cosf4_massv", 4)
TLI_DEFINE_VECFUNC("tan", "__tand2_massv", 2)
TLI_DEFINE_VECFUNC("tanf", "__tanf4_massv", 4)
TLI_DEFINE_VECFUNC("asin", "__asind2_massv", 2)
TLI_DEFINE_VECFUNC("asinf", "__asinf4_massv", 4)
TLI_DEFINE_VECFUNC("acos", "__acosd2_massv", 2)
TLI_DEFINE_VECFUNC("acosf", "__acosf4_massv", 4)
TLI_DEFINE_VECFUNC("atan", "__atand2_massv", 2)
TLI_DEFINE_VECFUNC("atanf", "__atanf4_massv", 4)
TLI_DEFINE_VECFUNC("atan2", "__atan2d2_massv", 2)
TLI_DEFINE_VECFUNC("atan2f", "__atan2f4_massv", 4)
// Hyperbolic Functions
TLI_DEFINE_VECFUNC("sinh", "__sinhd2_massv", 2)
TLI_DEFINE_VECFUNC("sinhf", "__sinhf4_massv", 4)
TLI_DEFINE_VECFUNC("cosh", "__coshd2_massv", 2)
TLI_DEFINE_VECFUNC("coshf", "__coshf4_massv", 4)
TLI_DEFINE_VECFUNC("tanh", "__tanhd2_massv", 2)
TLI_DEFINE_VECFUNC("tanhf", "__tanhf4_massv", 4)
TLI_DEFINE_VECFUNC("asinh", "__asinhd2_massv", 2)
TLI_DEFINE_VECFUNC("asinhf", "__asinhf4_massv", 4)
TLI_DEFINE_VECFUNC("acosh", "__acoshd2_massv", 2)
TLI_DEFINE_VECFUNC("acoshf", "__acoshf4_massv", 4)
TLI_DEFINE_VECFUNC("atanh", "__atanhd2_massv", 2)
TLI_DEFINE_VECFUNC("atanhf", "__atanhf4_massv", 4)
#elif defined(TLI_DEFINE_SVML_VECFUNCS) #elif defined(TLI_DEFINE_SVML_VECFUNCS)
// Intel SVM library's Vector Functions // Intel SVM library's Vector Functions
TLI_DEFINE_VECFUNC("sin", "__svml_sin2", 2) TLI_DEFINE_VECFUNC("sin", "__svml_sin2", 2)
TLI_DEFINE_VECFUNC("sin", "__svml_sin4", 4) TLI_DEFINE_VECFUNC("sin", "__svml_sin4", 4)
TLI_DEFINE_VECFUNC("sin", "__svml_sin8", 8) TLI_DEFINE_VECFUNC("sin", "__svml_sin8", 8)
TLI_DEFINE_VECFUNC("sinf", "__svml_sinf4", 4) TLI_DEFINE_VECFUNC("sinf", "__svml_sinf4", 4)
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

llvm/lib/Analysis/TargetLibraryInfo.cpp

Show All 17 Lines
static cl::opt<TargetLibraryInfoImpl::VectorLibrary> ClVectorLibrary( static cl::opt<TargetLibraryInfoImpl::VectorLibrary> ClVectorLibrary(
"vector-library", cl::Hidden, cl::desc("Vector functions library"), "vector-library", cl::Hidden, cl::desc("Vector functions library"),
cl::init(TargetLibraryInfoImpl::NoLibrary), cl::init(TargetLibraryInfoImpl::NoLibrary),
cl::values(clEnumValN(TargetLibraryInfoImpl::NoLibrary, "none", cl::values(clEnumValN(TargetLibraryInfoImpl::NoLibrary, "none",
"No vector functions library"), "No vector functions library"),
clEnumValN(TargetLibraryInfoImpl::Accelerate, "Accelerate", clEnumValN(TargetLibraryInfoImpl::Accelerate, "Accelerate",
"Accelerate framework"), "Accelerate framework"),
clEnumValN(TargetLibraryInfoImpl::MASSV, "MASSV",
"IBM MASS vector library"),
clEnumValN(TargetLibraryInfoImpl::SVML, "SVML", clEnumValN(TargetLibraryInfoImpl::SVML, "SVML",
"Intel SVML library"))); "Intel SVML library")));
StringRef const TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] = { StringRef const TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] = {
#define TLI_DEFINE_STRING #define TLI_DEFINE_STRING
#include "llvm/Analysis/TargetLibraryInfo.def" #include "llvm/Analysis/TargetLibraryInfo.def"
}; };
▲ Show 20 Lines • Show All 1,423 Lines • ▼ Show 20 Linesvoid TargetLibraryInfoImpl::addVectorizableFunctions(ArrayRef<VecDesc> Fns) {
llvm::sort(ScalarDescs, compareByVectorFnName); llvm::sort(ScalarDescs, compareByVectorFnName);
} }
void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib( void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib(
enum VectorLibrary VecLib) { enum VectorLibrary VecLib) {
switch (VecLib) { switch (VecLib) {
case Accelerate: { case Accelerate: {
const VecDesc VecFuncs[] = { const VecDesc VecFuncs[] = {
#define TLI_DEFINE_ACCELERATE_VECFUNCS #define TLI_DEFINE_ACCELERATE_VECFUNCS
#include "llvm/Analysis/VecFuncs.def" #include "llvm/Analysis/VecFuncs.def"
jsjiUnsubmitted
Not Done
ReplyInline Actions

Can we split the refactoring of these definitions into llvm/Analysis/VecFuncs.def into a NFC patch first?
And leave only the MASSV related change in this patch ?

jsji: Can we split the refactoring of these definitions into `llvm/Analysis/VecFuncs.def` into a NFC…
pjeeva01AuthorUnsubmitted
Not Done
ReplyInline Actions

@jsji Thank you for looking into this.

@mmasten @mzolotukhin If you agree with this refactoring suggestion, I will go ahead and create an NFC patch for the same.

pjeeva01: @jsji Thank you for looking into this. @mmasten @mzolotukhin If you agree with this…
pjeeva01AuthorUnsubmitted
Done
ReplyInline Actions

NFC patch that simply factors out these definitions into llvm/Analysis/VecFuncs.def is posted [[ llvm/Analysis/VecFuncs.def | here ]]

pjeeva01: NFC patch that simply factors out these definitions into llvm/Analysis/VecFuncs.def is posted…
hubert.reinterpretcastUnsubmitted
Not Done
ReplyInline Actions

You mean, posted as D60211?

hubert.reinterpretcast: You mean, posted as D60211?
}; };
addVectorizableFunctions(VecFuncs); addVectorizableFunctions(VecFuncs);
break; break;
} }
case MASSV: {
const VecDesc VecFuncs[] = {
#define TLI_DEFINE_MASSV_VECFUNCS
#include "llvm/Analysis/VecFuncs.def"
};
addVectorizableFunctions(VecFuncs);
break;
}
case SVML: { case SVML: {
const VecDesc VecFuncs[] = { const VecDesc VecFuncs[] = {
#define TLI_DEFINE_SVML_VECFUNCS #define TLI_DEFINE_SVML_VECFUNCS
#include "llvm/Analysis/VecFuncs.def" #include "llvm/Analysis/VecFuncs.def"
}; };
addVectorizableFunctions(VecFuncs); addVectorizableFunctions(VecFuncs);
break; break;
} }
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/PowerPC/massv-calls.ll

  • This file was added.
; RUN: opt -vector-library=MASSV -loop-vectorize -force-vector-interleave=1 -S < %s | FileCheck %s
jsjiUnsubmitted
Not Done
ReplyInline Actions

do we require any attr? eg: vsx? what happen to ppc without altivec or vsx?

jsji: do we require any attr? eg: vsx? what happen to ppc without altivec or vsx?
target datalayout = "e-m:e-i64:64-n32:64"
target triple = "powerpc64le-unknown-linux-gnu"
jsjiUnsubmitted
Not Done
ReplyInline Actions

How about powerpc (32 bit) or powerpc64?

jsji: How about powerpc (32 bit) or powerpc64?
declare double @cbrt(double) #0
declare float @cbrtf(float) #0
declare double @pow(double, double) #0
declare double @llvm.pow.f64(double, double) #0
declare float @powf(float, float) #0
declare float @llvm.pow.f32(float, float) #0
declare double @sqrt(double) #0
declare float @sqrtf(float) #0
declare double @exp(double) #0
declare double @llvm.exp.f64(double) #0
declare float @expf(float) #0
declare float @llvm.exp.f32(float) #0
declare double @exp2(double) #0
declare double @llvm.exp2.f64(double) #0
declare float @exp2f(float) #0
declare float @llvm.exp2.f32(float) #0
declare double @expm1(double) #0
declare float @expm1f(float) #0
declare double @log(double) #0
declare double @llvm.log.f64(double) #0
declare float @logf(float) #0
declare float @llvm.log.f32(float) #0
declare double @log1p(double) #0
declare float @log1pf(float) #0
declare double @log10(double) #0
declare double @llvm.log10.f64(double) #0
declare float @log10f(float) #0
declare float @llvm.log10.f32(float) #0
declare double @log2(double) #0
declare double @llvm.log2.f64(double) #0
declare float @log2f(float) #0
declare float @llvm.log2.f32(float) #0
declare double @sin(double) #0
declare double @llvm.sin.f64(double) #0
declare float @sinf(float) #0
declare float @llvm.sin.f32(float) #0
declare double @cos(double) #0
declare double @llvm.cos.f64(double) #0
declare float @cosf(float) #0
declare float @llvm.cos.f32(float) #0
declare double @tan(double) #0
declare float @tanf(float) #0
declare double @asin(double) #0
declare float @asinf(float) #0
declare double @acos(double) #0
declare float @acosf(float) #0
declare double @atan(double) #0
declare float @atanf(float) #0
declare double @atan2(double) #0
declare float @atan2f(float) #0
declare double @sinh(double) #0
declare float @sinhf(float) #0
declare double @cosh(double) #0
declare float @coshf(float) #0
declare double @tanh(double) #0
declare float @tanhf(float) #0
declare double @asinh(double) #0
declare float @asinhf(float) #0
declare double @acosh(double) #0
declare float @acoshf(float) #0
declare double @atanh(double) #0
declare float @atanhf(float) #0
define void @cbrt_f64(double* nocapture %varray) {
; CHECK-LABEL: @cbrt_f64(
; CHECK: __cbrtd2_massv{{.*}}<2 x double>
jsjiUnsubmitted
Not Done
ReplyInline Actions

It would be better if we check all the key elements of call , not only the name .
eg: call <2 x double> @__cbrtd2_massv(<2 x double> %2)

jsji: It would be better if we check all the key elements of call , not only the name . eg: call <2 x…
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @cbrt(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @cbrt_f32(float* nocapture %varray) {
; CHECK-LABEL: @cbrt_f32(
; CHECK: __cbrtf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @cbrtf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @pow_f64(double* nocapture %varray, double* nocapture readonly %exp) {
; CHECK-LABEL: @pow_f64(
; CHECK: __powd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%arrayidx = getelementptr inbounds double, double* %exp, i64 %iv
%tmp1 = load double, double* %arrayidx, align 4
%tmp2 = tail call double @pow(double %conv, double %tmp1)
%arrayidx2 = getelementptr inbounds double, double* %varray, i64 %iv
store double %tmp2, double* %arrayidx2, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @pow_f64_intrinsic(double* nocapture %varray, double* nocapture readonly %exp) {
; CHECK-LABEL: @pow_f64_intrinsic(
; CHECK: __powd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%arrayidx = getelementptr inbounds double, double* %exp, i64 %iv
%tmp1 = load double, double* %arrayidx, align 4
%tmp2 = tail call double @llvm.pow.f64(double %conv, double %tmp1)
%arrayidx2 = getelementptr inbounds double, double* %varray, i64 %iv
store double %tmp2, double* %arrayidx2, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @pow_f32(float* nocapture %varray, float* nocapture readonly %exp) {
; CHECK-LABEL: @pow_f32(
; CHECK: __powf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%arrayidx = getelementptr inbounds float, float* %exp, i64 %iv
%tmp1 = load float, float* %arrayidx, align 4
%tmp2 = tail call float @powf(float %conv, float %tmp1)
%arrayidx2 = getelementptr inbounds float, float* %varray, i64 %iv
store float %tmp2, float* %arrayidx2, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @pow_f32_intrinsic(float* nocapture %varray, float* nocapture readonly %exp) {
; CHECK-LABEL: @pow_f32_intrinsic(
; CHECK: __powf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%arrayidx = getelementptr inbounds float, float* %exp, i64 %iv
%tmp1 = load float, float* %arrayidx, align 4
%tmp2 = tail call float @llvm.pow.f32(float %conv, float %tmp1)
%arrayidx2 = getelementptr inbounds float, float* %varray, i64 %iv
store float %tmp2, float* %arrayidx2, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @sqrt_f64(double* nocapture %varray) {
; CHECK-LABEL: @sqrt_f64(
; CHECK: __sqrtd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @sqrt(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @sqrt_f32(float* nocapture %varray) {
; CHECK-LABEL: @sqrt_f32(
; CHECK: __sqrtf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @sqrtf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
jsjiUnsubmitted
Not Done
ReplyInline Actions

Missing some intrinsics test? @sqrt_f64_intrinsic?@sqrt_f32_intrinsic?

jsji: Missing some intrinsics test? @sqrt_f64_intrinsic?@sqrt_f32_intrinsic?
jsjiUnsubmitted
Not Done
ReplyInline Actions

Still missing in latest patch?

jsji: Still missing in latest patch?
define void @exp_f64(double* nocapture %varray) {
; CHECK-LABEL: @exp_f64(
; CHECK: __expd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @exp(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @exp_f64_intrinsic(double* nocapture %varray) {
; CHECK-LABEL: @exp_f64_intrinsic(
; CHECK: __expd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @llvm.exp.f64(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @exp_f32(float* nocapture %varray) {
; CHECK-LABEL: @exp_f32(
; CHECK: __expf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @expf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @exp_f32_intrinsic(float* nocapture %varray) {
; CHECK-LABEL: @exp_f32_intrinsic(
; CHECK: __expf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @llvm.exp.f32(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @exp2_f64(double* nocapture %varray) {
; CHECK-LABEL: @exp2_f64(
; CHECK: __exp2d2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @exp2(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @exp2_f64_intrinsic(double* nocapture %varray) {
; CHECK-LABEL: @exp2_f64_intrinsic(
; CHECK: __exp2d2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @llvm.exp2.f64(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @exp2_f32(float* nocapture %varray) {
; CHECK-LABEL: @exp2_f32(
; CHECK: __exp2f4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @exp2f(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @exp2_f32_intrinsic(float* nocapture %varray) {
; CHECK-LABEL: @exp2_f32_intrinsic(
; CHECK: __exp2f4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @llvm.exp2.f32(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @expm1_f64(double* nocapture %varray) {
; CHECK-LABEL: @expm1_f64(
; CHECK: __expm1d2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @expm1(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @expm1_f32(float* nocapture %varray) {
; CHECK-LABEL: @expm1_f32(
; CHECK: __expm1f4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @expm1f(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log_f64(double* nocapture %varray) {
; CHECK-LABEL: @log_f64(
; CHECK: __logd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @log(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log_f64_intrinsic(double* nocapture %varray) {
; CHECK-LABEL: @log_f64_intrinsic(
; CHECK: __logd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @llvm.log.f64(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log_f32(float* nocapture %varray) {
; CHECK-LABEL: @log_f32(
; CHECK: __logf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @logf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log_f32_intrinsic(float* nocapture %varray) {
; CHECK-LABEL: @log_f32_intrinsic(
; CHECK: __logf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @llvm.log.f32(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log1p_f64(double* nocapture %varray) {
; CHECK-LABEL: @log1p_f64(
; CHECK: __log1pd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @log1p(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log1p_f32(float* nocapture %varray) {
; CHECK-LABEL: @log1p_f32(
; CHECK: __log1pf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @log1pf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log10_f64(double* nocapture %varray) {
; CHECK-LABEL: @log10_f64(
; CHECK: __log10d2_massv(<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @log10(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log10_f64_intrinsic(double* nocapture %varray) {
; CHECK-LABEL: @log10_f64_intrinsic(
; CHECK: __log10d2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @llvm.log10.f64(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log10_f32(float* nocapture %varray) {
; CHECK-LABEL: @log10_f32(
; CHECK: __log10f4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @log10f(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log10_f32_intrinsic(float* nocapture %varray) {
; CHECK-LABEL: @log10_f32_intrinsic(
; CHECK: __log10f4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @llvm.log10.f32(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log2_f64(double* nocapture %varray) {
; CHECK-LABEL: @log2_f64(
; CHECK: __log2d2_massv(<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @log2(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log2_f64_intrinsic(double* nocapture %varray) {
; CHECK-LABEL: @log2_f64_intrinsic(
; CHECK: __log2d2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @llvm.log2.f64(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log2_f32(float* nocapture %varray) {
; CHECK-LABEL: @log2_f32(
; CHECK: __log2f4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @log2f(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @log2_f32_intrinsic(float* nocapture %varray) {
; CHECK-LABEL: @log2_f32_intrinsic(
; CHECK: __log2f4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @llvm.log2.f32(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @sin_f64(double* nocapture %varray) {
; CHECK-LABEL: @sin_f64(
; CHECK: __sind2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @sin(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @sin_f64_intrinsic(double* nocapture %varray) {
; CHECK-LABEL: @sin_f64_intrinsic(
; CHECK: __sind2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @llvm.sin.f64(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @sin_f32(float* nocapture %varray) {
; CHECK-LABEL: @sin_f32(
; CHECK: __sinf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @sinf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @sin_f32_intrinsic(float* nocapture %varray) {
; CHECK-LABEL: @sin_f32_intrinsic(
; CHECK: __sinf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @llvm.sin.f32(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @cos_f64(double* nocapture %varray) {
; CHECK-LABEL: @cos_f64(
; CHECK: __cosd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @cos(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @cos_f64_intrinsic(double* nocapture %varray) {
; CHECK-LABEL: @cos_f64_intrinsic(
; CHECK: [[TMP5:%.*]] = call <2 x double> @__cosd2_massv(<2 x double> [[TMP4:%.*]])
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @llvm.cos.f64(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @cos_f32(float* nocapture %varray) {
; CHECK-LABEL: @cos_f32(
; CHECK: __cosf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @cosf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @cos_f32_intrinsic(float* nocapture %varray) {
; CHECK-LABEL: @cos_f32_intrinsic(
; CHECK: __cosf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @llvm.cos.f32(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @tan_f64(double* nocapture %varray) {
; CHECK-LABEL: @tan_f64(
; CHECK: __tand2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @tan(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @tan_f32(float* nocapture %varray) {
; CHECK-LABEL: @tan_f32(
; CHECK: __tanf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @tanf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @asin_f64(double* nocapture %varray) {
; CHECK-LABEL: @asin_f64(
; CHECK: __asind2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @asin(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @asin_f32(float* nocapture %varray) {
; CHECK-LABEL: @asin_f32(
; CHECK: __asinf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @asinf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @acos_f64(double* nocapture %varray) {
; CHECK-LABEL: @acos_f64(
; CHECK: __acosd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @acos(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @acos_f32(float* nocapture %varray) {
; CHECK-LABEL: @acos_f32(
; CHECK: __acosf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @acosf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @atan_f64(double* nocapture %varray) {
; CHECK-LABEL: @atan_f64(
; CHECK: __atand2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @atan(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @atan_f32(float* nocapture %varray) {
; CHECK-LABEL: @atan_f32(
; CHECK: __atanf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @atanf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @atan2_f64(double* nocapture %varray) {
; CHECK-LABEL: @atan2_f64(
; CHECK: __atan2d2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @atan2(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @atan2_f32(float* nocapture %varray) {
; CHECK-LABEL: @atan2_f32(
; CHECK: __atan2f4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @atan2f(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @sinh_f64(double* nocapture %varray) {
; CHECK-LABEL: @sinh_f64(
; CHECK: __sinhd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @sinh(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @sinh_f32(float* nocapture %varray) {
; CHECK-LABEL: @sinh_f32(
; CHECK: __sinhf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @sinhf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @cosh_f64(double* nocapture %varray) {
; CHECK-LABEL: @cosh_f64(
; CHECK: __coshd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @cosh(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @cosh_f32(float* nocapture %varray) {
; CHECK-LABEL: @cosh_f32(
; CHECK: __coshf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @coshf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @tanh_f64(double* nocapture %varray) {
; CHECK-LABEL: @tanh_f64(
; CHECK: __tanhd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @tanh(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @tanh_f32(float* nocapture %varray) {
; CHECK-LABEL: @tanh_f32(
; CHECK: __tanhf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @tanhf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @asinh_f64(double* nocapture %varray) {
; CHECK-LABEL: @asinh_f64(
; CHECK: __asinhd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @asinh(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @asinh_f32(float* nocapture %varray) {
; CHECK-LABEL: @asinh_f32(
; CHECK: __asinhf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @asinhf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @acosh_f64(double* nocapture %varray) {
; CHECK-LABEL: @acosh_f64(
; CHECK: __acoshd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @acosh(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @acosh_f32(float* nocapture %varray) {
; CHECK-LABEL: @acosh_f32(
; CHECK: __acoshf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @acoshf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @atanh_f64(double* nocapture %varray) {
; CHECK-LABEL: @atanh_f64(
; CHECK: __atanhd2_massv{{.*}}<2 x double>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to double
%call = tail call double @atanh(double %conv)
%arrayidx = getelementptr inbounds double, double* %varray, i64 %iv
store double %call, double* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
define void @atanh_f32(float* nocapture %varray) {
; CHECK-LABEL: @atanh_f32(
; CHECK: __atanhf4_massv{{.*}}<4 x float>
; CHECK: ret void
;
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%tmp = trunc i64 %iv to i32
%conv = sitofp i32 %tmp to float
%call = tail call float @atanhf(float %conv)
%arrayidx = getelementptr inbounds float, float* %varray, i64 %iv
store float %call, float* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 1000
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}
jsjiUnsubmitted
Not Done
ReplyInline Actions

Shall we add some negative tests to make sure that we don't vectorize functions not in the list, eg: arbitrary functions, function in ACCELERATE/SVML but not in MASSV?

jsji: Shall we add some negative tests to make sure that we don't vectorize functions not in the list…
attributes #0 = { nounwind }
jsjiUnsubmitted
Not Done
ReplyInline Actions

Maybe add a negative test where the nobuiltin attribute is present too.

jsji: Maybe add a negative test where the nobuiltin attribute is present too.