[AIX] Enable int128 in 64 bit mode

[jsji]

Summary

This patch remove the override in AIX target,
so the int128 is enabled in 64 bit mode or with ForceEnableInt128.

[hubert.reinterpretcast]

Making a change to whether a platform has __int128 affects the ABI of libc++'s std::chrono::file_clock. We should make sure the mitigation patch is posted and accepted.

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/int128_ldst.ll

31

Confirming that this case matches GCC on AIX:

ld 4,8(3)
ld 3,0(3)
blr

[hubert.reinterpretcast]

Type alignment (16), choice of GPRs for argument passing (first available including r10), va_arg invocations, order of components (big endian), and calls to double/float conversions all check out. It may be reasonable to locate existing tests for these and make sure they also test 64-bit AIX.

[jsji]

llvm/test/CodeGen/PowerPC/int128_ldst.ll

31

$ gcc -maix64 -S -O p128.c -o t.s; grep blr -B3 t.s
.check1:

ld 4,8(3)
ld 3,0(3)
blr

[daltenty]

Making a change to whether a platform has __int128 affects the ABI of libc++'s std::chrono::file_clock. We should make sure the mitigation patch is posted and accepted.

Good point, but the std::chrono::file_clock interface hasn't shipped yet on the platform libc++, since it's currently still at a bit of a backlevel, so I don't think that should be blocking to enabling the type.

[hubert.reinterpretcast]

In D111078#3042913, @daltenty wrote:

Good point, but the std::chrono::file_clock interface hasn't shipped yet on the platform libc++, since it's currently still at a bit of a backlevel, so I don't think that should be blocking to enabling the type.

I am concerned that __int128 is an over-aligned type on AIX. The required alignment of the type is greater than the greatest fundamental alignment supported by default on the platform.

[jsji]

Address comments -- adding AIX triples to more existing tests.

[jsji]

Ping @hubert.reinterpretcast Any further comments?

[lkail]

I would like to see aix triple added to more existing tests involving ABI in llvm/test/CodeGen/PowerPC(such as ppc64-i128-abi.ll), since AIX has independent calling convention lowering and is different from linux.

[jsji]

Add AIX XCOFF triples to i128 tests, especially ppc64-i128-abi.ll.

[jsji]

ppc64-i128-abi.ll CHECK-P9 part depends on D94282: [PowerPC] Support ppc-asm-full-reg-names for AIX.

[lkail]

This LGTM as the start point to support int128 on AIX. We might need more patches involving libraries in the LLVM monorepo, we can do that progressively.

[hubert.reinterpretcast]

In D111078#3063245, @lkail wrote:

This LGTM as the start point to support int128 on AIX. We might need more patches involving libraries in the LLVM monorepo, we can do that progressively.

Agreed (although I find it slightly odd that the testing doesn't check the edge case where the argument value is split between r10 and the stack).

[jsji]

In D111078#3065552, @hubert.reinterpretcast wrote:

In D111078#3063245, @lkail wrote:

This LGTM as the start point to support int128 on AIX. We might need more patches involving libraries in the LLVM monorepo, we can do that progressively.

Agreed (although I find it slightly odd that the testing doesn't check the edge case where the argument value is split between r10 and the stack).

I can add more test in a follow up patch.

clang/lib/Basic/Targets/OSTargets.h

AIXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
     } else {
       this->WCharType = this->UnsignedShort;
     }
     this->UseZeroLengthBitfieldAlignment = true;
   }
 
   // AIX sets FLT_EVAL_METHOD to be 1.
   unsigned getFloatEvalMethod() const override { return 1; }
-  bool hasInt128Type() const override { return false; }
 
   bool defaultsToAIXPowerAlignment() const override { return true; }
 };
 
 // z/OS target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY ZOSTargetInfo : public OSTargetInfo<Target> {
 protected:

clang/test/AST/ast-print-int128.cpp

 // RUN: %clang_cc1 -ast-print -std=c++20 %s -o - -triple x86_64-linux | FileCheck %s
+// RUN: %clang_cc1 -ast-print -std=c++20 %s -o - -triple powerpc64-ibm-aix-xcoff | FileCheck %s
 
 template <bool>
 struct enable_if {
 };
 
 template <__uint128_t x, typename = typename enable_if<x != 0>::type>
 void f();
 
 template <__int128_t>
 void f();
 
 using T = decltype(f<0>());
 
 // CHECK: using T = decltype(f<0>());

