[PowerPC] Semachecking for XL compat builtin icbt

[quinnp]

Summary

This patch is in a series of patches to provide builtins for compatibility with the XL compiler.
This patch adds semachecking for an already implemented builtin, __icbt. __icbt is only
valid for Power8 and up.

[nemanjai]

LGTM.

[nemanjai]

clang/test/CodeGen/builtins-ppc-xlcompat-pwr8.c

2

Oh, I believe you're missing REQUIRES: powerpc-registered-target in this test case (please look at the requirements in the other builtins tests).

[quinnp]

Removing some FIXME comments and tests that are handled elsewhere with semachecking.

[quinnp]

Typo.

[quinnp]

clang/test/CodeGen/builtins-ppc-xlcompat-pwr8.c

2

I don't think I need REQUIRES: powerpc-registered-target, I am copying clang/test/CodeGen/builtins-ppc-xlcompat-pwr9.c which was committed here https://reviews.llvm.org/D102875#change-CGl81jJwEOZy. Although I may be wrong.

[quinnp]

Adding REQUIRES: powerpc-registered-target to a testcase and removing checks for entry: in front end test case.

[MaskRay]

clang/test/CodeGen/builtins-ppc-xlcompat-pwr8.c

10

This will attempt to write a file in srcdir which can cause an error if srcdir is in a readonly filesystem.

I added -o - in e8bc871ca2780788ad580bb23ef2621b09e6394b

clang/lib/Sema/SemaChecking.cpp

case PPC::BI__builtin_ppc_mtfsf:
     return SemaBuiltinConstantArgRange(TheCall, 0, 0, 255);
   case PPC::BI__builtin_ppc_mtfsfi:
     return SemaBuiltinConstantArgRange(TheCall, 0, 0, 7) ||
            SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
   case PPC::BI__builtin_ppc_alignx:
     return SemaBuiltinConstantArgPower2(TheCall, 0);
   case PPC::BI__builtin_ppc_rdlam:
     return SemaValueIsRunOfOnes(TheCall, 2);
+  case PPC::BI__builtin_ppc_icbt:
+    return SemaFeatureCheck(*this, TheCall, "isa-v207-instructions",
+                            diag::err_ppc_builtin_only_on_arch, "8");
 #define CUSTOM_BUILTIN(Name, Intr, Types, Acc) \
   case PPC::BI__builtin_##Name: \
     return SemaBuiltinPPCMMACall(TheCall, Types);
 #include "clang/Basic/BuiltinsPPC.def"
   }
   return SemaBuiltinConstantArgRange(TheCall, i, l, u);
 }
 

clang/test/CodeGen/builtins-ppc-xlcompat-pwr8.c

+// REQUIRES: powerpc-registered-target
+// RUN: %clang_cc1 -triple powerpc64-unknown-unknown -emit-llvm %s \
+// RUN:   -target-cpu pwr8 -o - | FileCheck %s -check-prefix=CHECK-PWR8
+// RUN: %clang_cc1 -triple powerpc64le-unknown-unknown -emit-llvm %s \
+// RUN:   -target-cpu pwr8 -o - | FileCheck %s -check-prefix=CHECK-PWR8
+// RUN: %clang_cc1 -triple powerpc64-unknown-aix -emit-llvm %s \
+// RUN:   -target-cpu pwr8 -o - | FileCheck %s -check-prefix=CHECK-PWR8
+// RUN: %clang_cc1 -triple powerpc-unknown-aix %s -emit-llvm %s \
+// RUN:   -target-cpu pwr8 -o - | FileCheck %s -check-prefix=CHECK-PWR8
+// RUN: not %clang_cc1 -triple powerpc64-unknown-unknown -emit-llvm %s \
+// RUN:   -target-cpu pwr7 2>&1 | FileCheck %s -check-prefix=CHECK-NOPWR8
+// RUN: not %clang_cc1 -triple powerpc64-unknown-aix -emit-llvm %s \
+// RUN:   -target-cpu pwr7 2>&1 | FileCheck %s -check-prefix=CHECK-NOPWR8
+// RUN: not %clang_cc1 -triple powerpc-unknown-aix %s -emit-llvm %s \
+// RUN:   -target-cpu pwr7 2>&1 | FileCheck %s -check-prefix=CHECK-NOPWR8
+
+extern void *a;
+
+void test_icbt() {
+// CHECK-LABEL: @test_icbt(
+
+  __icbt(a);
+// CHECK-PWR8: call void @llvm.ppc.icbt(i8* %0)
+// CHECK-NOPWR8: error: this builtin is only valid on POWER8 or later CPUs
+}
+
+void test_builtin_ppc_icbt() {
+// CHECK-LABEL: @test_builtin_ppc_icbt(
+
+  __builtin_ppc_icbt(a);
+// CHECK-PWR8: call void @llvm.ppc.icbt(i8* %0)
+// CHECK-NOPWR8: error: this builtin is only valid on POWER8 or later CPUs
+}

