r276934 - [OpenMP] Add support to map member expressions with references to pointers.
Richard Smith via cfe-commits
cfe-commits at lists.llvm.org
Thu Nov 3 15:13:24 PDT 2016
On Wed, Jul 27, 2016 at 3:52 PM, Samuel Antao via cfe-commits <
cfe-commits at lists.llvm.org> wrote:
> Author: sfantao
> Date: Wed Jul 27 17:52:16 2016
> New Revision: 276934
>
> URL: http://llvm.org/viewvc/llvm-project?rev=276934&view=rev
> Log:
> [OpenMP] Add support to map member expressions with references to pointers.
>
> Summary: This patch add support to map pointers through references in
> class members. Although a reference does not have storage that a user can
> access, it still has to be mapped in order to get the deep copy right and
> the dereferencing code work properly.
>
> Reviewers: hfinkel, carlo.bertolli, arpith-jacob, kkwli0, ABataev
>
> Subscribers: caomhin, cfe-commits
>
> Differential Revision: https://reviews.llvm.org/D22787
>
> Modified:
> cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp
> cfe/trunk/test/OpenMP/target_map_codegen.cpp
>
> Modified: cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/
> CGOpenMPRuntime.cpp?rev=276934&r1=276933&r2=276934&view=diff
> ============================================================
> ==================
> --- cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp Wed Jul 27 17:52:16 2016
> @@ -5320,14 +5320,34 @@ private:
> isa<OMPArraySectionExpr>(Next->getAssociatedExpression()))
> &&
> "Unexpected expression");
>
> - // Save the base we are currently using.
> - BasePointers.push_back(BP);
> -
> auto *LB = CGF.EmitLValue(I->getAssociatedExpression()).
> getPointer();
> auto *Size = getExprTypeSize(I->getAssociatedExpression());
>
> + // If we have a member expression and the current component is a
> + // reference, we have to map the reference too. Whenever we have a
> + // reference, the section that reference refers to is going to be
> a
> + // load instruction from the storage assigned to the reference.
> + if (isa<MemberExpr>(I->getAssociatedExpression()) &&
> + I->getAssociatedDeclaration()->getType()->isReferenceType())
> {
> + auto *LI = cast<llvm::LoadInst>(LB);
> + auto *RefAddr = LI->getPointerOperand();
> +
> + BasePointers.push_back(BP);
> + Pointers.push_back(RefAddr);
> + Sizes.push_back(CGF.getTypeSize(CGF.getContext().VoidPtrTy));
> + Types.push_back(getMapTypeBits(
> + /*MapType*/ OMPC_MAP_alloc, /*MapTypeModifier=*/OMPC_MAP_
> unknown,
> + !IsExpressionFirstInfo, IsCaptureFirstInfo));
> + IsExpressionFirstInfo = false;
> + IsCaptureFirstInfo = false;
> + // The reference will be the next base address.
> + BP = RefAddr;
> + }
> +
> + BasePointers.push_back(BP);
> Pointers.push_back(LB);
> Sizes.push_back(Size);
> +
> // We need to add a pointer flag for each map that comes from the
> // same expression except for the first one. We also need to
> signal
> // this map is the first one that relates with the current capture
>
> Modified: cfe/trunk/test/OpenMP/target_map_codegen.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/
> target_map_codegen.cpp?rev=276934&r1=276933&r2=276934&view=diff
> ============================================================
> ==================
> --- cfe/trunk/test/OpenMP/target_map_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/target_map_codegen.cpp Wed Jul 27 17:52:16 2016
>
This test file now takes 30s to run with a debug binary, and is one of
Clang's slowest tests (tests are typically expected to finish in well under
a second).
Can you take a look? Instead of running the compiler 174 times on the same
inputs with the same flags, how about just running it once and -- if
necessary -- storing the output to a temporary file and passing that to
FileCheck multiple times?
@@ -4564,4 +4564,193 @@ void explicit_maps_pointer_references (i
> }
> }
> #endif
> +///========================================================
> ==================///
> +// RUN: %clang_cc1 -DCK29 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu
> -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck
> %s --check-prefix CK29 --check-prefix CK29-64
> +// RUN: %clang_cc1 -DCK29 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu
> -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
> +// RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu
> -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t
> -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CK29
> --check-prefix CK29-64
> +// RUN: %clang_cc1 -DCK29 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu
> -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s
> --check-prefix CK29 --check-prefix CK29-32
> +// RUN: %clang_cc1 -DCK29 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x
> c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
> +// RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++
> -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s
> -emit-llvm -o - | FileCheck %s --check-prefix CK29 --check-prefix CK29-32
> +#ifdef CK29
> +
> +// CK29: [[SSA:%.+]] = type { double*, double** }
> +// CK29: [[SSB:%.+]] = type { [[SSA]]*, [[SSA]]** }
> +
> +// CK29: [[SIZE00:@.+]] = private {{.*}}constant [4 x i[[Z:64|32]]]
> [i[[Z:64|32]] {{8|4}}, i[[Z:64|32]] {{8|4}}, i[[Z:64|32]] {{8|4}},
> i[[Z:64|32]] 80]
> +// CK29: [[MTYPE00:@.+]] = private {{.*}}constant [4 x i32] [i32 35, i32
> 16, i32 19, i32 19]
> +
> +// CK29: [[SIZE01:@.+]] = private {{.*}}constant [4 x i[[Z]]] [i[[Z]]
> {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 80]
> +// CK29: [[MTYPE01:@.+]] = private {{.*}}constant [4 x i32] [i32 32, i32
> 19, i32 19, i32 19]
> +
> +// CK29: [[SIZE02:@.+]] = private {{.*}}constant [5 x i[[Z]]] [i[[Z]]
> {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 80]
> +// CK29: [[MTYPE02:@.+]] = private {{.*}}constant [5 x i32] [i32 32, i32
> 19, i32 16, i32 19, i32 19]
> +
> +struct SSA{
> + double *p;
> + double *≺
> + SSA(double *&pr) : pr(pr) {}
> +};
> +
> +struct SSB{
> + SSA *p;
> + SSA *≺
> + SSB(SSA *&pr) : pr(pr) {}
> +
> + // CK29-LABEL: define {{.+}}foo
> + void foo() {
> +
> + // Region 00
> + // CK29-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32
> 4, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[4 x
> i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]*
> [[MTYPE00]]{{.+}})
> +
> + // CK29-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
> + // CK29-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
> +
> + // CK29-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 0
> + // CK29-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 0
> + // CK29-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
> + // CK29-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
> + // CK29-DAG: [[CBPVAL0]] = bitcast [[SSB]]* [[VAR0:%.+]] to i8*
> + // CK29-DAG: [[CPVAL0]] = bitcast [[SSA]]** [[VAR00:%.+]] to i8*
> + // CK29-DAG: [[VAR0]] = load [[SSB]]*, [[SSB]]** %
> + // CK29-DAG: [[VAR00]] = getelementptr inbounds [[SSB]], [[SSB]]*
> [[VAR0]], i32 0, i32 0
> +
> + // CK29-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 1
> + // CK29-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 1
> + // CK29-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
> + // CK29-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
> + // CK29-DAG: [[CBPVAL1]] = bitcast [[SSA]]** [[VAR00]] to i8*
> + // CK29-DAG: [[CPVAL1]] = bitcast double*** [[VAR1:%.+]] to i8*
> + // CK29-DAG: [[VAR1]] = getelementptr inbounds [[SSA]], [[SSA]]*
> %{{.+}}, i32 0, i32 1
> +
> + // CK29-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 2
> + // CK29-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 2
> + // CK29-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
> + // CK29-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
> + // CK29-DAG: [[CBPVAL2]] = bitcast double*** [[VAR1]] to i8*
> + // CK29-DAG: [[CPVAL2]] = bitcast double** [[VAR2:%.+]] to i8*
> + // CK29-DAG: [[VAR2]] = load double**, double*** [[VAR22:%.+]],
> + // CK29-DAG: [[VAR22]] = getelementptr inbounds [[SSA]], [[SSA]]*
> %{{.+}}, i32 0, i32 1
> +
> + // CK29-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 3
> + // CK29-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 3
> + // CK29-DAG: store i8* [[CBPVAL3:%[^,]+]], i8** [[BP3]]
> + // CK29-DAG: store i8* [[CPVAL3:%[^,]+]], i8** [[P3]]
> + // CK29-DAG: [[CBPVAL3]] = bitcast double** [[VAR2]] to i8*
> + // CK29-DAG: [[CPVAL3]] = bitcast double* [[VAR3:%.+]] to i8*
> + // CK29-DAG: [[VAR3]] = getelementptr inbounds double, double*
> [[VAR33:%.+]], i{{.+}} 0
> + // CK29-DAG: [[VAR33]] = load double*, double** %{{.+}},
> +
> + // CK29: call void [[CALL00:@.+]]([[SSB]]* {{[^,]+}})
> + #pragma omp target map(p->pr[:10])
> + {
> + p->pr++;
> + }
> +
> + // Region 01
> + // CK29-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32
> 4, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[4 x
> i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]*
> [[MTYPE01]]{{.+}})
> +
> + // CK29-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
> + // CK29-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
> +
> + // CK29-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 0
> + // CK29-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 0
> + // CK29-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
> + // CK29-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
> + // CK29-DAG: [[CBPVAL0]] = bitcast [[SSB]]* [[VAR0:%.+]] to i8*
> + // CK29-DAG: [[CPVAL0]] = bitcast [[SSA]]*** [[VAR00:%.+]] to i8*
> + // CK29-DAG: [[VAR00]] = getelementptr inbounds [[SSB]], [[SSB]]*
> [[VAR0]], i32 0, i32 1
> +
> + // CK29-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 1
> + // CK29-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 1
> + // CK29-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
> + // CK29-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
> + // CK29-DAG: [[CBPVAL1]] = bitcast [[SSA]]*** [[VAR00]] to i8*
> + // CK29-DAG: [[CPVAL1]] = bitcast [[SSA]]** [[VAR1:%.+]] to i8*
> + // CK29-DAG: [[VAR1]] = load [[SSA]]**, [[SSA]]*** [[VAR00]],
> +
> + // CK29-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 2
> + // CK29-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 2
> + // CK29-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
> + // CK29-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
> + // CK29-DAG: [[CBPVAL2]] = bitcast [[SSA]]** [[VAR1]] to i8*
> + // CK29-DAG: [[CPVAL2]] = bitcast double** [[VAR2:%.+]] to i8*
> + // CK29-DAG: [[VAR2]] = getelementptr inbounds [[SSA]], [[SSA]]*
> %{{.+}}, i32 0, i32 0
> +
> + // CK29-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 3
> + // CK29-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 3
> + // CK29-DAG: store i8* [[CBPVAL3:%[^,]+]], i8** [[BP3]]
> + // CK29-DAG: store i8* [[CPVAL3:%[^,]+]], i8** [[P3]]
> + // CK29-DAG: [[CBPVAL3]] = bitcast double** [[VAR2]] to i8*
> + // CK29-DAG: [[CPVAL3]] = bitcast double* [[VAR3:%.+]] to i8*
> + // CK29-DAG: [[VAR3]] = getelementptr inbounds double, double*
> [[VAR33:%.+]], i{{.+}} 0
> + // CK29-DAG: [[VAR33]] = load double*, double** %{{.+}},
> +
> + // CK29: call void [[CALL00:@.+]]([[SSB]]* {{[^,]+}})
> + #pragma omp target map(pr->p[:10])
> + {
> + pr->p++;
> + }
> +
> + // Region 02
> + // CK29-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32
> 5, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[5 x
> i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[5 x i{{.+}}]*
> [[MTYPE02]]{{.+}})
> +
> + // CK29-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
> + // CK29-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
> +
> + // CK29-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 0
> + // CK29-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 0
> + // CK29-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
> + // CK29-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
> + // CK29-DAG: [[CBPVAL0]] = bitcast [[SSB]]* [[VAR0:%.+]] to i8*
> + // CK29-DAG: [[CPVAL0]] = bitcast [[SSA]]*** [[VAR00:%.+]] to i8*
> + // CK29-DAG: [[VAR00]] = getelementptr inbounds [[SSB]], [[SSB]]*
> [[VAR0]], i32 0, i32 1
> +
> + // CK29-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 1
> + // CK29-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 1
> + // CK29-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
> + // CK29-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
> + // CK29-DAG: [[CBPVAL1]] = bitcast [[SSA]]*** [[VAR00]] to i8*
> + // CK29-DAG: [[CPVAL1]] = bitcast [[SSA]]** [[VAR1:%.+]] to i8*
> + // CK29-DAG: [[VAR1]] = load [[SSA]]**, [[SSA]]*** [[VAR00]],
> +
> + // CK29-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 2
> + // CK29-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 2
> + // CK29-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
> + // CK29-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
> + // CK29-DAG: [[CBPVAL2]] = bitcast [[SSA]]** [[VAR1]] to i8*
> + // CK29-DAG: [[CPVAL2]] = bitcast double*** [[VAR2:%.+]] to i8*
> + // CK29-DAG: [[VAR2]] = getelementptr inbounds [[SSA]], [[SSA]]*
> %{{.+}}, i32 0, i32 1
> +
> + // CK29-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 3
> + // CK29-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 3
> + // CK29-DAG: store i8* [[CBPVAL3:%[^,]+]], i8** [[BP3]]
> + // CK29-DAG: store i8* [[CPVAL3:%[^,]+]], i8** [[P3]]
> + // CK29-DAG: [[CBPVAL3]] = bitcast double*** [[VAR2]] to i8*
> + // CK29-DAG: [[CPVAL3]] = bitcast double** [[VAR3:%.+]] to i8*
> + // CK29-DAG: [[VAR3]] = load double**, double*** [[VAR2]],
> +
> + // CK29-DAG: [[BP4:%.+]] = getelementptr inbounds {{.+}}[[BP]],
> i{{.+}} 0, i{{.+}} 4
> + // CK29-DAG: [[P4:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}}
> 0, i{{.+}} 4
> + // CK29-DAG: store i8* [[CBPVAL4:%[^,]+]], i8** [[BP4]]
> + // CK29-DAG: store i8* [[CPVAL4:%[^,]+]], i8** [[P4]]
> + // CK29-DAG: [[CBPVAL4]] = bitcast double** [[VAR3]] to i8*
> + // CK29-DAG: [[CPVAL4]] = bitcast double* [[VAR4:%.+]] to i8*
> + // CK29-DAG: [[VAR4]] = getelementptr inbounds double, double*
> [[VAR44:%.+]], i{{.+}} 0
> + // CK29-DAG: [[VAR44]] = load double*, double**
> +
> + // CK29: call void [[CALL00:@.+]]([[SSB]]* {{[^,]+}})
> + #pragma omp target map(pr->pr[:10])
> + {
> + pr->pr++;
> + }
> + }
> +};
> +
> +void explicit_maps_member_pointer_references(SSA *sap) {
> + double *d;
> + SSA sa(d);
> + SSB sb(sap);
> + sb.foo();
> +}
> +#endif
> #endif
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20161103/79daa1e3/attachment-0001.html>
More information about the cfe-commits
mailing list