diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -987,6 +987,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ CanQualType SingletonId; #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + CanQualType Id##Ty; +#include "clang/Basic/PPCTypes.def" // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand. mutable QualType AutoDeductTy; // Deduction against 'auto'. diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -2507,6 +2507,9 @@ // SVE Types #define SVE_TYPE(Name, Id, SingletonId) Id, #include "clang/Basic/AArch64SVEACLETypes.def" +// PPC MMA Types +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) Id, +#include "clang/Basic/PPCTypes.def" // All other builtin types #define BUILTIN_TYPE(Id, SingletonId) Id, #define LAST_BUILTIN_TYPE(Id) LastKind = Id diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td --- a/clang/include/clang/AST/TypeProperties.td +++ b/clang/include/clang/AST/TypeProperties.td @@ -760,6 +760,10 @@ case BuiltinType::ID: return ctx.SINGLETON_ID; #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(NAME, ID, SIZE) \ + case BuiltinType::ID: return ctx.ID##Ty; +#include "clang/Basic/PPCTypes.def" + #define BUILTIN_TYPE(ID, SINGLETON_ID) \ case BuiltinType::ID: return ctx.SINGLETON_ID; #include "clang/AST/BuiltinTypes.def" diff --git a/clang/include/clang/Basic/PPCTypes.def b/clang/include/clang/Basic/PPCTypes.def new file mode 100644 --- /dev/null +++ b/clang/include/clang/Basic/PPCTypes.def @@ -0,0 +1,20 @@ +//===-- PPCTypes.def - Metadata about PPC types -----------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines PPC types. +// Custom code should define this macro: +// +// PPC_MMA_VECTOR_TYPE(Name, Id, Size) - A MMA vector type of a given size +// (in bits). +// +//===----------------------------------------------------------------------===// + +PPC_MMA_VECTOR_TYPE(__vector_quad, VectorQuad, 512) +PPC_MMA_VECTOR_TYPE(__vector_pair, VectorPair, 256) + +#undef PPC_MMA_VECTOR_TYPE diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h --- a/clang/include/clang/Serialization/ASTBitCodes.h +++ b/clang/include/clang/Serialization/ASTBitCodes.h @@ -1074,6 +1074,9 @@ // \brief SVE types with auto numeration #define SVE_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID, #include "clang/Basic/AArch64SVEACLETypes.def" + // \brief PowerPC MMA types with auto numeration +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) PREDEF_TYPE_##Id##_ID, +#include "clang/Basic/PPCTypes.def" }; /// The number of predefined type IDs that are reserved for diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -1424,6 +1424,12 @@ #include "clang/Basic/AArch64SVEACLETypes.def" } + if (Target.getTriple().isPPC64() && Target.hasFeature("mma")) { +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + InitBuiltinType(Id##Ty, BuiltinType::Id); +#include "clang/Basic/PPCTypes.def" + } + // Builtin type for __objc_yes and __objc_no ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ? SignedCharTy : BoolTy); @@ -2142,6 +2148,12 @@ Align = 16; \ break; #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: \ + Width = Size; \ + Align = Size; \ + break; +#include "clang/Basic/PPCTypes.def" } break; case Type::ObjCObjectPointer: @@ -7056,6 +7068,9 @@ case BuiltinType::OCLReserveID: case BuiltinType::OCLSampler: case BuiltinType::Dependent: +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" #define BUILTIN_TYPE(KIND, ID) #define PLACEHOLDER_TYPE(KIND, ID) \ case BuiltinType::KIND: diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -1036,6 +1036,10 @@ case BuiltinType::Id: \ return Importer.getToContext().SingletonId; #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: \ + return Importer.getToContext().Id##Ty; +#include "clang/Basic/PPCTypes.def" #define SHARED_SINGLETON_TYPE(Expansion) #define BUILTIN_TYPE(Id, SingletonId) \ case BuiltinType::Id: return Importer.getToContext().SingletonId; diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -10312,6 +10312,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" return GCCTypeClass::None; case BuiltinType::Dependent: diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -2826,6 +2826,12 @@ Out << 'u' << type_name.size() << type_name; \ break; #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: \ + type_name = #Name; \ + Out << 'u' << type_name.size() << type_name; \ + break; +#include "clang/Basic/PPCTypes.def" } } diff --git a/clang/lib/AST/MicrosoftMangle.cpp b/clang/lib/AST/MicrosoftMangle.cpp --- a/clang/lib/AST/MicrosoftMangle.cpp +++ b/clang/lib/AST/MicrosoftMangle.cpp @@ -2090,6 +2090,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" case BuiltinType::ShortAccum: case BuiltinType::Accum: case BuiltinType::LongAccum: diff --git a/clang/lib/AST/NSAPI.cpp b/clang/lib/AST/NSAPI.cpp --- a/clang/lib/AST/NSAPI.cpp +++ b/clang/lib/AST/NSAPI.cpp @@ -474,6 +474,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" case BuiltinType::BoundMember: case BuiltinType::Dependent: case BuiltinType::Overload: diff --git a/clang/lib/AST/PrintfFormatString.cpp b/clang/lib/AST/PrintfFormatString.cpp --- a/clang/lib/AST/PrintfFormatString.cpp +++ b/clang/lib/AST/PrintfFormatString.cpp @@ -791,6 +791,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" #define SIGNED_TYPE(Id, SingletonId) #define UNSIGNED_TYPE(Id, SingletonId) #define FLOATING_TYPE(Id, SingletonId) diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -3044,6 +3044,10 @@ case Id: \ return Name; #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case Id: \ + return #Name; +#include "clang/Basic/PPCTypes.def" } llvm_unreachable("Invalid builtin type."); @@ -4048,6 +4052,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" case BuiltinType::BuiltinFn: case BuiltinType::NullPtr: case BuiltinType::IncompleteMatrixIdx: diff --git a/clang/lib/AST/TypeLoc.cpp b/clang/lib/AST/TypeLoc.cpp --- a/clang/lib/AST/TypeLoc.cpp +++ b/clang/lib/AST/TypeLoc.cpp @@ -403,6 +403,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" case BuiltinType::BuiltinFn: case BuiltinType::IncompleteMatrixIdx: case BuiltinType::OMPArraySection: diff --git a/clang/lib/Basic/Targets/PPC.h b/clang/lib/Basic/Targets/PPC.h --- a/clang/lib/Basic/Targets/PPC.h +++ b/clang/lib/Basic/Targets/PPC.h @@ -92,6 +92,11 @@ // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801, // 821, 823, 8540, e300c2, e300c3, e500mc64, e6500, 860, cell, titan, rs64. bool isValidCPUName(StringRef Name) const override; + bool isCPUP10OrNewer(StringRef Name) { + return llvm::StringSwitch(Name) + .Cases("power10", "pwr10", "future", true) + .Default(false); + } void fillValidCPUList(SmallVectorImpl &Values) const override; bool setCPU(const std::string &Name) override { @@ -395,12 +400,15 @@ LongWidth = LongAlign = PointerWidth = PointerAlign = 64; IntMaxType = SignedLong; Int64Type = SignedLong; + bool IsFuture = isCPUP10OrNewer(Opts.CPU); if ((Triple.getArch() == llvm::Triple::ppc64le)) { - resetDataLayout("e-m:e-i64:64-n32:64"); + resetDataLayout(IsFuture ? "e-m:e-i64:64-n32:64-v256:128:128-v512:128:128" + : "e-m:e-i64:64-n32:64"); ABI = "elfv2"; } else { - resetDataLayout("E-m:e-i64:64-n32:64"); + resetDataLayout(IsFuture ? "E-m:e-i64:64-n32:64-v256:128:128-v512:128:128" + : "E-m:e-i64:64-n32:64"); ABI = "elfv1"; } diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -735,6 +735,12 @@ // Return something safe. return CreateType(cast(CGM.getContext().IntTy)); } + // It doesn't make sense to generate debug info for PowerPC MMA vector types. + // So we return a safe type here to avoid generating an error. +#define PPC_MMA_VECTOR_TYPE(Name, Id, size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" + return CreateType(cast(CGM.getContext().IntTy)); case BuiltinType::UChar: case BuiltinType::Char_U: diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp --- a/clang/lib/CodeGen/CodeGenTypes.cpp +++ b/clang/lib/CodeGen/CodeGenTypes.cpp @@ -571,6 +571,13 @@ return llvm::VectorType::get(llvm::IntegerType::get(getLLVMContext(), 1), {16, true}); break; +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: \ + ResultType = \ + llvm::VectorType::get(ConvertType(Context.BoolTy), Size); \ + break; +#include "clang/Basic/PPCTypes.def" + case BuiltinType::Dependent: #define BUILTIN_TYPE(Id, SingletonId) #define PLACEHOLDER_TYPE(Id, SingletonId) \ diff --git a/clang/lib/CodeGen/ItaniumCXXABI.cpp b/clang/lib/CodeGen/ItaniumCXXABI.cpp --- a/clang/lib/CodeGen/ItaniumCXXABI.cpp +++ b/clang/lib/CodeGen/ItaniumCXXABI.cpp @@ -3003,6 +3003,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" case BuiltinType::ShortAccum: case BuiltinType::Accum: case BuiltinType::LongAccum: diff --git a/clang/lib/Index/USRGeneration.cpp b/clang/lib/Index/USRGeneration.cpp --- a/clang/lib/Index/USRGeneration.cpp +++ b/clang/lib/Index/USRGeneration.cpp @@ -729,6 +729,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" case BuiltinType::ShortAccum: case BuiltinType::Accum: case BuiltinType::LongAccum: diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -369,6 +369,13 @@ #include "clang/Basic/AArch64SVEACLETypes.def" } + if (Context.getTargetInfo().getTriple().isPPC64() && + Context.getTargetInfo().hasFeature("mma")) { +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + addImplicitTypedef(#Name, Context.Id##Ty); +#include "clang/Basic/PPCTypes.def" + } + if (Context.getTargetInfo().hasBuiltinMSVaList()) { DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list"); if (IdResolver.begin(MSVaList) == IdResolver.end()) diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -6042,6 +6042,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" #define PLACEHOLDER_TYPE(ID, SINGLETON_ID) #define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: #include "clang/AST/BuiltinTypes.def" @@ -19119,6 +19122,9 @@ #define SVE_TYPE(Name, Id, SingletonId) \ case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" #define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id: #define PLACEHOLDER_TYPE(Id, SingletonId) #include "clang/AST/BuiltinTypes.def" diff --git a/clang/lib/Serialization/ASTCommon.cpp b/clang/lib/Serialization/ASTCommon.cpp --- a/clang/lib/Serialization/ASTCommon.cpp +++ b/clang/lib/Serialization/ASTCommon.cpp @@ -237,6 +237,11 @@ ID = PREDEF_TYPE_##Id##_ID; \ break; #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case BuiltinType::Id: \ + ID = PREDEF_TYPE_##Id##_ID; \ + break; +#include "clang/Basic/PPCTypes.def" case BuiltinType::BuiltinFn: ID = PREDEF_TYPE_BUILTIN_FN; break; diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -7027,6 +7027,11 @@ T = Context.SingletonId; \ break; #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) \ + case PREDEF_TYPE_##Id##_ID: \ + T = Context.Id##Ty; \ + break; +#include "clang/Basic/PPCTypes.def" } assert(!T.isNull() && "Unknown predefined type"); diff --git a/clang/test/AST/ast-dump-ppc-mma-types.c b/clang/test/AST/ast-dump-ppc-mma-types.c new file mode 100644 --- /dev/null +++ b/clang/test/AST/ast-dump-ppc-mma-types.c @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -triple powerpc64le-unknown-unknown -target-cpu future \ +// RUN: -ast-dump -ast-dump-filter __vector %s | FileCheck %s +// RUN: %clang_cc1 -triple powerpc64le-unknown-unknown -target-cpu future \ +// RUN: -target-feature -mma -ast-dump %s | FileCheck %s \ +// RUN: --check-prefix=CHECK-NO-MMA +// RUN: %clang_cc1 -triple powerpc64le-unknown-unknown -target-cpu pwr9 \ +// RUN: -ast-dump %s | FileCheck %s --check-prefix=CHECK-PWR9 +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -ast-dump %s | FileCheck %s \ +// RUN: --check-prefix=CHECK-X86_64 +// RUN: %clang_cc1 -triple arm-unknown-unknown -ast-dump %s | FileCheck %s \ +// RUN: --check-prefix=CHECK-ARM +// RUN: %clang_cc1 -triple riscv64-unknown-unknown -ast-dump %s | FileCheck %s \ +// RUN: --check-prefix=CHECK-RISCV64 + +// This test case checks that the PowerPC __vector_pair and __vector_quad types +// are correctly defined. These types should only be defined on PowerPC targets +// supporting the mma feature. We also added checks on a couple of other targets +// to ensure the types are target-dependent. + +// CHECK: TypedefDecl {{.*}} implicit __vector_quad '__vector_quad' +// CHECK-NEXT: -BuiltinType {{.*}} '__vector_quad' +// CHECK: TypedefDecl {{.*}} implicit __vector_pair '__vector_pair' +// CHECK-NEXT: -BuiltinType {{.*}} '__vector_pair' + +// CHECK-NO-MMA-NOT: __vector_quad +// CHECK-NO-MMA-NOT: __vector_pair + +// CHECK-PWR9-NOT: __vector_quad +// CHECK-PWR9-NOT: __vector_pair + +// CHECK-X86_64-NOT: __vector_quad +// CHECK-X86_64-NOT: __vector_pair + +// CHECK-ARM-NOT: __vector_quad +// CHECK-ARM-NOT: __vector_pair + +// CHECK-RISCV64-NOT: __vector_quad +// CHECK-RISCV64-NOT: __vector_pair diff --git a/clang/test/CodeGen/ppc-mma-types.c b/clang/test/CodeGen/ppc-mma-types.c new file mode 100644 --- /dev/null +++ b/clang/test/CodeGen/ppc-mma-types.c @@ -0,0 +1,35 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py +// RUN: %clang_cc1 -triple powerpc64le-unknown-unknown -target-cpu future \ +// RUN: -emit-llvm -O3 -o - %s | FileCheck %s + +// CHECK-LABEL: @test1( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[PTR1:%.*]], i64 128 +// CHECK-NEXT: [[TMP0:%.*]] = bitcast i8* [[ADD_PTR]] to <512 x i1>* +// CHECK-NEXT: [[TMP1:%.*]] = load <512 x i1>, <512 x i1>* [[TMP0]], align 64, !tbaa !2 +// CHECK-NEXT: [[ADD_PTR1:%.*]] = getelementptr inbounds i8, i8* [[PTR2:%.*]], i64 64 +// CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[ADD_PTR1]] to <512 x i1>* +// CHECK-NEXT: store <512 x i1> [[TMP1]], <512 x i1>* [[TMP2]], align 64, !tbaa !2 +// CHECK-NEXT: ret void +// +void test1(void *ptr1, void *ptr2) { + __vector_quad *inp = (__vector_quad *)ptr1; + __vector_quad *outp = (__vector_quad *)ptr2; + *(outp + 1) = *(inp + 2); +} + +// CHECK-LABEL: @test2( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[PTR1:%.*]], i64 64 +// CHECK-NEXT: [[TMP0:%.*]] = bitcast i8* [[ADD_PTR]] to <256 x i1>* +// CHECK-NEXT: [[TMP1:%.*]] = load <256 x i1>, <256 x i1>* [[TMP0]], align 32, !tbaa !6 +// CHECK-NEXT: [[ADD_PTR1:%.*]] = getelementptr inbounds i8, i8* [[PTR2:%.*]], i64 32 +// CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[ADD_PTR1]] to <256 x i1>* +// CHECK-NEXT: store <256 x i1> [[TMP1]], <256 x i1>* [[TMP2]], align 32, !tbaa !6 +// CHECK-NEXT: ret void +// +void test2(void *ptr1, void *ptr2) { + __vector_pair *inp = (__vector_pair *)ptr1; + __vector_pair *outp = (__vector_pair *)ptr2; + *(outp + 1) = *(inp + 2); +} diff --git a/clang/test/CodeGenCXX/ppc-mangle-mma-types.cpp b/clang/test/CodeGenCXX/ppc-mangle-mma-types.cpp new file mode 100644 --- /dev/null +++ b/clang/test/CodeGenCXX/ppc-mangle-mma-types.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -triple powerpc64le-unknown-unknown -target-cpu future %s \ +// RUN: -emit-llvm -o - | FileCheck %s + +// CHECK: _Z2f1Pu13__vector_quad +void f1(__vector_quad *vq) {} + +// CHECK: _Z2f2Pu13__vector_pair +void f2(__vector_pair *vp) {} + +// CHECK: _Z2f3Pu13__vector_quad +void f3(__vector_quad *vq) {} + +// CHECK: _Z2f3Pu13__vector_pair +void f3(__vector_pair *vp) {} diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -1540,6 +1540,8 @@ case BuiltinType::OCLReserveID: #define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/AArch64SVEACLETypes.def" +#define PPC_MMA_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id: +#include "clang/Basic/PPCTypes.def" #define BUILTIN_TYPE(Id, SingletonId) #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: diff --git a/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp b/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp --- a/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp +++ b/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp @@ -124,7 +124,7 @@ } /// Return the datalayout string of a subtarget. -static std::string getDataLayoutString(const Triple &T) { +static std::string getDataLayoutString(const Triple &T, StringRef CPU) { bool is64Bit = T.getArch() == Triple::ppc64 || T.getArch() == Triple::ppc64le; std::string Ret; @@ -154,6 +154,14 @@ else Ret += "-n32"; + // Specify the vector alignment explicitly. For v256i1 and v512i1, the + // calculated alignment would be 256*alignment(i1) and 512*alignment(i1), + // which is 256 and 512 bytes - way over aligned. + bool IsCPUP10OrNewer = CPU == "pwr10" || CPU == "power10" || CPU == "future"; + if (IsCPUP10OrNewer && + (T.getArch() == Triple::ppc64le || T.getArch() == Triple::ppc64)) + Ret += "-v256:128:128-v512:128:128"; + return Ret; } @@ -305,7 +313,7 @@ Optional RM, Optional CM, CodeGenOpt::Level OL, bool JIT) - : LLVMTargetMachine(T, getDataLayoutString(TT), TT, CPU, + : LLVMTargetMachine(T, getDataLayoutString(TT, CPU), TT, CPU, computeFSAdditions(FS, OL, TT), Options, getEffectiveRelocModel(TT, RM), getEffectivePPCCodeModel(TT, CM, JIT), OL),