clang/test/Analysis/sval-dump-int128.c

 // RUN: %clang_analyze_cc1 -triple x86_64-linux-gnu -analyzer-checker=debug.ExprInspection %s -verify
+// RUN: %clang_analyze_cc1 -triple powerpc64-ibm-aix-xcoff -analyzer-checker=debug.ExprInspection %s -verify
 
 void clang_analyzer_dump(unsigned __int128 x);
 
 void testDumpInt128() {
   clang_analyzer_dump((unsigned __int128)5 << 64); // expected-warning{{92233720368547758080 U128b}}
 }

clang/test/CodeGen/dbg-const-int128.c

 // RUN: %clang_cc1 -triple x86_64-unknown-linux -S -emit-llvm -debug-info-kind=limited  %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple powerpc64-ibm-aix-xcoff -S -emit-llvm -debug-info-kind=limited  %s -o - | FileCheck %s
 // CHECK: !DIGlobalVariable({{.*}}
 // CHECK-NOT: expr:
 
 static const __uint128_t ro = 18446744073709551615;
 
 void bar(__uint128_t);
 void foo() { bar(ro); }

clang/test/CodeGen/debug-info.c

 // RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -debug-info-kind=limited %s | FileCheck %s
+// RUN: %clang_cc1 -triple powerpc64-ibm-aix-xcoff -o - -emit-llvm -debug-info-kind=limited %s | FileCheck %s
 
 // PR3023
 void convert(void) {
   struct { typeof(0) f0; } v0;
 }
 
 
 // PR2784

clang/test/CodeGen/extend-arg-64.c

 // RUN:                     %s -emit-llvm -o - | FileCheck %s \
 // RUN:    --implicit-check-not "ext {{.*}}to i64"
 
 // The option isn't supported on ppc, no effect
 // RUN: %clang_cc1 -triple ppc64le -fextend-arguments=64 \
 // RUN:                     %s -emit-llvm -o - | FileCheck %s \
 // RUN:    --implicit-check-not "ext {{.*}}to i64"
 
+// The option isn't supported on ppc, no effect
+// RUN: %clang_cc1 -DD128 -triple powerpc64-ibm-aix-xcoff -fextend-arguments=64 \
+// RUN:                     %s -emit-llvm -o - | FileCheck %s \
+// RUN:    --implicit-check-not "ext {{.*}}to i64"
+
+
 int vararg(int, ...);
 void knr();
 
 unsigned int u32;
 int s32;
 unsigned short u16;
 short s16;
 unsigned char u8;

clang/test/CodeGen/ppc-varargs-struct.c

 // REQUIRES: powerpc-registered-target
 // REQUIRES: asserts
 // RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple powerpc-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-PPC
+// RUN: %clang_cc1 -triple powerpc64-ibm-aix-xcoff -emit-llvm -o - %s | FileCheck %s
 
 #include <stdarg.h>
 
 struct x {
   long a;
   double b;
 };
 

clang/test/CodeGen/uint128_t.c

 // RUN: %clang_cc1 %s -emit-llvm -o - -triple=x86_64-apple-darwin9