clang/test/CodeGen/builtins-ppc-xlcompat-sync.c

-// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // REQUIRES: powerpc-registered-target
 // RUN: %clang_cc1 -triple powerpc64-unknown-unknown \
 // RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
 // RUN: %clang_cc1 -triple powerpc64le-unknown-unknown \
 // RUN:   -emit-llvm %s -o - -target-cpu pwr8 | FileCheck %s
 // RUN: %clang_cc1 -triple powerpc64-unknown-aix \
 // RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
 // RUN: %clang_cc1 -triple powerpc-unknown-aix \
 // RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s --check-prefix=CHECK-32
 
 extern unsigned long a;
 extern const void *b;
 extern void *c;
 
 // CHECK-LABEL: @test_popcntb(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* @a, align 8
+// CHECK:    [[TMP0:%.*]] = load i64, i64* @a, align 8
 // CHECK-NEXT:    [[TMP1:%.*]] = load i64, i64* @a, align 8
 // CHECK-NEXT:    [[POPCNTB:%.*]] = call i64 @llvm.ppc.popcntb.i64.i64(i64 [[TMP0]])
 // CHECK-NEXT:    ret i64 [[POPCNTB]]
 //
 // CHECK-32-LABEL: @test_popcntb(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-32-NEXT:    [[TMP1:%.*]] = load i32, i32* @a, align 4
 // CHECK-32-NEXT:    [[POPCNTB:%.*]] = call i32 @llvm.ppc.popcntb.i32.i32(i32 [[TMP0]])
 // CHECK-32-NEXT:    ret i32 [[POPCNTB]]
 //
 unsigned long test_popcntb() {
   return __popcntb(a);
 }
 
 // CHECK-LABEL: @test_eieio(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.eieio()
+// CHECK:    call void @llvm.ppc.eieio()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_eieio(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.eieio()
+// CHECK-32:    call void @llvm.ppc.eieio()
 // CHECK-32-NEXT:    ret void
 //
 void test_eieio() {
   __eieio();
 }
 
 // CHECK-LABEL: @test_iospace_eieio(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.iospace.eieio()
+// CHECK:    call void @llvm.ppc.iospace.eieio()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_iospace_eieio(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.iospace.eieio()
+// CHECK-32:    call void @llvm.ppc.iospace.eieio()
 // CHECK-32-NEXT:    ret void
 //
 void test_iospace_eieio() {
   __iospace_eieio();
 }
 
 // CHECK-LABEL: @test_isync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.isync()
+// CHECK:    call void @llvm.ppc.isync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_isync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.isync()
+// CHECK-32:    call void @llvm.ppc.isync()
 // CHECK-32-NEXT:    ret void
 //
 void test_isync() {
   __isync();
 }
 
 // CHECK-LABEL: @test_lwsync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.lwsync()
+// CHECK:    call void @llvm.ppc.lwsync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_lwsync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.lwsync()
+// CHECK-32:    call void @llvm.ppc.lwsync()
 // CHECK-32-NEXT:    ret void
 //
 void test_lwsync() {
   __lwsync();
 }
 
 // CHECK-LABEL: @test_iospace_lwsync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.iospace.lwsync()
+// CHECK:    call void @llvm.ppc.iospace.lwsync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_iospace_lwsync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.iospace.lwsync()
+// CHECK-32:    call void @llvm.ppc.iospace.lwsync()
 // CHECK-32-NEXT:    ret void
 //
 void test_iospace_lwsync() {
   __iospace_lwsync();
 }
 
 // CHECK-LABEL: @test_sync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.sync()
+// CHECK:    call void @llvm.ppc.sync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_sync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.sync()
+// CHECK-32:    call void @llvm.ppc.sync()
 // CHECK-32-NEXT:    ret void
 //
 void test_sync() {
   __sync();
 }
 
 // CHECK-LABEL: @test_iospace_sync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.iospace.sync()
+// CHECK:    call void @llvm.ppc.iospace.sync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_iospace_sync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.iospace.sync()
+// CHECK-32:    call void @llvm.ppc.iospace.sync()
 // CHECK-32-NEXT:    ret void
 //
 void test_iospace_sync() {
   __iospace_sync();
 }
 
 // CHECK-LABEL: @test_dcbfl(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbfl(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_dcbfl(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbfl(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_dcbfl() {
   __dcbfl(b);
 }
 
 // CHECK-LABEL: @test_dcbflp(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbflp(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_dcbflp(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbflp(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_dcbflp() {
   __dcbflp(b);
 }
 
 // CHECK-LABEL: @test_dcbst(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbst(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_dcbst(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbst(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_dcbst() {
   __dcbst(b);
 }
 
 // CHECK-LABEL: @test_dcbt(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbt(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_dcbt(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbt(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_dcbt() {
   __dcbt(c);
 }
 
 // CHECK-LABEL: @test_dcbtst(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbtst(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_dcbtst(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbtst(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_dcbtst() {
   __dcbtst(c);
 }
 
 // CHECK-LABEL: @test_dcbz(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbz(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_dcbz(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbz(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_dcbz() {
   __dcbz(c);
 }
 
-// FIXME: __icbt is only valid for pwr8 and up.
-// CHECK-LABEL: @test_icbt(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
-// CHECK-NEXT:    call void @llvm.ppc.icbt(i8* [[TMP0]])
-// CHECK-NEXT:    ret void
-//
-// CHECK-32-LABEL: @test_icbt(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
-// CHECK-32-NEXT:    call void @llvm.ppc.icbt(i8* [[TMP0]])
-// CHECK-32-NEXT:    ret void
-//
-void test_icbt() {
-  __icbt(c);
-}
-
 // CHECK-LABEL: @test_builtin_ppc_popcntb(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* @a, align 8
+// CHECK:    [[TMP0:%.*]] = load i64, i64* @a, align 8
 // CHECK-NEXT:    [[TMP1:%.*]] = load i64, i64* @a, align 8
 // CHECK-NEXT:    [[POPCNTB:%.*]] = call i64 @llvm.ppc.popcntb.i64.i64(i64 [[TMP0]])
 // CHECK-NEXT:    ret i64 [[POPCNTB]]
 //
 // CHECK-32-LABEL: @test_builtin_ppc_popcntb(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-32-NEXT:    [[TMP1:%.*]] = load i32, i32* @a, align 4
 // CHECK-32-NEXT:    [[POPCNTB:%.*]] = call i32 @llvm.ppc.popcntb.i32.i32(i32 [[TMP0]])
 // CHECK-32-NEXT:    ret i32 [[POPCNTB]]
 //
 unsigned long test_builtin_ppc_popcntb() {
   return __builtin_ppc_popcntb(a);
 }
 
 // CHECK-LABEL: @test_builtin_ppc_eieio(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.eieio()
+// CHECK:    call void @llvm.ppc.eieio()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_eieio(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.eieio()
+// CHECK-32:    call void @llvm.ppc.eieio()
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_eieio() {
   __builtin_ppc_eieio();
 }
 
 // CHECK-LABEL: @test_builtin_ppc_iospace_eieio(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.iospace.eieio()
+// CHECK:    call void @llvm.ppc.iospace.eieio()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_iospace_eieio(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.iospace.eieio()
+// CHECK-32:    call void @llvm.ppc.iospace.eieio()
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_iospace_eieio() {
   __builtin_ppc_iospace_eieio();
 }
 
 // CHECK-LABEL: @test_builtin_ppc_isync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.isync()
+// CHECK:    call void @llvm.ppc.isync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_isync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.isync()
+// CHECK-32:    call void @llvm.ppc.isync()
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_isync() {
   __builtin_ppc_isync();
 }
 
 // CHECK-LABEL: @test_builtin_ppc_lwsync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.lwsync()
+// CHECK:    call void @llvm.ppc.lwsync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_lwsync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.lwsync()
+// CHECK-32:    call void @llvm.ppc.lwsync()
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_lwsync() {
   __builtin_ppc_lwsync();
 }
 
 // CHECK-LABEL: @test_builtin_ppc_iospace_lwsync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.iospace.lwsync()
+// CHECK:    call void @llvm.ppc.iospace.lwsync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_iospace_lwsync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.iospace.lwsync()
+// CHECK-32:    call void @llvm.ppc.iospace.lwsync()
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_iospace_lwsync() {
   __builtin_ppc_iospace_lwsync();
 }
 
 // CHECK-LABEL: @test_builtin_ppc_sync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.sync()
+// CHECK:    call void @llvm.ppc.sync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_sync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.sync()
+// CHECK-32:    call void @llvm.ppc.sync()
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_sync() {
   __builtin_ppc_sync();
 }
 
 // CHECK-LABEL: @test_builtin_ppc_iospace_sync(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    call void @llvm.ppc.iospace.sync()