+// RUN: %clang_cc1 %s -emit-llvm -o - -triple=powerpc64-ibm-aix-xcoff
 
 typedef unsigned long long uint64_t;
 extern uint64_t numer;
 extern uint64_t denom;
 
 uint64_t
 f(uint64_t val)
 {

clang/test/CodeGenCXX/debug-info-enum-i128.cpp

 // RUN: %clang_cc1 %s -triple x86_64-windows-msvc -gcodeview -debug-info-kind=limited -emit-llvm -o - | FileCheck %s
 // RUN: %clang_cc1 %s -triple x86_64-linux-gnu -debug-info-kind=limited -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 %s -triple powerpc64-ibm-aix-xcoff -debug-info-kind=limited -emit-llvm -o - | FileCheck %s
 
 // FIXME: llvm.org/pr51221, the APSInt leaks
 // UNSUPPORTED: asan
 
 enum class uns : __uint128_t { unsval = __uint128_t(1) << 64 };
 uns t1() { return uns::unsval; }
 
 enum class sig : __int128 { sigval = -(__int128(1) << 64) };
 sig t2() { return sig::sigval; }
 
 
 // CHECK-LABEL: !DICompositeType(tag: DW_TAG_enumeration_type, name: "uns", {{.*}})
 // CHECK: !DIEnumerator(name: "unsval", value: 18446744073709551616, isUnsigned: true)
 
 // CHECK-LABEL: !DICompositeType(tag: DW_TAG_enumeration_type, name: "sig", {{.*}})
 // CHECK: !DIEnumerator(name: "sigval", value: -18446744073709551616)

clang/test/Driver/types.c

 // Check whether __int128_t and __uint128_t are supported.
 
 // RUN: not %clang -c --target=riscv32-unknown-linux-gnu -fsyntax-only %s \
 // RUN: 2>&1 | FileCheck %s
 
 // RUN: %clang -c --target=riscv32-unknown-linux-gnu -fsyntax-only %s \
 // RUN: -fno-force-enable-int128 -fforce-enable-int128
 
 // RUN: not %clang -c --target=riscv32-unknown-linux-gnu -fsyntax-only %s \
 // RUN: -fforce-enable-int128 -fno-force-enable-int128
 
 // RUN: not %clang -c --target=powerpc-ibm-aix -fsyntax-only %s \
 // RUN: 2>&1 | FileCheck %s
 
-// RUN: not %clang -c --target=powerpc64-ibm-aix -fsyntax-only %s \
-// RUN: 2>&1 | FileCheck %s
+// RUN: %clang -c --target=powerpc64-ibm-aix -fsyntax-only %s \
+// RUN: 2>&1
 
 void a() {
   __int128_t s;
   __uint128_t t;
 }
 
 // CHECK: error: use of undeclared identifier '__int128_t'
 // CHECK: error: use of undeclared identifier '__uint128_t'

clang/test/Preprocessor/init-ppc64.c

 // PPC64-AIX:#define __PTRDIFF_WIDTH__ 64
 // PPC64-AIX:#define __REGISTER_PREFIX__
 // PPC64-AIX:#define __SCHAR_MAX__ 127
 // PPC64-AIX:#define __SHRT_MAX__ 32767
 // PPC64-AIX:#define __SIG_ATOMIC_MAX__ 2147483647
 // PPC64-AIX:#define __SIG_ATOMIC_WIDTH__ 32
 // PPC64-AIX:#define __SIZEOF_DOUBLE__ 8
 // PPC64-AIX:#define __SIZEOF_FLOAT__ 4
+// PPC64-AIX:#define __SIZEOF_INT128__ 16
 // PPC64-AIX:#define __SIZEOF_INT__ 4
 // PPC64-AIX:#define __SIZEOF_LONG_DOUBLE__ 8
 // PPC64-AIX:#define __SIZEOF_LONG_LONG__ 8
 // PPC64-AIX:#define __SIZEOF_LONG__ 8
 // PPC64-AIX:#define __SIZEOF_POINTER__ 8
 // PPC64-AIX:#define __SIZEOF_PTRDIFF_T__ 8
 // PPC64-AIX:#define __SIZEOF_SHORT__ 2
 // PPC64-AIX:#define __SIZEOF_SIZE_T__ 8

clang/test/Sema/128bitint.c

 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-apple-darwin9 %s -DHAVE
 // RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux-gnu %s -DHAVE_NOT
+// RUN: %clang_cc1 -fsyntax-only -verify -triple powerpc64-ibm-aix-xcoff %s -DHAVE
+// RUN: %clang_cc1 -fsyntax-only -verify -triple powerpc-ibm-aix-xcoff %s -DHAVE_NOT
 
 #ifdef HAVE
 typedef int i128 __attribute__((__mode__(TI)));
 typedef unsigned u128 __attribute__((__mode__(TI)));
 
 int a[((i128)-1 ^ (i128)-2) == 1 ? 1 : -1];
 int a[(u128)-1 > 1LL ? 1 : -1];
 int a[__SIZEOF_INT128__ == 16 ? 1 : -1];

clang/test/Sema/const-eval.c

 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux %s -Wno-tautological-pointer-compare -Wno-pointer-to-int-cast
+// RUN: %clang_cc1 -fsyntax-only -verify -triple powerpc64-ibm-aix-xcoff %s -Wno-tautological-pointer-compare -Wno-pointer-to-int-cast
 
 #define EVAL_EXPR(testno, expr) enum { test##testno = (expr) }; struct check_positive##testno { int a[test##testno]; };
 int x;
 EVAL_EXPR(1, (_Bool)&x)
 EVAL_EXPR(2, (int)(1.0+(double)4))
 EVAL_EXPR(3, (int)(1.0+(float)4.0))
 EVAL_EXPR(4, (_Bool)(1 ? (void*)&x : 0))
 EVAL_EXPR(5, (_Bool)(int[]){0})

clang/test/Sema/redefine_extname.c

 // RUN: %clang_cc1 -triple=x86_64-unknown-linux -Wpragmas -verify %s
+// RUN: %clang_cc1 -triple=powerpc64-ibm-aix-xcoff -Wpragmas -verify %s
 
 // Check that pragma redefine_extname applies to external declarations only.
 #pragma redefine_extname foo_static bar_static
 static int foo_static() { return 1; } // expected-warning {{#pragma redefine_extname is applicable to external C declarations only; not applied to function 'foo_static'}}
 
 unsigned __int128_t; // expected-error {{redefinition of '__int128_t' as different kind of symbol}}

clang/test/Sema/types.c

 // RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=x86_64-apple-darwin9
 // RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=mips64-linux-gnu
 // RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=x86_64-unknown-linux
 // RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=x86_64-unknown-linux-gnux32
 // RUN: %clang_cc1 %s -fblocks -pedantic -pedantic -verify -triple=arm64_32-apple-ios7.0
+// RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=powerpc64-ibm-aix-xcoff
 
 // rdar://6097662
 typedef int (*T)[2];
 restrict T x;
 
 typedef int *S[2];
 restrict S y; // expected-error {{restrict requires a pointer or reference ('S' (aka 'int *[2]') is invalid)}}
 

llvm/test/CodeGen/PowerPC/ctrloop-i128.ll

-; RUN: llc -O1 -verify-machineinstrs < %s
-target datalayout = "E-m:e-i64:64-n32:64"
-target triple = "powerpc64-unknown-linux-gnu"
+; RUN: llc -O1 -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu < %s
+; RUN: llc -O1 -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff < %s
 
 ; Function Attrs: uwtable
 define fastcc void @_Crash_Fn() unnamed_addr #0 {
 entry-block:
   br label %_Label_0
 
 _Label_0:                                         ; preds = %_Label_0, %entry-block
   %result.0138 = phi i128 [ %5, %_Label_0 ], [ 0, %entry-block ]

llvm/test/CodeGen/PowerPC/int128_ldst.ll

 ; RUN:   -mcpu=pwr9  \
 ; RUN:   < %s | FileCheck %s --check-prefixes=CHECK,CHECK-PREP10,CHECK-P9
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8  \
 ; RUN:   < %s | FileCheck %s --check-prefixes=CHECK,CHECK-PREP10,CHECK-P8
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8  \
 ; RUN:   < %s | FileCheck %s --check-prefixes=CHECK,CHECK-PREP10,CHECK-P8
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr8  \
+; RUN:   < %s | FileCheck %s --check-prefixes=CHECK,CHECK-PREP10,CHECK-P8
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local i128 @ld_0___int128___int128(i64 %ptr) {
 ; CHECK-LABEL: ld_0___int128___int128:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    ld 5, 0(3)
 ; CHECK-NEXT:    ld 4, 8(3)
 ; CHECK-NEXT:    mr 3, 5
 ; CHECK-NEXT:    blr
 entry:
   %0 = inttoptr i64 %ptr to i128*
   %1 = load i128, i128* %0, align 16
   ret i128 %1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local i128 @ld_unalign16___int128___int128(i8* nocapture readonly %ptr) {

llvm/test/CodeGen/PowerPC/ppc64-i128-abi.ll

 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8 < %s | FileCheck %s -check-prefix=CHECK-LE \
 ; RUN:   --implicit-check-not xxswapd
 
 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8 < %s | FileCheck %s -check-prefix=CHECK-BE
 
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr8 < %s | FileCheck %s -check-prefix=CHECK-BE
+
 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8 -mattr=-vsx < %s | FileCheck %s -check-prefix=CHECK-NOVSX
 
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr8 -mattr=-vsx < %s | FileCheck %s -check-prefix=CHECK-NOVSX
+
 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8 -mattr=-vsx < %s | FileCheck %s -check-prefix=CHECK-NOVSX \
 ; RUN:   --implicit-check-not xxswapd
 
 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8 -mattr=-vsx < %s | FileCheck %s -check-prefix=CHECK-BE-NOVSX
 
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr8 -mattr=-vsx < %s | FileCheck %s -check-prefix=CHECK-BE-NOVSX
+
 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr8 -mattr=-vsx < %s | \
 ; RUN:   FileCheck %s -check-prefix=CHECK-LE-NOVSX --implicit-check-not xxswapd
 
 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr < %s | \
 ; RUN:   FileCheck %s -check-prefix=CHECK-P9 --implicit-check-not xxswapd
 
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr < %s | FileCheck %s -check-prefix=CHECK-P9
+
 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr9 -mattr=-vsx < %s | FileCheck %s -check-prefix=CHECK-NOVSX \
 ; RUN:   --implicit-check-not xxswapd
 
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:   -mcpu=pwr9 -mattr=-vsx < %s | FileCheck %s -check-prefix=CHECK-NOVSX
+
 ; RUN: llc -relocation-model=pic -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   -mcpu=pwr9 -mattr=-power9-vector -mattr=-direct-move < %s | \
 ; RUN:   FileCheck %s -check-prefix=CHECK-LE --implicit-check-not xxswapd
 
 @x = common global <1 x i128> zeroinitializer, align 16
 @y = common global <1 x i128> zeroinitializer, align 16
 @a = common global i128 zeroinitializer, align 16
 @b = common global i128 zeroinitializer, align 16

 
 ; CHECK-LE-LABEL: @call_v1i128_increment_by_one
 ; CHECK-LE: lvx 2, {{[0-9]+}}, {{[0-9]+}}
 ; CHECK-LE: bl v1i128_increment_by_one
 ; CHECK-LE: blr
 
 ; CHECK-P9-LABEL: @call_v1i128_increment_by_one
 ; CHECK-P9: lxv
-; CHECK-P9: bl v1i128_increment_by_one
+; CHECK-P9: bl {{.?}}v1i128_increment_by_one
 ; CHECK-P9: blr
 
 ; CHECK-BE-LABEL: @call_v1i128_increment_by_one
 ; CHECK-BE: lxvw4x 34, {{[0-9]+}}, {{[0-9]+}}
 ; CHECK-BE-NOT: xxswapd 34, {{[0-9]+}}
-; CHECK-BE: bl v1i128_increment_by_one
+; CHECK-BE: bl {{.?}}v1i128_increment_by_one
 ; CHECK-BE: blr
 
 ; CHECK-NOVSX-LABEL: @call_v1i128_increment_by_one
 ; CHECK-NOVSX: lvx 2, {{[0-9]+}}, {{[0-9]+}}
 ; CHECK-NOVSX-NOT: xxswapd {{[0-9]+}}, {{[0-9]+}}
-; CHECK-NOVSX: bl v1i128_increment_by_one
+; CHECK-NOVSX: bl {{.?}}v1i128_increment_by_one
 ; CHECK-NOVSX: blr
 }
 
 define <1 x i128> @call_v1i128_increment_by_val() nounwind {
        %tmp = load <1 x i128>, <1 x i128>* @x, align 16
        %tmp2 = load <1 x i128>, <1 x i128>* @y, align 16
        %ret = call <1 x i128> @v1i128_increment_by_val(<1 x i128> %tmp, <1 x i128> %tmp2)
        ret <1 x i128> %ret
 
 ; CHECK-LE-LABEL: @call_v1i128_increment_by_val
 ; CHECK-LE: lvx 2, {{[0-9]+}}, {{[0-9]+}}
 ; CHECK-LE: lvx 3, {{[0-9]+}}, {{[0-9]+}}
 ; CHECK-LE: bl v1i128_increment_by_val
 ; CHECK-LE: blr
 
 ; CHECK-P9-LABEL: @call_v1i128_increment_by_val
 ; CHECK-P9-DAG: lxv v2
 ; CHECK-P9-DAG: lxv v3
-; CHECK-P9: bl v1i128_increment_by_val
+; CHECK-P9: bl {{.?}}v1i128_increment_by_val
 ; CHECK-P9: blr
 
 ; CHECK-BE-LABEL: @call_v1i128_increment_by_val
 
 
 ; CHECK-BE-DAG: lxvw4x 35, {{[0-9]+}}, {{[0-9]+}}
 ; CHECK-BE-NOT: xxswapd 34, {{[0-9]+}}
 ; CHECK-BE-NOT: xxswapd 35, {{[0-9]+}}
-; CHECK-BE: bl v1i128_increment_by_val
+; CHECK-BE: bl {{.?}}v1i128_increment_by_val
 ; CHECK-BE: blr
 
 ; CHECK-NOVSX-LABEL: @call_v1i128_increment_by_val
 ; CHECK-NOVSX-DAG: lvx 2, {{[0-9]+}}, {{[0-9]+}}
 ; CHECK-NOVSX-DAG: lvx 3, {{[0-9]+}}, {{[0-9]+}}
 ; CHECK-NOVSX-NOT: xxswapd 34, {{[0-9]+}}
 ; CHECK-NOVSX-NOT: xxswapd 35, {{[0-9]+}}
-; CHECK-NOVSX: bl v1i128_increment_by_val
+; CHECK-NOVSX: bl {{.?}}v1i128_increment_by_val
 ; CHECK-NOVSX: blr
 
 }
 
 define i128 @call_i128_increment_by_one() nounwind {
        %tmp = load i128, i128* @a, align 16
        %ret = call i128 @i128_increment_by_one(i128 %tmp)
        ret i128 %ret
 ;       %ret4 = call i128 @i128_increment_by_val(i128 %tmp2, i128 %tmp2)
 ; CHECK-LE-LABEL: @call_i128_increment_by_one
 ; CHECK-LE-DAG: ld 3, 0([[BASEREG:[0-9]+]])
 ; CHECK-LE-DAG: ld 4, 8([[BASEREG]])
 ; CHECK-LE: bl i128_increment_by_one
 ; CHECK-LE: blr
 
 ; CHECK-BE-LABEL: @call_i128_increment_by_one
 ; CHECK-BE-DAG: ld 3, 0([[BASEREG:[0-9]+]])
 ; CHECK-BE-DAG: ld 4, 8([[BASEREG]])
-; CHECK-BE: bl i128_increment_by_one
+; CHECK-BE: bl {{.?}}i128_increment_by_one
 ; CHECK-BE: blr
 
 ; CHECK-NOVSX-LABEL: @call_i128_increment_by_one
 ; CHECK-NOVSX-DAG: ld 3, 0([[BASEREG:[0-9]+]])
 ; CHECK-NOVSX-DAG: ld 4, 8([[BASEREG]])
-; CHECK-NOVSX: bl i128_increment_by_one
+; CHECK-NOVSX: bl {{.?}}i128_increment_by_one
 ; CHECK-NOVSX: blr
 }
 
 define i128 @call_i128_increment_by_val() nounwind {
        %tmp = load i128, i128* @a, align 16
        %tmp2 = load i128, i128* @b, align 16
        %ret = call i128 @i128_increment_by_val(i128 %tmp, i128 %tmp2)
        ret i128 %ret
 ; CHECK-LE-LABEL: @call_i128_increment_by_val
 ; CHECK-LE-DAG: ld 3, 0([[P1BASEREG:[0-9]+]])
 ; CHECK-LE-DAG: ld 4, 8([[P1BASEREG]])
 ; CHECK-LE-DAG: ld 5, 0([[P2BASEREG:[0-9]+]])
 ; CHECK-LE-DAG: ld 6, 8([[P2BASEREG]])
 ; CHECK-LE: bl i128_increment_by_val
 ; CHECK-LE: blr
 
 ; CHECK-BE-LABEL: @call_i128_increment_by_val
 ; CHECK-BE-DAG: ld 3, 0([[P1BASEREG:[0-9]+]])
 ; CHECK-BE-DAG: ld 4, 8([[P1BASEREG]])
 ; CHECK-BE-DAG: ld 5, 0([[P2BASEREG:[0-9]+]])
 ; CHECK-BE-DAG: ld 6, 8([[P2BASEREG]])
-; CHECK-BE: bl i128_increment_by_val
+; CHECK-BE: bl {{.?}}i128_increment_by_val
 ; CHECK-BE: blr
 
 ; CHECK-NOVSX-LABEL: @call_i128_increment_by_val
 ; CHECK-NOVSX-DAG: ld 3, 0([[P1BASEREG:[0-9]+]])
 ; CHECK-NOVSX-DAG: ld 4, 8([[P1BASEREG]])
 ; CHECK-NOVSX-DAG: ld 5, 0([[P2BASEREG:[0-9]+]])
 ; CHECK-NOVSX-DAG: ld 6, 8([[P2BASEREG]])
-; CHECK-NOVSX: bl i128_increment_by_val
+; CHECK-NOVSX: bl {{.?}}i128_increment_by_val
 ; CHECK-NOVSX: blr
 }