+// CHECK:    call void @llvm.ppc.iospace.sync()
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_iospace_sync(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    call void @llvm.ppc.iospace.sync()
+// CHECK-32:    call void @llvm.ppc.iospace.sync()
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_iospace_sync() {
   __builtin_ppc_iospace_sync();
 }
 
 // CHECK-LABEL: @test_builtin_ppc_dcbfl(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbfl(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_dcbfl(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbfl(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_dcbfl() {
   __builtin_ppc_dcbfl(b);
 }
 
 // CHECK-LABEL: @test_builtin_ppc_dcbflp(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbflp(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_dcbflp(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbflp(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_dcbflp() {
   __builtin_ppc_dcbflp(b);
 }
 
 // CHECK-LABEL: @test_builtin_ppc_dcbst(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @b, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbst(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_dcbst(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @b, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbst(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_dcbst() {
   __builtin_ppc_dcbst(b);
 }
 
 // CHECK-LABEL: @test_builtin_ppc_dcbt(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbt(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_dcbt(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbt(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_dcbt() {
   __builtin_ppc_dcbt(c);
 }
 
 // CHECK-LABEL: @test_builtin_ppc_dcbtst(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbtst(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_dcbtst(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbtst(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_dcbtst() {
   __builtin_ppc_dcbtst(c);
 }
 
 // CHECK-LABEL: @test_builtin_ppc_dcbz(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
+// CHECK:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
 // CHECK-NEXT:    call void @llvm.ppc.dcbz(i8* [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 // CHECK-32-LABEL: @test_builtin_ppc_dcbz(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
+// CHECK-32:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
 // CHECK-32-NEXT:    call void @llvm.ppc.dcbz(i8* [[TMP0]])
 // CHECK-32-NEXT:    ret void
 //
 void test_builtin_ppc_dcbz() {
   __builtin_ppc_dcbz(c);
 }
-
-// FIXME: __icbt is only valid for pwr8 and up.
-// CHECK-LABEL: @test_builtin_ppc_icbt(
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 8
-// CHECK-NEXT:    call void @llvm.ppc.icbt(i8* [[TMP0]])
-// CHECK-NEXT:    ret void
-//
-// CHECK-32-LABEL: @test_builtin_ppc_icbt(
-// CHECK-32-NEXT:  entry:
-// CHECK-32-NEXT:    [[TMP0:%.*]] = load i8*, i8** @c, align 4
-// CHECK-32-NEXT:    call void @llvm.ppc.icbt(i8* [[TMP0]])
-// CHECK-32-NEXT:    ret void
-//
-void test_builtin_ppc_icbt() {
-  __builtin_ppc_icbt(c);
-}

llvm/include/llvm/IR/IntrinsicsPowerPC.td

let TargetPrefix = "ppc" in {
   def int_ppc_dcbt  : GCCBuiltin<"__builtin_ppc_dcbt">,
                       Intrinsic<[], [llvm_ptr_ty],
     [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
   def int_ppc_dcbtst : GCCBuiltin<"__builtin_ppc_dcbtst">,
                        Intrinsic<[], [llvm_ptr_ty],
     [IntrArgMemOnly, NoCapture<ArgIndex<0>>]>;
   def int_ppc_dcbz  : GCCBuiltin<"__builtin_ppc_dcbz">,
                       Intrinsic<[], [llvm_ptr_ty], []>;
-// FIXME: __icbt is only valid for pwr8 and up.
   def int_ppc_icbt : GCCBuiltin<"__builtin_ppc_icbt">,
                      Intrinsic<[], [llvm_ptr_ty], []>;
   
   // Population Count in each Byte.
   def int_ppc_popcntb : Intrinsic<[llvm_anyint_ty], [llvm_anyint_ty], [IntrNoMem]>;
   
   // sync instruction (i.e. sync 0, a.k.a hwsync)
   def int_ppc_sync : GCCBuiltin<"__builtin_ppc_sync">,

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-sync-32.ll

 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    sync
 ; CHECK-NEXT:    blr
 entry:
   call void @llvm.ppc.iospace.sync()
   ret void
 }
 declare void @llvm.ppc.iospace.sync()
-
-; FIXME: __icbt is only valid for pwr8 and up.
-define dso_local void @test_builtin_ppc_icbt() {
-; CHECK-LABEL: test_builtin_ppc_icbt:
-; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    lwz 3, -8(1)
-; CHECK-NEXT:    icbt 0, 0, 3
-; CHECK-NEXT:    blr
-entry:
-  %a = alloca i8*, align 8
-  %0 = load i8*, i8** %a, align 8
-  call void @llvm.ppc.icbt(i8* %0)
-  ret void
-}
-declare void @llvm.ppc.icbt(i8*)

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-sync-64.ll

 ; CHECK-AIX-NEXT:    sync
 ; CHECK-AIX-NEXT:    blr
 entry:
   call void @llvm.ppc.iospace.sync()
   ret void
 }
 declare void @llvm.ppc.iospace.sync()
 
-; FIXME: __icbt is only valid for pwr8 and up.
 define dso_local void @test_builtin_ppc_icbt() {
 ; CHECK-LABEL: test_builtin_ppc_icbt:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    ld r3, -8(r1)
 ; CHECK-NEXT:    icbt 0, 0, r3
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-AIX-LABEL: test_builtin_ppc_icbt: