diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 05379f44a0a39..ef843c333106b 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -619,6 +619,18 @@ OpenMP Support Improvements ^^^^^^^^^^^^ +- Mapping of expressions that have base-pointers now conforms to the OpenMP's + conditional pointer-attachment based on both pointee and poitner being + present, and one being new. This also lays the foundation of supporting + OpenMP 6.1's attach map-type modifier. +- Several improvements were made to the handling of maps on list items involving + multiple levels of pointer dereferences, including not mapping intermediate + expressions, and grouping the items that share the same base-pointer, as + belonging to the same containing structure. +- Support of array-sections on ``use_device_addr`` was made more robust, + including diagnosing when the array-section's base is not a named-variable. +- Handling of ``use_device_addr`` and ``use_device_ptr`` in the presence of + other maps with the same base-pointer/variable, was improved. Additional Information ====================== diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index b157cbb0b8069..0a232c557414e 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -11702,6 +11702,9 @@ def err_omp_expected_addressable_lvalue_or_array_item : Error< "expected addressable lvalue expression, array element%select{ or array section|, array section or array shaping expression}0%select{| of non 'omp_depend_t' type}1">; def err_omp_expected_named_var_member_or_array_expression: Error< "expected expression containing only member accesses and/or array sections based on named variables">; +def err_omp_expected_base_pointer_var_name_member_expr + : Error<"base-pointer is not a variable name%select{| or data member of " + "current class}0">; def err_omp_bit_fields_forbidden_in_clause : Error< "bit fields cannot be used to specify storage in a '%0' clause">; def err_array_section_does_not_specify_contiguous_storage : Error< diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.cpp b/clang/lib/CodeGen/CGOpenMPRuntime.cpp index fa946921d468b..063b26bf01b0b 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntime.cpp +++ b/clang/lib/CodeGen/CGOpenMPRuntime.cpp @@ -6804,7 +6804,6 @@ LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); class MappableExprsHandler { public: /// Custom comparator for attach-pointer expressions that compares them by - /// complexity (i.e. their component-depth) first, then by the order in which /// they were computed by collectAttachPtrExprInfo(), if they are semantically /// different. struct AttachPtrExprComparator { @@ -7418,6 +7417,38 @@ class MappableExprsHandler { return ConstLength.getSExtValue() != 1; } + /// Emit an attach entry into \p CombinedInfo, using the information from \p + /// AttachInfo. For example, for a map of form `int *p; ... map(p[1:10])`, + /// an attach entry has the following form: + /// &p, &p[1], sizeof(void*), ATTACH + void emitAttachEntry(CodeGenFunction &CGF, MapCombinedInfoTy &CombinedInfo, + const AttachInfoTy &AttachInfo) const { + assert(AttachInfo.isValid() && + "Expected valid attach pointer/pointee information!"); + + // Size is the size of the pointer itself - use pointer size, not BaseDecl + // size + llvm::Value *PointerSize = CGF.Builder.CreateIntCast( + llvm::ConstantInt::get( + CGF.CGM.SizeTy, CGF.getContext() + .getTypeSizeInChars(CGF.getContext().VoidPtrTy) + .getQuantity()), + CGF.Int64Ty, /*isSigned=*/true); + + CombinedInfo.Exprs.emplace_back(AttachInfo.AttachPtrDecl, + AttachInfo.AttachMapExpr); + CombinedInfo.BasePointers.push_back( + AttachInfo.AttachPtrAddr.emitRawPointer(CGF)); + CombinedInfo.DevicePtrDecls.push_back(nullptr); + CombinedInfo.DevicePointers.push_back(DeviceInfoTy::None); + CombinedInfo.Pointers.push_back( + AttachInfo.AttachPteeAddr.emitRawPointer(CGF)); + CombinedInfo.Sizes.push_back(PointerSize); + CombinedInfo.Types.push_back(OpenMPOffloadMappingFlags::OMP_MAP_ATTACH); + CombinedInfo.Mappers.push_back(nullptr); + CombinedInfo.NonContigInfo.Dims.push_back(1); + } + /// A helper class to copy structures with overlapped elements, i.e. those /// which have mappings of both "s" and "s.mem". Consecutive elements that /// are not explicitly copied have mapping nodes synthesized for them, @@ -7533,17 +7564,21 @@ class MappableExprsHandler { OMPClauseMappableExprCommon::MappableExprComponentListRef Components, MapCombinedInfoTy &CombinedInfo, MapCombinedInfoTy &StructBaseCombinedInfo, - StructRangeInfoTy &PartialStruct, bool IsFirstComponentList, - bool IsImplicit, bool GenerateAllInfoForClauses, - const ValueDecl *Mapper = nullptr, bool ForDeviceAddr = false, - const ValueDecl *BaseDecl = nullptr, const Expr *MapExpr = nullptr, + StructRangeInfoTy &PartialStruct, AttachInfoTy &AttachInfo, + bool IsFirstComponentList, bool IsImplicit, + bool GenerateAllInfoForClauses, const ValueDecl *Mapper = nullptr, + bool ForDeviceAddr = false, const ValueDecl *BaseDecl = nullptr, + const Expr *MapExpr = nullptr, ArrayRef - OverlappedElements = {}, - bool AreBothBasePtrAndPteeMapped = false) const { + OverlappedElements = {}) const { + // The following summarizes what has to be generated for each map and the // types below. The generated information is expressed in this order: // base pointer, section pointer, size, flags // (to add to the ones that come from the map type and modifier). + // Entries annotated with (+) are only generated for "target" constructs, + // and only if the variable at the beginning of the expression is used in + // the region. // // double d; // int i[100]; @@ -7559,6 +7594,7 @@ class MappableExprsHandler { // float f[50]; // S1 s; // double *p; + // double *&pref; // struct S2 *ps; // int &ref; // } @@ -7578,19 +7614,34 @@ class MappableExprsHandler { // &p, &p, sizeof(float*), TARGET_PARAM | TO | FROM // // map(p[1:24]) - // &p, &p[1], 24*sizeof(float), TARGET_PARAM | TO | FROM | PTR_AND_OBJ - // in unified shared memory mode or for local pointers - // p, &p[1], 24*sizeof(float), TARGET_PARAM | TO | FROM + // p, &p[1], 24*sizeof(float), TARGET_PARAM | TO | FROM // map pointee + // &p, &p[1], sizeof(void*), ATTACH // attach pointer/pointee, if both + // // are present, and either is new + // + // map((22])p) + // p, p, 22*sizeof(float), TARGET_PARAM | TO | FROM + // &p, p, sizeof(void*), ATTACH // // map((*a)[0:3]) - // &(*a), &(*a), sizeof(pointer), TARGET_PARAM | TO | FROM - // &(*a), &(*a)[0], 3*sizeof(int), PTR_AND_OBJ | TO | FROM + // a, a, 0, TARGET_PARAM | IMPLICIT // (+) + // (*a)[0], &(*a)[0], 3 * sizeof(int), TO | FROM + // &(*a), &(*a)[0], sizeof(void*), ATTACH + // (+) Only on target, if a is used in the region + // Note: Since the attach base-pointer is `*a`, which is not a scalar + // variable, it doesn't determine the clause on `a`. `a` is mapped using + // a zero-length-array-section map by generateDefaultMapInfo, if it is + // referenced in the target region, because it is a pointer. // // map(**a) - // &(*a), &(*a), sizeof(pointer), TARGET_PARAM | TO | FROM - // &(*a), &(**a), sizeof(int), PTR_AND_OBJ | TO | FROM + // a, a, 0, TARGET_PARAM | IMPLICIT // (+) + // &(*a)[0], &(*a)[0], sizeof(int), TO | FROM + // &(*a), &(*a)[0], sizeof(void*), ATTACH + // (+) Only on target, if a is used in the region // // map(s) + // FIXME: This needs to also imply map(ref_ptr_ptee: s.ref), since the + // effect is supposed to be same as if the user had a map for every element + // of the struct. We currently do a shallow-map of s. // &s, &s, sizeof(S2), TARGET_PARAM | TO | FROM // // map(s.i) @@ -7603,122 +7654,138 @@ class MappableExprsHandler { // &s, &(s.p), sizeof(double*), TARGET_PARAM | TO | FROM // // map(to: s.p[:22]) - // &s, &(s.p), sizeof(double*), TARGET_PARAM (*) - // &s, &(s.p), sizeof(double*), MEMBER_OF(1) (**) - // &(s.p), &(s.p[0]), 22*sizeof(double), - // MEMBER_OF(1) | PTR_AND_OBJ | TO (***) - // (*) alloc space for struct members, only this is a target parameter - // (**) map the pointer (nothing to be mapped in this example) (the compiler - // optimizes this entry out, same in the examples below) - // (***) map the pointee (map: to) + // &s, &(s.p), sizeof(double*), TARGET_PARAM | IMPLICIT // (+) + // &(s.p[0]), &(s.p[0]), 22 * sizeof(double*), TO | FROM + // &(s.p), &(s.p[0]), sizeof(void*), ATTACH // // map(to: s.ref) - // &s, &(s.ref), sizeof(int*), TARGET_PARAM (*) - // &s, &(s.ref), sizeof(int), MEMBER_OF(1) | PTR_AND_OBJ | TO (***) - // (*) alloc space for struct members, only this is a target parameter + // &s, &(ptr(s.ref)), sizeof(int*), TARGET_PARAM (*) + // &s, &(ptee(s.ref)), sizeof(int), MEMBER_OF(1) | PTR_AND_OBJ | TO (***) + // (*) alloc space for struct members, only this is a target parameter. // (**) map the pointer (nothing to be mapped in this example) (the compiler // optimizes this entry out, same in the examples below) // (***) map the pointee (map: to) + // Note: ptr(s.ref) represents the referring pointer of s.ref + // ptee(s.ref) represents the referenced pointee of s.ref + // + // map(to: s.pref) + // &s, &(ptr(s.pref)), sizeof(double**), TARGET_PARAM + // &s, &(ptee(s.pref)), sizeof(double*), MEMBER_OF(1) | PTR_AND_OBJ | TO + // + // map(to: s.pref[:22]) + // &s, &(ptr(s.pref)), sizeof(double**), TARGET_PARAM | IMPLICIT // (+) + // &s, &(ptee(s.pref)), sizeof(double*), MEMBER_OF(1) | PTR_AND_OBJ | TO | + // FROM | IMPLICIT // (+) + // &(ptee(s.pref)[0]), &(ptee(s.pref)[0]), 22 * sizeof(double), TO + // &(ptee(s.pref)), &(ptee(s.pref)[0]), sizeof(void*), ATTACH // // map(s.ps) // &s, &(s.ps), sizeof(S2*), TARGET_PARAM | TO | FROM // // map(from: s.ps->s.i) - // &s, &(s.ps), sizeof(S2*), TARGET_PARAM - // &s, &(s.ps), sizeof(S2*), MEMBER_OF(1) - // &(s.ps), &(s.ps->s.i), sizeof(int), MEMBER_OF(1) | PTR_AND_OBJ | FROM + // &s, &(s.ps), sizeof(S2*), TARGET_PARAM | TO | FROM | IMPLICIT // (+) + // &(s.ps[0]), &(s.ps->s.i), sizeof(int), FROM + // &(s.ps), &(s.ps->s.i), sizeof(void*), ATTACH // // map(to: s.ps->ps) - // &s, &(s.ps), sizeof(S2*), TARGET_PARAM - // &s, &(s.ps), sizeof(S2*), MEMBER_OF(1) - // &(s.ps), &(s.ps->ps), sizeof(S2*), MEMBER_OF(1) | PTR_AND_OBJ | TO + // &s, &(s.ps), sizeof(S2*), TARGET_PARAM | TO | FROM | IMPLICIT // (+) + // &(s.ps[0]), &(s.ps->ps), sizeof(S2*), TO + // &(s.ps), &(s.ps->ps), sizeof(void*), ATTACH // // map(s.ps->ps->ps) - // &s, &(s.ps), sizeof(S2*), TARGET_PARAM - // &s, &(s.ps), sizeof(S2*), MEMBER_OF(1) - // &(s.ps), &(s.ps->ps), sizeof(S2*), MEMBER_OF(1) | PTR_AND_OBJ - // &(s.ps->ps), &(s.ps->ps->ps), sizeof(S2*), PTR_AND_OBJ | TO | FROM + // &s, &(s.ps), sizeof(S2*), TARGET_PARAM | TO | FROM | IMPLICIT // (+) + // &(s.ps->ps[0]), &(s.ps->ps->ps), sizeof(S2*), TO + // &(s.ps->ps), &(s.ps->ps->ps), sizeof(void*), ATTACH // // map(to: s.ps->ps->s.f[:22]) - // &s, &(s.ps), sizeof(S2*), TARGET_PARAM - // &s, &(s.ps), sizeof(S2*), MEMBER_OF(1) - // &(s.ps), &(s.ps->ps), sizeof(S2*), MEMBER_OF(1) | PTR_AND_OBJ - // &(s.ps->ps), &(s.ps->ps->s.f[0]), 22*sizeof(float), PTR_AND_OBJ | TO + // &s, &(s.ps), sizeof(S2*), TARGET_PARAM | TO | FROM | IMPLICIT // (+) + // &(s.ps->ps[0]), &(s.ps->ps->s.f[0]), 22*sizeof(float), TO + // &(s.ps->ps), &(s.ps->ps->s.f[0]), sizeof(void*), ATTACH // // map(ps) // &ps, &ps, sizeof(S2*), TARGET_PARAM | TO | FROM // // map(ps->i) - // ps, &(ps->i), sizeof(int), TARGET_PARAM | TO | FROM + // ps, &(ps->i), sizeof(int), TARGET_PARAM | TO | FROM + // &ps, &(ps->i), sizeof(void*), ATTACH // // map(ps->s.f) - // ps, &(ps->s.f[0]), 50*sizeof(float), TARGET_PARAM | TO | FROM + // ps, &(ps->s.f[0]), 50*sizeof(float), TARGET_PARAM | TO | FROM + // &ps, &(ps->s.f[0]), sizeof(ps), ATTACH // // map(from: ps->p) - // ps, &(ps->p), sizeof(double*), TARGET_PARAM | FROM + // ps, &(ps->p), sizeof(double*), TARGET_PARAM | FROM + // &ps, &(ps->p), sizeof(ps), ATTACH // // map(to: ps->p[:22]) - // ps, &(ps->p), sizeof(double*), TARGET_PARAM - // ps, &(ps->p), sizeof(double*), MEMBER_OF(1) - // &(ps->p), &(ps->p[0]), 22*sizeof(double), MEMBER_OF(1) | PTR_AND_OBJ | TO + // ps, &(ps[0]), 0, TARGET_PARAM | IMPLICIT // (+) + // &(ps->p[0]), &(ps->p[0]), 22*sizeof(double), TO + // &(ps->p), &(ps->p[0]), sizeof(void*), ATTACH // // map(ps->ps) - // ps, &(ps->ps), sizeof(S2*), TARGET_PARAM | TO | FROM + // ps, &(ps->ps), sizeof(S2*), TARGET_PARAM | TO | FROM + // &ps, &(ps->ps), sizeof(ps), ATTACH // // map(from: ps->ps->s.i) - // ps, &(ps->ps), sizeof(S2*), TARGET_PARAM - // ps, &(ps->ps), sizeof(S2*), MEMBER_OF(1) - // &(ps->ps), &(ps->ps->s.i), sizeof(int), MEMBER_OF(1) | PTR_AND_OBJ | FROM + // ps, &(ps[0]), 0, TARGET_PARAM | IMPLICIT // (+) + // &(ps->ps[0]), &(ps->ps->s.i), sizeof(int), FROM + // &(ps->ps), &(ps->ps->s.i), sizeof(void*), ATTACH // // map(from: ps->ps->ps) - // ps, &(ps->ps), sizeof(S2*), TARGET_PARAM - // ps, &(ps->ps), sizeof(S2*), MEMBER_OF(1) - // &(ps->ps), &(ps->ps->ps), sizeof(S2*), MEMBER_OF(1) | PTR_AND_OBJ | FROM + // ps, &ps[0], 0, TARGET_PARAM | IMPLICIT // (+) + // &(ps->ps[0]), &(ps->ps->ps), sizeof(S2*), FROM + // &(ps->ps), &(ps->ps->ps), sizeof(void*), ATTACH // // map(ps->ps->ps->ps) - // ps, &(ps->ps), sizeof(S2*), TARGET_PARAM - // ps, &(ps->ps), sizeof(S2*), MEMBER_OF(1) - // &(ps->ps), &(ps->ps->ps), sizeof(S2*), MEMBER_OF(1) | PTR_AND_OBJ - // &(ps->ps->ps), &(ps->ps->ps->ps), sizeof(S2*), PTR_AND_OBJ | TO | FROM + // ps, &ps[0], 0, TARGET_PARAM | IMPLICIT // (+) + // &(ps->ps->ps[0]), &(ps->ps->ps->ps), sizeof(S2*), FROM + // &(ps->ps->ps), &(ps->ps->ps->ps), sizeof(void*), ATTACH // // map(to: ps->ps->ps->s.f[:22]) - // ps, &(ps->ps), sizeof(S2*), TARGET_PARAM - // ps, &(ps->ps), sizeof(S2*), MEMBER_OF(1) - // &(ps->ps), &(ps->ps->ps), sizeof(S2*), MEMBER_OF(1) | PTR_AND_OBJ - // &(ps->ps->ps), &(ps->ps->ps->s.f[0]), 22*sizeof(float), PTR_AND_OBJ | TO + // ps, &ps[0], 0, TARGET_PARAM | IMPLICIT // (+) + // &(ps->ps->ps[0]), &(ps->ps->ps->s.f[0]), 22*sizeof(float), TO + // &(ps->ps->ps), &(ps->ps->ps->s.f[0]), sizeof(void*), ATTACH // // map(to: s.f[:22]) map(from: s.p[:33]) - // &s, &(s.f[0]), 50*sizeof(float) + sizeof(struct S1) + - // sizeof(double*) (**), TARGET_PARAM - // &s, &(s.f[0]), 22*sizeof(float), MEMBER_OF(1) | TO - // &s, &(s.p), sizeof(double*), MEMBER_OF(1) - // &(s.p), &(s.p[0]), 33*sizeof(double), MEMBER_OF(1) | PTR_AND_OBJ | FROM - // (*) allocate contiguous space needed to fit all mapped members even if + // On target, and if s is used in the region: + // + // &s, &(s.f[0]), 50*sizeof(float) + + // sizeof(struct S1) + + // sizeof(double*) (**), TARGET_PARAM + // &s, &(s.f[0]), 22*sizeof(float), MEMBER_OF(1) | TO + // &s, &(s.p), sizeof(double*), MEMBER_OF(1) | TO | + // FROM | IMPLICIT + // &(s.p[0]), &(s.p[0]), 33*sizeof(double), FROM + // &(s.p), &(s.p[0]), sizeof(void*), ATTACH + // (**) allocate contiguous space needed to fit all mapped members even if // we allocate space for members not mapped (in this example, // s.f[22..49] and s.s are not mapped, yet we must allocate space for // them as well because they fall between &s.f[0] and &s.p) // + // On other constructs, and, if s is not used in the region, on target: + // &s, &(s.f[0]), 22*sizeof(float), TO + // &(s.p[0]), &(s.p[0]), 33*sizeof(double), FROM + // &(s.p), &(s.p[0]), sizeof(void*), ATTACH + // // map(from: s.f[:22]) map(to: ps->p[:33]) - // &s, &(s.f[0]), 22*sizeof(float), TARGET_PARAM | FROM - // ps, &(ps->p), sizeof(S2*), TARGET_PARAM - // ps, &(ps->p), sizeof(double*), MEMBER_OF(2) (*) - // &(ps->p), &(ps->p[0]), 33*sizeof(double), MEMBER_OF(2) | PTR_AND_OBJ | TO - // (*) the struct this entry pertains to is the 2nd element in the list of - // arguments, hence MEMBER_OF(2) + // &s, &(s.f[0]), 22*sizeof(float), TARGET_PARAM | FROM + // &ps[0], &ps[0], 0, TARGET_PARAM | IMPLICIT // (+) + // &(ps->p[0]), &(ps->p[0]), 33*sizeof(double), TO + // &(ps->p), &(ps->p[0]), sizeof(void*), ATTACH // // map(from: s.f[:22], s.s) map(to: ps->p[:33]) - // &s, &(s.f[0]), 50*sizeof(float) + sizeof(struct S1), TARGET_PARAM - // &s, &(s.f[0]), 22*sizeof(float), MEMBER_OF(1) | FROM - // &s, &(s.s), sizeof(struct S1), MEMBER_OF(1) | FROM - // ps, &(ps->p), sizeof(S2*), TARGET_PARAM - // ps, &(ps->p), sizeof(double*), MEMBER_OF(4) (*) - // &(ps->p), &(ps->p[0]), 33*sizeof(double), MEMBER_OF(4) | PTR_AND_OBJ | TO - // (*) the struct this entry pertains to is the 4th element in the list - // of arguments, hence MEMBER_OF(4) + // &s, &(s.f[0]), 50*sizeof(float) + + // sizeof(struct S1), TARGET_PARAM + // &s, &(s.f[0]), 22*sizeof(float), MEMBER_OF(1) | FROM + // &s, &(s.s), sizeof(struct S1), MEMBER_OF(1) | FROM + // ps, &ps[0], 0, TARGET_PARAM | IMPLICIT // (+) + // &(ps->p[0]), &(ps->p[0]), 33*sizeof(double), TO + // &(ps->p), &(ps->p[0]), sizeof(void*), ATTACH // - // map(p, p[:100]) - // ===> map(p[:100]) - // &p, &p[0], 100*sizeof(float), TARGET_PARAM | PTR_AND_OBJ | TO | FROM + // map(p[:100], p) + // &p, &p, sizeof(float*), TARGET_PARAM | TO | FROM + // p, &p[0], 100*sizeof(float), TO | FROM + // &p, &p[0], sizeof(float*), ATTACH // Track if the map information being generated is the first for a capture. bool IsCaptureFirstInfo = IsFirstComponentList; @@ -7737,14 +7804,26 @@ class MappableExprsHandler { bool IsExpressionFirstInfo = true; bool FirstPointerInComplexData = false; Address BP = Address::invalid(); + Address FinalLowestElem = Address::invalid(); const Expr *AssocExpr = I->getAssociatedExpression(); const auto *AE = dyn_cast(AssocExpr); const auto *OASE = dyn_cast(AssocExpr); const auto *OAShE = dyn_cast(AssocExpr); - if (AreBothBasePtrAndPteeMapped && std::next(I) == CE) - return; - if (isa(AssocExpr)) { + // Get the pointer-attachment base-pointer for the given list, if any. + const Expr *AttachPtrExpr = getAttachPtrExpr(Components); + auto [AttachPtrAddr, AttachPteeBaseAddr] = + getAttachPtrAddrAndPteeBaseAddr(AttachPtrExpr, CGF); + + bool HasAttachPtr = AttachPtrExpr != nullptr; + bool FirstComponentIsForAttachPtr = AssocExpr == AttachPtrExpr; + bool SeenAttachPtr = FirstComponentIsForAttachPtr; + + if (FirstComponentIsForAttachPtr) { + // No need to process AttachPtr here. It will be processed at the end + // after we have computed the pointee's address. + ++I; + } else if (isa(AssocExpr)) { // The base is the 'this' pointer. The content of the pointer is going // to be the base of the field being mapped. BP = CGF.LoadCXXThisAddress(); @@ -7786,9 +7865,8 @@ class MappableExprsHandler { // can be associated with the combined storage if shared memory mode is // active or the base declaration is not global variable. const auto *VD = dyn_cast(I->getAssociatedDeclaration()); - if (!AreBothBasePtrAndPteeMapped && - (CGF.CGM.getOpenMPRuntime().hasRequiresUnifiedSharedMemory() || - !VD || VD->hasLocalStorage())) + if (CGF.CGM.getOpenMPRuntime().hasRequiresUnifiedSharedMemory() || + !VD || VD->hasLocalStorage() || HasAttachPtr) BP = CGF.EmitLoadOfPointer(BP, Ty->castAs()); else FirstPointerInComplexData = true; @@ -7875,7 +7953,28 @@ class MappableExprsHandler { } } + bool SeenFirstNonBinOpExprAfterAttachPtr = false; for (; I != CE; ++I) { + // If we have a valid attach-ptr, we skip processing all components until + // after the attach-ptr. + if (HasAttachPtr && !SeenAttachPtr) { + SeenAttachPtr |= I->getAssociatedExpression() == AttachPtrExpr; + continue; + } + + // After finding the attach pointer, skip binary-ops, to skip past + // expressions like (p + 10), for a map like map(*(p + 10)), where p is + // the attach-ptr. + if (HasAttachPtr && !SeenFirstNonBinOpExprAfterAttachPtr) { + const auto *BO = dyn_cast(I->getAssociatedExpression()); + if (BO) + continue; + + // Found the first non-binary-operator component after attach + SeenFirstNonBinOpExprAfterAttachPtr = true; + BP = AttachPteeBaseAddr; + } + // If the current component is member of a struct (parent struct) mark it. if (!EncounteredME) { EncounteredME = dyn_cast(I->getAssociatedExpression()); @@ -7997,6 +8096,11 @@ class MappableExprsHandler { .getAddress(); } + // Save the final LowestElem, to use it as the pointee in attach maps, + // if emitted. + if (Next == CE) + FinalLowestElem = LowestElem; + // If this component is a pointer inside the base struct then we don't // need to create any entry for it - it will be combined with the object // it is pointing to into a single PTR_AND_OBJ entry. @@ -8099,13 +8203,11 @@ class MappableExprsHandler { // same expression except for the first one. We also need to signal // this map is the first one that relates with the current capture // (there is a set of entries for each capture). - OpenMPOffloadMappingFlags Flags = - getMapTypeBits(MapType, MapModifiers, MotionModifiers, IsImplicit, - !IsExpressionFirstInfo || RequiresReference || - FirstPointerInComplexData || IsMemberReference, - AreBothBasePtrAndPteeMapped || - (IsCaptureFirstInfo && !RequiresReference), - IsNonContiguous); + OpenMPOffloadMappingFlags Flags = getMapTypeBits( + MapType, MapModifiers, MotionModifiers, IsImplicit, + !IsExpressionFirstInfo || RequiresReference || + FirstPointerInComplexData || IsMemberReference, + IsCaptureFirstInfo && !RequiresReference, IsNonContiguous); if (!IsExpressionFirstInfo || IsMemberReference) { // If we have a PTR_AND_OBJ pair where the OBJ is a pointer as well, @@ -8197,6 +8299,14 @@ class MappableExprsHandler { if (!EncounteredME) PartialStruct.HasCompleteRecord = true; + // Populate ATTACH information for later processing by emitAttachEntry. + if (shouldEmitAttachEntry(AttachPtrExpr, BaseDecl, CGF, CurDir)) { + AttachInfo.AttachPtrAddr = AttachPtrAddr; + AttachInfo.AttachPteeAddr = FinalLowestElem; + AttachInfo.AttachPtrDecl = BaseDecl; + AttachInfo.AttachMapExpr = MapExpr; + } + if (!IsNonContiguous) return; @@ -8687,42 +8797,41 @@ class MappableExprsHandler { }; auto &&MapInfoGen = - [&DeferredInfo, &UseDeviceDataCombinedInfoGen, - &InfoGen](CodeGenFunction &CGF, const Expr *IE, const ValueDecl *VD, - OMPClauseMappableExprCommon::MappableExprComponentListRef - Components, - bool IsImplicit, bool IsDevAddr) { + [&UseDeviceDataCombinedInfoGen]( + CodeGenFunction &CGF, const Expr *IE, const ValueDecl *VD, + OMPClauseMappableExprCommon::MappableExprComponentListRef + Components, + bool IsImplicit, bool IsDevAddr, + bool IEIsAttachPtrForDevAddr = false) { // We didn't find any match in our map information - generate a zero // size array section - if the pointer is a struct member we defer // this action until the whole struct has been processed. - if (isa(IE)) { - // Insert the pointer into Info to be processed by - // generateInfoForComponentList. Because it is a member pointer - // without a pointee, no entry will be generated for it, therefore - // we need to generate one after the whole struct has been - // processed. Nonetheless, generateInfoForComponentList must be - // called to take the pointer into account for the calculation of - // the range of the partial struct. - InfoGen(nullptr, Other, Components, OMPC_MAP_unknown, {}, {}, - /*ReturnDevicePointer=*/false, IsImplicit, nullptr, nullptr, - IsDevAddr); - DeferredInfo[nullptr].emplace_back(IE, VD, IsDevAddr); + // TODO: Check for any reason to still add a map for member fields. + // The following seems to be working fine. + llvm::Value *Ptr; + if (IsDevAddr && !IEIsAttachPtrForDevAddr) { + if (IE->isGLValue()) + Ptr = CGF.EmitLValue(IE).getPointer(CGF); + else + Ptr = CGF.EmitScalarExpr(IE); } else { - llvm::Value *Ptr; - if (IsDevAddr) { - if (IE->isGLValue()) - Ptr = CGF.EmitLValue(IE).getPointer(CGF); - else - Ptr = CGF.EmitScalarExpr(IE); - } else { - Ptr = CGF.EmitLoadOfScalar(CGF.EmitLValue(IE), IE->getExprLoc()); - } - UseDeviceDataCombinedInfoGen(VD, Ptr, CGF, IsDevAddr); + Ptr = CGF.EmitLoadOfScalar(CGF.EmitLValue(IE), IE->getExprLoc()); } + bool TreatDevAddrAsDevPtr = IEIsAttachPtrForDevAddr; + // For the purpose of address-translation, treat something like the + // following: + // int *p; + // ... use_device_addr(p[1]) + // equivalent to + // ... use_device_ptr(p) + UseDeviceDataCombinedInfoGen(VD, Ptr, CGF, /*IsDevAddr=*/IsDevAddr && + !TreatDevAddrAsDevPtr); }; - auto &&IsMapInfoExist = [&Info](CodeGenFunction &CGF, const ValueDecl *VD, - const Expr *IE, bool IsDevAddr) -> bool { + auto &&IsMapInfoExist = [&Info, this](CodeGenFunction &CGF, + const ValueDecl *VD, const Expr *IE, + const Expr *DesiredAttachPtrExpr, + bool IsDevAddr) -> bool { // We potentially have map information for this declaration already. // Look for the first set of components that refer to it. If found, // return true. @@ -8733,30 +8842,41 @@ class MappableExprsHandler { if (It != Info.end()) { bool Found = false; for (auto &Data : It->second) { - auto *CI = llvm::find_if(Data, [VD](const MapInfo &MI) { - return MI.Components.back().getAssociatedDeclaration() == VD; + MapInfo *CI = nullptr; + // We potentially have multiple maps for the same decl. We need to + // only consider those for which the attach-ptr matches the desired + // attach-ptr. + auto *It = llvm::find_if(Data, [&](const MapInfo &MI) { + if (MI.Components.back().getAssociatedDeclaration() != VD) + return false; + + const Expr *MapAttachPtr = getAttachPtrExpr(MI.Components); + bool Match = AttachPtrComparator.areEqual(MapAttachPtr, + DesiredAttachPtrExpr); + return Match; }); - // If we found a map entry, signal that the pointer has to be - // returned and move on to the next declaration. Exclude cases where - // the base pointer is mapped as array subscript, array section or - // array shaping. The base address is passed as a pointer to base in - // this case and cannot be used as a base for use_device_ptr list - // item. - if (CI != Data.end()) { + + if (It != Data.end()) + CI = &*It; + + if (CI) { if (IsDevAddr) { - CI->ForDeviceAddr = IsDevAddr; + CI->ForDeviceAddr = true; CI->ReturnDevicePointer = true; Found = true; break; } else { auto PrevCI = std::next(CI->Components.rbegin()); const auto *VarD = dyn_cast(VD); + const Expr *AttachPtrExpr = getAttachPtrExpr(CI->Components); if (CGF.CGM.getOpenMPRuntime().hasRequiresUnifiedSharedMemory() || isa(IE) || !VD->getType().getNonReferenceType()->isPointerType() || PrevCI == CI->Components.rend() || isa(PrevCI->getAssociatedExpression()) || !VarD || - VarD->hasLocalStorage()) { + VarD->hasLocalStorage() || + (isa_and_nonnull(AttachPtrExpr) && + VD == cast(AttachPtrExpr)->getDecl())) { CI->ForDeviceAddr = IsDevAddr; CI->ReturnDevicePointer = true; Found = true; @@ -8788,7 +8908,18 @@ class MappableExprsHandler { const ValueDecl *VD = Components.back().getAssociatedDeclaration(); VD = cast(VD->getCanonicalDecl()); const Expr *IE = Components.back().getAssociatedExpression(); - if (IsMapInfoExist(CGF, VD, IE, /*IsDevAddr=*/false)) + // For use_device_ptr, we match an existing map clause if its attach-ptr + // is same as the use_device_ptr operand. e.g. + // map expr | use_device_ptr expr | current behavior + // ---------|---------------------|----------------- + // p[1] | p | match + // ps->a | ps | match + // p | p | no match + const Expr *UDPOperandExpr = + Components.front().getAssociatedExpression(); + if (IsMapInfoExist(CGF, VD, IE, + /*DesiredAttachPtrExpr=*/UDPOperandExpr, + /*IsDevAddr=*/false)) continue; MapInfoGen(CGF, IE, VD, Components, C->isImplicit(), /*IsDevAddr=*/false); @@ -8809,65 +8940,115 @@ class MappableExprsHandler { if (!Processed.insert(VD).second) continue; VD = cast(VD->getCanonicalDecl()); + // For use_device_addr, we match an existing map clause if the + // use_device_addr operand's attach-ptr matches the map operand's + // attach-ptr. + // We chould also restrict to only match cases when there is a full + // match between the map/use_device_addr clause exprs, but that may be + // unnecessary. + // + // map expr | use_device_addr expr | current | possible restrictive/ + // | | behavior | safer behavior + // ---------|----------------------|-----------|----------------------- + // p | p | match | match + // p[0] | p[0] | match | match + // p[0:1] | p[0] | match | no match + // p[0:1] | p[2:1] | match | no match + // p[1] | p[0] | match | no match + // ps->a | ps->b | match | no match + // p | p[0] | no match | no match + // pp | pp[0][0] | no match | no match + const Expr *UDAAttachPtrExpr = getAttachPtrExpr(Components); const Expr *IE = std::get<1>(L).back().getAssociatedExpression(); - if (IsMapInfoExist(CGF, VD, IE, /*IsDevAddr=*/true)) + assert((!UDAAttachPtrExpr || UDAAttachPtrExpr == IE) && + "use_device_addr operand has an attach-ptr, but does not match " + "last component's expr."); + if (IsMapInfoExist(CGF, VD, IE, + /*DesiredAttachPtrExpr=*/UDAAttachPtrExpr, + /*IsDevAddr=*/true)) continue; MapInfoGen(CGF, IE, VD, Components, C->isImplicit(), - /*IsDevAddr=*/true); + /*IsDevAddr=*/true, + /*IEIsAttachPtrForDevAddr=*/UDAAttachPtrExpr != nullptr); } } for (const auto &Data : Info) { - StructRangeInfoTy PartialStruct; - // Current struct information: MapCombinedInfoTy CurInfo; - // Current struct base information: - MapCombinedInfoTy StructBaseCurInfo; const Decl *D = Data.first; const ValueDecl *VD = cast_or_null(D); - bool HasMapBasePtr = false; - bool HasMapArraySec = false; - if (VD && VD->getType()->isAnyPointerType()) { - for (const auto &M : Data.second) { - HasMapBasePtr = any_of(M, [](const MapInfo &L) { - return isa_and_present(L.VarRef); - }); - HasMapArraySec = any_of(M, [](const MapInfo &L) { - return isa_and_present( - L.VarRef); - }); - if (HasMapBasePtr && HasMapArraySec) - break; - } - } + // Group component lists by their AttachPtrExpr and process them in order + // of increasing complexity (nullptr first, then simple expressions like + // p, then more complex ones like p[0], etc.) + // + // This is similar to how generateInfoForCaptureFromClauseInfo handles + // grouping for target constructs. + SmallVector, 16> AttachPtrMapInfoPairs; + + // First, collect all MapData entries with their attach-ptr exprs. for (const auto &M : Data.second) { for (const MapInfo &L : M) { assert(!L.Components.empty() && "Not expecting declaration with no component lists."); + const Expr *AttachPtrExpr = getAttachPtrExpr(L.Components); + AttachPtrMapInfoPairs.emplace_back(AttachPtrExpr, L); + } + } + + // Next, sort by increasing order of their complexity. + llvm::stable_sort(AttachPtrMapInfoPairs, + [this](const auto &LHS, const auto &RHS) { + return AttachPtrComparator(LHS.first, RHS.first); + }); + + std::optional MemberOfValueForFirstCombinedEntry = std::nullopt; + bool IsFirstGroup = true; + + // And finally, process them all in order, grouping those with + // equivalent attach-ptr exprs together. + auto *It = AttachPtrMapInfoPairs.begin(); + while (It != AttachPtrMapInfoPairs.end()) { + const Expr *AttachPtrExpr = It->first; + + SmallVector GroupLists; + while (It != AttachPtrMapInfoPairs.end() && + (It->first == AttachPtrExpr || + AttachPtrComparator.areEqual(It->first, AttachPtrExpr))) { + GroupLists.push_back(It->second); + ++It; + } + assert(!GroupLists.empty() && "GroupLists should not be empty"); + + StructRangeInfoTy PartialStruct; + AttachInfoTy AttachInfo; + MapCombinedInfoTy GroupCurInfo; + // Current group's struct base information: + MapCombinedInfoTy GroupStructBaseCurInfo; + for (const MapInfo &L : GroupLists) { // Remember the current base pointer index. - unsigned CurrentBasePointersIdx = CurInfo.BasePointers.size(); + unsigned CurrentBasePointersIdx = GroupCurInfo.BasePointers.size(); unsigned StructBasePointersIdx = - StructBaseCurInfo.BasePointers.size(); - CurInfo.NonContigInfo.IsNonContiguous = + GroupStructBaseCurInfo.BasePointers.size(); + + GroupCurInfo.NonContigInfo.IsNonContiguous = L.Components.back().isNonContiguous(); generateInfoForComponentList( L.MapType, L.MapModifiers, L.MotionModifiers, L.Components, - CurInfo, StructBaseCurInfo, PartialStruct, + GroupCurInfo, GroupStructBaseCurInfo, PartialStruct, AttachInfo, /*IsFirstComponentList=*/false, L.IsImplicit, /*GenerateAllInfoForClauses*/ true, L.Mapper, L.ForDeviceAddr, VD, - L.VarRef, /*OverlappedElements*/ {}, - HasMapBasePtr && HasMapArraySec); + L.VarRef, /*OverlappedElements*/ {}); // If this entry relates to a device pointer, set the relevant // declaration and add the 'return pointer' flag. if (L.ReturnDevicePointer) { - // Check whether a value was added to either CurInfo or - // StructBaseCurInfo and error if no value was added to either of - // them: - assert((CurrentBasePointersIdx < CurInfo.BasePointers.size() || + // Check whether a value was added to either GroupCurInfo or + // GroupStructBaseCurInfo and error if no value was added to either + // of them: + assert((CurrentBasePointersIdx < GroupCurInfo.BasePointers.size() || StructBasePointersIdx < - StructBaseCurInfo.BasePointers.size()) && + GroupStructBaseCurInfo.BasePointers.size()) && "Unexpected number of mapped base pointers."); // Choose a base pointer index which is always valid: @@ -8876,35 +9057,70 @@ class MappableExprsHandler { assert(RelevantVD && "No relevant declaration related with device pointer??"); - // If StructBaseCurInfo has been updated this iteration then work on - // the first new entry added to it i.e. make sure that when multiple - // values are added to any of the lists, the first value added is - // being modified by the assignments below (not the last value - // added). - if (StructBasePointersIdx < StructBaseCurInfo.BasePointers.size()) { - StructBaseCurInfo.DevicePtrDecls[StructBasePointersIdx] = + // If GroupStructBaseCurInfo has been updated this iteration then + // work on the first new entry added to it i.e. make sure that when + // multiple values are added to any of the lists, the first value + // added is being modified by the assignments below (not the last + // value added). + if (StructBasePointersIdx < + GroupStructBaseCurInfo.BasePointers.size()) { + GroupStructBaseCurInfo.DevicePtrDecls[StructBasePointersIdx] = RelevantVD; - StructBaseCurInfo.DevicePointers[StructBasePointersIdx] = + GroupStructBaseCurInfo.DevicePointers[StructBasePointersIdx] = L.ForDeviceAddr ? DeviceInfoTy::Address : DeviceInfoTy::Pointer; - StructBaseCurInfo.Types[StructBasePointersIdx] |= + GroupStructBaseCurInfo.Types[StructBasePointersIdx] |= OpenMPOffloadMappingFlags::OMP_MAP_RETURN_PARAM; } else { - CurInfo.DevicePtrDecls[CurrentBasePointersIdx] = RelevantVD; - CurInfo.DevicePointers[CurrentBasePointersIdx] = + GroupCurInfo.DevicePtrDecls[CurrentBasePointersIdx] = RelevantVD; + GroupCurInfo.DevicePointers[CurrentBasePointersIdx] = L.ForDeviceAddr ? DeviceInfoTy::Address : DeviceInfoTy::Pointer; - CurInfo.Types[CurrentBasePointersIdx] |= + GroupCurInfo.Types[CurrentBasePointersIdx] |= OpenMPOffloadMappingFlags::OMP_MAP_RETURN_PARAM; } } } + + // Unify entries in one list making sure the struct mapping precedes the + // individual fields: + MapCombinedInfoTy GroupUnionCurInfo; + GroupUnionCurInfo.append(GroupStructBaseCurInfo); + GroupUnionCurInfo.append(GroupCurInfo); + + // If there is an entry in PartialStruct it means we have a struct with + // individual members mapped. Emit an extra combined entry. + if (PartialStruct.Base.isValid()) { + GroupUnionCurInfo.NonContigInfo.Dims.push_back(0); + std::optional CombinedEntryIndex = emitCombinedEntry( + CurInfo, GroupUnionCurInfo.Types, PartialStruct, AttachInfo, + /*IsMapThis*/ !VD, OMPBuilder, VD, + /*OffsetForMemberOfFlag=*/CombinedInfo.BasePointers.size(), + /*NotTargetParam=*/true); + // Track the first group's combined entry's final-index for deferred + // entries to reference. + if (IsFirstGroup && CombinedEntryIndex.has_value()) + MemberOfValueForFirstCombinedEntry = + CombinedInfo.BasePointers.size() + *CombinedEntryIndex; + } + + // Append this group's results to the overall CurInfo in the correct + // order: combined-entry -> original-field-entries -> attach-entry + CurInfo.append(GroupUnionCurInfo); + if (AttachInfo.isValid()) + emitAttachEntry(CGF, CurInfo, AttachInfo); + + IsFirstGroup = false; } // Append any pending zero-length pointers which are struct members and // used with use_device_ptr or use_device_addr. + // FIXME: This is now redundant as we are not populating DeferredInfo + // anymore. Remove unless we find a legitimate need of populating + // using DefferedInfo during the review process. auto CI = DeferredInfo.find(Data.first); if (CI != DeferredInfo.end()) { + size_t DeferredStartIdx = CurInfo.Types.size(); for (const DeferredDevicePtrEntryTy &L : CI->second) { llvm::Value *BasePtr; llvm::Value *Ptr; @@ -8942,25 +9158,25 @@ class MappableExprsHandler { llvm::Constant::getNullValue(this->CGF.Int64Ty)); CurInfo.Mappers.push_back(nullptr); } - } - // Unify entries in one list making sure the struct mapping precedes the - // individual fields: - MapCombinedInfoTy UnionCurInfo; - UnionCurInfo.append(StructBaseCurInfo); - UnionCurInfo.append(CurInfo); - - // If there is an entry in PartialStruct it means we have a struct with - // individual members mapped. Emit an extra combined entry. - if (PartialStruct.Base.isValid()) { - UnionCurInfo.NonContigInfo.Dims.push_back(0); - // Emit a combined entry: - emitCombinedEntry(CombinedInfo, UnionCurInfo.Types, PartialStruct, - /*IsMapThis*/ !VD, OMPBuilder, VD); + // Correct the MEMBER_OF flags for the deferred entries we just added. + if (MemberOfValueForFirstCombinedEntry.has_value() && + DeferredStartIdx < CurInfo.Types.size()) { + // Use the tracked combined entry index from the first group + // Note that this assumes that the entries for use_device_ptr/addr + // should belong to the CombinedEntry emitted when handling the first + // "group". e.g. Even if we have `map(this->sp->a, this->sp->b)`, the + // CombinedEntry created for those, with `this->sp` as the attach-ptr, + // would not be the first attach-entry. + OpenMPOffloadMappingFlags MemberOfFlag = + OMPBuilder.getMemberOfFlag(*MemberOfValueForFirstCombinedEntry); + for (size_t I = DeferredStartIdx; I < CurInfo.Types.size(); ++I) + OMPBuilder.setCorrectMemberOfFlag(CurInfo.Types[I], MemberOfFlag); + } } // We need to append the results of this capture to what we already have. - CombinedInfo.append(UnionCurInfo); + CombinedInfo.append(CurInfo); } // Append data for use_device_ptr clauses. CombinedInfo.append(UseDeviceDataCombinedInfo); @@ -9010,6 +9226,32 @@ class MappableExprsHandler { LambdasMap.try_emplace(std::get<0>(L), C); } } + + auto CollectAttachPtrExprsForClauseComponents = [this](const auto *C) { + for (auto L : C->component_lists()) { + OMPClauseMappableExprCommon::MappableExprComponentListRef Components = + std::get<1>(L); + if (!Components.empty()) + collectAttachPtrExprInfo(Components, CurDir); + } + }; + + // Populate the AttachPtrExprMap for all component lists from map-related + // clauses. + for (const auto *C : Dir.getClausesOfKind()) + CollectAttachPtrExprsForClauseComponents(C); + for (const auto *C : Dir.getClausesOfKind()) + CollectAttachPtrExprsForClauseComponents(C); + for (const auto *C : Dir.getClausesOfKind()) + CollectAttachPtrExprsForClauseComponents(C); + for (const auto *C : Dir.getClausesOfKind()) + CollectAttachPtrExprsForClauseComponents(C); + for (const auto *C : Dir.getClausesOfKind()) + CollectAttachPtrExprsForClauseComponents(C); + for (const auto *C : Dir.getClausesOfKind()) + CollectAttachPtrExprsForClauseComponents(C); + for (const auto *C : Dir.getClausesOfKind()) + CollectAttachPtrExprsForClauseComponents(C); } /// Constructor for the declare mapper directive. @@ -9019,24 +9261,30 @@ class MappableExprsHandler { /// Generate code for the combined entry if we have a partially mapped struct /// and take care of the mapping flags of the arguments corresponding to /// individual struct members. - void emitCombinedEntry(MapCombinedInfoTy &CombinedInfo, - MapFlagsArrayTy &CurTypes, - const StructRangeInfoTy &PartialStruct, bool IsMapThis, - llvm::OpenMPIRBuilder &OMPBuilder, - const ValueDecl *VD = nullptr, - unsigned OffsetForMemberOfFlag = 0, - bool NotTargetParams = true) const { + /// If a valid \p AttachInfo exists, its pointee addr will be updated to point + /// to the combined-entry's begin address, if emitted. + /// \p PartialStruct contains attach base-pointer information. + /// \returns The index of the combined entry if one was added, std::nullopt + /// otherwise. + std::optional emitCombinedEntry( + MapCombinedInfoTy &CombinedInfo, MapFlagsArrayTy &CurTypes, + const StructRangeInfoTy &PartialStruct, AttachInfoTy &AttachInfo, + bool IsMapThis, llvm::OpenMPIRBuilder &OMPBuilder, const ValueDecl *VD, + unsigned OffsetForMemberOfFlag, bool NotTargetParams) const { if (CurTypes.size() == 1 && ((CurTypes.back() & OpenMPOffloadMappingFlags::OMP_MAP_MEMBER_OF) != OpenMPOffloadMappingFlags::OMP_MAP_MEMBER_OF) && !PartialStruct.IsArraySection) - return; + return std::nullopt; + Address LBAddr = PartialStruct.LowestElem.second; Address HBAddr = PartialStruct.HighestElem.second; if (PartialStruct.HasCompleteRecord) { LBAddr = PartialStruct.LB; HBAddr = PartialStruct.LB; } + // Capture the index where the combined entry will be inserted + size_t CombinedEntryIndex = CombinedInfo.BasePointers.size(); CombinedInfo.Exprs.push_back(VD); // Base is the base of the struct CombinedInfo.BasePointers.push_back(PartialStruct.Base.emitRawPointer(CGF)); @@ -9111,11 +9359,32 @@ class MappableExprsHandler { // All other current entries will be MEMBER_OF the combined entry // (except for PTR_AND_OBJ entries which do not have a placeholder value - // 0xFFFF in the MEMBER_OF field). + // 0xFFFF in the MEMBER_OF field, or ATTACH entries since they are expected + // to be handled by themselves, after all other maps). OpenMPOffloadMappingFlags MemberOfFlag = OMPBuilder.getMemberOfFlag( OffsetForMemberOfFlag + CombinedInfo.BasePointers.size() - 1); for (auto &M : CurTypes) OMPBuilder.setCorrectMemberOfFlag(M, MemberOfFlag); + + // When we are emitting a combined entry. If there were any pending + // attachments to be done, we do them to the begin address of the combined + // entry. Note that this means only one attachment per combined-entry will + // be done. So, for instance, if we have: + // S *ps; + // ... map(ps->a, ps->b) + // When we are emitting a combined entry. If AttachInfo is valid, + // update the pointee address to point to the begin address of the combined + // entry. This ensures that if we have multiple maps like: + // `map(ps->a, ps->b)`, we still get a single ATTACH entry, like: + // + // &ps[0], &ps->a, sizeof(ps->a to ps->b), ALLOC // combined-entry + // &ps[0], &ps->a, sizeof(ps->a), TO | FROM + // &ps[0], &ps->b, sizeof(ps->b), TO | FROM + // &ps, &ps->a, sizeof(void*), ATTACH // Use combined-entry's LB + if (AttachInfo.isValid()) + AttachInfo.AttachPteeAddr = LBAddr; + + return CombinedEntryIndex; } /// Generate all the base pointers, section pointers, sizes, map types, and @@ -9256,46 +9525,16 @@ class MappableExprsHandler { } } - /// For a capture that has an associated clause, generate the base pointers, - /// section pointers, sizes, map types, and mappers (all included in - /// \a CurCaptureVarInfo). - void generateInfoForCaptureFromClauseInfo( - const CapturedStmt::Capture *Cap, llvm::Value *Arg, - MapCombinedInfoTy &CurCaptureVarInfo, llvm::OpenMPIRBuilder &OMPBuilder, - unsigned OffsetForMemberOfFlag) const { - assert(!Cap->capturesVariableArrayType() && - "Not expecting to generate map info for a variable array type!"); - - // We need to know when we generating information for the first component - const ValueDecl *VD = Cap->capturesThis() - ? nullptr - : Cap->getCapturedVar()->getCanonicalDecl(); - - // for map(to: lambda): skip here, processing it in - // generateDefaultMapInfo - if (LambdasMap.count(VD)) - return; - - // If this declaration appears in a is_device_ptr clause we just have to - // pass the pointer by value. If it is a reference to a declaration, we just - // pass its value. - if (VD && (DevPointersMap.count(VD) || HasDevAddrsMap.count(VD))) { - CurCaptureVarInfo.Exprs.push_back(VD); - CurCaptureVarInfo.BasePointers.emplace_back(Arg); - CurCaptureVarInfo.DevicePtrDecls.emplace_back(VD); - CurCaptureVarInfo.DevicePointers.emplace_back(DeviceInfoTy::Pointer); - CurCaptureVarInfo.Pointers.push_back(Arg); - CurCaptureVarInfo.Sizes.push_back(CGF.Builder.CreateIntCast( - CGF.getTypeSize(CGF.getContext().VoidPtrTy), CGF.Int64Ty, - /*isSigned=*/true)); - CurCaptureVarInfo.Types.push_back( - OpenMPOffloadMappingFlags::OMP_MAP_LITERAL | - OpenMPOffloadMappingFlags::OMP_MAP_TARGET_PARAM); - CurCaptureVarInfo.Mappers.push_back(nullptr); + /// Populate component lists for non-lambda captured variables from map, + /// is_device_ptr and has_device_addr clause info. + void populateComponentListsForNonLambdaCaptureFromClauses( + const ValueDecl *VD, MapDataArrayTy &DeclComponentLists, + SmallVectorImpl< + SmallVector> + &StorageForImplicitlyAddedComponentLists) const { + if (VD && LambdasMap.count(VD)) return; - } - MapDataArrayTy DeclComponentLists; // For member fields list in is_device_ptr, store it in // DeclComponentLists for generating components info. static const OpenMPMapModifierKind Unknown = OMPC_MAP_MODIFIER_unknown; @@ -9314,8 +9553,6 @@ class MappableExprsHandler { assert(isa(CurDir) && "Expect a executable directive"); const auto *CurExecDir = cast(CurDir); - bool HasMapBasePtr = false; - bool HasMapArraySec = false; for (const auto *C : CurExecDir->getClausesOfKind()) { const auto *EI = C->getVarRefs().begin(); for (const auto L : C->decl_component_lists(VD)) { @@ -9327,17 +9564,20 @@ class MappableExprsHandler { assert(VDecl == VD && "We got information for the wrong declaration??"); assert(!Components.empty() && "Not expecting declaration with no component lists."); - if (VD && E && VD->getType()->isAnyPointerType() && isa(E)) - HasMapBasePtr = true; - if (VD && E && VD->getType()->isAnyPointerType() && - (isa(E) || isa(E))) - HasMapArraySec = true; DeclComponentLists.emplace_back(Components, C->getMapType(), C->getMapTypeModifiers(), C->isImplicit(), Mapper, E); ++EI; } } + + // For the target construct, if there's a map with a base-pointer that's + // a member of an implicitly captured struct, of the current class, + // we need to emit an implicit map on the pointer. + if (isOpenMPTargetExecutionDirective(CurExecDir->getDirectiveKind())) + addImplicitMapForAttachPtrBaseIfMemberOfCapturedVD( + VD, DeclComponentLists, StorageForImplicitlyAddedComponentLists); + llvm::stable_sort(DeclComponentLists, [](const MapData &LHS, const MapData &RHS) { ArrayRef MapModifiers = std::get<2>(LHS); @@ -9352,42 +9592,294 @@ class MappableExprsHandler { bool HasAllocsR = MapType == OMPC_MAP_alloc; return (HasPresent && !HasPresentR) || (HasAllocs && !HasAllocsR); }); + } + + /// On a target construct, if there's an implicit map on a struct, or that of + /// this[:], and an explicit map with a member of that struct/class as the + /// base-pointer, we need to make sure that base-pointer is implicitly mapped, + /// to make sure we don't map the full struct/class. For example: + /// + /// \code + /// struct S { + /// int dummy[10000]; + /// int *p; + /// void f1() { + /// #pragma omp target map(p[0:1]) + /// (void)this; + /// } + /// }; S s; + /// + /// void f2() { + /// #pragma omp target map(s.p[0:10]) + /// (void)s; + /// } + /// \endcode + /// + /// Only `this-p` and `s.p` should be mapped in the two cases above. + // + // OpenMP 6.0: 7.9.6 map clause, pg 285 + // If a list item with an implicitly determined data-mapping attribute does + // not have any corresponding storage in the device data environment prior to + // a task encountering the construct associated with the map clause, and one + // or more contiguous parts of the original storage are either list items or + // base pointers to list items that are explicitly mapped on the construct, + // only those parts of the original storage will have corresponding storage in + // the device data environment as a result of the map clauses on the + // construct. + void addImplicitMapForAttachPtrBaseIfMemberOfCapturedVD( + const ValueDecl *CapturedVD, MapDataArrayTy &DeclComponentLists, + SmallVectorImpl< + SmallVector> + &ComponentVectorStorage) const { + bool IsThisCapture = CapturedVD == nullptr; + + for (const auto &ComponentsAndAttachPtr : AttachPtrExprMap) { + OMPClauseMappableExprCommon::MappableExprComponentListRef + ComponentsWithAttachPtr = ComponentsAndAttachPtr.first; + const Expr *AttachPtrExpr = ComponentsAndAttachPtr.second; + if (!AttachPtrExpr) + continue; + + const auto *ME = dyn_cast(AttachPtrExpr); + if (!ME) + continue; + + const Expr *Base = ME->getBase()->IgnoreParenImpCasts(); + + // If we are handling a "this" capture, then we are looking for + // attach-ptrs of form `this->p`, either explicitly or implicitly. + if (IsThisCapture && !ME->isImplicitCXXThis() && !isa(Base)) + continue; + + if (!IsThisCapture && (!isa(Base) || + cast(Base)->getDecl() != CapturedVD)) + continue; + + // For non-this captures, we are looking for attach-ptrs of form + // `s.p`. + // For non-this captures, we are looking for attach-ptrs like `s.p`. + if (!IsThisCapture && (ME->isArrow() || !isa(Base) || + cast(Base)->getDecl() != CapturedVD)) + continue; + + // Check if we have an existing map on either: + // this[:], s, this->p, or s.p, in which case, we don't need to add + // an implicit one for the attach-ptr s.p/this->p. + bool FoundExistingMap = false; + for (const MapData &ExistingL : DeclComponentLists) { + OMPClauseMappableExprCommon::MappableExprComponentListRef + ExistingComponents = std::get<0>(ExistingL); + + if (ExistingComponents.empty()) + continue; + + // First check if we have a map like map(this->p) or map(s.p). + const auto &FirstComponent = ExistingComponents.front(); + const Expr *FirstExpr = FirstComponent.getAssociatedExpression(); + + if (!FirstExpr) + continue; + + // First check if we have a map like map(this->p) or map(s.p). + if (AttachPtrComparator.areEqual(FirstExpr, AttachPtrExpr)) { + FoundExistingMap = true; + break; + } + + // Check if we have a map like this[0:1] + if (IsThisCapture) { + if (const auto *OASE = dyn_cast(FirstExpr)) { + if (isa(OASE->getBase()->IgnoreParenImpCasts())) { + FoundExistingMap = true; + break; + } + } + continue; + } + + // When the attach-ptr is something like `s.p`, check if + // `s` itself is mapped explicitly. + if (const auto *DRE = dyn_cast(FirstExpr)) { + if (DRE->getDecl() == CapturedVD) { + FoundExistingMap = true; + break; + } + } + } + + if (FoundExistingMap) + continue; + + // If no base map is found, we need to create an implicit map for the + // attach-pointer expr. + + ComponentVectorStorage.emplace_back(); + auto &AttachPtrComponents = ComponentVectorStorage.back(); + + static const OpenMPMapModifierKind Unknown = OMPC_MAP_MODIFIER_unknown; + bool SeenAttachPtrComponent = false; + // For creating a map on the attach-ptr `s.p/this->p`, we copy all + // components from the component-list which has `s.p/this->p` + // as the attach-ptr, starting from the component which matches + // `s.p/this->p`. This way, we'll have component-lists of + // `s.p` -> `s`, and `this->p` -> `this`. + for (size_t i = 0; i < ComponentsWithAttachPtr.size(); ++i) { + const auto &Component = ComponentsWithAttachPtr[i]; + const Expr *ComponentExpr = Component.getAssociatedExpression(); + + if (!SeenAttachPtrComponent && ComponentExpr != AttachPtrExpr) + continue; + SeenAttachPtrComponent = true; + + AttachPtrComponents.emplace_back(Component.getAssociatedExpression(), + Component.getAssociatedDeclaration(), + Component.isNonContiguous()); + } + assert(!AttachPtrComponents.empty() && + "Could not populate component-lists for mapping attach-ptr"); + + DeclComponentLists.emplace_back( + AttachPtrComponents, OMPC_MAP_tofrom, Unknown, + /*IsImplicit=*/true, /*mapper=*/nullptr, AttachPtrExpr); + } + } + + /// For a capture that has an associated clause, generate the base pointers, + /// section pointers, sizes, map types, and mappers (all included in + /// \a CurCaptureVarInfo). + void generateInfoForCaptureFromClauseInfo( + const MapDataArrayTy &DeclComponentListsFromClauses, + const CapturedStmt::Capture *Cap, llvm::Value *Arg, + MapCombinedInfoTy &CurCaptureVarInfo, llvm::OpenMPIRBuilder &OMPBuilder, + unsigned OffsetForMemberOfFlag) const { + assert(!Cap->capturesVariableArrayType() && + "Not expecting to generate map info for a variable array type!"); + + // We need to know when we generating information for the first component + const ValueDecl *VD = Cap->capturesThis() + ? nullptr + : Cap->getCapturedVar()->getCanonicalDecl(); + + // for map(to: lambda): skip here, processing it in + // generateDefaultMapInfo + if (LambdasMap.count(VD)) + return; + + // If this declaration appears in a is_device_ptr clause we just have to + // pass the pointer by value. If it is a reference to a declaration, we just + // pass its value. + if (VD && (DevPointersMap.count(VD) || HasDevAddrsMap.count(VD))) { + CurCaptureVarInfo.Exprs.push_back(VD); + CurCaptureVarInfo.BasePointers.emplace_back(Arg); + CurCaptureVarInfo.DevicePtrDecls.emplace_back(VD); + CurCaptureVarInfo.DevicePointers.emplace_back(DeviceInfoTy::Pointer); + CurCaptureVarInfo.Pointers.push_back(Arg); + CurCaptureVarInfo.Sizes.push_back(CGF.Builder.CreateIntCast( + CGF.getTypeSize(CGF.getContext().VoidPtrTy), CGF.Int64Ty, + /*isSigned=*/true)); + CurCaptureVarInfo.Types.push_back( + OpenMPOffloadMappingFlags::OMP_MAP_LITERAL | + OpenMPOffloadMappingFlags::OMP_MAP_TARGET_PARAM); + CurCaptureVarInfo.Mappers.push_back(nullptr); + return; + } auto GenerateInfoForComponentLists = - [&](ArrayRef DeclComponentLists, + [&](ArrayRef DeclComponentListsFromClauses, bool IsEligibleForTargetParamFlag) { MapCombinedInfoTy CurInfoForComponentLists; StructRangeInfoTy PartialStruct; + AttachInfoTy AttachInfo; - if (DeclComponentLists.empty()) + if (DeclComponentListsFromClauses.empty()) return; generateInfoForCaptureFromComponentLists( - VD, DeclComponentLists, CurInfoForComponentLists, PartialStruct, - IsEligibleForTargetParamFlag, - /*AreBothBasePtrAndPteeMapped=*/HasMapBasePtr && HasMapArraySec); + VD, DeclComponentListsFromClauses, CurInfoForComponentLists, + PartialStruct, AttachInfo, IsEligibleForTargetParamFlag); // If there is an entry in PartialStruct it means we have a // struct with individual members mapped. Emit an extra combined // entry. if (PartialStruct.Base.isValid()) { CurCaptureVarInfo.append(PartialStruct.PreliminaryMapData); - emitCombinedEntry( + (void)emitCombinedEntry( CurCaptureVarInfo, CurInfoForComponentLists.Types, - PartialStruct, Cap->capturesThis(), OMPBuilder, nullptr, - OffsetForMemberOfFlag, + PartialStruct, AttachInfo, Cap->capturesThis(), OMPBuilder, + nullptr, OffsetForMemberOfFlag, /*NotTargetParams*/ !IsEligibleForTargetParamFlag); } - // Return if we didn't add any entries. - if (CurInfoForComponentLists.BasePointers.empty()) - return; - + // We do the appends to get the entries in the following order: + // combined-entry -> individual-field-entries -> attach-entry, CurCaptureVarInfo.append(CurInfoForComponentLists); + if (AttachInfo.isValid()) + emitAttachEntry(CGF, CurCaptureVarInfo, AttachInfo); }; - GenerateInfoForComponentLists(DeclComponentLists, - /*IsEligibleForTargetParamFlag=*/true); + // Group component lists by their AttachPtrExpr and process them in order + // of increasing complexity (nullptr first, then simple expressions like p, + // then more complex ones like p[0], etc.) + // + // This ensure that we: + // * handle maps that can contribute towards setting the kernel argument, + // (e.g. map(ps), or map(ps[0])), before any that cannot (e.g. ps->pt->d). + // * allocate a single contiguous storage for all exprs with the same + // captured var and having the same attach-ptr. + // + // Example: The map clauses below should be handled grouped together based + // on their attachable-base-pointers: + // map-clause | attachable-base-pointer + // --------------------------+------------------------ + // map(p, ps) | nullptr + // map(p[0]) | p + // map(p[0]->b, p[0]->c) | p[0] + // map(ps->d, ps->e, ps->pt) | ps + // map(ps->pt->d, ps->pt->e) | ps->pt + + // First, collect all MapData entries with their attach-ptr exprs. + SmallVector, 16> AttachPtrMapDataPairs; + + for (const MapData &L : DeclComponentListsFromClauses) { + OMPClauseMappableExprCommon::MappableExprComponentListRef Components = + std::get<0>(L); + const Expr *AttachPtrExpr = getAttachPtrExpr(Components); + AttachPtrMapDataPairs.emplace_back(AttachPtrExpr, L); + } + + // Next, sort by increasing order of their complexity. + llvm::stable_sort(AttachPtrMapDataPairs, + [this](const auto &LHS, const auto &RHS) { + return AttachPtrComparator(LHS.first, RHS.first); + }); + + bool NoDefaultMappingDoneForVD = CurCaptureVarInfo.BasePointers.empty(); + bool IsFirstGroup = true; + + // And finally, process them all in order, grouping those with + // equivalent attach-ptr exprs together. + auto *It = AttachPtrMapDataPairs.begin(); + while (It != AttachPtrMapDataPairs.end()) { + const Expr *AttachPtrExpr = It->first; + + MapDataArrayTy GroupLists; + while (It != AttachPtrMapDataPairs.end() && + (It->first == AttachPtrExpr || + AttachPtrComparator.areEqual(It->first, AttachPtrExpr))) { + GroupLists.push_back(It->second); + ++It; + } + assert(!GroupLists.empty() && "GroupLists should not be empty"); + + // Determine if this group of component-lists is eligible for TARGET_PARAM + // flag. Only the first group processed should be eligible, and only if no + // default mapping was done. + bool IsEligibleForTargetParamFlag = + IsFirstGroup && NoDefaultMappingDoneForVD; + + GenerateInfoForComponentLists(GroupLists, IsEligibleForTargetParamFlag); + IsFirstGroup = false; + } } /// Generate the base pointers, section pointers, sizes, map types, and @@ -9396,8 +9888,7 @@ class MappableExprsHandler { void generateInfoForCaptureFromComponentLists( const ValueDecl *VD, ArrayRef DeclComponentLists, MapCombinedInfoTy &CurComponentListInfo, StructRangeInfoTy &PartialStruct, - bool IsListEligibleForTargetParamFlag, - bool AreBothBasePtrAndPteeMapped = false) const { + AttachInfoTy &AttachInfo, bool IsListEligibleForTargetParamFlag) const { // Find overlapping elements (including the offset from the base element). llvm::SmallDenseMap< const MapData *, @@ -9537,8 +10028,8 @@ class MappableExprsHandler { OverlappedComponents = Pair.getSecond(); generateInfoForComponentList( MapType, MapModifiers, {}, Components, CurComponentListInfo, - StructBaseCombinedInfo, PartialStruct, AddTargetParamFlag, IsImplicit, - /*GenerateAllInfoForClauses*/ false, Mapper, + StructBaseCombinedInfo, PartialStruct, AttachInfo, AddTargetParamFlag, + IsImplicit, /*GenerateAllInfoForClauses*/ false, Mapper, /*ForDeviceAddr=*/false, VD, VarRef, OverlappedComponents); AddTargetParamFlag = false; } @@ -9556,10 +10047,10 @@ class MappableExprsHandler { if (It == OverlappedData.end()) generateInfoForComponentList( MapType, MapModifiers, {}, Components, CurComponentListInfo, - StructBaseCombinedInfo, PartialStruct, AddTargetParamFlag, - IsImplicit, /*GenerateAllInfoForClauses*/ false, Mapper, - /*ForDeviceAddr=*/false, VD, VarRef, - /*OverlappedElements*/ {}, AreBothBasePtrAndPteeMapped); + StructBaseCombinedInfo, PartialStruct, AttachInfo, + AddTargetParamFlag, IsImplicit, /*GenerateAllInfoForClauses*/ false, + Mapper, /*ForDeviceAddr=*/false, VD, VarRef, + /*OverlappedElements*/ {}); AddTargetParamFlag = false; } } @@ -10057,10 +10548,49 @@ static void genMapInfoForCaptures( OpenMPOffloadMappingFlags::OMP_MAP_IMPLICIT); CurInfo.Mappers.push_back(nullptr); } else { + const ValueDecl *CapturedVD = + CI->capturesThis() ? nullptr + : CI->getCapturedVar()->getCanonicalDecl(); + bool HasEntryWithCVAsAttachPtr = false; + if (CapturedVD) + HasEntryWithCVAsAttachPtr = + MEHandler.hasAttachEntryForCapturedVar(CapturedVD); + + // Populate component lists for the captured variable from clauses. + MappableExprsHandler::MapDataArrayTy DeclComponentLists; + SmallVector< + SmallVector, 4> + StorageForImplicitlyAddedComponentLists; + MEHandler.populateComponentListsForNonLambdaCaptureFromClauses( + CapturedVD, DeclComponentLists, + StorageForImplicitlyAddedComponentLists); + + // OpenMP 6.0, 15.8, target construct, restrictions: + // * A list item in a map clause that is specified on a target construct + // must have a base variable or base pointer. + // + // Map clauses on a target construct must either have a base pointer, or a + // base-variable. So, if we don't have a base-pointer, that means that it + // must have a base-variable, i.e. we have a map like `map(s)`, `map(s.x)` + // etc. In such cases, we do not need to handle default map generation + // for `s`. + bool HasEntryWithoutAttachPtr = + llvm::any_of(DeclComponentLists, [&](const auto &MapData) { + OMPClauseMappableExprCommon::MappableExprComponentListRef + Components = std::get<0>(MapData); + return !MEHandler.getAttachPtrExpr(Components); + }); + + // Generate default map info first if there's no direct map with CV as + // the base-variable, or attach pointer. + if (DeclComponentLists.empty() || + (!HasEntryWithCVAsAttachPtr && !HasEntryWithoutAttachPtr)) + MEHandler.generateDefaultMapInfo(*CI, **RI, *CV, CurInfo); + // If we have any information in the map clause, we use it, otherwise we // just do a default mapping. MEHandler.generateInfoForCaptureFromClauseInfo( - CI, *CV, CurInfo, OMPBuilder, + DeclComponentLists, CI, *CV, CurInfo, OMPBuilder, /*OffsetForMemberOfFlag=*/CombinedInfo.BasePointers.size()); if (!CI->capturesThis()) @@ -10068,9 +10598,6 @@ static void genMapInfoForCaptures( else MappedVarSet.insert(nullptr); - if (CurInfo.BasePointers.empty()) - MEHandler.generateDefaultMapInfo(*CI, **RI, *CV, CurInfo); - // Generate correct mapping for variables captured by reference in // lambdas. if (CI->capturesVariable()) diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp index 0fa21e89b1236..0e6feef3540ad 100644 --- a/clang/lib/Sema/SemaOpenMP.cpp +++ b/clang/lib/Sema/SemaOpenMP.cpp @@ -2217,6 +2217,7 @@ bool SemaOpenMP::isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, // | ptr | n.a. | - | x | - | - | bycopy| // | ptr | n.a. | x | - | - | - | null | // | ptr | n.a. | - | - | - | x | byref | + // | ptr | n.a. | - | - | - | x, x[] | bycopy| // | ptr | n.a. | - | - | - | x[] | bycopy| // | ptr | n.a. | - | - | x | | bycopy| // | ptr | n.a. | - | - | x | x | bycopy| @@ -2242,18 +2243,22 @@ bool SemaOpenMP::isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, // - For pointers mapped by value that have either an implicit map or an // array section, the runtime library may pass the NULL value to the // device instead of the value passed to it by the compiler. + // - If both a pointer an a dereference of it are mapped, then the pointer + // should be passed by reference. if (Ty->isReferenceType()) Ty = Ty->castAs()->getPointeeType(); - // Locate map clauses and see if the variable being captured is referred to - // in any of those clauses. Here we only care about variables, not fields, - // because fields are part of aggregates. + // Locate map clauses and see if the variable being captured is mapped by + // itself, or referred to, in any of those clauses. Here we only care about + // variables, not fields, because fields are part of aggregates. bool IsVariableAssociatedWithSection = false; + bool IsVariableItselfMapped = false; DSAStack->checkMappableExprComponentListsForDeclAtLevel( D, Level, [&IsVariableUsedInMapClause, &IsVariableAssociatedWithSection, + &IsVariableItselfMapped, D](OMPClauseMappableExprCommon::MappableExprComponentListRef MapExprComponents, OpenMPClauseKind WhereFoundClauseKind) { @@ -2269,8 +2274,19 @@ bool SemaOpenMP::isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, assert(EI != EE && "Invalid map expression!"); - if (isa(EI->getAssociatedExpression())) - IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D; + if (isa(EI->getAssociatedExpression()) && + EI->getAssociatedDeclaration() == D) { + IsVariableUsedInMapClause = true; + + // If the component list has only one element, it's for mapping the + // variable itself, like map(p). This takes precedence in + // determining how it's captured, so we don't need to look further + // for any other maps that use the variable (like map(p[0]) etc.) + if (MapExprComponents.size() == 1) { + IsVariableItselfMapped = true; + return true; + } + } ++EI; if (EI == EE) @@ -2284,8 +2300,10 @@ bool SemaOpenMP::isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, isa(EI->getAssociatedExpression()) || isa(Last->getAssociatedExpression())) { IsVariableAssociatedWithSection = true; - // There is nothing more we need to know about this variable. - return true; + // We've found a case like map(p[0]) or map(p->a) or map(*p), + // so we are done with this particular map, but we need to keep + // looking in case we find a map(p). + return false; } // Keep looking for more map info. @@ -2294,8 +2312,23 @@ bool SemaOpenMP::isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, if (IsVariableUsedInMapClause) { // If variable is identified in a map clause it is always captured by - // reference except if it is a pointer that is dereferenced somehow. - IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection); + // reference except if it is a pointer that is dereferenced somehow, but + // not itself mapped. + // + // OpenMP 6.0, 7.1.1: Data sharing attribute rules, variables referenced + // in a construct:: + // If a list item in a has_device_addr clause or in a map clause on the + // target construct has a base pointer, and the base pointer is a scalar + // variable *that is not a list item in a map clause on the construct*, + // the base pointer is firstprivate. + // + // OpenMP 4.5, 2.15.1.1: Data-sharing Attribute Rules for Variables + // Referenced in a Construct: + // If an array section is a list item in a map clause on the target + // construct and the array section is derived from a variable for which + // the type is pointer then that variable is firstprivate. + IsByRef = IsVariableItselfMapped || + !(Ty->isPointerType() && IsVariableAssociatedWithSection); } else { // By default, all the data that has a scalar type is mapped by copy // (except for reduction variables). @@ -22838,8 +22871,10 @@ static void checkMappableExpressionList( OpenMPMapClauseKind MapType = OMPC_MAP_unknown, ArrayRef Modifiers = {}, bool IsMapTypeImplicit = false, bool NoDiagnose = false) { - // We only expect mappable expressions in 'to', 'from', and 'map' clauses. - assert((CKind == OMPC_map || CKind == OMPC_to || CKind == OMPC_from) && + // We only expect mappable expressions in 'to', 'from', 'map', and + // 'use_device_addr' clauses. + assert((CKind == OMPC_map || CKind == OMPC_to || CKind == OMPC_from || + CKind == OMPC_use_device_addr) && "Unexpected clause kind with mappable expressions!"); unsigned OMPVersion = SemaRef.getLangOpts().OpenMP; @@ -24543,17 +24578,67 @@ SemaOpenMP::ActOnOpenMPUseDeviceAddrClause(ArrayRef VarList, // similar properties of a first private variable. DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_firstprivate, Ref); - // Create a mappable component for the list item. List items in this clause - // only need a component. - MVLI.VarBaseDeclarations.push_back(D); - MVLI.VarComponents.emplace_back(); - Expr *Component = SimpleRefExpr; - if (VD && (isa(RefExpr->IgnoreParenImpCasts()) || - isa(RefExpr->IgnoreParenImpCasts()))) - Component = - SemaRef.DefaultFunctionArrayLvalueConversion(SimpleRefExpr).get(); - MVLI.VarComponents.back().emplace_back(Component, D, - /*IsNonContiguous=*/false); + // Use the map-like approach to fully populate VarComponents + OMPClauseMappableExprCommon::MappableExprComponentList CurComponents; + + const Expr *BE = checkMapClauseExpressionBase( + SemaRef, RefExpr, CurComponents, OMPC_use_device_addr, + DSAStack->getCurrentDirective(), + /*NoDiagnose=*/false); + + if (!BE) + continue; + + assert(!CurComponents.empty() && + "use_device_addr clause expression with no components!"); + + // OpenMP use_device_addr: If a list item is an array section, the array + // base must be a base language identifier. We caught the cases where + // the array-section has a base-variable in getPrivateItem. e.g. + // struct S { + // int a[10]; + // }; S s1; + // ... use_device_addr(s1.a[0]) // not ok, caught already + // + // But we still neeed to verify that the base-pointer is also a + // base-language identifier, and catch cases like: + // int *pa[10]; *p; + // ... use_device_addr(pa[1][2]) // not ok, base-pointer is pa[1] + // ... use_device_addr(p[1]) // ok + // ... use_device_addr(this->p[1]) // ok + auto AttachPtrResult = OMPClauseMappableExprCommon::findAttachPtrExpr( + CurComponents, DSAStack->getCurrentDirective()); + const Expr *AttachPtrExpr = AttachPtrResult.first; + + if (AttachPtrExpr) { + const Expr *BaseExpr = AttachPtrExpr->IgnoreParenImpCasts(); + bool IsValidBase = false; + + if (isa(BaseExpr)) + IsValidBase = true; + else if (const auto *ME = dyn_cast(BaseExpr); + ME && isa(ME->getBase()->IgnoreParenImpCasts())) + IsValidBase = true; + + if (!IsValidBase) { + SemaRef.Diag(ELoc, + diag::err_omp_expected_base_pointer_var_name_member_expr) + << (SemaRef.getCurrentThisType().isNull() ? 0 : 1) + << AttachPtrExpr->getSourceRange(); + continue; + } + } + + // Get the declaration from the components + ValueDecl *CurDeclaration = CurComponents.back().getAssociatedDeclaration(); + assert(isa(BE) || + CurDeclaration && + "Unexpected null decl for use_device_addr clause."); + + MVLI.VarBaseDeclarations.push_back(CurDeclaration); + MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1); + MVLI.VarComponents.back().append(CurComponents.begin(), + CurComponents.end()); } if (MVLI.ProcessedVarList.empty()) diff --git a/clang/test/OpenMP/bug59160.c b/clang/test/OpenMP/bug59160.c index 7790b4bfb285b..d38ea09d10c01 100644 --- a/clang/test/OpenMP/bug59160.c +++ b/clang/test/OpenMP/bug59160.c @@ -8,7 +8,13 @@ void zoo(void) { xp[1] = &x[0]; short **xpp = &xp[0]; x[1] = 111; -#pragma omp target data map(tofrom: xpp[1][1]) use_device_addr(xpp[1][1]) + +// NOTE: use_device_addr on xpp[1][1] is non-compliant, as the base-pointer +// is xpp[1], which is not a base-language identifier. +#pragma omp target data map(tofrom: xpp[1][1]) //use_device_addr(xpp[1][1]) +// FIXME: The assumption that xpp should not be mapped is incorrect. +// The base-pointer of the array-section is xpp[1], not xpp, so the implicit +// clause on xpp, i.e. a zero-length array-section amp, should still be emitted. #pragma omp target has_device_addr(xpp[1][1]) { xpp[1][1] = 222; diff --git a/clang/test/OpenMP/bug60602.cpp b/clang/test/OpenMP/bug60602.cpp index 0789ef958e523..9b2dff791cccd 100644 --- a/clang/test/OpenMP/bug60602.cpp +++ b/clang/test/OpenMP/bug60602.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --version 2 +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" --version 2 // Test host codegen. // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s // expected-no-diagnostics @@ -16,6 +16,12 @@ int kernel_within_loop(int *a, int *b, int N, int num_iters) { } return a[N-1]; } +//. +// CHECK: @.offload_sizes = private unnamed_addr constant [5 x i64] [i64 4, i64 0, i64 8, i64 0, i64 8] +// CHECK: @.offload_maptypes = private unnamed_addr constant [5 x i64] [i64 800, i64 35, i64 16384, i64 35, i64 16384] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [5 x i64] [i64 4, i64 0, i64 8, i64 0, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [5 x i64] [i64 800, i64 35, i64 16384, i64 35, i64 16384] +//. // CHECK-LABEL: define dso_local noundef signext i32 @_Z18kernel_within_loopPiS_ii // CHECK-SAME: (ptr noundef [[A:%.*]], ptr noundef [[B:%.*]], i32 noundef signext [[N:%.*]], i32 noundef signext [[NUM_ITERS:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: entry: @@ -25,16 +31,16 @@ int kernel_within_loop(int *a, int *b, int N, int num_iters) { // CHECK-NEXT: [[NUM_ITERS_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[I:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[N_CASTED:%.*]] = alloca i64, align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [5 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [5 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [5 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [5 x i64], align 8 // CHECK-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8 // CHECK-NEXT: [[N_CASTED3:%.*]] = alloca i64, align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS8:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS9:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS10:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_SIZES11:%.*]] = alloca [3 x i64], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS8:%.*]] = alloca [5 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS9:%.*]] = alloca [5 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS10:%.*]] = alloca [5 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_SIZES11:%.*]] = alloca [5 x i64], align 8 // CHECK-NEXT: [[TMP:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[DOTCAPTURE_EXPR_:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[DOTCAPTURE_EXPR_12:%.*]] = alloca i32, align 4 @@ -68,165 +74,189 @@ int kernel_within_loop(int *a, int *b, int N, int num_iters) { // CHECK-NEXT: [[TMP12:%.*]] = load i32, ptr [[N_ADDR]], align 4 // CHECK-NEXT: [[CONV2:%.*]] = sext i32 [[TMP12]] to i64 // CHECK-NEXT: [[TMP13:%.*]] = mul nuw i64 [[CONV2]], 4 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes, i64 24, i1 false) -// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes, i64 40, i1 false) +// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 // CHECK-NEXT: store i64 [[TMP3]], ptr [[TMP14]], align 8 -// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 // CHECK-NEXT: store i64 [[TMP3]], ptr [[TMP15]], align 8 -// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 // CHECK-NEXT: store ptr null, ptr [[TMP16]], align 8 -// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 // CHECK-NEXT: store ptr [[TMP6]], ptr [[TMP17]], align 8 -// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 // CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP18]], align 8 -// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 1 +// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 1 // CHECK-NEXT: store i64 [[TMP9]], ptr [[TMP19]], align 8 -// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 // CHECK-NEXT: store ptr null, ptr [[TMP20]], align 8 -// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP10]], ptr [[TMP21]], align 8 -// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP22]], align 8 -// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 2 -// CHECK-NEXT: store i64 [[TMP13]], ptr [[TMP23]], align 8 -// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK-NEXT: store ptr null, ptr [[TMP24]], align 8 -// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP28]], align 4 -// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 -// CHECK-NEXT: store i32 3, ptr [[TMP29]], align 4 -// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP25]], ptr [[TMP30]], align 8 -// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP26]], ptr [[TMP31]], align 8 -// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 -// CHECK-NEXT: store ptr [[TMP27]], ptr [[TMP32]], align 8 -// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes, ptr [[TMP33]], align 8 -// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP34]], align 8 -// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP35]], align 8 -// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP36]], align 8 -// CHECK-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP37]], align 8 -// CHECK-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 1, i32 0, i32 0], ptr [[TMP38]], align 4 -// CHECK-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP39]], align 4 -// CHECK-NEXT: [[TMP40:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP40]], align 4 -// CHECK-NEXT: [[TMP41:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB2:[0-9]+]], i64 -1, i32 1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z18kernel_within_loopPiS_ii_l9.region_id, ptr [[KERNEL_ARGS]]) -// CHECK-NEXT: [[TMP42:%.*]] = icmp ne i32 [[TMP41]], 0 -// CHECK-NEXT: br i1 [[TMP42]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] +// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[A_ADDR]], ptr [[TMP21]], align 8 +// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP22]], align 8 +// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK-NEXT: store ptr null, ptr [[TMP23]], align 8 +// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP10]], ptr [[TMP24]], align 8 +// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP25]], align 8 +// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 3 +// CHECK-NEXT: store i64 [[TMP13]], ptr [[TMP26]], align 8 +// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 +// CHECK-NEXT: store ptr null, ptr [[TMP27]], align 8 +// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[B_ADDR]], ptr [[TMP28]], align 8 +// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP29]], align 8 +// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 +// CHECK-NEXT: store ptr null, ptr [[TMP30]], align 8 +// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP34]], align 4 +// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 +// CHECK-NEXT: store i32 5, ptr [[TMP35]], align 4 +// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP31]], ptr [[TMP36]], align 8 +// CHECK-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP32]], ptr [[TMP37]], align 8 +// CHECK-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[TMP33]], ptr [[TMP38]], align 8 +// CHECK-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes, ptr [[TMP39]], align 8 +// CHECK-NEXT: [[TMP40:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP40]], align 8 +// CHECK-NEXT: [[TMP41:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP41]], align 8 +// CHECK-NEXT: [[TMP42:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP42]], align 8 +// CHECK-NEXT: [[TMP43:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP43]], align 8 +// CHECK-NEXT: [[TMP44:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 1, i32 0, i32 0], ptr [[TMP44]], align 4 +// CHECK-NEXT: [[TMP45:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP45]], align 4 +// CHECK-NEXT: [[TMP46:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP46]], align 4 +// CHECK-NEXT: [[TMP47:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB2:[0-9]+]], i64 -1, i32 1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z18kernel_within_loopPiS_ii_l9.region_id, ptr [[KERNEL_ARGS]]) +// CHECK-NEXT: [[TMP48:%.*]] = icmp ne i32 [[TMP47]], 0 +// CHECK-NEXT: br i1 [[TMP48]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] // CHECK: omp_offload.failed: // CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z18kernel_within_loopPiS_ii_l9(i64 [[TMP3]], ptr [[TMP4]], ptr [[TMP5]]) #[[ATTR2:[0-9]+]] // CHECK-NEXT: br label [[OMP_OFFLOAD_CONT]] // CHECK: omp_offload.cont: -// CHECK-NEXT: [[TMP43:%.*]] = load i32, ptr [[N_ADDR]], align 4 -// CHECK-NEXT: store i32 [[TMP43]], ptr [[N_CASTED3]], align 4 -// CHECK-NEXT: [[TMP44:%.*]] = load i64, ptr [[N_CASTED3]], align 8 -// CHECK-NEXT: [[TMP45:%.*]] = load ptr, ptr [[A_ADDR]], align 8 -// CHECK-NEXT: [[TMP46:%.*]] = load ptr, ptr [[B_ADDR]], align 8 -// CHECK-NEXT: [[TMP47:%.*]] = load ptr, ptr [[A_ADDR]], align 8 -// CHECK-NEXT: [[TMP48:%.*]] = load ptr, ptr [[A_ADDR]], align 8 -// CHECK-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP48]], i64 0 // CHECK-NEXT: [[TMP49:%.*]] = load i32, ptr [[N_ADDR]], align 4 -// CHECK-NEXT: [[CONV5:%.*]] = sext i32 [[TMP49]] to i64 -// CHECK-NEXT: [[TMP50:%.*]] = mul nuw i64 [[CONV5]], 4 -// CHECK-NEXT: [[TMP51:%.*]] = load ptr, ptr [[B_ADDR]], align 8 +// CHECK-NEXT: store i32 [[TMP49]], ptr [[N_CASTED3]], align 4 +// CHECK-NEXT: [[TMP50:%.*]] = load i64, ptr [[N_CASTED3]], align 8 +// CHECK-NEXT: [[TMP51:%.*]] = load ptr, ptr [[A_ADDR]], align 8 // CHECK-NEXT: [[TMP52:%.*]] = load ptr, ptr [[B_ADDR]], align 8 -// CHECK-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP52]], i64 0 -// CHECK-NEXT: [[TMP53:%.*]] = load i32, ptr [[N_ADDR]], align 4 -// CHECK-NEXT: [[CONV7:%.*]] = sext i32 [[TMP53]] to i64 -// CHECK-NEXT: [[TMP54:%.*]] = mul nuw i64 [[CONV7]], 4 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES11]], ptr align 8 @.offload_sizes.1, i64 24, i1 false) -// CHECK-NEXT: [[TMP55:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP44]], ptr [[TMP55]], align 8 -// CHECK-NEXT: [[TMP56:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP44]], ptr [[TMP56]], align 8 -// CHECK-NEXT: [[TMP57:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS10]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP57]], align 8 -// CHECK-NEXT: [[TMP58:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[TMP47]], ptr [[TMP58]], align 8 -// CHECK-NEXT: [[TMP59:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP59]], align 8 -// CHECK-NEXT: [[TMP60:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES11]], i32 0, i32 1 -// CHECK-NEXT: store i64 [[TMP50]], ptr [[TMP60]], align 8 -// CHECK-NEXT: [[TMP61:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS10]], i64 0, i64 1 -// CHECK-NEXT: store ptr null, ptr [[TMP61]], align 8 -// CHECK-NEXT: [[TMP62:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP51]], ptr [[TMP62]], align 8 -// CHECK-NEXT: [[TMP63:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP63]], align 8 -// CHECK-NEXT: [[TMP64:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES11]], i32 0, i32 2 -// CHECK-NEXT: store i64 [[TMP54]], ptr [[TMP64]], align 8 -// CHECK-NEXT: [[TMP65:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS10]], i64 0, i64 2 -// CHECK-NEXT: store ptr null, ptr [[TMP65]], align 8 -// CHECK-NEXT: [[TMP66:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 0 -// CHECK-NEXT: [[TMP67:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 0 -// CHECK-NEXT: [[TMP68:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES11]], i32 0, i32 0 -// CHECK-NEXT: [[TMP69:%.*]] = load i32, ptr [[N_ADDR]], align 4 -// CHECK-NEXT: store i32 [[TMP69]], ptr [[DOTCAPTURE_EXPR_]], align 4 -// CHECK-NEXT: [[TMP70:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_]], align 4 -// CHECK-NEXT: [[SUB:%.*]] = sub i32 [[TMP70]], -2 +// CHECK-NEXT: [[TMP53:%.*]] = load ptr, ptr [[A_ADDR]], align 8 +// CHECK-NEXT: [[TMP54:%.*]] = load ptr, ptr [[A_ADDR]], align 8 +// CHECK-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP54]], i64 0 +// CHECK-NEXT: [[TMP55:%.*]] = load i32, ptr [[N_ADDR]], align 4 +// CHECK-NEXT: [[CONV5:%.*]] = sext i32 [[TMP55]] to i64 +// CHECK-NEXT: [[TMP56:%.*]] = mul nuw i64 [[CONV5]], 4 +// CHECK-NEXT: [[TMP57:%.*]] = load ptr, ptr [[B_ADDR]], align 8 +// CHECK-NEXT: [[TMP58:%.*]] = load ptr, ptr [[B_ADDR]], align 8 +// CHECK-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP58]], i64 0 +// CHECK-NEXT: [[TMP59:%.*]] = load i32, ptr [[N_ADDR]], align 4 +// CHECK-NEXT: [[CONV7:%.*]] = sext i32 [[TMP59]] to i64 +// CHECK-NEXT: [[TMP60:%.*]] = mul nuw i64 [[CONV7]], 4 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES11]], ptr align 8 @.offload_sizes.1, i64 40, i1 false) +// CHECK-NEXT: [[TMP61:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 0 +// CHECK-NEXT: store i64 [[TMP50]], ptr [[TMP61]], align 8 +// CHECK-NEXT: [[TMP62:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 0 +// CHECK-NEXT: store i64 [[TMP50]], ptr [[TMP62]], align 8 +// CHECK-NEXT: [[TMP63:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS10]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP63]], align 8 +// CHECK-NEXT: [[TMP64:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP53]], ptr [[TMP64]], align 8 +// CHECK-NEXT: [[TMP65:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP65]], align 8 +// CHECK-NEXT: [[TMP66:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES11]], i32 0, i32 1 +// CHECK-NEXT: store i64 [[TMP56]], ptr [[TMP66]], align 8 +// CHECK-NEXT: [[TMP67:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS10]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP67]], align 8 +// CHECK-NEXT: [[TMP68:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[A_ADDR]], ptr [[TMP68]], align 8 +// CHECK-NEXT: [[TMP69:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP69]], align 8 +// CHECK-NEXT: [[TMP70:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS10]], i64 0, i64 2 +// CHECK-NEXT: store ptr null, ptr [[TMP70]], align 8 +// CHECK-NEXT: [[TMP71:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP57]], ptr [[TMP71]], align 8 +// CHECK-NEXT: [[TMP72:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP72]], align 8 +// CHECK-NEXT: [[TMP73:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES11]], i32 0, i32 3 +// CHECK-NEXT: store i64 [[TMP60]], ptr [[TMP73]], align 8 +// CHECK-NEXT: [[TMP74:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS10]], i64 0, i64 3 +// CHECK-NEXT: store ptr null, ptr [[TMP74]], align 8 +// CHECK-NEXT: [[TMP75:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[B_ADDR]], ptr [[TMP75]], align 8 +// CHECK-NEXT: [[TMP76:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP76]], align 8 +// CHECK-NEXT: [[TMP77:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS10]], i64 0, i64 4 +// CHECK-NEXT: store ptr null, ptr [[TMP77]], align 8 +// CHECK-NEXT: [[TMP78:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS8]], i32 0, i32 0 +// CHECK-NEXT: [[TMP79:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS9]], i32 0, i32 0 +// CHECK-NEXT: [[TMP80:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES11]], i32 0, i32 0 +// CHECK-NEXT: [[TMP81:%.*]] = load i32, ptr [[N_ADDR]], align 4 +// CHECK-NEXT: store i32 [[TMP81]], ptr [[DOTCAPTURE_EXPR_]], align 4 +// CHECK-NEXT: [[TMP82:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_]], align 4 +// CHECK-NEXT: [[SUB:%.*]] = sub i32 [[TMP82]], -2 // CHECK-NEXT: [[DIV:%.*]] = udiv i32 [[SUB]], 3 // CHECK-NEXT: [[SUB13:%.*]] = sub i32 [[DIV]], 1 // CHECK-NEXT: store i32 [[SUB13]], ptr [[DOTCAPTURE_EXPR_12]], align 4 -// CHECK-NEXT: [[TMP71:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_12]], align 4 -// CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP71]], 1 -// CHECK-NEXT: [[TMP72:%.*]] = zext i32 [[ADD]] to i64 -// CHECK-NEXT: [[TMP73:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP73]], align 4 -// CHECK-NEXT: [[TMP74:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 1 -// CHECK-NEXT: store i32 3, ptr [[TMP74]], align 4 -// CHECK-NEXT: [[TMP75:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP66]], ptr [[TMP75]], align 8 -// CHECK-NEXT: [[TMP76:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP67]], ptr [[TMP76]], align 8 -// CHECK-NEXT: [[TMP77:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 4 -// CHECK-NEXT: store ptr [[TMP68]], ptr [[TMP77]], align 8 -// CHECK-NEXT: [[TMP78:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP78]], align 8 -// CHECK-NEXT: [[TMP79:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP79]], align 8 -// CHECK-NEXT: [[TMP80:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP80]], align 8 -// CHECK-NEXT: [[TMP81:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 8 -// CHECK-NEXT: store i64 [[TMP72]], ptr [[TMP81]], align 8 -// CHECK-NEXT: [[TMP82:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP82]], align 8 -// CHECK-NEXT: [[TMP83:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP83]], align 4 -// CHECK-NEXT: [[TMP84:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP84]], align 4 -// CHECK-NEXT: [[TMP85:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP85]], align 4 -// CHECK-NEXT: [[TMP86:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB2]], i64 -1, i32 0, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z18kernel_within_loopPiS_ii_l13.region_id, ptr [[KERNEL_ARGS14]]) -// CHECK-NEXT: [[TMP87:%.*]] = icmp ne i32 [[TMP86]], 0 -// CHECK-NEXT: br i1 [[TMP87]], label [[OMP_OFFLOAD_FAILED15:%.*]], label [[OMP_OFFLOAD_CONT16:%.*]] +// CHECK-NEXT: [[TMP83:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_12]], align 4 +// CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP83]], 1 +// CHECK-NEXT: [[TMP84:%.*]] = zext i32 [[ADD]] to i64 +// CHECK-NEXT: [[TMP85:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP85]], align 4 +// CHECK-NEXT: [[TMP86:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 1 +// CHECK-NEXT: store i32 5, ptr [[TMP86]], align 4 +// CHECK-NEXT: [[TMP87:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP78]], ptr [[TMP87]], align 8 +// CHECK-NEXT: [[TMP88:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP79]], ptr [[TMP88]], align 8 +// CHECK-NEXT: [[TMP89:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[TMP80]], ptr [[TMP89]], align 8 +// CHECK-NEXT: [[TMP90:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP90]], align 8 +// CHECK-NEXT: [[TMP91:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP91]], align 8 +// CHECK-NEXT: [[TMP92:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP92]], align 8 +// CHECK-NEXT: [[TMP93:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 8 +// CHECK-NEXT: store i64 [[TMP84]], ptr [[TMP93]], align 8 +// CHECK-NEXT: [[TMP94:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP94]], align 8 +// CHECK-NEXT: [[TMP95:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP95]], align 4 +// CHECK-NEXT: [[TMP96:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP96]], align 4 +// CHECK-NEXT: [[TMP97:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP97]], align 4 +// CHECK-NEXT: [[TMP98:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB2]], i64 -1, i32 0, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z18kernel_within_loopPiS_ii_l13.region_id, ptr [[KERNEL_ARGS14]]) +// CHECK-NEXT: [[TMP99:%.*]] = icmp ne i32 [[TMP98]], 0 +// CHECK-NEXT: br i1 [[TMP99]], label [[OMP_OFFLOAD_FAILED15:%.*]], label [[OMP_OFFLOAD_CONT16:%.*]] // CHECK: omp_offload.failed15: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z18kernel_within_loopPiS_ii_l13(i64 [[TMP44]], ptr [[TMP45]], ptr [[TMP46]]) #[[ATTR2]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z18kernel_within_loopPiS_ii_l13(i64 [[TMP50]], ptr [[TMP51]], ptr [[TMP52]]) #[[ATTR2]] // CHECK-NEXT: br label [[OMP_OFFLOAD_CONT16]] // CHECK: omp_offload.cont16: // CHECK-NEXT: br label [[FOR_INC:%.*]] // CHECK: for.inc: -// CHECK-NEXT: [[TMP88:%.*]] = load i32, ptr [[I]], align 4 -// CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP88]], 1 +// CHECK-NEXT: [[TMP100:%.*]] = load i32, ptr [[I]], align 4 +// CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP100]], 1 // CHECK-NEXT: store i32 [[INC]], ptr [[I]], align 4 -// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP5:![0-9]+]] +// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP7:![0-9]+]] // CHECK: for.end: -// CHECK-NEXT: [[TMP89:%.*]] = load ptr, ptr [[A_ADDR]], align 8 -// CHECK-NEXT: [[TMP90:%.*]] = load i32, ptr [[N_ADDR]], align 4 -// CHECK-NEXT: [[SUB17:%.*]] = sub nsw i32 [[TMP90]], 1 +// CHECK-NEXT: [[TMP101:%.*]] = load ptr, ptr [[A_ADDR]], align 8 +// CHECK-NEXT: [[TMP102:%.*]] = load i32, ptr [[N_ADDR]], align 4 +// CHECK-NEXT: [[SUB17:%.*]] = sub nsw i32 [[TMP102]], 1 // CHECK-NEXT: [[IDXPROM:%.*]] = sext i32 [[SUB17]] to i64 -// CHECK-NEXT: [[ARRAYIDX18:%.*]] = getelementptr inbounds i32, ptr [[TMP89]], i64 [[IDXPROM]] -// CHECK-NEXT: [[TMP91:%.*]] = load i32, ptr [[ARRAYIDX18]], align 4 -// CHECK-NEXT: ret i32 [[TMP91]] +// CHECK-NEXT: [[ARRAYIDX18:%.*]] = getelementptr inbounds i32, ptr [[TMP101]], i64 [[IDXPROM]] +// CHECK-NEXT: [[TMP103:%.*]] = load i32, ptr [[ARRAYIDX18]], align 4 +// CHECK-NEXT: ret i32 [[TMP103]] // // // CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z18kernel_within_loopPiS_ii_l9 diff --git a/clang/test/OpenMP/copy-gaps-1.cpp b/clang/test/OpenMP/copy-gaps-1.cpp index 3d4fae352eed6..2166d78764744 100644 --- a/clang/test/OpenMP/copy-gaps-1.cpp +++ b/clang/test/OpenMP/copy-gaps-1.cpp @@ -18,6 +18,17 @@ struct T : public S { int main() { T v; +// &v, &v, sizeof(v), ALLOC | PARAM +// &v, &v.z + sizeof(int), sizeof(v.p1 to v.p2), TO | FROM | MEMBER_OF_1 +// &v, &v.c + sizeof(int), sizeof(T) - (&v.c + sizeof(int))), TO | FROM | MEMBER_OF_1 +// &v, &v.x, sizeof(v.x), TO | FROM | MEMBER_OF_1 +// &v, &v.y, sizeof(v.y), TO | FROM | MEMBER_OF_1 +// &v, &v.z, sizeof(v.z), TO | FROM | MEMBER_OF_1 +// &v, &v.a, sizeof(v.a), TO | FROM | MEMBER_OF_1 +// &v, &v.b, sizeof(v.b), TO | FROM | MEMBER_OF_1 +// &v, &v.c, sizeof(v.c), TO | FROM | MEMBER_OF_1 +// &v.p1[0], &v.p1[0], 8 * sizeof(int), TO | FROM +// &v.p1, &v.p1[0], sizeof(v.p1), ATTACH #pragma omp target map(tofrom: v, v.x, v.y, v.z, v.p1[:8], v.a, v.b, v.c) { v.x++; @@ -32,21 +43,21 @@ int main() { return 0; } -// CHECK: [[CSTSZ:@.+]] = private {{.*}}constant [10 x i64] [i64 0, i64 0, i64 0, i64 4, i64 4, i64 4, i64 32, i64 4, i64 4, i64 4] -// CHECK: [[CSTTY:@.+]] = private {{.*}}constant [10 x i64] [i64 [[#0x20]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000013]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]]] +// CHECK: [[CSTSZ:@.+]] = private {{.*}}constant [11 x i64] [i64 0, i64 0, i64 0, i64 4, i64 4, i64 4, i64 4, i64 4, i64 4, i64 32, i64 8] +// CHECK: [[CSTTY:@.+]] = private {{.*}}constant [11 x i64] [i64 [[#0x20]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x3]], i64 [[#0x4000]]] // CHECK-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CHECK-DAG: [[KSIZE:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 // CHECK-DAG: store ptr [[SZBASE:%.+]], ptr [[KSIZE]], align 8 -// CHECK-DAG: [[SZBASE]] = getelementptr inbounds [10 x i64], ptr [[SIZES:%[^,]*]], i32 0, i32 0 +// CHECK-DAG: [[SZBASE]] = getelementptr inbounds [11 x i64], ptr [[SIZES:%[^,]*]], i32 0, i32 0 -// Check for filling of four non-constant size elements here: the whole struct +// Check for filling of three non-constant size elements here: the whole struct // size, the (padded) region covering p1 & p2, and the padding at the end of // struct T. -// CHECK-DAG: [[STR:%.+]] = getelementptr inbounds [10 x i64], ptr [[SIZES]], i32 0, i32 0 +// CHECK-DAG: [[STR:%.+]] = getelementptr inbounds [11 x i64], ptr [[SIZES]], i32 0, i32 0 // CHECK-DAG: store i64 %{{.+}}, ptr [[STR]], align 8 -// CHECK-DAG: [[P1P2:%.+]] = getelementptr inbounds [10 x i64], ptr [[SIZES]], i32 0, i32 1 +// CHECK-DAG: [[P1P2:%.+]] = getelementptr inbounds [11 x i64], ptr [[SIZES]], i32 0, i32 1 // CHECK-DAG: store i64 %{{.+}}, ptr [[P1P2]], align 8 -// CHECK-DAG: [[PAD:%.+]] = getelementptr inbounds [10 x i64], ptr [[SIZES]], i32 0, i32 2 +// CHECK-DAG: [[PAD:%.+]] = getelementptr inbounds [11 x i64], ptr [[SIZES]], i32 0, i32 2 // CHECK-DAG: store i64 %{{.+}}, ptr [[PAD]], align 8 diff --git a/clang/test/OpenMP/copy-gaps-6.cpp b/clang/test/OpenMP/copy-gaps-6.cpp index 9c62fde1c3762..e09929a95e2d8 100644 --- a/clang/test/OpenMP/copy-gaps-6.cpp +++ b/clang/test/OpenMP/copy-gaps-6.cpp @@ -11,6 +11,10 @@ struct S { int main() { S v; +// &v, &v, sizeof(v), ALLOC | PARAM +// &v, &v.x + sizeof(int), sizeof(v.arr to v.y), TO | FROM | MEMBER_OF_1 +// &v, &v.x, sizeof(v.x), TO | FROM | MEMBER_OF_1 +// &v, &v.z, sizeof(v.z), TO | FROM | MEMBER_OF_1 #pragma omp target map(tofrom: v, v.x, v.z) { v.x++; @@ -18,6 +22,11 @@ int main() { v.z += 3; } +// &v, &v, sizeof(v), ALLOC | PARAM +// &v, &v.x + sizeof(int), sizeof(v.arr to v.z), TO | FROM | MEMBER_OF_1 +// &v, &v.x, sizeof(v.x), TO | FROM | MEMBER_OF_1 +// &v.arr[0], &v.arr[0], 4 * sizeof(int), TO | FROM +// &v.arr, &v.arr[0], sizeof(void*), ATTACH #pragma omp target map(tofrom: v, v.x, v.arr[:1]) { v.x++; @@ -26,6 +35,9 @@ int main() { v.z += 4; } +// &v, &v, sizeof(v), TO | FROM | PARAM +// &v.arr[0], &v.arr[0], 4 * sizeof(int), TO | FROM +// &v.arr, &v.arr[0], sizeof(void*), ATTACH #pragma omp target map(tofrom: v, v.arr[:1]) { v.x++; @@ -40,11 +52,11 @@ int main() { // CHECK: [[CSTSZ0:@.+]] = private {{.*}}constant [4 x i64] [i64 0, i64 0, i64 4, i64 4] // CHECK: [[CSTTY0:@.+]] = private {{.*}}constant [4 x i64] [i64 [[#0x20]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]]] -// CHECK: [[CSTSZ1:@.+]] = private {{.*}}constant [4 x i64] [i64 0, i64 0, i64 4, i64 4] -// CHECK: [[CSTTY1:@.+]] = private {{.*}}constant [4 x i64] [i64 [[#0x20]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000013]]] +// CHECK: [[CSTSZ1:@.+]] = private {{.*}}constant [5 x i64] [i64 0, i64 0, i64 4, i64 4, i64 8] +// CHECK: [[CSTTY1:@.+]] = private {{.*}}constant [5 x i64] [i64 [[#0x20]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x3]], i64 [[#0x4000]]] -// CHECK: [[CSTSZ2:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 24, i64 4] -// CHECK: [[CSTTY2:@.+]] = private {{.*}}constant [3 x i64] [i64 [[#0x20]], i64 [[#0x1000000000003]], i64 [[#0x1000000000013]]] +// CHECK: [[CSTSZ2:@.+]] = private {{.*}}constant [3 x i64] [i64 24, i64 4, i64 8] +// CHECK: [[CSTTY2:@.+]] = private {{.*}}constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] // CHECK-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CHECK-DAG: [[KSIZE:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 @@ -64,24 +76,19 @@ int main() { // CHECK-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CHECK-DAG: [[KSIZE:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 // CHECK-DAG: store ptr [[SZBASE:%.+]], ptr [[KSIZE]], align 8 -// CHECK-DAG: [[SZBASE]] = getelementptr inbounds [4 x i64], ptr [[SIZES:%[^,]*]], i32 0, i32 0 +// CHECK-DAG: [[SZBASE]] = getelementptr inbounds [5 x i64], ptr [[SIZES:%[^,]*]], i32 0, i32 0 // Fill two non-constant size elements here: the whole struct size, and the // region covering v.arr, v.y and v.z. -// CHECK-DAG: [[STR:%.+]] = getelementptr inbounds [4 x i64], ptr [[SIZES]], i32 0, i32 0 +// CHECK-DAG: [[STR:%.+]] = getelementptr inbounds [5 x i64], ptr [[SIZES]], i32 0, i32 0 // CHECK-DAG: store i64 %{{.+}}, ptr [[STR]], align 8 -// CHECK-DAG: [[ARRYZ:%.+]] = getelementptr inbounds [4 x i64], ptr [[SIZES]], i32 0, i32 1 +// CHECK-DAG: [[ARRYZ:%.+]] = getelementptr inbounds [5 x i64], ptr [[SIZES]], i32 0, i32 1 // CHECK-DAG: store i64 %{{.+}}, ptr [[ARRYZ]], align 8 // CHECK: call void // CHECK-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CHECK-DAG: [[KSIZE:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CHECK-DAG: store ptr [[SZBASE:%.+]], ptr [[KSIZE]], align 8 -// CHECK-DAG: [[SZBASE]] = getelementptr inbounds [3 x i64], ptr [[SIZES:%[^,]*]], i32 0, i32 0 - -// Fill one non-constant size element here: the whole struct size. - -// CHECK-DAG: [[STR:%.+]] = getelementptr inbounds [3 x i64], ptr [[SIZES]], i32 0, i32 0 -// CHECK-DAG: store i64 %{{.+}}, ptr [[STR]], align 8 +// No overlap, so no non-constant size element here. +// CHECK-NOT: store ptr [[CSTSZ2]], ptr [[KSIZE]], align 8 diff --git a/clang/test/OpenMP/map_struct_ordering.cpp b/clang/test/OpenMP/map_struct_ordering.cpp index a52ddad465f37..e3c0bea5b04e7 100644 --- a/clang/test/OpenMP/map_struct_ordering.cpp +++ b/clang/test/OpenMP/map_struct_ordering.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" --prefix-filecheck-ir-name _ --version 4 +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals all --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" --global-hex-value-regex ".offload_maptypes.*" --version 4 // RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK @@ -18,20 +18,33 @@ int map_struct() { dat.xi = 3; dat.arr[0][0] = 1; + // &dat, &dat, sizeof(dat), TO + // &dat.datum[0], &dat.datum[0], 10 * sizeof(int), TO + // &dat.datum, &dat.datum[0], sizeof(void*), ATTACH #pragma omp target enter data map(to: dat.datum[:10]) map(to: dat) + // &dat, &dat, sizeof(dat), IMPLICIT | TO | FROM | PARAM #pragma omp target { dat.xi = 4; dat.datum[dat.arr[0][0]] = dat.xi; } + // &dat, &dat, sizeof(dat), FROM #pragma omp target exit data map(from: dat) return dat.xi; } #endif +//. +// CHECK: @.offload_sizes = private unnamed_addr constant [3 x i64] [i64 264, i64 40, i64 8] +// CHECK: @.offload_maptypes = private unnamed_addr constant [3 x i64] [i64 [[#0x1]], i64 [[#0x1]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 264] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x223]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [1 x i64] [i64 264] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [1 x i64] [i64 [[#0x2]]] +//. // CHECK-LABEL: define dso_local noundef signext i32 @_Z10map_structv( // CHECK-SAME: ) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: entry: @@ -39,7 +52,6 @@ int map_struct() { // CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x ptr], align 8 // CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x ptr], align 8 // CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 8 // CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS4:%.*]] = alloca [1 x ptr], align 8 // CHECK-NEXT: [[DOTOFFLOAD_PTRS5:%.*]] = alloca [1 x ptr], align 8 // CHECK-NEXT: [[DOTOFFLOAD_MAPPERS6:%.*]] = alloca [1 x ptr], align 8 @@ -55,100 +67,92 @@ int map_struct() { // CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [30 x i64], ptr [[ARRAYIDX]], i64 0, i64 0 // CHECK-NEXT: store i64 1, ptr [[ARRAYIDX1]], align 8 // CHECK-NEXT: [[DATUM:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[DAT]], i32 0, i32 0 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[DATUM]], align 8 // CHECK-NEXT: [[DATUM2:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[DAT]], i32 0, i32 0 -// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[DATUM2]], align 8 -// CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP0]], i64 0 -// CHECK-NEXT: [[TMP1:%.*]] = getelementptr [[STRUCT_DESCRIPTOR]], ptr [[DAT]], i32 1 -// CHECK-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[TMP1]] to i64 -// CHECK-NEXT: [[TMP3:%.*]] = ptrtoint ptr [[DAT]] to i64 -// CHECK-NEXT: [[TMP4:%.*]] = sub i64 [[TMP2]], [[TMP3]] -// CHECK-NEXT: [[TMP5:%.*]] = sdiv exact i64 [[TMP4]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes, i64 24, i1 false) -// CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP6]], align 8 -// CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP7]], align 8 -// CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP5]], ptr [[TMP8]], align 8 -// CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP9]], align 8 -// CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP10]], align 8 -// CHECK-NEXT: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP11]], align 8 -// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK-NEXT: store ptr null, ptr [[TMP12]], align 8 -// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[DATUM]], ptr [[TMP13]], align 8 -// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[ARRAYIDX3]], ptr [[TMP14]], align 8 -// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[DATUM2]], align 8 +// CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP1]], i64 0 +// CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP2]], align 8 +// CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP3]], align 8 +// CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP4]], align 8 +// CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX3]], ptr [[TMP6]], align 8 +// CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP7]], align 8 +// CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[DATUM]], ptr [[TMP8]], align 8 +// CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX3]], ptr [[TMP9]], align 8 +// CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK-NEXT: store ptr null, ptr [[TMP10]], align 8 +// CHECK-NEXT: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 3, ptr [[TMP11]], ptr [[TMP12]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS4]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP13]], align 8 +// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS5]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP14]], align 8 +// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS6]], i64 0, i64 0 // CHECK-NEXT: store ptr null, ptr [[TMP15]], align 8 -// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 3, ptr [[TMP16]], ptr [[TMP17]], ptr [[TMP18]], ptr @.offload_maptypes, ptr null, ptr null) -// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS4]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP19]], align 8 -// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS5]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP20]], align 8 -// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS6]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP21]], align 8 -// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS4]], i32 0, i32 0 -// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS5]], i32 0, i32 0 -// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP24]], align 4 -// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 -// CHECK-NEXT: store i32 1, ptr [[TMP25]], align 4 -// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP22]], ptr [[TMP26]], align 8 -// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP23]], ptr [[TMP27]], align 8 -// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 -// CHECK-NEXT: store ptr @.offload_sizes.1, ptr [[TMP28]], align 8 -// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP29]], align 8 -// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP30]], align 8 -// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP31]], align 8 -// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP32]], align 8 -// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP33]], align 8 -// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP34]], align 4 -// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP35]], align 4 -// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP36]], align 4 -// CHECK-NEXT: [[TMP37:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z10map_structv_l23.region_id, ptr [[KERNEL_ARGS]]) -// CHECK-NEXT: [[TMP38:%.*]] = icmp ne i32 [[TMP37]], 0 -// CHECK-NEXT: br i1 [[TMP38]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] +// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS4]], i32 0, i32 0 +// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS5]], i32 0, i32 0 +// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP18]], align 4 +// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 +// CHECK-NEXT: store i32 1, ptr [[TMP19]], align 4 +// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP16]], ptr [[TMP20]], align 8 +// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP17]], ptr [[TMP21]], align 8 +// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 +// CHECK-NEXT: store ptr @.offload_sizes.1, ptr [[TMP22]], align 8 +// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP23]], align 8 +// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP24]], align 8 +// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP25]], align 8 +// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP26]], align 8 +// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP27]], align 8 +// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP28]], align 4 +// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP29]], align 4 +// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP30]], align 4 +// CHECK-NEXT: [[TMP31:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z10map_structv_l27.region_id, ptr [[KERNEL_ARGS]]) +// CHECK-NEXT: [[TMP32:%.*]] = icmp ne i32 [[TMP31]], 0 +// CHECK-NEXT: br i1 [[TMP32]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] // CHECK: omp_offload.failed: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z10map_structv_l23(ptr [[DAT]]) #[[ATTR3:[0-9]+]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z10map_structv_l27(ptr [[DAT]]) #[[ATTR2:[0-9]+]] // CHECK-NEXT: br label [[OMP_OFFLOAD_CONT]] // CHECK: omp_offload.cont: -// CHECK-NEXT: [[TMP39:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP39]], align 8 -// CHECK-NEXT: [[TMP40:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP40]], align 8 -// CHECK-NEXT: [[TMP41:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP41]], align 8 -// CHECK-NEXT: [[TMP42:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 0 -// CHECK-NEXT: [[TMP43:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP42]], ptr [[TMP43]], ptr @.offload_sizes.3, ptr @.offload_maptypes.4, ptr null, ptr null) +// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP33]], align 8 +// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[DAT]], ptr [[TMP34]], align 8 +// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP35]], align 8 +// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 0 +// CHECK-NEXT: [[TMP37:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP36]], ptr [[TMP37]], ptr @.offload_sizes.3, ptr @.offload_maptypes.4, ptr null, ptr null) // CHECK-NEXT: [[XI10:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[DAT]], i32 0, i32 2 -// CHECK-NEXT: [[TMP44:%.*]] = load i32, ptr [[XI10]], align 8 -// CHECK-NEXT: ret i32 [[TMP44]] +// CHECK-NEXT: [[TMP38:%.*]] = load i32, ptr [[XI10]], align 8 +// CHECK-NEXT: ret i32 [[TMP38]] // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z10map_structv_l23( -// CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(264) [[DAT:%.*]]) #[[ATTR4:[0-9]+]] { +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z10map_structv_l27( +// CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(264) [[DAT:%.*]]) #[[ATTR3:[0-9]+]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[DAT_ADDR:%.*]] = alloca ptr, align 8 // CHECK-NEXT: store ptr [[DAT]], ptr [[DAT_ADDR]], align 8 -// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[DAT_ADDR]], align 8 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[DAT_ADDR]], align 8, !nonnull [[META5:![0-9]+]], !align [[META6:![0-9]+]] // CHECK-NEXT: [[XI:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR:%.*]], ptr [[TMP0]], i32 0, i32 2 // CHECK-NEXT: store i32 4, ptr [[XI]], align 8 // CHECK-NEXT: [[XI1:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP0]], i32 0, i32 2 diff --git a/clang/test/OpenMP/reduction_implicit_map.cpp b/clang/test/OpenMP/reduction_implicit_map.cpp index a7db3da7d1f86..79c85447d7422 100644 --- a/clang/test/OpenMP/reduction_implicit_map.cpp +++ b/clang/test/OpenMP/reduction_implicit_map.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-globals --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" // RUN: %clang_cc1 -verify -fopenmp -fopenmp-cuda-mode -x c++ \ // RUN: -triple powerpc64le-unknown-unknown -DCUDA \ // RUN: -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm-bc %s -o \ @@ -97,6 +97,21 @@ int main() #endif return 0; } +//. +// CHECK1: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 4] +// CHECK1: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 547] +// CHECK1: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 8000] +// CHECK1: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 547] +//. +// CHECK2: @.offload_sizes = private unnamed_addr constant [5 x i64] [i64 4, i64 4, i64 4, i64 0, i64 4] +// CHECK2: @.offload_maptypes = private unnamed_addr constant [5 x i64] [i64 800, i64 547, i64 16384, i64 33, i64 16384] +// CHECK2: @.offload_sizes.1 = private unnamed_addr constant [5 x i64] [i64 4, i64 12, i64 4, i64 0, i64 4] +// CHECK2: @.offload_maptypes.2 = private unnamed_addr constant [5 x i64] [i64 800, i64 547, i64 16384, i64 33, i64 16384] +// CHECK2: @.offload_sizes.3 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] +// CHECK2: @.offload_maptypes.4 = private unnamed_addr constant [2 x i64] [i64 800, i64 547] +// CHECK2: @.offload_sizes.5 = private unnamed_addr constant [2 x i64] [i64 4, i64 4] +// CHECK2: @.offload_maptypes.6 = private unnamed_addr constant [2 x i64] [i64 800, i64 547] +//. // CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooi_l32 // CHECK-SAME: (ptr noalias noundef [[DYN_PTR:%.*]], ptr noundef [[E:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: entry: @@ -410,7 +425,7 @@ int main() // CHECK1-NEXT: entry: // CHECK1-NEXT: [[O_ADDR:%.*]] = alloca ptr, align 8 // CHECK1-NEXT: store ptr [[O]], ptr [[O_ADDR]], align 8 -// CHECK1-NEXT: [[TMP0:%.*]] = load ptr, ptr [[O_ADDR]], align 8 +// CHECK1-NEXT: [[TMP0:%.*]] = load ptr, ptr [[O_ADDR]], align 8, !nonnull [[META7:![0-9]+]], !align [[META8:![0-9]+]] // CHECK1-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @[[GLOB2]], i32 1, ptr @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3barv_l50.omp_outlined, ptr [[TMP0]]) // CHECK1-NEXT: ret void // @@ -427,7 +442,7 @@ int main() // CHECK1-NEXT: store ptr [[DOTGLOBAL_TID_]], ptr [[DOTGLOBAL_TID__ADDR]], align 8 // CHECK1-NEXT: store ptr [[DOTBOUND_TID_]], ptr [[DOTBOUND_TID__ADDR]], align 8 // CHECK1-NEXT: store ptr [[O]], ptr [[O_ADDR]], align 8 -// CHECK1-NEXT: [[TMP0:%.*]] = load ptr, ptr [[O_ADDR]], align 8 +// CHECK1-NEXT: [[TMP0:%.*]] = load ptr, ptr [[O_ADDR]], align 8, !nonnull [[META7]], !align [[META8]] // CHECK1-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [5 x %class.S2], ptr [[TMP0]], i64 0, i64 0 // CHECK1-NEXT: call void @_ZN2S2C1Ev(ptr noundef nonnull align 4 dereferenceable(4) [[O1]]) // CHECK1-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[TMP0]] to i64 @@ -447,7 +462,7 @@ int main() // CHECK1-NEXT: [[TMP7:%.*]] = load i32, ptr [[I]], align 4 // CHECK1-NEXT: [[INC:%.*]] = add nsw i32 [[TMP7]], 1 // CHECK1-NEXT: store i32 [[INC]], ptr [[I]], align 4 -// CHECK1-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP5:![0-9]+]] +// CHECK1-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP9:![0-9]+]] // CHECK1: for.end: // CHECK1-NEXT: [[TMP8:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOMP_REDUCTION_RED_LIST]], i64 0, i64 0 // CHECK1-NEXT: store ptr [[O1]], ptr [[TMP8]], align 8 @@ -498,7 +513,7 @@ int main() // CHECK1-NEXT: entry: // CHECK1-NEXT: [[B_ADDR:%.*]] = alloca ptr, align 8 // CHECK1-NEXT: store ptr [[B]], ptr [[B_ADDR]], align 8 -// CHECK1-NEXT: [[TMP0:%.*]] = load ptr, ptr [[B_ADDR]], align 8 +// CHECK1-NEXT: [[TMP0:%.*]] = load ptr, ptr [[B_ADDR]], align 8, !nonnull [[META7]], !align [[META13:![0-9]+]] // CHECK1-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @[[GLOB2]], i32 1, ptr @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3barv_l55.omp_outlined, ptr [[TMP0]]) // CHECK1-NEXT: ret void // @@ -524,7 +539,7 @@ int main() // CHECK1-NEXT: store ptr [[DOTGLOBAL_TID_]], ptr [[DOTGLOBAL_TID__ADDR]], align 8 // CHECK1-NEXT: store ptr [[DOTBOUND_TID_]], ptr [[DOTBOUND_TID__ADDR]], align 8 // CHECK1-NEXT: store ptr [[B]], ptr [[B_ADDR]], align 8 -// CHECK1-NEXT: [[TMP0:%.*]] = load ptr, ptr [[B_ADDR]], align 8 +// CHECK1-NEXT: [[TMP0:%.*]] = load ptr, ptr [[B_ADDR]], align 8, !nonnull [[META7]], !align [[META13]] // CHECK1-NEXT: store i64 0, ptr [[DOTOMP_LB]], align 8 // CHECK1-NEXT: store i64 9, ptr [[DOTOMP_UB]], align 8 // CHECK1-NEXT: store i64 1, ptr [[DOTOMP_STRIDE]], align 8 @@ -811,19 +826,19 @@ int main() // CHECK2-NEXT: [[SIZE_ADDR:%.*]] = alloca i32, align 4 // CHECK2-NEXT: [[OUTPUT_ADDR:%.*]] = alloca ptr, align 4 // CHECK2-NEXT: [[SIZE_CASTED:%.*]] = alloca i32, align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x ptr], align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x ptr], align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x ptr], align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [5 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [5 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [5 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [5 x i64], align 4 // CHECK2-NEXT: [[TMP:%.*]] = alloca i32, align 4 // CHECK2-NEXT: [[DOTCAPTURE_EXPR_:%.*]] = alloca i32, align 4 // CHECK2-NEXT: [[DOTCAPTURE_EXPR_2:%.*]] = alloca i32, align 4 // CHECK2-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8 // CHECK2-NEXT: [[SIZE_CASTED4:%.*]] = alloca i32, align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_BASEPTRS7:%.*]] = alloca [3 x ptr], align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_PTRS8:%.*]] = alloca [3 x ptr], align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_MAPPERS9:%.*]] = alloca [3 x ptr], align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_SIZES10:%.*]] = alloca [3 x i64], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_BASEPTRS7:%.*]] = alloca [5 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_PTRS8:%.*]] = alloca [5 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_MAPPERS9:%.*]] = alloca [5 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_SIZES10:%.*]] = alloca [5 x i64], align 4 // CHECK2-NEXT: [[_TMP11:%.*]] = alloca i32, align 4 // CHECK2-NEXT: [[DOTCAPTURE_EXPR_12:%.*]] = alloca i32, align 4 // CHECK2-NEXT: [[DOTCAPTURE_EXPR_13:%.*]] = alloca i32, align 4 @@ -856,254 +871,278 @@ int main() // CHECK2-NEXT: [[TMP8:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 // CHECK2-NEXT: [[TMP9:%.*]] = mul nuw i32 [[TMP8]], 4 // CHECK2-NEXT: [[TMP10:%.*]] = sext i32 [[TMP9]] to i64 -// CHECK2-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[DOTOFFLOAD_SIZES]], ptr align 4 @.offload_sizes, i32 24, i1 false) -// CHECK2-NEXT: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK2-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[DOTOFFLOAD_SIZES]], ptr align 4 @.offload_sizes, i32 40, i1 false) +// CHECK2-NEXT: [[TMP11:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 // CHECK2-NEXT: store i32 [[TMP1]], ptr [[TMP11]], align 4 -// CHECK2-NEXT: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP12:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 // CHECK2-NEXT: store i32 [[TMP1]], ptr [[TMP12]], align 4 -// CHECK2-NEXT: [[TMP13:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP13:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0 // CHECK2-NEXT: store ptr null, ptr [[TMP13]], align 4 -// CHECK2-NEXT: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK2-NEXT: [[TMP14:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 // CHECK2-NEXT: store ptr [[TMP4]], ptr [[TMP14]], align 4 -// CHECK2-NEXT: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK2-NEXT: [[TMP15:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 // CHECK2-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP15]], align 4 -// CHECK2-NEXT: [[TMP16:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1 +// CHECK2-NEXT: [[TMP16:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1 // CHECK2-NEXT: store ptr null, ptr [[TMP16]], align 4 -// CHECK2-NEXT: [[TMP17:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK2-NEXT: store ptr [[TMP6]], ptr [[TMP17]], align 4 -// CHECK2-NEXT: [[TMP18:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK2-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP18]], align 4 -// CHECK2-NEXT: [[TMP19:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 2 -// CHECK2-NEXT: store i64 [[TMP10]], ptr [[TMP19]], align 4 -// CHECK2-NEXT: [[TMP20:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 2 -// CHECK2-NEXT: store ptr null, ptr [[TMP20]], align 4 -// CHECK2-NEXT: [[TMP21:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP22:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP23:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP24:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 -// CHECK2-NEXT: store i32 [[TMP24]], ptr [[DOTCAPTURE_EXPR_]], align 4 -// CHECK2-NEXT: [[TMP25:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_]], align 4 -// CHECK2-NEXT: [[SUB:%.*]] = sub nsw i32 [[TMP25]], 0 +// CHECK2-NEXT: [[TMP17:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK2-NEXT: store ptr [[OUTPUT_ADDR]], ptr [[TMP17]], align 4 +// CHECK2-NEXT: [[TMP18:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK2-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP18]], align 4 +// CHECK2-NEXT: [[TMP19:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 2 +// CHECK2-NEXT: store ptr null, ptr [[TMP19]], align 4 +// CHECK2-NEXT: [[TMP20:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 +// CHECK2-NEXT: store ptr [[TMP6]], ptr [[TMP20]], align 4 +// CHECK2-NEXT: [[TMP21:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 +// CHECK2-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP21]], align 4 +// CHECK2-NEXT: [[TMP22:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 3 +// CHECK2-NEXT: store i64 [[TMP10]], ptr [[TMP22]], align 4 +// CHECK2-NEXT: [[TMP23:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 3 +// CHECK2-NEXT: store ptr null, ptr [[TMP23]], align 4 +// CHECK2-NEXT: [[TMP24:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 +// CHECK2-NEXT: store ptr [[INPUT_ADDR]], ptr [[TMP24]], align 4 +// CHECK2-NEXT: [[TMP25:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// CHECK2-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP25]], align 4 +// CHECK2-NEXT: [[TMP26:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 4 +// CHECK2-NEXT: store ptr null, ptr [[TMP26]], align 4 +// CHECK2-NEXT: [[TMP27:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP28:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP29:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP30:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 +// CHECK2-NEXT: store i32 [[TMP30]], ptr [[DOTCAPTURE_EXPR_]], align 4 +// CHECK2-NEXT: [[TMP31:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_]], align 4 +// CHECK2-NEXT: [[SUB:%.*]] = sub nsw i32 [[TMP31]], 0 // CHECK2-NEXT: [[DIV:%.*]] = sdiv i32 [[SUB]], 1 // CHECK2-NEXT: [[SUB3:%.*]] = sub nsw i32 [[DIV]], 1 // CHECK2-NEXT: store i32 [[SUB3]], ptr [[DOTCAPTURE_EXPR_2]], align 4 -// CHECK2-NEXT: [[TMP26:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_2]], align 4 -// CHECK2-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP26]], 1 -// CHECK2-NEXT: [[TMP27:%.*]] = zext i32 [[ADD]] to i64 -// CHECK2-NEXT: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 -// CHECK2-NEXT: store i32 3, ptr [[TMP28]], align 4 -// CHECK2-NEXT: [[TMP29:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 -// CHECK2-NEXT: store i32 3, ptr [[TMP29]], align 4 -// CHECK2-NEXT: [[TMP30:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 -// CHECK2-NEXT: store ptr [[TMP21]], ptr [[TMP30]], align 4 -// CHECK2-NEXT: [[TMP31:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 -// CHECK2-NEXT: store ptr [[TMP22]], ptr [[TMP31]], align 4 -// CHECK2-NEXT: [[TMP32:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 -// CHECK2-NEXT: store ptr [[TMP23]], ptr [[TMP32]], align 4 -// CHECK2-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 -// CHECK2-NEXT: store ptr @.offload_maptypes, ptr [[TMP33]], align 4 -// CHECK2-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 -// CHECK2-NEXT: store ptr null, ptr [[TMP34]], align 4 -// CHECK2-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 -// CHECK2-NEXT: store ptr null, ptr [[TMP35]], align 4 -// CHECK2-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 -// CHECK2-NEXT: store i64 [[TMP27]], ptr [[TMP36]], align 8 -// CHECK2-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 -// CHECK2-NEXT: store i64 0, ptr [[TMP37]], align 8 -// CHECK2-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 -// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP38]], align 4 -// CHECK2-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 -// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP39]], align 4 -// CHECK2-NEXT: [[TMP40:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 -// CHECK2-NEXT: store i32 0, ptr [[TMP40]], align 4 -// CHECK2-NEXT: [[TMP41:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB4:[0-9]+]], i64 -1, i32 0, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l69.region_id, ptr [[KERNEL_ARGS]]) -// CHECK2-NEXT: [[TMP42:%.*]] = icmp ne i32 [[TMP41]], 0 -// CHECK2-NEXT: br i1 [[TMP42]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] +// CHECK2-NEXT: [[TMP32:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_2]], align 4 +// CHECK2-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP32]], 1 +// CHECK2-NEXT: [[TMP33:%.*]] = zext i32 [[ADD]] to i64 +// CHECK2-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 +// CHECK2-NEXT: store i32 3, ptr [[TMP34]], align 4 +// CHECK2-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 +// CHECK2-NEXT: store i32 5, ptr [[TMP35]], align 4 +// CHECK2-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK2-NEXT: store ptr [[TMP27]], ptr [[TMP36]], align 4 +// CHECK2-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 +// CHECK2-NEXT: store ptr [[TMP28]], ptr [[TMP37]], align 4 +// CHECK2-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 +// CHECK2-NEXT: store ptr [[TMP29]], ptr [[TMP38]], align 4 +// CHECK2-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 +// CHECK2-NEXT: store ptr @.offload_maptypes, ptr [[TMP39]], align 4 +// CHECK2-NEXT: [[TMP40:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK2-NEXT: store ptr null, ptr [[TMP40]], align 4 +// CHECK2-NEXT: [[TMP41:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 +// CHECK2-NEXT: store ptr null, ptr [[TMP41]], align 4 +// CHECK2-NEXT: [[TMP42:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK2-NEXT: store i64 [[TMP33]], ptr [[TMP42]], align 8 +// CHECK2-NEXT: [[TMP43:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 +// CHECK2-NEXT: store i64 0, ptr [[TMP43]], align 8 +// CHECK2-NEXT: [[TMP44:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP44]], align 4 +// CHECK2-NEXT: [[TMP45:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 +// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP45]], align 4 +// CHECK2-NEXT: [[TMP46:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 +// CHECK2-NEXT: store i32 0, ptr [[TMP46]], align 4 +// CHECK2-NEXT: [[TMP47:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB4:[0-9]+]], i64 -1, i32 0, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l69.region_id, ptr [[KERNEL_ARGS]]) +// CHECK2-NEXT: [[TMP48:%.*]] = icmp ne i32 [[TMP47]], 0 +// CHECK2-NEXT: br i1 [[TMP48]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] // CHECK2: omp_offload.failed: // CHECK2-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l69(i32 [[TMP1]], ptr [[TMP2]], ptr [[TMP3]]) #[[ATTR2:[0-9]+]] // CHECK2-NEXT: br label [[OMP_OFFLOAD_CONT]] // CHECK2: omp_offload.cont: -// CHECK2-NEXT: [[TMP43:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 -// CHECK2-NEXT: store i32 [[TMP43]], ptr [[SIZE_CASTED4]], align 4 -// CHECK2-NEXT: [[TMP44:%.*]] = load i32, ptr [[SIZE_CASTED4]], align 4 -// CHECK2-NEXT: [[TMP45:%.*]] = load ptr, ptr [[OUTPUT_ADDR]], align 4 -// CHECK2-NEXT: [[TMP46:%.*]] = load ptr, ptr [[INPUT_ADDR]], align 4 -// CHECK2-NEXT: [[TMP47:%.*]] = load ptr, ptr [[OUTPUT_ADDR]], align 4 -// CHECK2-NEXT: [[TMP48:%.*]] = load ptr, ptr [[OUTPUT_ADDR]], align 4 -// CHECK2-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP48]], i32 0 -// CHECK2-NEXT: [[TMP49:%.*]] = load ptr, ptr [[INPUT_ADDR]], align 4 -// CHECK2-NEXT: [[TMP50:%.*]] = load ptr, ptr [[INPUT_ADDR]], align 4 -// CHECK2-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP50]], i32 0 -// CHECK2-NEXT: [[TMP51:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 -// CHECK2-NEXT: [[TMP52:%.*]] = mul nuw i32 [[TMP51]], 4 -// CHECK2-NEXT: [[TMP53:%.*]] = sext i32 [[TMP52]] to i64 -// CHECK2-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[DOTOFFLOAD_SIZES10]], ptr align 4 @.offload_sizes.1, i32 24, i1 false) -// CHECK2-NEXT: [[TMP54:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 0 -// CHECK2-NEXT: store i32 [[TMP44]], ptr [[TMP54]], align 4 -// CHECK2-NEXT: [[TMP55:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 0 -// CHECK2-NEXT: store i32 [[TMP44]], ptr [[TMP55]], align 4 -// CHECK2-NEXT: [[TMP56:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i32 0, i32 0 -// CHECK2-NEXT: store ptr null, ptr [[TMP56]], align 4 -// CHECK2-NEXT: [[TMP57:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 1 -// CHECK2-NEXT: store ptr [[TMP47]], ptr [[TMP57]], align 4 -// CHECK2-NEXT: [[TMP58:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 1 -// CHECK2-NEXT: store ptr [[ARRAYIDX5]], ptr [[TMP58]], align 4 -// CHECK2-NEXT: [[TMP59:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i32 0, i32 1 -// CHECK2-NEXT: store ptr null, ptr [[TMP59]], align 4 -// CHECK2-NEXT: [[TMP60:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 2 -// CHECK2-NEXT: store ptr [[TMP49]], ptr [[TMP60]], align 4 -// CHECK2-NEXT: [[TMP61:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 2 -// CHECK2-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP61]], align 4 -// CHECK2-NEXT: [[TMP62:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES10]], i32 0, i32 2 -// CHECK2-NEXT: store i64 [[TMP53]], ptr [[TMP62]], align 4 -// CHECK2-NEXT: [[TMP63:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i32 0, i32 2 -// CHECK2-NEXT: store ptr null, ptr [[TMP63]], align 4 -// CHECK2-NEXT: [[TMP64:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP65:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP66:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES10]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP67:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 -// CHECK2-NEXT: store i32 [[TMP67]], ptr [[DOTCAPTURE_EXPR_12]], align 4 -// CHECK2-NEXT: [[TMP68:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_12]], align 4 -// CHECK2-NEXT: [[SUB14:%.*]] = sub nsw i32 [[TMP68]], 0 +// CHECK2-NEXT: [[TMP49:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 +// CHECK2-NEXT: store i32 [[TMP49]], ptr [[SIZE_CASTED4]], align 4 +// CHECK2-NEXT: [[TMP50:%.*]] = load i32, ptr [[SIZE_CASTED4]], align 4 +// CHECK2-NEXT: [[TMP51:%.*]] = load ptr, ptr [[OUTPUT_ADDR]], align 4 +// CHECK2-NEXT: [[TMP52:%.*]] = load ptr, ptr [[INPUT_ADDR]], align 4 +// CHECK2-NEXT: [[TMP53:%.*]] = load ptr, ptr [[OUTPUT_ADDR]], align 4 +// CHECK2-NEXT: [[TMP54:%.*]] = load ptr, ptr [[OUTPUT_ADDR]], align 4 +// CHECK2-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP54]], i32 0 +// CHECK2-NEXT: [[TMP55:%.*]] = load ptr, ptr [[INPUT_ADDR]], align 4 +// CHECK2-NEXT: [[TMP56:%.*]] = load ptr, ptr [[INPUT_ADDR]], align 4 +// CHECK2-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP56]], i32 0 +// CHECK2-NEXT: [[TMP57:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 +// CHECK2-NEXT: [[TMP58:%.*]] = mul nuw i32 [[TMP57]], 4 +// CHECK2-NEXT: [[TMP59:%.*]] = sext i32 [[TMP58]] to i64 +// CHECK2-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[DOTOFFLOAD_SIZES10]], ptr align 4 @.offload_sizes.1, i32 40, i1 false) +// CHECK2-NEXT: [[TMP60:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 0 +// CHECK2-NEXT: store i32 [[TMP50]], ptr [[TMP60]], align 4 +// CHECK2-NEXT: [[TMP61:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 0 +// CHECK2-NEXT: store i32 [[TMP50]], ptr [[TMP61]], align 4 +// CHECK2-NEXT: [[TMP62:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i32 0, i32 0 +// CHECK2-NEXT: store ptr null, ptr [[TMP62]], align 4 +// CHECK2-NEXT: [[TMP63:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 1 +// CHECK2-NEXT: store ptr [[TMP53]], ptr [[TMP63]], align 4 +// CHECK2-NEXT: [[TMP64:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 1 +// CHECK2-NEXT: store ptr [[ARRAYIDX5]], ptr [[TMP64]], align 4 +// CHECK2-NEXT: [[TMP65:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i32 0, i32 1 +// CHECK2-NEXT: store ptr null, ptr [[TMP65]], align 4 +// CHECK2-NEXT: [[TMP66:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 2 +// CHECK2-NEXT: store ptr [[OUTPUT_ADDR]], ptr [[TMP66]], align 4 +// CHECK2-NEXT: [[TMP67:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 2 +// CHECK2-NEXT: store ptr [[ARRAYIDX5]], ptr [[TMP67]], align 4 +// CHECK2-NEXT: [[TMP68:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i32 0, i32 2 +// CHECK2-NEXT: store ptr null, ptr [[TMP68]], align 4 +// CHECK2-NEXT: [[TMP69:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 3 +// CHECK2-NEXT: store ptr [[TMP55]], ptr [[TMP69]], align 4 +// CHECK2-NEXT: [[TMP70:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 3 +// CHECK2-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP70]], align 4 +// CHECK2-NEXT: [[TMP71:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES10]], i32 0, i32 3 +// CHECK2-NEXT: store i64 [[TMP59]], ptr [[TMP71]], align 4 +// CHECK2-NEXT: [[TMP72:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i32 0, i32 3 +// CHECK2-NEXT: store ptr null, ptr [[TMP72]], align 4 +// CHECK2-NEXT: [[TMP73:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 4 +// CHECK2-NEXT: store ptr [[INPUT_ADDR]], ptr [[TMP73]], align 4 +// CHECK2-NEXT: [[TMP74:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 4 +// CHECK2-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP74]], align 4 +// CHECK2-NEXT: [[TMP75:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS9]], i32 0, i32 4 +// CHECK2-NEXT: store ptr null, ptr [[TMP75]], align 4 +// CHECK2-NEXT: [[TMP76:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS7]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP77:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS8]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP78:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES10]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP79:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 +// CHECK2-NEXT: store i32 [[TMP79]], ptr [[DOTCAPTURE_EXPR_12]], align 4 +// CHECK2-NEXT: [[TMP80:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_12]], align 4 +// CHECK2-NEXT: [[SUB14:%.*]] = sub nsw i32 [[TMP80]], 0 // CHECK2-NEXT: [[DIV15:%.*]] = sdiv i32 [[SUB14]], 1 // CHECK2-NEXT: [[SUB16:%.*]] = sub nsw i32 [[DIV15]], 1 // CHECK2-NEXT: store i32 [[SUB16]], ptr [[DOTCAPTURE_EXPR_13]], align 4 -// CHECK2-NEXT: [[TMP69:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_13]], align 4 -// CHECK2-NEXT: [[ADD17:%.*]] = add nsw i32 [[TMP69]], 1 -// CHECK2-NEXT: [[TMP70:%.*]] = zext i32 [[ADD17]] to i64 -// CHECK2-NEXT: [[TMP71:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 0 -// CHECK2-NEXT: store i32 3, ptr [[TMP71]], align 4 -// CHECK2-NEXT: [[TMP72:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 1 -// CHECK2-NEXT: store i32 3, ptr [[TMP72]], align 4 -// CHECK2-NEXT: [[TMP73:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 2 -// CHECK2-NEXT: store ptr [[TMP64]], ptr [[TMP73]], align 4 -// CHECK2-NEXT: [[TMP74:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 3 -// CHECK2-NEXT: store ptr [[TMP65]], ptr [[TMP74]], align 4 -// CHECK2-NEXT: [[TMP75:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 4 -// CHECK2-NEXT: store ptr [[TMP66]], ptr [[TMP75]], align 4 -// CHECK2-NEXT: [[TMP76:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 5 -// CHECK2-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP76]], align 4 -// CHECK2-NEXT: [[TMP77:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 6 -// CHECK2-NEXT: store ptr null, ptr [[TMP77]], align 4 -// CHECK2-NEXT: [[TMP78:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 7 -// CHECK2-NEXT: store ptr null, ptr [[TMP78]], align 4 -// CHECK2-NEXT: [[TMP79:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 8 -// CHECK2-NEXT: store i64 [[TMP70]], ptr [[TMP79]], align 8 -// CHECK2-NEXT: [[TMP80:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 9 -// CHECK2-NEXT: store i64 0, ptr [[TMP80]], align 8 -// CHECK2-NEXT: [[TMP81:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 10 -// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP81]], align 4 -// CHECK2-NEXT: [[TMP82:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 11 -// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP82]], align 4 -// CHECK2-NEXT: [[TMP83:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 12 -// CHECK2-NEXT: store i32 0, ptr [[TMP83]], align 4 -// CHECK2-NEXT: [[TMP84:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB4]], i64 -1, i32 0, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l73.region_id, ptr [[KERNEL_ARGS18]]) -// CHECK2-NEXT: [[TMP85:%.*]] = icmp ne i32 [[TMP84]], 0 -// CHECK2-NEXT: br i1 [[TMP85]], label [[OMP_OFFLOAD_FAILED19:%.*]], label [[OMP_OFFLOAD_CONT20:%.*]] +// CHECK2-NEXT: [[TMP81:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_13]], align 4 +// CHECK2-NEXT: [[ADD17:%.*]] = add nsw i32 [[TMP81]], 1 +// CHECK2-NEXT: [[TMP82:%.*]] = zext i32 [[ADD17]] to i64 +// CHECK2-NEXT: [[TMP83:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 0 +// CHECK2-NEXT: store i32 3, ptr [[TMP83]], align 4 +// CHECK2-NEXT: [[TMP84:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 1 +// CHECK2-NEXT: store i32 5, ptr [[TMP84]], align 4 +// CHECK2-NEXT: [[TMP85:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 2 +// CHECK2-NEXT: store ptr [[TMP76]], ptr [[TMP85]], align 4 +// CHECK2-NEXT: [[TMP86:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 3 +// CHECK2-NEXT: store ptr [[TMP77]], ptr [[TMP86]], align 4 +// CHECK2-NEXT: [[TMP87:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 4 +// CHECK2-NEXT: store ptr [[TMP78]], ptr [[TMP87]], align 4 +// CHECK2-NEXT: [[TMP88:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 5 +// CHECK2-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP88]], align 4 +// CHECK2-NEXT: [[TMP89:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 6 +// CHECK2-NEXT: store ptr null, ptr [[TMP89]], align 4 +// CHECK2-NEXT: [[TMP90:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 7 +// CHECK2-NEXT: store ptr null, ptr [[TMP90]], align 4 +// CHECK2-NEXT: [[TMP91:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 8 +// CHECK2-NEXT: store i64 [[TMP82]], ptr [[TMP91]], align 8 +// CHECK2-NEXT: [[TMP92:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 9 +// CHECK2-NEXT: store i64 0, ptr [[TMP92]], align 8 +// CHECK2-NEXT: [[TMP93:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 10 +// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP93]], align 4 +// CHECK2-NEXT: [[TMP94:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 11 +// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP94]], align 4 +// CHECK2-NEXT: [[TMP95:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS18]], i32 0, i32 12 +// CHECK2-NEXT: store i32 0, ptr [[TMP95]], align 4 +// CHECK2-NEXT: [[TMP96:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB4]], i64 -1, i32 0, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l73.region_id, ptr [[KERNEL_ARGS18]]) +// CHECK2-NEXT: [[TMP97:%.*]] = icmp ne i32 [[TMP96]], 0 +// CHECK2-NEXT: br i1 [[TMP97]], label [[OMP_OFFLOAD_FAILED19:%.*]], label [[OMP_OFFLOAD_CONT20:%.*]] // CHECK2: omp_offload.failed19: -// CHECK2-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l73(i32 [[TMP44]], ptr [[TMP45]], ptr [[TMP46]]) #[[ATTR2]] +// CHECK2-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l73(i32 [[TMP50]], ptr [[TMP51]], ptr [[TMP52]]) #[[ATTR2]] // CHECK2-NEXT: br label [[OMP_OFFLOAD_CONT20]] // CHECK2: omp_offload.cont20: -// CHECK2-NEXT: [[TMP86:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 -// CHECK2-NEXT: store i32 [[TMP86]], ptr [[SIZE_CASTED21]], align 4 -// CHECK2-NEXT: [[TMP87:%.*]] = load i32, ptr [[SIZE_CASTED21]], align 4 +// CHECK2-NEXT: [[TMP98:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 +// CHECK2-NEXT: store i32 [[TMP98]], ptr [[SIZE_CASTED21]], align 4 +// CHECK2-NEXT: [[TMP99:%.*]] = load i32, ptr [[SIZE_CASTED21]], align 4 // CHECK2-NEXT: [[ARRAYIDX22:%.*]] = getelementptr inbounds nuw [10 x i32], ptr [[A]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP88:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 -// CHECK2-NEXT: store i32 [[TMP87]], ptr [[TMP88]], align 4 -// CHECK2-NEXT: [[TMP89:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 -// CHECK2-NEXT: store i32 [[TMP87]], ptr [[TMP89]], align 4 -// CHECK2-NEXT: [[TMP90:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 0 -// CHECK2-NEXT: store ptr null, ptr [[TMP90]], align 4 -// CHECK2-NEXT: [[TMP91:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 1 -// CHECK2-NEXT: store ptr [[A]], ptr [[TMP91]], align 4 -// CHECK2-NEXT: [[TMP92:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 1 -// CHECK2-NEXT: store ptr [[ARRAYIDX22]], ptr [[TMP92]], align 4 -// CHECK2-NEXT: [[TMP93:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 1 -// CHECK2-NEXT: store ptr null, ptr [[TMP93]], align 4 -// CHECK2-NEXT: [[TMP94:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP95:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP96:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 0 -// CHECK2-NEXT: store i32 3, ptr [[TMP96]], align 4 -// CHECK2-NEXT: [[TMP97:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 1 -// CHECK2-NEXT: store i32 2, ptr [[TMP97]], align 4 -// CHECK2-NEXT: [[TMP98:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 2 -// CHECK2-NEXT: store ptr [[TMP94]], ptr [[TMP98]], align 4 -// CHECK2-NEXT: [[TMP99:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 3 -// CHECK2-NEXT: store ptr [[TMP95]], ptr [[TMP99]], align 4 -// CHECK2-NEXT: [[TMP100:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 4 -// CHECK2-NEXT: store ptr @.offload_sizes.3, ptr [[TMP100]], align 4 -// CHECK2-NEXT: [[TMP101:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 5 -// CHECK2-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP101]], align 4 -// CHECK2-NEXT: [[TMP102:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 6 +// CHECK2-NEXT: [[TMP100:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 +// CHECK2-NEXT: store i32 [[TMP99]], ptr [[TMP100]], align 4 +// CHECK2-NEXT: [[TMP101:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 +// CHECK2-NEXT: store i32 [[TMP99]], ptr [[TMP101]], align 4 +// CHECK2-NEXT: [[TMP102:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 0 // CHECK2-NEXT: store ptr null, ptr [[TMP102]], align 4 -// CHECK2-NEXT: [[TMP103:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 7 -// CHECK2-NEXT: store ptr null, ptr [[TMP103]], align 4 -// CHECK2-NEXT: [[TMP104:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 8 -// CHECK2-NEXT: store i64 0, ptr [[TMP104]], align 8 -// CHECK2-NEXT: [[TMP105:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 9 -// CHECK2-NEXT: store i64 0, ptr [[TMP105]], align 8 -// CHECK2-NEXT: [[TMP106:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 10 -// CHECK2-NEXT: store [3 x i32] [i32 1, i32 0, i32 0], ptr [[TMP106]], align 4 -// CHECK2-NEXT: [[TMP107:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 11 -// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP107]], align 4 -// CHECK2-NEXT: [[TMP108:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 12 -// CHECK2-NEXT: store i32 0, ptr [[TMP108]], align 4 -// CHECK2-NEXT: [[TMP109:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB4]], i64 -1, i32 1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l78.region_id, ptr [[KERNEL_ARGS26]]) -// CHECK2-NEXT: [[TMP110:%.*]] = icmp ne i32 [[TMP109]], 0 -// CHECK2-NEXT: br i1 [[TMP110]], label [[OMP_OFFLOAD_FAILED27:%.*]], label [[OMP_OFFLOAD_CONT28:%.*]] +// CHECK2-NEXT: [[TMP103:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 1 +// CHECK2-NEXT: store ptr [[A]], ptr [[TMP103]], align 4 +// CHECK2-NEXT: [[TMP104:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 1 +// CHECK2-NEXT: store ptr [[ARRAYIDX22]], ptr [[TMP104]], align 4 +// CHECK2-NEXT: [[TMP105:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 1 +// CHECK2-NEXT: store ptr null, ptr [[TMP105]], align 4 +// CHECK2-NEXT: [[TMP106:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP107:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP108:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 0 +// CHECK2-NEXT: store i32 3, ptr [[TMP108]], align 4 +// CHECK2-NEXT: [[TMP109:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 1 +// CHECK2-NEXT: store i32 2, ptr [[TMP109]], align 4 +// CHECK2-NEXT: [[TMP110:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 2 +// CHECK2-NEXT: store ptr [[TMP106]], ptr [[TMP110]], align 4 +// CHECK2-NEXT: [[TMP111:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 3 +// CHECK2-NEXT: store ptr [[TMP107]], ptr [[TMP111]], align 4 +// CHECK2-NEXT: [[TMP112:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 4 +// CHECK2-NEXT: store ptr @.offload_sizes.3, ptr [[TMP112]], align 4 +// CHECK2-NEXT: [[TMP113:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 5 +// CHECK2-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP113]], align 4 +// CHECK2-NEXT: [[TMP114:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 6 +// CHECK2-NEXT: store ptr null, ptr [[TMP114]], align 4 +// CHECK2-NEXT: [[TMP115:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 7 +// CHECK2-NEXT: store ptr null, ptr [[TMP115]], align 4 +// CHECK2-NEXT: [[TMP116:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 8 +// CHECK2-NEXT: store i64 0, ptr [[TMP116]], align 8 +// CHECK2-NEXT: [[TMP117:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 9 +// CHECK2-NEXT: store i64 0, ptr [[TMP117]], align 8 +// CHECK2-NEXT: [[TMP118:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 10 +// CHECK2-NEXT: store [3 x i32] [i32 1, i32 0, i32 0], ptr [[TMP118]], align 4 +// CHECK2-NEXT: [[TMP119:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 11 +// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP119]], align 4 +// CHECK2-NEXT: [[TMP120:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS26]], i32 0, i32 12 +// CHECK2-NEXT: store i32 0, ptr [[TMP120]], align 4 +// CHECK2-NEXT: [[TMP121:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB4]], i64 -1, i32 1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l78.region_id, ptr [[KERNEL_ARGS26]]) +// CHECK2-NEXT: [[TMP122:%.*]] = icmp ne i32 [[TMP121]], 0 +// CHECK2-NEXT: br i1 [[TMP122]], label [[OMP_OFFLOAD_FAILED27:%.*]], label [[OMP_OFFLOAD_CONT28:%.*]] // CHECK2: omp_offload.failed27: -// CHECK2-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l78(i32 [[TMP87]], ptr [[A]]) #[[ATTR2]] +// CHECK2-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l78(i32 [[TMP99]], ptr [[A]]) #[[ATTR2]] // CHECK2-NEXT: br label [[OMP_OFFLOAD_CONT28]] // CHECK2: omp_offload.cont28: -// CHECK2-NEXT: [[TMP111:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 -// CHECK2-NEXT: store i32 [[TMP111]], ptr [[SIZE_CASTED29]], align 4 -// CHECK2-NEXT: [[TMP112:%.*]] = load i32, ptr [[SIZE_CASTED29]], align 4 +// CHECK2-NEXT: [[TMP123:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 +// CHECK2-NEXT: store i32 [[TMP123]], ptr [[SIZE_CASTED29]], align 4 +// CHECK2-NEXT: [[TMP124:%.*]] = load i32, ptr [[SIZE_CASTED29]], align 4 // CHECK2-NEXT: [[ARRAYIDX30:%.*]] = getelementptr inbounds [10 x i32], ptr [[A]], i32 0, i32 3 -// CHECK2-NEXT: [[TMP113:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS31]], i32 0, i32 0 -// CHECK2-NEXT: store i32 [[TMP112]], ptr [[TMP113]], align 4 -// CHECK2-NEXT: [[TMP114:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS32]], i32 0, i32 0 -// CHECK2-NEXT: store i32 [[TMP112]], ptr [[TMP114]], align 4 -// CHECK2-NEXT: [[TMP115:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS33]], i32 0, i32 0 -// CHECK2-NEXT: store ptr null, ptr [[TMP115]], align 4 -// CHECK2-NEXT: [[TMP116:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS31]], i32 0, i32 1 -// CHECK2-NEXT: store ptr [[A]], ptr [[TMP116]], align 4 -// CHECK2-NEXT: [[TMP117:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS32]], i32 0, i32 1 -// CHECK2-NEXT: store ptr [[ARRAYIDX30]], ptr [[TMP117]], align 4 -// CHECK2-NEXT: [[TMP118:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS33]], i32 0, i32 1 -// CHECK2-NEXT: store ptr null, ptr [[TMP118]], align 4 -// CHECK2-NEXT: [[TMP119:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS31]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP120:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS32]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP121:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 0 -// CHECK2-NEXT: store i32 3, ptr [[TMP121]], align 4 -// CHECK2-NEXT: [[TMP122:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 1 -// CHECK2-NEXT: store i32 2, ptr [[TMP122]], align 4 -// CHECK2-NEXT: [[TMP123:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 2 -// CHECK2-NEXT: store ptr [[TMP119]], ptr [[TMP123]], align 4 -// CHECK2-NEXT: [[TMP124:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 3 -// CHECK2-NEXT: store ptr [[TMP120]], ptr [[TMP124]], align 4 -// CHECK2-NEXT: [[TMP125:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 4 -// CHECK2-NEXT: store ptr @.offload_sizes.5, ptr [[TMP125]], align 4 -// CHECK2-NEXT: [[TMP126:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 5 -// CHECK2-NEXT: store ptr @.offload_maptypes.6, ptr [[TMP126]], align 4 -// CHECK2-NEXT: [[TMP127:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 6 +// CHECK2-NEXT: [[TMP125:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS31]], i32 0, i32 0 +// CHECK2-NEXT: store i32 [[TMP124]], ptr [[TMP125]], align 4 +// CHECK2-NEXT: [[TMP126:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS32]], i32 0, i32 0 +// CHECK2-NEXT: store i32 [[TMP124]], ptr [[TMP126]], align 4 +// CHECK2-NEXT: [[TMP127:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS33]], i32 0, i32 0 // CHECK2-NEXT: store ptr null, ptr [[TMP127]], align 4 -// CHECK2-NEXT: [[TMP128:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 7 -// CHECK2-NEXT: store ptr null, ptr [[TMP128]], align 4 -// CHECK2-NEXT: [[TMP129:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 8 -// CHECK2-NEXT: store i64 0, ptr [[TMP129]], align 8 -// CHECK2-NEXT: [[TMP130:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 9 -// CHECK2-NEXT: store i64 0, ptr [[TMP130]], align 8 -// CHECK2-NEXT: [[TMP131:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 10 -// CHECK2-NEXT: store [3 x i32] [i32 1, i32 0, i32 0], ptr [[TMP131]], align 4 -// CHECK2-NEXT: [[TMP132:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 11 -// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP132]], align 4 -// CHECK2-NEXT: [[TMP133:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 12 -// CHECK2-NEXT: store i32 0, ptr [[TMP133]], align 4 -// CHECK2-NEXT: [[TMP134:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB4]], i64 -1, i32 1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l81.region_id, ptr [[KERNEL_ARGS34]]) -// CHECK2-NEXT: [[TMP135:%.*]] = icmp ne i32 [[TMP134]], 0 -// CHECK2-NEXT: br i1 [[TMP135]], label [[OMP_OFFLOAD_FAILED35:%.*]], label [[OMP_OFFLOAD_CONT36:%.*]] +// CHECK2-NEXT: [[TMP128:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS31]], i32 0, i32 1 +// CHECK2-NEXT: store ptr [[A]], ptr [[TMP128]], align 4 +// CHECK2-NEXT: [[TMP129:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS32]], i32 0, i32 1 +// CHECK2-NEXT: store ptr [[ARRAYIDX30]], ptr [[TMP129]], align 4 +// CHECK2-NEXT: [[TMP130:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS33]], i32 0, i32 1 +// CHECK2-NEXT: store ptr null, ptr [[TMP130]], align 4 +// CHECK2-NEXT: [[TMP131:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS31]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP132:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS32]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP133:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 0 +// CHECK2-NEXT: store i32 3, ptr [[TMP133]], align 4 +// CHECK2-NEXT: [[TMP134:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 1 +// CHECK2-NEXT: store i32 2, ptr [[TMP134]], align 4 +// CHECK2-NEXT: [[TMP135:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 2 +// CHECK2-NEXT: store ptr [[TMP131]], ptr [[TMP135]], align 4 +// CHECK2-NEXT: [[TMP136:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 3 +// CHECK2-NEXT: store ptr [[TMP132]], ptr [[TMP136]], align 4 +// CHECK2-NEXT: [[TMP137:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 4 +// CHECK2-NEXT: store ptr @.offload_sizes.5, ptr [[TMP137]], align 4 +// CHECK2-NEXT: [[TMP138:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 5 +// CHECK2-NEXT: store ptr @.offload_maptypes.6, ptr [[TMP138]], align 4 +// CHECK2-NEXT: [[TMP139:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 6 +// CHECK2-NEXT: store ptr null, ptr [[TMP139]], align 4 +// CHECK2-NEXT: [[TMP140:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 7 +// CHECK2-NEXT: store ptr null, ptr [[TMP140]], align 4 +// CHECK2-NEXT: [[TMP141:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 8 +// CHECK2-NEXT: store i64 0, ptr [[TMP141]], align 8 +// CHECK2-NEXT: [[TMP142:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 9 +// CHECK2-NEXT: store i64 0, ptr [[TMP142]], align 8 +// CHECK2-NEXT: [[TMP143:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 10 +// CHECK2-NEXT: store [3 x i32] [i32 1, i32 0, i32 0], ptr [[TMP143]], align 4 +// CHECK2-NEXT: [[TMP144:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 11 +// CHECK2-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP144]], align 4 +// CHECK2-NEXT: [[TMP145:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS34]], i32 0, i32 12 +// CHECK2-NEXT: store i32 0, ptr [[TMP145]], align 4 +// CHECK2-NEXT: [[TMP146:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB4]], i64 -1, i32 1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l81.region_id, ptr [[KERNEL_ARGS34]]) +// CHECK2-NEXT: [[TMP147:%.*]] = icmp ne i32 [[TMP146]], 0 +// CHECK2-NEXT: br i1 [[TMP147]], label [[OMP_OFFLOAD_FAILED35:%.*]], label [[OMP_OFFLOAD_CONT36:%.*]] // CHECK2: omp_offload.failed35: -// CHECK2-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l81(i32 [[TMP112]], ptr [[A]]) #[[ATTR2]] +// CHECK2-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3sumPiiS__l81(i32 [[TMP124]], ptr [[A]]) #[[ATTR2]] // CHECK2-NEXT: br label [[OMP_OFFLOAD_CONT36]] // CHECK2: omp_offload.cont36: // CHECK2-NEXT: ret void @@ -1855,7 +1894,7 @@ int main() // CHECK2-NEXT: [[SIZE_CASTED:%.*]] = alloca i32, align 4 // CHECK2-NEXT: store i32 [[SIZE]], ptr [[SIZE_ADDR]], align 4 // CHECK2-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 -// CHECK2-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 4 +// CHECK2-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 4, !nonnull [[META14:![0-9]+]], !align [[META15:![0-9]+]] // CHECK2-NEXT: [[TMP1:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 // CHECK2-NEXT: store i32 [[TMP1]], ptr [[SIZE_CASTED]], align 4 // CHECK2-NEXT: [[TMP2:%.*]] = load i32, ptr [[SIZE_CASTED]], align 4 @@ -1877,7 +1916,7 @@ int main() // CHECK2-NEXT: store ptr [[DOTBOUND_TID_]], ptr [[DOTBOUND_TID__ADDR]], align 4 // CHECK2-NEXT: store i32 [[SIZE]], ptr [[SIZE_ADDR]], align 4 // CHECK2-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 -// CHECK2-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 4 +// CHECK2-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 4, !nonnull [[META14]], !align [[META15]] // CHECK2-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw [10 x i32], ptr [[TMP0]], i32 0, i32 0 // CHECK2-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds nuw [10 x i32], ptr [[TMP0]], i32 0, i32 1 // CHECK2-NEXT: [[ARRAY_BEGIN:%.*]] = getelementptr inbounds [2 x i32], ptr [[A2]], i32 0, i32 0 @@ -1909,7 +1948,7 @@ int main() // CHECK2-NEXT: [[TMP9:%.*]] = load i32, ptr [[I]], align 4 // CHECK2-NEXT: [[INC:%.*]] = add nsw i32 [[TMP9]], 1 // CHECK2-NEXT: store i32 [[INC]], ptr [[I]], align 4 -// CHECK2-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP10:![0-9]+]] +// CHECK2-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP16:![0-9]+]] // CHECK2: for.end: // CHECK2-NEXT: [[TMP10:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOMP_REDUCTION_RED_LIST]], i32 0, i32 0 // CHECK2-NEXT: store ptr [[A2]], ptr [[TMP10]], align 4 @@ -1996,7 +2035,7 @@ int main() // CHECK2-NEXT: [[SIZE_CASTED:%.*]] = alloca i32, align 4 // CHECK2-NEXT: store i32 [[SIZE]], ptr [[SIZE_ADDR]], align 4 // CHECK2-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 -// CHECK2-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 4 +// CHECK2-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 4, !nonnull [[META14]], !align [[META15]] // CHECK2-NEXT: [[TMP1:%.*]] = load i32, ptr [[SIZE_ADDR]], align 4 // CHECK2-NEXT: store i32 [[TMP1]], ptr [[SIZE_CASTED]], align 4 // CHECK2-NEXT: [[TMP2:%.*]] = load i32, ptr [[SIZE_CASTED]], align 4 @@ -2018,7 +2057,7 @@ int main() // CHECK2-NEXT: store ptr [[DOTBOUND_TID_]], ptr [[DOTBOUND_TID__ADDR]], align 4 // CHECK2-NEXT: store i32 [[SIZE]], ptr [[SIZE_ADDR]], align 4 // CHECK2-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 -// CHECK2-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 4 +// CHECK2-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 4, !nonnull [[META14]], !align [[META15]] // CHECK2-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i32], ptr [[TMP0]], i32 0, i32 3 // CHECK2-NEXT: store i32 0, ptr [[A1]], align 4 // CHECK2-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[TMP0]] to i64 @@ -2039,7 +2078,7 @@ int main() // CHECK2-NEXT: [[TMP8:%.*]] = load i32, ptr [[I]], align 4 // CHECK2-NEXT: [[INC:%.*]] = add nsw i32 [[TMP8]], 1 // CHECK2-NEXT: store i32 [[INC]], ptr [[I]], align 4 -// CHECK2-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP12:![0-9]+]] +// CHECK2-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP18:![0-9]+]] // CHECK2: for.end: // CHECK2-NEXT: [[TMP9:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOMP_REDUCTION_RED_LIST]], i32 0, i32 0 // CHECK2-NEXT: store ptr [[A1]], ptr [[TMP9]], align 4 diff --git a/clang/test/OpenMP/target_data_codegen.cpp b/clang/test/OpenMP/target_data_codegen.cpp index 926aa593f2ba1..01c555b999c28 100644 --- a/clang/test/OpenMP/target_data_codegen.cpp +++ b/clang/test/OpenMP/target_data_codegen.cpp @@ -37,8 +37,8 @@ double gc[100]; // CK1: [[MTYPE03:@.+]] = {{.+}}constant [1 x i64] [i64 5] -// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] +// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 24, i64 {{4|8}}] +// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 1, i64 [[#0x4000]]] // CK1: [[MTYPE05:@.+]] = {{.+}}constant [1 x i64] [i64 1025] @@ -132,32 +132,32 @@ void foo(int arg) { {++arg;} // Region 04 - // CK1-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%[^,]+]], ptr [[MTYPE04]], ptr null, ptr null) + // + // &gb.b[0], &gb.b[/*lb=*/0], 3 * sizeof(gb.b[0]), TO + // &gb.b, &gb.b[/*lb=*/0], sizeof(gb.b), ATTACH + // + // CK1-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE04]], ptr [[MTYPE04]], ptr null, ptr null) // CK1-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK1-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK1-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PSZ:%[^,]+]] // CK1-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK1-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK1-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PSZ]], i{{.+}} 0, i{{.+}} 0 - // CK1-DAG: store ptr @gb, ptr [[BP0]] - // CK1-DAG: store ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), ptr [[P0]] - // CK1-DAG: [[DIV:%.+]] = sdiv exact i64 sub (i64 ptrtoint (ptr getelementptr (ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), i32 1) to i64), i64 ptrtoint (ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) to i64)), ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) - // CK1-DAG: store i64 [[DIV]], ptr [[PS0]], + // CK1-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK1-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK1-DAG: [[VAR0]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1) + // CK1-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:.+]], i{{.+}} 0 + // CK1-DAG: [[SEC00]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1) // CK1-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK1-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 // CK1-DAG: store ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), ptr [[BP1]] - // CK1-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] - // CK1-DAG: [[SEC1]] = getelementptr inbounds {{.+}}ptr [[SEC11:%[^,]+]], i{{.+}} 0 - // CK1-DAG: [[SEC11]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), + // CK1-DAG: store ptr [[SEC0]], ptr [[P1]] // CK1: %{{.+}} = add nsw i32 %{{[^,]+}}, 1 - // CK1-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%[^,]+]], ptr [[MTYPE04]], ptr null, ptr null) + // CK1-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE04]], ptr [[MTYPE04]], ptr null, ptr null) // CK1-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP]] // CK1-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P]] - // CK1-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PSZ]] #pragma omp target data map(to: gb.b[:3]) {++arg;} @@ -342,8 +342,8 @@ struct ST { } }; -// CK2: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK2: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710677] +// CK2: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 24, i64 {{4|8}}] +// CK2: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 5, i64 [[#0x4000]]] // CK2-LABEL: _Z3bari int bar(int arg){ @@ -352,30 +352,32 @@ int bar(int arg){ } // Region 00 +// +// &b[0], &b[1], 3 * sizeof(b[0]), ALWAYS | TO +// &b, &b[1], sizeof(b), ATTACH +// // CK2-DAG: [[DEV:%[^,]+]] = sext i32 [[DEVi32:%[^,]+]] to i64 // CK2-DAG: [[DEVi32]] = load i32, ptr %{{[^,]+}}, // CK2: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK2: [[IFTHEN]] -// CK2-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 [[DEV]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%[^,]+]], ptr [[MTYPE00]], ptr null, ptr null) +// CK2-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 [[DEV]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]], ptr null, ptr null) // CK2-DAG: [[GEPBP]] = getelementptr inbounds [2 x ptr], ptr [[BP:%[^,]+]] // CK2-DAG: [[GEPP]] = getelementptr inbounds [2 x ptr], ptr [[P:%[^,]+]] -// CK2-DAG: [[GEPS]] = getelementptr inbounds [2 x i64], ptr [[PS:%[^,]+]] // CK2-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK2-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK2-DAG: [[PS0:%.+]] = getelementptr inbounds [2 x i64], ptr [[PS]], i{{.+}} 0, i{{.+}} 0 // CK2-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] // CK2-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK2-DAG: store i64 {{%.+}}, ptr [[PS0]], -// CK2-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK2-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%[^,]+]] +// CK2-DAG: [[VAR00]] = getelementptr inbounds nuw [[ST]], ptr [[THIS:%this.*]], i32 0, i32 1 +// CK2-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[SEC00:%[^,]+]], i{{.+}} 1 +// CK2-DAG: [[SEC00]] = load ptr, ptr [[SEC000:%[^,]+]], +// CK2-DAG: [[SEC000]] = getelementptr inbounds {{.*}}ptr [[THIS]], i32 0, i32 1 // CK2-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK2-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK2-DAG: store ptr [[SEC0]], ptr [[BP1]] -// CK2-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] -// CK2-DAG: [[SEC1]] = getelementptr inbounds {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 1 -// CK2-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK2-DAG: [[SEC111]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK2-DAG: store ptr [[VAR00]], ptr [[BP1]] +// CK2-DAG: store ptr [[SEC0]], ptr [[P1]] // CK2: br label %[[IFEND:[^,]+]] @@ -386,10 +388,9 @@ int bar(int arg){ // CK2: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK2: [[IFTHEN]] -// CK2-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 [[DEV]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%[^,]+]], ptr [[MTYPE00]], ptr null, ptr null) +// CK2-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 [[DEV]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]], ptr null, ptr null) // CK2-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP]] // CK2-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P]] -// CK2-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS]] // CK2: br label %[[IFEND:[^,]+]] // CK2: [[IFELSE]] // CK2: br label %[[IFEND]] @@ -453,8 +454,8 @@ struct STT { } }; -// CK4: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK4: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976711701] +// CK4: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 24, i64 {{4|8}}] +// CK4: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 [[#0x405]], i64 [[#0x4000]]] // CK4-LABEL: _Z3bari int bar(int arg){ @@ -463,30 +464,32 @@ int bar(int arg){ } // Region 00 +// +// &b[0], &b[1], 3 * sizeof(b[0]), CLOSE | ALWAYS | TO +// &b, &b[1], sizeof(b), ATTACH +// // CK4-DAG: [[DEV:%[^,]+]] = sext i32 [[DEVi32:%[^,]+]] to i64 // CK4-DAG: [[DEVi32]] = load i32, ptr %{{[^,]+}}, // CK4: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK4: [[IFTHEN]] -// CK4-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 [[DEV]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE00]], ptr null, ptr null) +// CK4-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 [[DEV]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]], ptr null, ptr null) // CK4-DAG: [[GEPBP]] = getelementptr inbounds [2 x ptr], ptr [[BP:%[^,]+]] // CK4-DAG: [[GEPP]] = getelementptr inbounds [2 x ptr], ptr [[P:%[^,]+]] -// CK4-DAG: [[GEPS]] = getelementptr inbounds [2 x i64], ptr [[PS:%[^,]+]] // CK4-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK4-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK4-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 // CK4-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] // CK4-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK4-DAG: store i64 {{%.+}}, ptr [[PS0]], -// CK4-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK4-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%[^,]*]] +// CK4-DAG: [[VAR00]] = getelementptr inbounds {{.*}}, ptr [[THIS:%this.*]], i32 0, i32 1 +// CK4-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:%[^,]+]], i{{.+}} 1 +// CK4-DAG: [[SEC00]] = load ptr, ptr [[SEC000:%[^,]+]], +// CK4-DAG: [[SEC000]] = getelementptr inbounds {{.*}}, ptr [[THIS]], i32 0, i32 1 // CK4-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK4-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK4-DAG: store ptr [[SEC0]], ptr [[BP1]] -// CK4-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] -// CK4-DAG: [[SEC1]] = getelementptr inbounds {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 1 -// CK4-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK4-DAG: [[SEC111]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK4-DAG: store ptr [[VAR00]], ptr [[BP1]] +// CK4-DAG: store ptr [[SEC0]], ptr [[P1]] // CK4: br label %[[IFEND:[^,]+]] @@ -497,10 +500,9 @@ int bar(int arg){ // CK4: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK4: [[IFTHEN]] -// CK4-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 [[DEV]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE00]], ptr null, ptr null) +// CK4-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 [[DEV]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]], ptr null, ptr null) // CK4-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP]] // CK4-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P]] -// CK4-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS]] // CK4: br label %[[IFEND:[^,]+]] // CK4: [[IFELSE]] // CK4: br label %[[IFEND]] @@ -532,7 +534,12 @@ struct S2 { void test_close_modifier(int arg) { S2 *ps; -// CK5: private unnamed_addr constant [5 x i64] [i64 1027, i64 0, i64 562949953421328, i64 16, i64 1043] +// CK5: private unnamed_addr constant [3 x i64] [i64 1027, i64 1027, i64 16384] +// +// &arg, &arg, sizeof(arg), CLOSE | TOFROM +// &ps->ps->ps->ps[0], &ps->ps->ps->ps[0].s, sizeof(ps->ps->ps->ps[0].s), CLOSE | TOFROM +// &ps->ps->ps->ps, &ps->ps->ps->ps[0].s, sizeof(struct S2 *), ATTACH +// #pragma omp target data map(close, tofrom \ : arg, ps->ps->ps->ps->s) { @@ -623,40 +630,42 @@ void test_present_modifier(int arg) { S2 *ps1; S2 *ps2; - // Make sure the struct picks up present even if another element of the struct - // doesn't have present. - // CK8: private unnamed_addr constant [11 x i64] [i64 0, i64 {{4|8}}, i64 {{4|8}}, i64 4, i64 4, i64 4, i64 0, i64 4, i64 {{4|8}}, i64 {{4|8}}, i64 4] - // CK8: private unnamed_addr constant [11 x i64] - +// Make sure the struct picks up present even if another element of the struct +// doesn't have present. +// CK8: private unnamed_addr constant [9 x i64] [i64 4, i64 {{4|8}}, i64 4, i64 {{4|8}}, i64 4, i64 4, i64 {{4|8}}, i64 4, i64 {{4|8}}] +// CK8: private unnamed_addr constant [9 x i64] // ps1 // -// PRESENT=0x1000 = 0x1000 -// MEMBER_OF_1=0x1000000000000 | PRESENT=0x1000 | PTR_AND_OBJ=0x10 = 0x1000000001010 -// PRESENT=0x1000 | PTR_AND_OBJ=0x10 = 0x1010 -// PRESENT=0x1000 | PTR_AND_OBJ=0x10 | FROM=0x2 | TO=0x1 = 0x1013 -// MEMBER_OF_1=0x1000000000000 | FROM=0x2 | TO=0x1 = 0x1000000000003 +// &ps1[0], &ps1->s, sizeof(ps1->s), FROM | TO +// &ps1, &ps1->s, sizeof(ps1), ATTACH +// +// CK8-SAME: {{^}} [i64 3, i64 [[#0x4000]], // -// CK8-SAME: {{^}} [i64 [[#0x1000]], i64 [[#0x1000000001010]], -// CK8-SAME: {{^}} i64 [[#0x1010]], i64 [[#0x1013]], i64 [[#0x1000000000003]], +// &ps1->ps->ps->ps[0], &ps1->ps->ps->ps[0].s, sizeof(ps1->ps->ps->ps[0].s), PRESENT | FROM | TO +// &ps1->ps->ps->ps, &ps1->ps->ps->ps[0].s, sizeof(struct S2 *), ATTACH +// +// CK8-SAME: {{^}} i64 [[#0x1003]], i64 [[#0x4000]], // arg // -// PRESENT=0x1000 | FROM=0x2 | TO=0x1 = 0x1003 +// &arg, &arg, sizeof(arg), PRESENT | FROM | TO // // CK8-SAME: {{^}} i64 [[#0x1003]], // ps2 // -// PRESENT=0x1000 = 0x1000 -// MEMBER_OF_7=0x7000000000000 | PRESENT=0x1000 | FROM=0x2 | TO=0x1 = 0x7000000001003 -// MEMBER_OF_7=0x7000000000000 | PTR_AND_OBJ=0x10 = 0x7000000000010 -// PTR_AND_OBJ=0x10 = 0x10 -// PTR_AND_OBJ=0x10 | FROM=0x2 | TO=0x1 = 0x13 +// &ps2[0], &ps2->s, sizeof(ps2->s), PRESENT | FROM | TO +// &ps2, &ps2->s, sizeof(ps2), ATTACH // -// CK8-SAME: {{^}} i64 [[#0x1000]], i64 [[#0x7000000001003]], -// CK8-SAME: {{^}} i64 [[#0x7000000000010]], i64 [[#0x10]], i64 [[#0x13]]] +// CK8-SAME: {{^}} i64 [[#0x1003]], i64 [[#0x4000]], +// +// &ps2->ps->ps->ps[0], &ps2->ps->ps->ps[0].s, sizeof(ps2->ps->ps->ps[0].s), FROM | TO +// &ps2->ps->ps->ps, &ps2->ps->ps->ps[0].s, sizeof(struct S2 *), ATTACH +// +// CK8-SAME: {{^}} i64 3, i64 [[#0x4000]]] + #pragma omp target data map(tofrom \ - : ps1->s) \ + : ps1->s) \ map(present, tofrom \ : arg, ps1->ps->ps->ps->s, ps2->s) \ map(tofrom \ diff --git a/clang/test/OpenMP/target_data_if_logical_codegen.cpp b/clang/test/OpenMP/target_data_if_logical_codegen.cpp index 85d98b0c3bcd4..ce1b5fd4bf87f 100644 --- a/clang/test/OpenMP/target_data_if_logical_codegen.cpp +++ b/clang/test/OpenMP/target_data_if_logical_codegen.cpp @@ -1,5 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --version 3 -// REQUIRES: amdgpu-registered-target +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" --global-hex-value-regex ".offload_maptypes.*" --version 3 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fopenmp-targets=amdgcn-amd-amdhsa -emit-llvm %s -o - \ // RUN: | FileCheck %s @@ -34,6 +33,13 @@ int main() { } #endif +// &p[0], &p[0], sizeof(p0]), TO +// &p, &p[0], sizeof(void*), ATTACH + +//. +// CHECK: @.offload_sizes = private unnamed_addr constant [2 x i64] [i64 4, i64 8] +// CHECK: @.offload_maptypes = private unnamed_addr constant [2 x i64] [i64 [[#0x1]], i64 [[#0x4000]]] +//. // CHECK-LABEL: define dso_local noundef i32 @_Z10if_logicalv( // CHECK-SAME: ) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: entry: @@ -42,63 +48,69 @@ int main() { // CHECK-NEXT: [[B:%.*]] = alloca i8, align 1 // CHECK-NEXT: [[PP:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[P:%.*]] = alloca ptr, align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [1 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [1 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [1 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [2 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [2 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [2 x ptr], align 8 // CHECK-NEXT: [[CALL:%.*]] = call noundef zeroext i1 @_Z3foob(i1 noundef zeroext true) -// CHECK-NEXT: [[FROMBOOL:%.*]] = zext i1 [[CALL]] to i8 -// CHECK-NEXT: store i8 [[FROMBOOL]], ptr [[A]], align 1 +// CHECK-NEXT: [[STOREDV:%.*]] = zext i1 [[CALL]] to i8 +// CHECK-NEXT: store i8 [[STOREDV]], ptr [[A]], align 1 // CHECK-NEXT: [[CALL1:%.*]] = call noundef zeroext i1 @_Z3foob(i1 noundef zeroext true) -// CHECK-NEXT: [[FROMBOOL2:%.*]] = zext i1 [[CALL1]] to i8 -// CHECK-NEXT: store i8 [[FROMBOOL2]], ptr [[B]], align 1 +// CHECK-NEXT: [[STOREDV2:%.*]] = zext i1 [[CALL1]] to i8 +// CHECK-NEXT: store i8 [[STOREDV2]], ptr [[B]], align 1 // CHECK-NEXT: store i32 42, ptr [[PP]], align 4 // CHECK-NEXT: store ptr [[PP]], ptr [[P]], align 8 // CHECK-NEXT: [[TMP0:%.*]] = load i8, ptr [[A]], align 1 -// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1 -// CHECK-NEXT: br i1 [[TOBOOL]], label [[LAND_RHS:%.*]], label [[LAND_END:%.*]] +// CHECK-NEXT: [[LOADEDV:%.*]] = trunc i8 [[TMP0]] to i1 +// CHECK-NEXT: br i1 [[LOADEDV]], label [[LAND_RHS:%.*]], label [[LAND_END:%.*]] // CHECK: land.rhs: // CHECK-NEXT: [[TMP1:%.*]] = load i8, ptr [[B]], align 1 -// CHECK-NEXT: [[TOBOOL3:%.*]] = trunc i8 [[TMP1]] to i1 +// CHECK-NEXT: [[LOADEDV3:%.*]] = trunc i8 [[TMP1]] to i1 // CHECK-NEXT: br label [[LAND_END]] // CHECK: land.end: -// CHECK-NEXT: [[TMP2:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[TOBOOL3]], [[LAND_RHS]] ] +// CHECK-NEXT: [[TMP2:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[LOADEDV3]], [[LAND_RHS]] ] // CHECK-NEXT: br i1 [[TMP2]], label [[OMP_IF_THEN:%.*]], label [[OMP_IF_ELSE:%.*]] // CHECK: omp_if.then: // CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[P]], align 8 // CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[P]], align 8 // CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP4]], i64 0 -// CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 // CHECK-NEXT: store ptr [[TMP3]], ptr [[TMP5]], align 8 -// CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 // CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 -// CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 // CHECK-NEXT: store ptr null, ptr [[TMP7]], align 8 -// CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 1, ptr [[TMP8]], ptr [[TMP9]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[P]], ptr [[TMP8]], align 8 +// CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP10]], align 8 +// CHECK-NEXT: [[TMP11:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 2, ptr [[TMP11]], ptr [[TMP12]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) // CHECK-NEXT: br label [[OMP_IF_END:%.*]] // CHECK: omp_if.else: // CHECK-NEXT: br label [[OMP_IF_END]] // CHECK: omp_if.end: -// CHECK-NEXT: [[TMP10:%.*]] = load ptr, ptr [[P]], align 8 -// CHECK-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds i32, ptr [[TMP10]], i64 0 -// CHECK-NEXT: [[TMP11:%.*]] = load i32, ptr [[ARRAYIDX4]], align 4 -// CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP11]], 1 +// CHECK-NEXT: [[TMP13:%.*]] = load ptr, ptr [[P]], align 8 +// CHECK-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds i32, ptr [[TMP13]], i64 0 +// CHECK-NEXT: [[TMP14:%.*]] = load i32, ptr [[ARRAYIDX4]], align 4 +// CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP14]], 1 // CHECK-NEXT: store i32 [[INC]], ptr [[ARRAYIDX4]], align 4 // CHECK-NEXT: br i1 [[TMP2]], label [[OMP_IF_THEN5:%.*]], label [[OMP_IF_ELSE6:%.*]] // CHECK: omp_if.then5: -// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP12]], ptr [[TMP13]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 2, ptr [[TMP15]], ptr [[TMP16]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) // CHECK-NEXT: br label [[OMP_IF_END7:%.*]] // CHECK: omp_if.else6: // CHECK-NEXT: br label [[OMP_IF_END7]] // CHECK: omp_if.end7: -// CHECK-NEXT: [[TMP14:%.*]] = load ptr, ptr [[P]], align 8 -// CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds i32, ptr [[TMP14]], i64 0 -// CHECK-NEXT: [[TMP15:%.*]] = load i32, ptr [[ARRAYIDX8]], align 4 -// CHECK-NEXT: [[TOBOOL9:%.*]] = icmp ne i32 [[TMP15]], 0 -// CHECK-NEXT: br i1 [[TOBOOL9]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] +// CHECK-NEXT: [[TMP17:%.*]] = load ptr, ptr [[P]], align 8 +// CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds i32, ptr [[TMP17]], i64 0 +// CHECK-NEXT: [[TMP18:%.*]] = load i32, ptr [[ARRAYIDX8]], align 4 +// CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[TMP18]], 0 +// CHECK-NEXT: br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] // CHECK: if.then: // CHECK-NEXT: store i32 1, ptr [[RETVAL]], align 4 // CHECK-NEXT: br label [[RETURN:%.*]] @@ -106,8 +118,8 @@ int main() { // CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4 // CHECK-NEXT: br label [[RETURN]] // CHECK: return: -// CHECK-NEXT: [[TMP16:%.*]] = load i32, ptr [[RETVAL]], align 4 -// CHECK-NEXT: ret i32 [[TMP16]] +// CHECK-NEXT: [[TMP19:%.*]] = load i32, ptr [[RETVAL]], align 4 +// CHECK-NEXT: ret i32 [[TMP19]] // // // CHECK-LABEL: define dso_local noundef i32 @main( diff --git a/clang/test/OpenMP/target_data_map_codegen_hold.cpp b/clang/test/OpenMP/target_data_map_codegen_hold.cpp index 3b115acaa2afb..38fcf57e1473e 100644 --- a/clang/test/OpenMP/target_data_map_codegen_hold.cpp +++ b/clang/test/OpenMP/target_data_map_codegen_hold.cpp @@ -49,8 +49,9 @@ struct S2 { // PTR_AND_OBJ = 0x10 // CLOSE = 0x400 // OMPX_HOLD = 0x2000 +// ATTACH = 0x4000 // MEMBER_OF_1 = 0x1000000000000 -// MEMBER_OF_7 = 0x7000000000000 +// MEMBER_OF_8 = 0x8000000000000 //. // CHECK-PPC64LE: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 20] @@ -59,8 +60,8 @@ struct S2 { // CHECK-PPC64LE: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x2405]]] // CHECK-PPC64LE: @.offload_sizes.3 = private unnamed_addr constant [1 x i64] [i64 4] // CHECK-PPC64LE: @.offload_maptypes.4 = private unnamed_addr constant [1 x i64] [i64 [[#0x2003]]] -// CHECK-PPC64LE: @.offload_sizes.5 = private unnamed_addr constant [11 x i64] [i64 0, i64 4, i64 8, i64 8, i64 4, i64 4, i64 0, i64 4, i64 8, i64 8, i64 4] -// CHECK-PPC64LE: @.offload_maptypes.6 = private unnamed_addr constant [11 x i64] [i64 [[#0x2000]], i64 [[#0x1000000002003]], i64 [[#0x1000000002010]], i64 [[#0x2010]], i64 [[#0x2013]], i64 [[#0x3]], i64 [[#0x2000]], i64 [[#0x7000000002003]], i64 [[#0x7000000002010]], i64 [[#0x2010]], i64 [[#0x2013]]] +// CHECK-PPC64LE: @.offload_sizes.5 = private unnamed_addr constant [9 x i64] [i64 4, i64 8, i64 4, i64 8, i64 4, i64 4, i64 8, i64 4, i64 8] +// CHECK-PPC64LE: @.offload_maptypes.6 = private unnamed_addr constant [9 x i64] [i64 [[#0x3]], i64 [[#0x4000]], i64 [[#0x2003]], i64 [[#0x4000]], i64 [[#0x3]], i64 [[#0x2003]], i64 [[#0x4000]], i64 [[#0x3]], i64 [[#0x4000]]] //. // CHECK-I386: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 20] // CHECK-I386: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x2001]]] @@ -68,8 +69,8 @@ struct S2 { // CHECK-I386: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x2405]]] // CHECK-I386: @.offload_sizes.3 = private unnamed_addr constant [1 x i64] [i64 4] // CHECK-I386: @.offload_maptypes.4 = private unnamed_addr constant [1 x i64] [i64 [[#0x2003]]] -// CHECK-I386: @.offload_sizes.5 = private unnamed_addr constant [11 x i64] [i64 0, i64 4, i64 4, i64 4, i64 4, i64 4, i64 0, i64 4, i64 4, i64 4, i64 4] -// CHECK-I386: @.offload_maptypes.6 = private unnamed_addr constant [11 x i64] [i64 [[#0x2000]], i64 [[#0x1000000002003]], i64 [[#0x1000000002010]], i64 [[#0x2010]], i64 [[#0x2013]], i64 [[#0x3]], i64 [[#0x2000]], i64 [[#0x7000000002003]], i64 [[#0x7000000002010]], i64 [[#0x2010]], i64 [[#0x2013]]] +// CHECK-I386: @.offload_sizes.5 = private unnamed_addr constant [9 x i64] [i64 4, i64 4, i64 4, i64 4, i64 4, i64 4, i64 4, i64 4, i64 4] +// CHECK-I386: @.offload_maptypes.6 = private unnamed_addr constant [9 x i64] [i64 [[#0x3]], i64 [[#0x4000]], i64 [[#0x2003]], i64 [[#0x4000]], i64 [[#0x3]], i64 [[#0x2003]], i64 [[#0x4000]], i64 [[#0x3]], i64 [[#0x4000]]] //. // CHECK-PPC64LE-LABEL: @_Z3fooi( // CHECK-PPC64LE-NEXT: entry: @@ -86,10 +87,9 @@ struct S2 { // CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS5:%.*]] = alloca [1 x ptr], align 8 // CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS6:%.*]] = alloca [1 x ptr], align 8 // CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS7:%.*]] = alloca [1 x ptr], align 8 -// CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS29:%.*]] = alloca [11 x ptr], align 8 -// CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS30:%.*]] = alloca [11 x ptr], align 8 -// CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS31:%.*]] = alloca [11 x ptr], align 8 -// CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [11 x i64], align 8 +// CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS23:%.*]] = alloca [9 x ptr], align 8 +// CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS24:%.*]] = alloca [9 x ptr], align 8 +// CHECK-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS25:%.*]] = alloca [9 x ptr], align 8 // CHECK-PPC64LE-NEXT: store i32 [[ARG:%.*]], ptr [[ARG_ADDR]], align 4 // CHECK-PPC64LE-NEXT: [[TMP0:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 // CHECK-PPC64LE-NEXT: store ptr [[LB]], ptr [[TMP0]], align 8 @@ -140,142 +140,103 @@ struct S2 { // CHECK-PPC64LE-NEXT: [[TMP25:%.*]] = load ptr, ptr [[PS1]], align 8 // CHECK-PPC64LE-NEXT: [[S:%.*]] = getelementptr inbounds nuw [[STRUCT_S2:%.*]], ptr [[TMP25]], i32 0, i32 0 // CHECK-PPC64LE-NEXT: [[TMP26:%.*]] = load ptr, ptr [[PS1]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP27:%.*]] = load ptr, ptr [[PS1]], align 8 -// CHECK-PPC64LE-NEXT: [[PS:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP27]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP28:%.*]] = load ptr, ptr [[PS1]], align 8 -// CHECK-PPC64LE-NEXT: [[PS9:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP28]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP29:%.*]] = load ptr, ptr [[PS9]], align 8 -// CHECK-PPC64LE-NEXT: [[PS10:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP29]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[PS:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP26]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP27:%.*]] = load ptr, ptr [[PS]], align 8 +// CHECK-PPC64LE-NEXT: [[PS9:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP27]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP28:%.*]] = load ptr, ptr [[PS9]], align 8 +// CHECK-PPC64LE-NEXT: [[PS10:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP28]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP29:%.*]] = load ptr, ptr [[PS10]], align 8 // CHECK-PPC64LE-NEXT: [[TMP30:%.*]] = load ptr, ptr [[PS1]], align 8 -// CHECK-PPC64LE-NEXT: [[PS11:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP30]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP31:%.*]] = load ptr, ptr [[PS11]], align 8 -// CHECK-PPC64LE-NEXT: [[PS12:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP31]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP32:%.*]] = load ptr, ptr [[PS12]], align 8 -// CHECK-PPC64LE-NEXT: [[PS13:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP32]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP33:%.*]] = load ptr, ptr [[PS1]], align 8 -// CHECK-PPC64LE-NEXT: [[PS14:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP33]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP34:%.*]] = load ptr, ptr [[PS14]], align 8 -// CHECK-PPC64LE-NEXT: [[PS15:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP34]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP35:%.*]] = load ptr, ptr [[PS15]], align 8 -// CHECK-PPC64LE-NEXT: [[PS16:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP35]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP36:%.*]] = load ptr, ptr [[PS16]], align 8 -// CHECK-PPC64LE-NEXT: [[S17:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP36]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: [[TMP37:%.*]] = getelementptr ptr, ptr [[PS]], i32 1 -// CHECK-PPC64LE-NEXT: [[TMP38:%.*]] = ptrtoint ptr [[TMP37]] to i64 -// CHECK-PPC64LE-NEXT: [[TMP39:%.*]] = ptrtoint ptr [[S]] to i64 -// CHECK-PPC64LE-NEXT: [[TMP40:%.*]] = sub i64 [[TMP38]], [[TMP39]] -// CHECK-PPC64LE-NEXT: [[TMP41:%.*]] = sdiv exact i64 [[TMP40]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) +// CHECK-PPC64LE-NEXT: [[TMP31:%.*]] = load ptr, ptr [[PS1]], align 8 +// CHECK-PPC64LE-NEXT: [[PS11:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP31]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP32:%.*]] = load ptr, ptr [[PS11]], align 8 +// CHECK-PPC64LE-NEXT: [[PS12:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP32]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP33:%.*]] = load ptr, ptr [[PS12]], align 8 +// CHECK-PPC64LE-NEXT: [[PS13:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP33]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP34:%.*]] = load ptr, ptr [[PS13]], align 8 +// CHECK-PPC64LE-NEXT: [[S14:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP34]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: [[TMP35:%.*]] = load ptr, ptr [[PS2]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP36:%.*]] = load ptr, ptr [[PS2]], align 8 +// CHECK-PPC64LE-NEXT: [[S15:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP36]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: [[TMP37:%.*]] = load ptr, ptr [[PS2]], align 8 +// CHECK-PPC64LE-NEXT: [[PS16:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP37]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP38:%.*]] = load ptr, ptr [[PS16]], align 8 +// CHECK-PPC64LE-NEXT: [[PS17:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP38]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP39:%.*]] = load ptr, ptr [[PS17]], align 8 +// CHECK-PPC64LE-NEXT: [[PS18:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP39]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP40:%.*]] = load ptr, ptr [[PS18]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP41:%.*]] = load ptr, ptr [[PS2]], align 8 // CHECK-PPC64LE-NEXT: [[TMP42:%.*]] = load ptr, ptr [[PS2]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP43:%.*]] = load ptr, ptr [[PS2]], align 8 -// CHECK-PPC64LE-NEXT: [[S18:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP43]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: [[TMP44:%.*]] = load ptr, ptr [[PS2]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP45:%.*]] = load ptr, ptr [[PS2]], align 8 -// CHECK-PPC64LE-NEXT: [[PS19:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP45]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP46:%.*]] = load ptr, ptr [[PS2]], align 8 -// CHECK-PPC64LE-NEXT: [[PS20:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP46]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP47:%.*]] = load ptr, ptr [[PS20]], align 8 -// CHECK-PPC64LE-NEXT: [[PS21:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP47]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP48:%.*]] = load ptr, ptr [[PS2]], align 8 -// CHECK-PPC64LE-NEXT: [[PS22:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP48]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP49:%.*]] = load ptr, ptr [[PS22]], align 8 -// CHECK-PPC64LE-NEXT: [[PS23:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP49]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP50:%.*]] = load ptr, ptr [[PS23]], align 8 -// CHECK-PPC64LE-NEXT: [[PS24:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP50]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP51:%.*]] = load ptr, ptr [[PS2]], align 8 -// CHECK-PPC64LE-NEXT: [[PS25:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP51]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP52:%.*]] = load ptr, ptr [[PS25]], align 8 -// CHECK-PPC64LE-NEXT: [[PS26:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP52]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP53:%.*]] = load ptr, ptr [[PS26]], align 8 -// CHECK-PPC64LE-NEXT: [[PS27:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP53]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: [[TMP54:%.*]] = load ptr, ptr [[PS27]], align 8 -// CHECK-PPC64LE-NEXT: [[S28:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP54]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: [[TMP55:%.*]] = getelementptr ptr, ptr [[PS19]], i32 1 -// CHECK-PPC64LE-NEXT: [[TMP56:%.*]] = ptrtoint ptr [[TMP55]] to i64 -// CHECK-PPC64LE-NEXT: [[TMP57:%.*]] = ptrtoint ptr [[S18]] to i64 -// CHECK-PPC64LE-NEXT: [[TMP58:%.*]] = sub i64 [[TMP56]], [[TMP57]] -// CHECK-PPC64LE-NEXT: [[TMP59:%.*]] = sdiv exact i64 [[TMP58]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK-PPC64LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes.5, i64 88, i1 false) -// CHECK-PPC64LE-NEXT: [[TMP60:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: store ptr [[TMP24]], ptr [[TMP60]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP61:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: store ptr [[S]], ptr [[TMP61]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP62:%.*]] = getelementptr inbounds [11 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: store i64 [[TMP41]], ptr [[TMP62]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP63:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 0 +// CHECK-PPC64LE-NEXT: [[PS19:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP42]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP43:%.*]] = load ptr, ptr [[PS19]], align 8 +// CHECK-PPC64LE-NEXT: [[PS20:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP43]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP44:%.*]] = load ptr, ptr [[PS20]], align 8 +// CHECK-PPC64LE-NEXT: [[PS21:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP44]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: [[TMP45:%.*]] = load ptr, ptr [[PS21]], align 8 +// CHECK-PPC64LE-NEXT: [[S22:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP45]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: [[TMP46:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: store ptr [[TMP24]], ptr [[TMP46]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP47:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: store ptr [[S]], ptr [[TMP47]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP48:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 0 +// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP48]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP49:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: store ptr [[PS1]], ptr [[TMP49]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP50:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 1 +// CHECK-PPC64LE-NEXT: store ptr [[S]], ptr [[TMP50]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP51:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 1 +// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP51]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP52:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 2 +// CHECK-PPC64LE-NEXT: store ptr [[TMP29]], ptr [[TMP52]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP53:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 2 +// CHECK-PPC64LE-NEXT: store ptr [[S14]], ptr [[TMP53]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP54:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 2 +// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP54]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP55:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 3 +// CHECK-PPC64LE-NEXT: store ptr [[PS10]], ptr [[TMP55]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP56:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 3 +// CHECK-PPC64LE-NEXT: store ptr [[S14]], ptr [[TMP56]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP57:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 3 +// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP57]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP58:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 4 +// CHECK-PPC64LE-NEXT: store ptr [[ARG_ADDR]], ptr [[TMP58]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP59:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 4 +// CHECK-PPC64LE-NEXT: store ptr [[ARG_ADDR]], ptr [[TMP59]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP60:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 4 +// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP60]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP61:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 5 +// CHECK-PPC64LE-NEXT: store ptr [[TMP35]], ptr [[TMP61]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP62:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 5 +// CHECK-PPC64LE-NEXT: store ptr [[S15]], ptr [[TMP62]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP63:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 5 // CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP63]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP64:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: store ptr [[TMP24]], ptr [[TMP64]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP65:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 1 -// CHECK-PPC64LE-NEXT: store ptr [[S]], ptr [[TMP65]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP66:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 1 +// CHECK-PPC64LE-NEXT: [[TMP64:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 6 +// CHECK-PPC64LE-NEXT: store ptr [[PS2]], ptr [[TMP64]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP65:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 6 +// CHECK-PPC64LE-NEXT: store ptr [[S15]], ptr [[TMP65]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP66:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 6 // CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP66]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP67:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 2 -// CHECK-PPC64LE-NEXT: store ptr [[PS]], ptr [[TMP67]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP68:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 2 -// CHECK-PPC64LE-NEXT: store ptr [[PS10]], ptr [[TMP68]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP69:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 2 +// CHECK-PPC64LE-NEXT: [[TMP67:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 7 +// CHECK-PPC64LE-NEXT: store ptr [[TMP40]], ptr [[TMP67]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP68:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 7 +// CHECK-PPC64LE-NEXT: store ptr [[S22]], ptr [[TMP68]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP69:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 7 // CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP69]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP70:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 3 -// CHECK-PPC64LE-NEXT: store ptr [[PS10]], ptr [[TMP70]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP71:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 3 -// CHECK-PPC64LE-NEXT: store ptr [[PS13]], ptr [[TMP71]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP72:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 3 +// CHECK-PPC64LE-NEXT: [[TMP70:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 8 +// CHECK-PPC64LE-NEXT: store ptr [[PS18]], ptr [[TMP70]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP71:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 8 +// CHECK-PPC64LE-NEXT: store ptr [[S22]], ptr [[TMP71]], align 8 +// CHECK-PPC64LE-NEXT: [[TMP72:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i64 0, i64 8 // CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP72]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP73:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 4 -// CHECK-PPC64LE-NEXT: store ptr [[PS13]], ptr [[TMP73]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP74:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 4 -// CHECK-PPC64LE-NEXT: store ptr [[S17]], ptr [[TMP74]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP75:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 4 -// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP75]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP76:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 5 -// CHECK-PPC64LE-NEXT: store ptr [[ARG_ADDR]], ptr [[TMP76]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP77:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 5 -// CHECK-PPC64LE-NEXT: store ptr [[ARG_ADDR]], ptr [[TMP77]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP78:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 5 -// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP78]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP79:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 6 -// CHECK-PPC64LE-NEXT: store ptr [[TMP42]], ptr [[TMP79]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP80:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 6 -// CHECK-PPC64LE-NEXT: store ptr [[S18]], ptr [[TMP80]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP81:%.*]] = getelementptr inbounds [11 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 6 -// CHECK-PPC64LE-NEXT: store i64 [[TMP59]], ptr [[TMP81]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP82:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 6 -// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP82]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP83:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 7 -// CHECK-PPC64LE-NEXT: store ptr [[TMP42]], ptr [[TMP83]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP84:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 7 -// CHECK-PPC64LE-NEXT: store ptr [[S18]], ptr [[TMP84]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP85:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 7 -// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP85]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP86:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 8 -// CHECK-PPC64LE-NEXT: store ptr [[PS19]], ptr [[TMP86]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP87:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 8 -// CHECK-PPC64LE-NEXT: store ptr [[PS21]], ptr [[TMP87]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP88:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 8 -// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP88]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP89:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 9 -// CHECK-PPC64LE-NEXT: store ptr [[PS21]], ptr [[TMP89]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP90:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 9 -// CHECK-PPC64LE-NEXT: store ptr [[PS24]], ptr [[TMP90]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP91:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 9 -// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP91]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP92:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 10 -// CHECK-PPC64LE-NEXT: store ptr [[PS24]], ptr [[TMP92]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP93:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 10 -// CHECK-PPC64LE-NEXT: store ptr [[S28]], ptr [[TMP93]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP94:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i64 0, i64 10 -// CHECK-PPC64LE-NEXT: store ptr null, ptr [[TMP94]], align 8 -// CHECK-PPC64LE-NEXT: [[TMP95:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: [[TMP96:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: [[TMP97:%.*]] = getelementptr inbounds [11 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 11, ptr [[TMP95]], ptr [[TMP96]], ptr [[TMP97]], ptr @.offload_maptypes.6, ptr null, ptr null) -// CHECK-PPC64LE-NEXT: [[TMP98:%.*]] = load i32, ptr [[ARG_ADDR]], align 4 -// CHECK-PPC64LE-NEXT: [[INC32:%.*]] = add nsw i32 [[TMP98]], 1 -// CHECK-PPC64LE-NEXT: store i32 [[INC32]], ptr [[ARG_ADDR]], align 4 -// CHECK-PPC64LE-NEXT: [[TMP99:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: [[TMP100:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: [[TMP101:%.*]] = getelementptr inbounds [11 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-PPC64LE-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 11, ptr [[TMP99]], ptr [[TMP100]], ptr [[TMP101]], ptr @.offload_maptypes.6, ptr null, ptr null) +// CHECK-PPC64LE-NEXT: [[TMP73:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: [[TMP74:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 9, ptr [[TMP73]], ptr [[TMP74]], ptr @.offload_sizes.5, ptr @.offload_maptypes.6, ptr null, ptr null) +// CHECK-PPC64LE-NEXT: [[TMP75:%.*]] = load i32, ptr [[ARG_ADDR]], align 4 +// CHECK-PPC64LE-NEXT: [[INC26:%.*]] = add nsw i32 [[TMP75]], 1 +// CHECK-PPC64LE-NEXT: store i32 [[INC26]], ptr [[ARG_ADDR]], align 4 +// CHECK-PPC64LE-NEXT: [[TMP76:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: [[TMP77:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 +// CHECK-PPC64LE-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 9, ptr [[TMP76]], ptr [[TMP77]], ptr @.offload_sizes.5, ptr @.offload_maptypes.6, ptr null, ptr null) // CHECK-PPC64LE-NEXT: ret void // // CHECK-I386-LABEL: @_Z3fooi( @@ -293,10 +254,9 @@ struct S2 { // CHECK-I386-NEXT: [[DOTOFFLOAD_BASEPTRS5:%.*]] = alloca [1 x ptr], align 4 // CHECK-I386-NEXT: [[DOTOFFLOAD_PTRS6:%.*]] = alloca [1 x ptr], align 4 // CHECK-I386-NEXT: [[DOTOFFLOAD_MAPPERS7:%.*]] = alloca [1 x ptr], align 4 -// CHECK-I386-NEXT: [[DOTOFFLOAD_BASEPTRS29:%.*]] = alloca [11 x ptr], align 4 -// CHECK-I386-NEXT: [[DOTOFFLOAD_PTRS30:%.*]] = alloca [11 x ptr], align 4 -// CHECK-I386-NEXT: [[DOTOFFLOAD_MAPPERS31:%.*]] = alloca [11 x ptr], align 4 -// CHECK-I386-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [11 x i64], align 4 +// CHECK-I386-NEXT: [[DOTOFFLOAD_BASEPTRS23:%.*]] = alloca [9 x ptr], align 4 +// CHECK-I386-NEXT: [[DOTOFFLOAD_PTRS24:%.*]] = alloca [9 x ptr], align 4 +// CHECK-I386-NEXT: [[DOTOFFLOAD_MAPPERS25:%.*]] = alloca [9 x ptr], align 4 // CHECK-I386-NEXT: store i32 [[ARG:%.*]], ptr [[ARG_ADDR]], align 4 // CHECK-I386-NEXT: [[TMP0:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 // CHECK-I386-NEXT: store ptr [[LB]], ptr [[TMP0]], align 4 @@ -347,142 +307,103 @@ struct S2 { // CHECK-I386-NEXT: [[TMP25:%.*]] = load ptr, ptr [[PS1]], align 4 // CHECK-I386-NEXT: [[S:%.*]] = getelementptr inbounds nuw [[STRUCT_S2:%.*]], ptr [[TMP25]], i32 0, i32 0 // CHECK-I386-NEXT: [[TMP26:%.*]] = load ptr, ptr [[PS1]], align 4 -// CHECK-I386-NEXT: [[TMP27:%.*]] = load ptr, ptr [[PS1]], align 4 -// CHECK-I386-NEXT: [[PS:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP27]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP28:%.*]] = load ptr, ptr [[PS1]], align 4 -// CHECK-I386-NEXT: [[PS9:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP28]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP29:%.*]] = load ptr, ptr [[PS9]], align 4 -// CHECK-I386-NEXT: [[PS10:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP29]], i32 0, i32 1 +// CHECK-I386-NEXT: [[PS:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP26]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP27:%.*]] = load ptr, ptr [[PS]], align 4 +// CHECK-I386-NEXT: [[PS9:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP27]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP28:%.*]] = load ptr, ptr [[PS9]], align 4 +// CHECK-I386-NEXT: [[PS10:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP28]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP29:%.*]] = load ptr, ptr [[PS10]], align 4 // CHECK-I386-NEXT: [[TMP30:%.*]] = load ptr, ptr [[PS1]], align 4 -// CHECK-I386-NEXT: [[PS11:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP30]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP31:%.*]] = load ptr, ptr [[PS11]], align 4 -// CHECK-I386-NEXT: [[PS12:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP31]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP32:%.*]] = load ptr, ptr [[PS12]], align 4 -// CHECK-I386-NEXT: [[PS13:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP32]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP33:%.*]] = load ptr, ptr [[PS1]], align 4 -// CHECK-I386-NEXT: [[PS14:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP33]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP34:%.*]] = load ptr, ptr [[PS14]], align 4 -// CHECK-I386-NEXT: [[PS15:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP34]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP35:%.*]] = load ptr, ptr [[PS15]], align 4 -// CHECK-I386-NEXT: [[PS16:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP35]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP36:%.*]] = load ptr, ptr [[PS16]], align 4 -// CHECK-I386-NEXT: [[S17:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP36]], i32 0, i32 0 -// CHECK-I386-NEXT: [[TMP37:%.*]] = getelementptr ptr, ptr [[PS]], i32 1 -// CHECK-I386-NEXT: [[TMP38:%.*]] = ptrtoint ptr [[TMP37]] to i64 -// CHECK-I386-NEXT: [[TMP39:%.*]] = ptrtoint ptr [[S]] to i64 -// CHECK-I386-NEXT: [[TMP40:%.*]] = sub i64 [[TMP38]], [[TMP39]] -// CHECK-I386-NEXT: [[TMP41:%.*]] = sdiv exact i64 [[TMP40]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) +// CHECK-I386-NEXT: [[TMP31:%.*]] = load ptr, ptr [[PS1]], align 4 +// CHECK-I386-NEXT: [[PS11:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP31]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP32:%.*]] = load ptr, ptr [[PS11]], align 4 +// CHECK-I386-NEXT: [[PS12:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP32]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP33:%.*]] = load ptr, ptr [[PS12]], align 4 +// CHECK-I386-NEXT: [[PS13:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP33]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP34:%.*]] = load ptr, ptr [[PS13]], align 4 +// CHECK-I386-NEXT: [[S14:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP34]], i32 0, i32 0 +// CHECK-I386-NEXT: [[TMP35:%.*]] = load ptr, ptr [[PS2]], align 4 +// CHECK-I386-NEXT: [[TMP36:%.*]] = load ptr, ptr [[PS2]], align 4 +// CHECK-I386-NEXT: [[S15:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP36]], i32 0, i32 0 +// CHECK-I386-NEXT: [[TMP37:%.*]] = load ptr, ptr [[PS2]], align 4 +// CHECK-I386-NEXT: [[PS16:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP37]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP38:%.*]] = load ptr, ptr [[PS16]], align 4 +// CHECK-I386-NEXT: [[PS17:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP38]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP39:%.*]] = load ptr, ptr [[PS17]], align 4 +// CHECK-I386-NEXT: [[PS18:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP39]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP40:%.*]] = load ptr, ptr [[PS18]], align 4 +// CHECK-I386-NEXT: [[TMP41:%.*]] = load ptr, ptr [[PS2]], align 4 // CHECK-I386-NEXT: [[TMP42:%.*]] = load ptr, ptr [[PS2]], align 4 -// CHECK-I386-NEXT: [[TMP43:%.*]] = load ptr, ptr [[PS2]], align 4 -// CHECK-I386-NEXT: [[S18:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP43]], i32 0, i32 0 -// CHECK-I386-NEXT: [[TMP44:%.*]] = load ptr, ptr [[PS2]], align 4 -// CHECK-I386-NEXT: [[TMP45:%.*]] = load ptr, ptr [[PS2]], align 4 -// CHECK-I386-NEXT: [[PS19:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP45]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP46:%.*]] = load ptr, ptr [[PS2]], align 4 -// CHECK-I386-NEXT: [[PS20:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP46]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP47:%.*]] = load ptr, ptr [[PS20]], align 4 -// CHECK-I386-NEXT: [[PS21:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP47]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP48:%.*]] = load ptr, ptr [[PS2]], align 4 -// CHECK-I386-NEXT: [[PS22:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP48]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP49:%.*]] = load ptr, ptr [[PS22]], align 4 -// CHECK-I386-NEXT: [[PS23:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP49]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP50:%.*]] = load ptr, ptr [[PS23]], align 4 -// CHECK-I386-NEXT: [[PS24:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP50]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP51:%.*]] = load ptr, ptr [[PS2]], align 4 -// CHECK-I386-NEXT: [[PS25:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP51]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP52:%.*]] = load ptr, ptr [[PS25]], align 4 -// CHECK-I386-NEXT: [[PS26:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP52]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP53:%.*]] = load ptr, ptr [[PS26]], align 4 -// CHECK-I386-NEXT: [[PS27:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP53]], i32 0, i32 1 -// CHECK-I386-NEXT: [[TMP54:%.*]] = load ptr, ptr [[PS27]], align 4 -// CHECK-I386-NEXT: [[S28:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP54]], i32 0, i32 0 -// CHECK-I386-NEXT: [[TMP55:%.*]] = getelementptr ptr, ptr [[PS19]], i32 1 -// CHECK-I386-NEXT: [[TMP56:%.*]] = ptrtoint ptr [[TMP55]] to i64 -// CHECK-I386-NEXT: [[TMP57:%.*]] = ptrtoint ptr [[S18]] to i64 -// CHECK-I386-NEXT: [[TMP58:%.*]] = sub i64 [[TMP56]], [[TMP57]] -// CHECK-I386-NEXT: [[TMP59:%.*]] = sdiv exact i64 [[TMP58]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK-I386-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[DOTOFFLOAD_SIZES]], ptr align 4 @.offload_sizes.5, i32 88, i1 false) -// CHECK-I386-NEXT: [[TMP60:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 0 -// CHECK-I386-NEXT: store ptr [[TMP24]], ptr [[TMP60]], align 4 -// CHECK-I386-NEXT: [[TMP61:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 0 -// CHECK-I386-NEXT: store ptr [[S]], ptr [[TMP61]], align 4 -// CHECK-I386-NEXT: [[TMP62:%.*]] = getelementptr inbounds [11 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-I386-NEXT: store i64 [[TMP41]], ptr [[TMP62]], align 4 -// CHECK-I386-NEXT: [[TMP63:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 0 +// CHECK-I386-NEXT: [[PS19:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP42]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP43:%.*]] = load ptr, ptr [[PS19]], align 4 +// CHECK-I386-NEXT: [[PS20:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP43]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP44:%.*]] = load ptr, ptr [[PS20]], align 4 +// CHECK-I386-NEXT: [[PS21:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP44]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP45:%.*]] = load ptr, ptr [[PS21]], align 4 +// CHECK-I386-NEXT: [[S22:%.*]] = getelementptr inbounds nuw [[STRUCT_S2]], ptr [[TMP45]], i32 0, i32 0 +// CHECK-I386-NEXT: [[TMP46:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 +// CHECK-I386-NEXT: store ptr [[TMP24]], ptr [[TMP46]], align 4 +// CHECK-I386-NEXT: [[TMP47:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 +// CHECK-I386-NEXT: store ptr [[S]], ptr [[TMP47]], align 4 +// CHECK-I386-NEXT: [[TMP48:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 0 +// CHECK-I386-NEXT: store ptr null, ptr [[TMP48]], align 4 +// CHECK-I386-NEXT: [[TMP49:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 1 +// CHECK-I386-NEXT: store ptr [[PS1]], ptr [[TMP49]], align 4 +// CHECK-I386-NEXT: [[TMP50:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 1 +// CHECK-I386-NEXT: store ptr [[S]], ptr [[TMP50]], align 4 +// CHECK-I386-NEXT: [[TMP51:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 1 +// CHECK-I386-NEXT: store ptr null, ptr [[TMP51]], align 4 +// CHECK-I386-NEXT: [[TMP52:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 2 +// CHECK-I386-NEXT: store ptr [[TMP29]], ptr [[TMP52]], align 4 +// CHECK-I386-NEXT: [[TMP53:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 2 +// CHECK-I386-NEXT: store ptr [[S14]], ptr [[TMP53]], align 4 +// CHECK-I386-NEXT: [[TMP54:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 2 +// CHECK-I386-NEXT: store ptr null, ptr [[TMP54]], align 4 +// CHECK-I386-NEXT: [[TMP55:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 3 +// CHECK-I386-NEXT: store ptr [[PS10]], ptr [[TMP55]], align 4 +// CHECK-I386-NEXT: [[TMP56:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 3 +// CHECK-I386-NEXT: store ptr [[S14]], ptr [[TMP56]], align 4 +// CHECK-I386-NEXT: [[TMP57:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 3 +// CHECK-I386-NEXT: store ptr null, ptr [[TMP57]], align 4 +// CHECK-I386-NEXT: [[TMP58:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 4 +// CHECK-I386-NEXT: store ptr [[ARG_ADDR]], ptr [[TMP58]], align 4 +// CHECK-I386-NEXT: [[TMP59:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 4 +// CHECK-I386-NEXT: store ptr [[ARG_ADDR]], ptr [[TMP59]], align 4 +// CHECK-I386-NEXT: [[TMP60:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 4 +// CHECK-I386-NEXT: store ptr null, ptr [[TMP60]], align 4 +// CHECK-I386-NEXT: [[TMP61:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 5 +// CHECK-I386-NEXT: store ptr [[TMP35]], ptr [[TMP61]], align 4 +// CHECK-I386-NEXT: [[TMP62:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 5 +// CHECK-I386-NEXT: store ptr [[S15]], ptr [[TMP62]], align 4 +// CHECK-I386-NEXT: [[TMP63:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 5 // CHECK-I386-NEXT: store ptr null, ptr [[TMP63]], align 4 -// CHECK-I386-NEXT: [[TMP64:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 1 -// CHECK-I386-NEXT: store ptr [[TMP24]], ptr [[TMP64]], align 4 -// CHECK-I386-NEXT: [[TMP65:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 1 -// CHECK-I386-NEXT: store ptr [[S]], ptr [[TMP65]], align 4 -// CHECK-I386-NEXT: [[TMP66:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 1 +// CHECK-I386-NEXT: [[TMP64:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 6 +// CHECK-I386-NEXT: store ptr [[PS2]], ptr [[TMP64]], align 4 +// CHECK-I386-NEXT: [[TMP65:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 6 +// CHECK-I386-NEXT: store ptr [[S15]], ptr [[TMP65]], align 4 +// CHECK-I386-NEXT: [[TMP66:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 6 // CHECK-I386-NEXT: store ptr null, ptr [[TMP66]], align 4 -// CHECK-I386-NEXT: [[TMP67:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 2 -// CHECK-I386-NEXT: store ptr [[PS]], ptr [[TMP67]], align 4 -// CHECK-I386-NEXT: [[TMP68:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 2 -// CHECK-I386-NEXT: store ptr [[PS10]], ptr [[TMP68]], align 4 -// CHECK-I386-NEXT: [[TMP69:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 2 +// CHECK-I386-NEXT: [[TMP67:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 7 +// CHECK-I386-NEXT: store ptr [[TMP40]], ptr [[TMP67]], align 4 +// CHECK-I386-NEXT: [[TMP68:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 7 +// CHECK-I386-NEXT: store ptr [[S22]], ptr [[TMP68]], align 4 +// CHECK-I386-NEXT: [[TMP69:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 7 // CHECK-I386-NEXT: store ptr null, ptr [[TMP69]], align 4 -// CHECK-I386-NEXT: [[TMP70:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 3 -// CHECK-I386-NEXT: store ptr [[PS10]], ptr [[TMP70]], align 4 -// CHECK-I386-NEXT: [[TMP71:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 3 -// CHECK-I386-NEXT: store ptr [[PS13]], ptr [[TMP71]], align 4 -// CHECK-I386-NEXT: [[TMP72:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 3 +// CHECK-I386-NEXT: [[TMP70:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 8 +// CHECK-I386-NEXT: store ptr [[PS18]], ptr [[TMP70]], align 4 +// CHECK-I386-NEXT: [[TMP71:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 8 +// CHECK-I386-NEXT: store ptr [[S22]], ptr [[TMP71]], align 4 +// CHECK-I386-NEXT: [[TMP72:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS25]], i32 0, i32 8 // CHECK-I386-NEXT: store ptr null, ptr [[TMP72]], align 4 -// CHECK-I386-NEXT: [[TMP73:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 4 -// CHECK-I386-NEXT: store ptr [[PS13]], ptr [[TMP73]], align 4 -// CHECK-I386-NEXT: [[TMP74:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 4 -// CHECK-I386-NEXT: store ptr [[S17]], ptr [[TMP74]], align 4 -// CHECK-I386-NEXT: [[TMP75:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 4 -// CHECK-I386-NEXT: store ptr null, ptr [[TMP75]], align 4 -// CHECK-I386-NEXT: [[TMP76:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 5 -// CHECK-I386-NEXT: store ptr [[ARG_ADDR]], ptr [[TMP76]], align 4 -// CHECK-I386-NEXT: [[TMP77:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 5 -// CHECK-I386-NEXT: store ptr [[ARG_ADDR]], ptr [[TMP77]], align 4 -// CHECK-I386-NEXT: [[TMP78:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 5 -// CHECK-I386-NEXT: store ptr null, ptr [[TMP78]], align 4 -// CHECK-I386-NEXT: [[TMP79:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 6 -// CHECK-I386-NEXT: store ptr [[TMP42]], ptr [[TMP79]], align 4 -// CHECK-I386-NEXT: [[TMP80:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 6 -// CHECK-I386-NEXT: store ptr [[S18]], ptr [[TMP80]], align 4 -// CHECK-I386-NEXT: [[TMP81:%.*]] = getelementptr inbounds [11 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 6 -// CHECK-I386-NEXT: store i64 [[TMP59]], ptr [[TMP81]], align 4 -// CHECK-I386-NEXT: [[TMP82:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 6 -// CHECK-I386-NEXT: store ptr null, ptr [[TMP82]], align 4 -// CHECK-I386-NEXT: [[TMP83:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 7 -// CHECK-I386-NEXT: store ptr [[TMP42]], ptr [[TMP83]], align 4 -// CHECK-I386-NEXT: [[TMP84:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 7 -// CHECK-I386-NEXT: store ptr [[S18]], ptr [[TMP84]], align 4 -// CHECK-I386-NEXT: [[TMP85:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 7 -// CHECK-I386-NEXT: store ptr null, ptr [[TMP85]], align 4 -// CHECK-I386-NEXT: [[TMP86:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 8 -// CHECK-I386-NEXT: store ptr [[PS19]], ptr [[TMP86]], align 4 -// CHECK-I386-NEXT: [[TMP87:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 8 -// CHECK-I386-NEXT: store ptr [[PS21]], ptr [[TMP87]], align 4 -// CHECK-I386-NEXT: [[TMP88:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 8 -// CHECK-I386-NEXT: store ptr null, ptr [[TMP88]], align 4 -// CHECK-I386-NEXT: [[TMP89:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 9 -// CHECK-I386-NEXT: store ptr [[PS21]], ptr [[TMP89]], align 4 -// CHECK-I386-NEXT: [[TMP90:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 9 -// CHECK-I386-NEXT: store ptr [[PS24]], ptr [[TMP90]], align 4 -// CHECK-I386-NEXT: [[TMP91:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 9 -// CHECK-I386-NEXT: store ptr null, ptr [[TMP91]], align 4 -// CHECK-I386-NEXT: [[TMP92:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 10 -// CHECK-I386-NEXT: store ptr [[PS24]], ptr [[TMP92]], align 4 -// CHECK-I386-NEXT: [[TMP93:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 10 -// CHECK-I386-NEXT: store ptr [[S28]], ptr [[TMP93]], align 4 -// CHECK-I386-NEXT: [[TMP94:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_MAPPERS31]], i32 0, i32 10 -// CHECK-I386-NEXT: store ptr null, ptr [[TMP94]], align 4 -// CHECK-I386-NEXT: [[TMP95:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 0 -// CHECK-I386-NEXT: [[TMP96:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 0 -// CHECK-I386-NEXT: [[TMP97:%.*]] = getelementptr inbounds [11 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-I386-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 11, ptr [[TMP95]], ptr [[TMP96]], ptr [[TMP97]], ptr @.offload_maptypes.6, ptr null, ptr null) -// CHECK-I386-NEXT: [[TMP98:%.*]] = load i32, ptr [[ARG_ADDR]], align 4 -// CHECK-I386-NEXT: [[INC32:%.*]] = add nsw i32 [[TMP98]], 1 -// CHECK-I386-NEXT: store i32 [[INC32]], ptr [[ARG_ADDR]], align 4 -// CHECK-I386-NEXT: [[TMP99:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_BASEPTRS29]], i32 0, i32 0 -// CHECK-I386-NEXT: [[TMP100:%.*]] = getelementptr inbounds [11 x ptr], ptr [[DOTOFFLOAD_PTRS30]], i32 0, i32 0 -// CHECK-I386-NEXT: [[TMP101:%.*]] = getelementptr inbounds [11 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-I386-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 11, ptr [[TMP99]], ptr [[TMP100]], ptr [[TMP101]], ptr @.offload_maptypes.6, ptr null, ptr null) +// CHECK-I386-NEXT: [[TMP73:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 +// CHECK-I386-NEXT: [[TMP74:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 +// CHECK-I386-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 9, ptr [[TMP73]], ptr [[TMP74]], ptr @.offload_sizes.5, ptr @.offload_maptypes.6, ptr null, ptr null) +// CHECK-I386-NEXT: [[TMP75:%.*]] = load i32, ptr [[ARG_ADDR]], align 4 +// CHECK-I386-NEXT: [[INC26:%.*]] = add nsw i32 [[TMP75]], 1 +// CHECK-I386-NEXT: store i32 [[INC26]], ptr [[ARG_ADDR]], align 4 +// CHECK-I386-NEXT: [[TMP76:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS23]], i32 0, i32 0 +// CHECK-I386-NEXT: [[TMP77:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS24]], i32 0, i32 0 +// CHECK-I386-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 9, ptr [[TMP76]], ptr [[TMP77]], ptr @.offload_sizes.5, ptr @.offload_maptypes.6, ptr null, ptr null) // CHECK-I386-NEXT: ret void // void foo(int arg) { diff --git a/clang/test/OpenMP/target_data_map_pointer_array_subscript_codegen.cpp b/clang/test/OpenMP/target_data_map_pointer_array_subscript_codegen.cpp index eed1889f3c5cb..af5016f14b2dd 100644 --- a/clang/test/OpenMP/target_data_map_pointer_array_subscript_codegen.cpp +++ b/clang/test/OpenMP/target_data_map_pointer_array_subscript_codegen.cpp @@ -33,20 +33,60 @@ typedef struct { MyObject *objects; #pragma omp end declare target -// CHECK-DAG: [[SIZES0:@.+]] = private unnamed_addr constant [1 x i64] [i64 {{8|4}}] -// CHECK-DAG: [[MAPS0:@.+]] = private unnamed_addr constant [1 x i64] [i64 17] -// CHECK-DAG: [[SIZES1:@.+]] = private unnamed_addr constant [2 x i64] [i64 0, i64 4] -// CHECK-DAG: [[MAPS1:@.+]] = private unnamed_addr constant [2 x i64] [i64 0, i64 281474976710673] +// CHECK-DAG: [[SIZES0:@.+]] = private unnamed_addr constant [2 x i64] [i64 {{8|4}}, i64 {{8|4}}] +// CHECK-DAG: [[MAPS0:@.+]] = private unnamed_addr constant [2 x i64] [i64 1, i64 16384] +// CHECK-DAG: [[SIZES1:@.+]] = private unnamed_addr constant [2 x i64] [i64 4, i64 {{8|4}}] +// CHECK-DAG: [[MAPS1:@.+]] = private unnamed_addr constant [2 x i64] [i64 1, i64 16384] // CHECK: @main int main(void) { -// CHECK: [[BPTR0:%.+]] = getelementptr inbounds [1 x ptr], ptr %{{.+}}, i32 0, i32 0 -// CHECK: store ptr @objects, ptr [[BPTR0]], -// CHECK: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr %{{.+}}, ptr %{{.+}}, ptr [[SIZES0]], ptr [[MAPS0]], ptr null, ptr null) + +// &objects[0], &objects[1], 1 * sizeof(objects[0]), TO +// &objects, &objects[1], sizeof(objects), ATTACH + +// CHECK-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[BPGEP:%.+]], ptr [[PGEP:%.+]], ptr [[SIZES0]], ptr [[MAPS0]], ptr null, ptr null) +// CHECK-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] +// CHECK-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] + +// CHECK-DAG: [[BP0:%.+]] = getelementptr inbounds {{.*}}ptr [[BP]], i32 0, i32 0 +// CHECK-DAG: [[P0:%.+]] = getelementptr inbounds {{.*}}ptr [[P]], i32 0, i32 0 +// CHECK-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] +// CHECK-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] +// CHECK-DAG: [[RVAR0]] = load ptr, ptr @objects +// CHECK-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 1 +// CHECK-DAG: [[RVAR00]] = load ptr, ptr @objects + +// CHECK-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CHECK-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CHECK-DAG: store ptr @objects, ptr [[BP1]] +// CHECK-DAG: store ptr [[SEC0]], ptr [[P1]] + #pragma omp target enter data map(to : objects [1:1]) -// CHECK: [[OBJ:%.+]] = load ptr, ptr @objects, -// CHECK: [[BPTR0:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 -// CHECK: store ptr [[OBJ]], ptr [[BPTR0]], -// CHECK: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, ptr [[MAPS1]], ptr null, ptr null) + +// &objects[1].arr[0], &objects[1].arr[/*lb=*/0], 1 * sizeof(objects[1], arr[0:1]), TO +// &objects[1].arr, &objects[1].arr[/*lb=*/0], sizeof(objects[1].arr), ATTACH + +// CHECK-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[BPGEP:%.+]], ptr [[PGEP:%.+]], ptr [[SIZES1]], ptr [[MAPS1]], ptr null, ptr null) +// CHECK-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] +// CHECK-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] + +// CHECK-DAG: [[BP0:%.+]] = getelementptr inbounds {{.*}}ptr [[BP]], i32 0, i32 0 +// CHECK-DAG: [[P0:%.+]] = getelementptr inbounds {{.*}}ptr [[P]], i32 0, i32 0 +// CHECK-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] +// CHECK-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] +// CHECK-DAG: [[RVAR0]] = load ptr, ptr [[RVAR00:[^,]+]] +// CHECK-DAG: [[RVAR00]] = getelementptr inbounds nuw %struct.MyObject, ptr [[RVAR000:%[^,]+]], i32 0, i32 0 +// CHECK-DAG: [[RVAR000]] = getelementptr inbounds %struct.MyObject, ptr [[RVAR0000:%[^,]+]], i{{.*}} 1 +// CHECK-DAG: [[RVAR0000]] = load ptr, ptr @objects +// CHECK-DAG: [[SEC0]] = getelementptr inbounds nuw i32, ptr [[SEC00:%.*]], i{{.*}} 0 +// CHECK-DAG: [[SEC00]] = load ptr, ptr [[SEC000:[^,]+]] +// CHECK-DAG: [[SEC000]] = getelementptr inbounds nuw %struct.MyObject, ptr [[SEC0000:%[^,]+]], i32 0, i32 0 +// CHECK-DAG: [[SEC0000]] = getelementptr inbounds %struct.MyObject, ptr [[SEC00000:%[^,]+]], i{{.*}} 1 +// CHECK-DAG: [[SEC00000]] = load ptr, ptr @objects + +// CHECK-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CHECK-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CHECK-DAG: store ptr [[RVAR00]], ptr [[BP1]] +// CHECK-DAG: store ptr [[SEC0]], ptr [[P1]] #pragma omp target enter data map(to : objects[1].arr [0:1]) return 0; diff --git a/clang/test/OpenMP/target_data_use_device_addr_codegen.cpp b/clang/test/OpenMP/target_data_use_device_addr_codegen.cpp index a67d3258ea071..d6fe11a989eb6 100644 --- a/clang/test/OpenMP/target_data_use_device_addr_codegen.cpp +++ b/clang/test/OpenMP/target_data_use_device_addr_codegen.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --version 5 +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals all --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" --global-hex-value-regex ".offload_maptypes.*" --version 5 // RUN: %clang_cc1 -verify -Wno-vla -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -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 -Wno-vla %s -emit-llvm -o - | FileCheck %s @@ -19,9 +19,6 @@ #ifndef HEADER #define HEADER -// 64 = 0x40 = OMP_MAP_RETURN_PARAM -// 0 = OMP_MAP_NONE -// 281474976710720 = 0x1000000000040 = OMP_MAP_MEMBER_OF | OMP_MAP_RETURN_PARAM struct S { int a = 0; @@ -30,6 +27,15 @@ struct S { int arr[4]; S() {} void foo() { + // &this[0], &this->a, sizeof(this[0].(a-to-arr[a]), ALLOC + // &this[0], &this->a, sizeof(a), TO | FROM | RETURN_PARAM | MEMBER_OF(1) + // &this[0], &ref_ptee(this->ref), sizeof(this->ref[0]), TO | FROM | PTR_AND_OBJ | RETURN_PARAM | MEMBER_OF(1) + // &this[0], &this->arr[0], 4 * sizeof(arr[0]), TO | FROM | RETURN_PARAM | MEMBER_OF(1) + // &ptr[0], &ptr[3], 4 * sizeof(ptr[0]), TO | FROM | RETURN_PARAM + // &ptr[0], &ptr[0], 1 * sizeof(ptr[0]), TO | FROM + // [ &ptr[0], &ptr[0], 8, TO | FROM ] // ptr[:] (OMP60) + // &ptr, &ptr[0], sizeof(void*), ATTACH + // TODO: Check why the size for map(ptr[:]) is 8, instead of 0 #ifdef OMP60 #pragma omp target data map(tofrom: a, ptr [3:4], ref, ptr[0], arr[:a], ptr[:]) use_device_addr(a, ptr [3:4], ref, ptr[0], arr[:a], ptr[:]) #else @@ -52,7 +58,19 @@ int main() { S s; s.foo(); #ifdef OMP60 -#pragma omp target data map(tofrom: a, ptr [3:4], ref, ptr[0], arr[:(int)a], vla[0], ptr[:], argv[0][:]) use_device_addr(a, ptr [3:4], ref, ptr[0], arr[:(int)a], vla[0], ptr[:], argv[0][:]) + // &a, &a, sizeof(a), TO | FROM | RETURN_PARAM + // &ptr[0], &ptr[3], 4 * sizeof(ptr[3]), TO | FROM | RETURN_PARAM + // &ptr[0], &ptr[0], sizeof(ptr[0]), TO | FROM + // [ &ptr[0], &ptr[0], 8, TO | FROM ] // ptr[:] (OMP60) + // &ptr, &ptr[0], sizeof(void*), ATTACH + // &ref_ptee(ref), &ref_ptee(ref), sizeof(ref_ptee(ref)), TO | FROM | RETURN_PARAM + // &arr, &arr[0], a * sizeof(arr[0]), TO | FROM | RETURN_PARAM + // &vla, &vla[0], sizeof(vla[0]), TO | FROM | RETURN_PARAM + // [ &argv[0][0], &argv[0][0], 8, TO | FROM ] // argv[0][:] (OPM60) + // [ &argv[0], &argv[0][0], 8, ATTACH ] // argv[0][:] (OMP60) + // NOTE: use_device_addr(argv[0][:]) is illegal, because the base-pointer, + // argv[0], is not a named variable. +#pragma omp target data map(tofrom: a, ptr [3:4], ref, ptr[0], arr[:(int)a], vla[0], ptr[:], argv[0][:]) use_device_addr(a, ptr [3:4], ref, ptr[0], arr[:(int)a], vla[0], ptr[:]) #else #pragma omp target data map(tofrom: a, ptr [3:4], ref, ptr[0], arr[:(int)a], vla[0]) use_device_addr(a, ptr [3:4], ref, ptr[0], arr[:(int)a], vla[0]) #endif // OMP60 @@ -60,12 +78,18 @@ int main() { return a; } - - - - - #endif +//. +// CHECK: @.offload_sizes = private unnamed_addr constant [7 x i64] [i64 4, i64 16, i64 4, i64 8, i64 4, i64 0, i64 4] +// CHECK: @.offload_maptypes = private unnamed_addr constant [7 x i64] [i64 [[#0x43]], i64 [[#0x43]], i64 [[#0x3]], i64 [[#0x4000]], i64 [[#0x43]], i64 [[#0x43]], i64 [[#0x43]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [7 x i64] [i64 0, i64 4, i64 4, i64 0, i64 16, i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [7 x i64] [i64 [[#0x0]], i64 [[#0x1000000000043]], i64 [[#0x1000000000053]], i64 [[#0x1000000000043]], i64 [[#0x43]], i64 [[#0x3]], i64 [[#0x4000]]] +//. +// OMP60: @.offload_sizes = private unnamed_addr constant [10 x i64] [i64 4, i64 16, i64 4, i64 8, i64 8, i64 4, i64 0, i64 4, i64 8, i64 8] +// OMP60: @.offload_maptypes = private unnamed_addr constant [10 x i64] [i64 [[#0x43]], i64 [[#0x43]], i64 [[#0x3]], i64 [[#0x3]], i64 [[#0x4000]], i64 [[#0x43]], i64 [[#0x43]], i64 [[#0x43]], i64 [[#0x3]], i64 [[#0x4000]]] +// OMP60: @.offload_sizes.1 = private unnamed_addr constant [8 x i64] [i64 0, i64 4, i64 4, i64 0, i64 16, i64 4, i64 8, i64 8] +// OMP60: @.offload_maptypes.2 = private unnamed_addr constant [8 x i64] [i64 [[#0x0]], i64 [[#0x1000000000043]], i64 [[#0x1000000000053]], i64 [[#0x1000000000043]], i64 [[#0x43]], i64 [[#0x3]], i64 [[#0x3]], i64 [[#0x4000]]] +//. // CHECK-LABEL: define dso_local noundef signext i32 @main( // CHECK-SAME: ) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] @@ -77,10 +101,10 @@ int main() { // CHECK-NEXT: [[SAVED_STACK:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[__VLA_EXPR0:%.*]] = alloca i64, align 8 // CHECK-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [6 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [6 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [6 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [6 x i64], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [7 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [7 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [7 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [7 x i64], align 8 // CHECK-NEXT: [[TMP:%.*]] = alloca ptr, align 8 // CHECK-NEXT: store i32 0, ptr [[RETVAL]], align 4 // CHECK-NEXT: store float 0.000000e+00, ptr [[A]], align 4 @@ -96,95 +120,103 @@ int main() { // CHECK-NEXT: call void @_ZN1SC1Ev(ptr noundef nonnull align 8 dereferenceable(40) [[S]]) // CHECK-NEXT: call void @_ZN1S3fooEv(ptr noundef nonnull align 8 dereferenceable(40) [[S]]) // CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw float, ptr [[TMP3]], i64 3 // CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds float, ptr [[TMP4]], i64 0 -// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3:![0-9]+]], !align [[META4:![0-9]+]] -// CHECK-NEXT: [[TMP6:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3]], !align [[META4]] +// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw float, ptr [[TMP4]], i64 3 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[PTR]], align 8 +// CHECK-NEXT: [[TMP6:%.*]] = load ptr, ptr [[PTR]], align 8 +// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds float, ptr [[TMP6]], i64 0 +// CHECK-NEXT: [[TMP7:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3:![0-9]+]], !align [[META4:![0-9]+]] +// CHECK-NEXT: [[TMP8:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3]], !align [[META4]] // CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds nuw [4 x float], ptr [[ARR]], i64 0, i64 0 -// CHECK-NEXT: [[TMP7:%.*]] = load float, ptr [[A]], align 4 -// CHECK-NEXT: [[CONV3:%.*]] = fptosi float [[TMP7]] to i32 +// CHECK-NEXT: [[TMP9:%.*]] = load float, ptr [[A]], align 4 +// CHECK-NEXT: [[CONV3:%.*]] = fptosi float [[TMP9]] to i32 // CHECK-NEXT: [[CONV4:%.*]] = sext i32 [[CONV3]] to i64 -// CHECK-NEXT: [[TMP8:%.*]] = mul nuw i64 [[CONV4]], 4 +// CHECK-NEXT: [[TMP10:%.*]] = mul nuw i64 [[CONV4]], 4 // CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds float, ptr [[VLA]], i64 0 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes, i64 48, i1 false) -// CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[A]], ptr [[TMP9]], align 8 -// CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[A]], ptr [[TMP10]], align 8 -// CHECK-NEXT: [[TMP11:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP11]], align 8 -// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[PTR]], ptr [[TMP12]], align 8 -// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP13]], align 8 -// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK-NEXT: store ptr null, ptr [[TMP14]], align 8 -// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[PTR]], ptr [[TMP15]], align 8 -// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP16]], align 8 -// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK-NEXT: store ptr null, ptr [[TMP17]], align 8 -// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP5]], ptr [[TMP18]], align 8 -// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP6]], ptr [[TMP19]], align 8 -// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 -// CHECK-NEXT: store ptr null, ptr [[TMP20]], align 8 -// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 -// CHECK-NEXT: store ptr [[ARR]], ptr [[TMP21]], align 8 -// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 -// CHECK-NEXT: store ptr [[ARRAYIDX2]], ptr [[TMP22]], align 8 -// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds [6 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 4 -// CHECK-NEXT: store i64 [[TMP8]], ptr [[TMP23]], align 8 -// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 -// CHECK-NEXT: store ptr null, ptr [[TMP24]], align 8 -// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5 -// CHECK-NEXT: store ptr [[VLA]], ptr [[TMP25]], align 8 -// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 5 -// CHECK-NEXT: store ptr [[ARRAYIDX5]], ptr [[TMP26]], align 8 -// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5 -// CHECK-NEXT: store ptr null, ptr [[TMP27]], align 8 -// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [6 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 6, ptr [[TMP28]], ptr [[TMP29]], ptr [[TMP30]], ptr @.offload_maptypes, ptr null, ptr null) -// CHECK-NEXT: [[TMP31:%.*]] = load ptr, ptr [[TMP9]], align 8 -// CHECK-NEXT: [[TMP32:%.*]] = load ptr, ptr [[TMP18]], align 8 -// CHECK-NEXT: store ptr [[TMP32]], ptr [[TMP]], align 8 -// CHECK-NEXT: [[TMP33:%.*]] = load ptr, ptr [[TMP21]], align 8 -// CHECK-NEXT: [[TMP34:%.*]] = load ptr, ptr [[TMP25]], align 8 -// CHECK-NEXT: [[TMP35:%.*]] = load float, ptr [[TMP31]], align 4 -// CHECK-NEXT: [[INC:%.*]] = fadd float [[TMP35]], 1.000000e+00 -// CHECK-NEXT: store float [[INC]], ptr [[TMP31]], align 4 -// CHECK-NEXT: [[TMP36:%.*]] = load ptr, ptr [[TMP12]], align 8 -// CHECK-NEXT: [[TMP37:%.*]] = load float, ptr [[TMP36]], align 4 -// CHECK-NEXT: [[INC6:%.*]] = fadd float [[TMP37]], 1.000000e+00 -// CHECK-NEXT: store float [[INC6]], ptr [[TMP36]], align 4 -// CHECK-NEXT: [[TMP38:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META3]], !align [[META4]] -// CHECK-NEXT: [[TMP39:%.*]] = load float, ptr [[TMP38]], align 4 -// CHECK-NEXT: [[INC7:%.*]] = fadd float [[TMP39]], 1.000000e+00 -// CHECK-NEXT: store float [[INC7]], ptr [[TMP38]], align 4 -// CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds [4 x float], ptr [[TMP33]], i64 0, i64 0 -// CHECK-NEXT: [[TMP40:%.*]] = load float, ptr [[ARRAYIDX8]], align 4 -// CHECK-NEXT: [[INC9:%.*]] = fadd float [[TMP40]], 1.000000e+00 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes, i64 56, i1 false) +// CHECK-NEXT: [[TMP11:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[A]], ptr [[TMP11]], align 8 +// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[A]], ptr [[TMP12]], align 8 +// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP13]], align 8 +// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP3]], ptr [[TMP14]], align 8 +// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP15]], align 8 +// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP16]], align 8 +// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP5]], ptr [[TMP17]], align 8 +// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP18]], align 8 +// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK-NEXT: store ptr null, ptr [[TMP19]], align 8 +// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[PTR]], ptr [[TMP20]], align 8 +// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP21]], align 8 +// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 +// CHECK-NEXT: store ptr null, ptr [[TMP22]], align 8 +// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[TMP7]], ptr [[TMP23]], align 8 +// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[TMP8]], ptr [[TMP24]], align 8 +// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 +// CHECK-NEXT: store ptr null, ptr [[TMP25]], align 8 +// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5 +// CHECK-NEXT: store ptr [[ARR]], ptr [[TMP26]], align 8 +// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 5 +// CHECK-NEXT: store ptr [[ARRAYIDX2]], ptr [[TMP27]], align 8 +// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 5 +// CHECK-NEXT: store i64 [[TMP10]], ptr [[TMP28]], align 8 +// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5 +// CHECK-NEXT: store ptr null, ptr [[TMP29]], align 8 +// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6 +// CHECK-NEXT: store ptr [[VLA]], ptr [[TMP30]], align 8 +// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 6 +// CHECK-NEXT: store ptr [[ARRAYIDX5]], ptr [[TMP31]], align 8 +// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 6 +// CHECK-NEXT: store ptr null, ptr [[TMP32]], align 8 +// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 7, ptr [[TMP33]], ptr [[TMP34]], ptr [[TMP35]], ptr @.offload_maptypes, ptr null, ptr null) +// CHECK-NEXT: [[TMP36:%.*]] = load ptr, ptr [[TMP11]], align 8 +// CHECK-NEXT: [[TMP37:%.*]] = load ptr, ptr [[TMP23]], align 8 +// CHECK-NEXT: store ptr [[TMP37]], ptr [[TMP]], align 8 +// CHECK-NEXT: [[TMP38:%.*]] = load ptr, ptr [[TMP26]], align 8 +// CHECK-NEXT: [[TMP39:%.*]] = load ptr, ptr [[TMP30]], align 8 +// CHECK-NEXT: [[TMP40:%.*]] = load float, ptr [[TMP36]], align 4 +// CHECK-NEXT: [[INC:%.*]] = fadd float [[TMP40]], 1.000000e+00 +// CHECK-NEXT: store float [[INC]], ptr [[TMP36]], align 4 +// CHECK-NEXT: [[TMP41:%.*]] = load ptr, ptr [[TMP14]], align 8 +// CHECK-NEXT: [[TMP42:%.*]] = load float, ptr [[TMP41]], align 4 +// CHECK-NEXT: [[INC6:%.*]] = fadd float [[TMP42]], 1.000000e+00 +// CHECK-NEXT: store float [[INC6]], ptr [[TMP41]], align 4 +// CHECK-NEXT: [[TMP43:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META3]], !align [[META4]] +// CHECK-NEXT: [[TMP44:%.*]] = load float, ptr [[TMP43]], align 4 +// CHECK-NEXT: [[INC7:%.*]] = fadd float [[TMP44]], 1.000000e+00 +// CHECK-NEXT: store float [[INC7]], ptr [[TMP43]], align 4 +// CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds [4 x float], ptr [[TMP38]], i64 0, i64 0 +// CHECK-NEXT: [[TMP45:%.*]] = load float, ptr [[ARRAYIDX8]], align 4 +// CHECK-NEXT: [[INC9:%.*]] = fadd float [[TMP45]], 1.000000e+00 // CHECK-NEXT: store float [[INC9]], ptr [[ARRAYIDX8]], align 4 -// CHECK-NEXT: [[ARRAYIDX10:%.*]] = getelementptr inbounds float, ptr [[TMP34]], i64 0 -// CHECK-NEXT: [[TMP41:%.*]] = load float, ptr [[ARRAYIDX10]], align 4 -// CHECK-NEXT: [[INC11:%.*]] = fadd float [[TMP41]], 1.000000e+00 +// CHECK-NEXT: [[ARRAYIDX10:%.*]] = getelementptr inbounds float, ptr [[TMP39]], i64 0 +// CHECK-NEXT: [[TMP46:%.*]] = load float, ptr [[ARRAYIDX10]], align 4 +// CHECK-NEXT: [[INC11:%.*]] = fadd float [[TMP46]], 1.000000e+00 // CHECK-NEXT: store float [[INC11]], ptr [[ARRAYIDX10]], align 4 -// CHECK-NEXT: [[TMP42:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP43:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP44:%.*]] = getelementptr inbounds [6 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 6, ptr [[TMP42]], ptr [[TMP43]], ptr [[TMP44]], ptr @.offload_maptypes, ptr null, ptr null) -// CHECK-NEXT: [[TMP45:%.*]] = load float, ptr [[A]], align 4 -// CHECK-NEXT: [[CONV12:%.*]] = fptosi float [[TMP45]] to i32 +// CHECK-NEXT: [[TMP47:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP48:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP49:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 7, ptr [[TMP47]], ptr [[TMP48]], ptr [[TMP49]], ptr @.offload_maptypes, ptr null, ptr null) +// CHECK-NEXT: [[TMP50:%.*]] = load float, ptr [[A]], align 4 +// CHECK-NEXT: [[CONV12:%.*]] = fptosi float [[TMP50]] to i32 // CHECK-NEXT: store i32 [[CONV12]], ptr [[RETVAL]], align 4 -// CHECK-NEXT: [[TMP46:%.*]] = load ptr, ptr [[SAVED_STACK]], align 8 -// CHECK-NEXT: call void @llvm.stackrestore.p0(ptr [[TMP46]]) -// CHECK-NEXT: [[TMP47:%.*]] = load i32, ptr [[RETVAL]], align 4 -// CHECK-NEXT: ret i32 [[TMP47]] +// CHECK-NEXT: [[TMP51:%.*]] = load ptr, ptr [[SAVED_STACK]], align 8 +// CHECK-NEXT: call void @llvm.stackrestore.p0(ptr [[TMP51]]) +// CHECK-NEXT: [[TMP52:%.*]] = load i32, ptr [[RETVAL]], align 4 +// CHECK-NEXT: ret i32 [[TMP52]] // // // CHECK-LABEL: define linkonce_odr void @_ZN1SC1Ev( @@ -201,10 +233,10 @@ int main() { // CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(40) [[THIS:%.*]]) #[[ATTR2]] comdat { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [6 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [6 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [6 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [6 x i64], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [7 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [7 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [7 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [7 x i64], align 8 // CHECK-NEXT: [[TMP:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[_TMP11:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[_TMP12:%.*]] = alloca ptr, align 8 @@ -213,110 +245,118 @@ int main() { // CHECK-NEXT: store ptr [[THIS]], ptr [[THIS_ADDR]], align 8 // CHECK-NEXT: [[THIS1:%.*]] = load ptr, ptr [[THIS_ADDR]], align 8 // CHECK-NEXT: [[A:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[THIS1]], i32 0, i32 0 -// CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// CHECK-NEXT: [[PTR2:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[PTR2]], align 8 -// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP0]], i64 3 // CHECK-NEXT: [[REF:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 2 -// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3]], !align [[META4]] -// CHECK-NEXT: [[PTR3:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// CHECK-NEXT: [[PTR4:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[PTR4]], align 8 -// CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds i32, ptr [[TMP2]], i64 0 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3]], !align [[META4]] // CHECK-NEXT: [[ARR:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 3 -// CHECK-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[ARR]], i64 0, i64 0 -// CHECK-NEXT: [[A7:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[A7]], align 8 -// CHECK-NEXT: [[CONV:%.*]] = sext i32 [[TMP3]] to i64 -// CHECK-NEXT: [[TMP4:%.*]] = mul nuw i64 [[CONV]], 4 -// CHECK-NEXT: [[A8:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[A8]], align 8 -// CHECK-NEXT: [[TMP6:%.*]] = sext i32 [[TMP5]] to i64 -// CHECK-NEXT: [[LB_ADD_LEN:%.*]] = add nsw i64 -1, [[TMP6]] -// CHECK-NEXT: [[ARR9:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 3 -// CHECK-NEXT: [[ARRAYIDX10:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[ARR9]], i64 0, i64 [[LB_ADD_LEN]] -// CHECK-NEXT: [[TMP7:%.*]] = getelementptr i32, ptr [[ARRAYIDX10]], i32 1 -// CHECK-NEXT: [[TMP8:%.*]] = ptrtoint ptr [[TMP7]] to i64 -// CHECK-NEXT: [[TMP9:%.*]] = ptrtoint ptr [[A]] to i64 -// CHECK-NEXT: [[TMP10:%.*]] = sub i64 [[TMP8]], [[TMP9]] -// CHECK-NEXT: [[TMP11:%.*]] = sdiv exact i64 [[TMP10]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes.1, i64 48, i1 false) -// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[THIS1]], ptr [[TMP12]], align 8 -// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[A]], ptr [[TMP13]], align 8 -// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [6 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP11]], ptr [[TMP14]], align 8 -// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP15]], align 8 -// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[THIS1]], ptr [[TMP16]], align 8 -// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[A]], ptr [[TMP17]], align 8 -// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK-NEXT: store ptr null, ptr [[TMP18]], align 8 -// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[PTR]], ptr [[TMP19]], align 8 -// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP20]], align 8 -// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK-NEXT: store ptr null, ptr [[TMP21]], align 8 -// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[THIS1]], ptr [[TMP22]], align 8 -// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP1]], ptr [[TMP23]], align 8 -// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 -// CHECK-NEXT: store ptr null, ptr [[TMP24]], align 8 -// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 -// CHECK-NEXT: store ptr [[PTR3]], ptr [[TMP25]], align 8 -// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 -// CHECK-NEXT: store ptr [[ARRAYIDX5]], ptr [[TMP26]], align 8 -// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 +// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[ARR]], i64 0, i64 0 +// CHECK-NEXT: [[A2:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 0 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[A2]], align 8 +// CHECK-NEXT: [[CONV:%.*]] = sext i32 [[TMP1]] to i64 +// CHECK-NEXT: [[TMP2:%.*]] = mul nuw i64 [[CONV]], 4 +// CHECK-NEXT: [[A3:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 0 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[A3]], align 8 +// CHECK-NEXT: [[TMP4:%.*]] = sext i32 [[TMP3]] to i64 +// CHECK-NEXT: [[LB_ADD_LEN:%.*]] = add nsw i64 -1, [[TMP4]] +// CHECK-NEXT: [[ARR4:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 3 +// CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[ARR4]], i64 0, i64 [[LB_ADD_LEN]] +// CHECK-NEXT: [[TMP5:%.*]] = getelementptr i32, ptr [[ARRAYIDX5]], i32 1 +// CHECK-NEXT: [[TMP6:%.*]] = ptrtoint ptr [[TMP5]] to i64 +// CHECK-NEXT: [[TMP7:%.*]] = ptrtoint ptr [[A]] to i64 +// CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[TMP6]], [[TMP7]] +// CHECK-NEXT: [[TMP9:%.*]] = sdiv exact i64 [[TMP8]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) +// CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// CHECK-NEXT: [[TMP10:%.*]] = load ptr, ptr [[PTR]], align 8 +// CHECK-NEXT: [[PTR6:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// CHECK-NEXT: [[TMP11:%.*]] = load ptr, ptr [[PTR6]], align 8 +// CHECK-NEXT: [[ARRAYIDX7:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP11]], i64 3 +// CHECK-NEXT: [[PTR8:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// CHECK-NEXT: [[TMP12:%.*]] = load ptr, ptr [[PTR8]], align 8 +// CHECK-NEXT: [[PTR9:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// CHECK-NEXT: [[TMP13:%.*]] = load ptr, ptr [[PTR9]], align 8 +// CHECK-NEXT: [[ARRAYIDX10:%.*]] = getelementptr inbounds i32, ptr [[TMP13]], i64 0 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes.1, i64 56, i1 false) +// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[THIS1]], ptr [[TMP14]], align 8 +// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[A]], ptr [[TMP15]], align 8 +// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: store i64 [[TMP9]], ptr [[TMP16]], align 8 +// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP17]], align 8 +// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[THIS1]], ptr [[TMP18]], align 8 +// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[A]], ptr [[TMP19]], align 8 +// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP20]], align 8 +// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[THIS1]], ptr [[TMP21]], align 8 +// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP0]], ptr [[TMP22]], align 8 +// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK-NEXT: store ptr null, ptr [[TMP23]], align 8 +// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[THIS1]], ptr [[TMP24]], align 8 +// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP25]], align 8 +// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 3 +// CHECK-NEXT: store i64 [[TMP2]], ptr [[TMP26]], align 8 +// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 // CHECK-NEXT: store ptr null, ptr [[TMP27]], align 8 -// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5 -// CHECK-NEXT: store ptr [[THIS1]], ptr [[TMP28]], align 8 -// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 5 -// CHECK-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP29]], align 8 -// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [6 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 5 -// CHECK-NEXT: store i64 [[TMP4]], ptr [[TMP30]], align 8 -// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5 -// CHECK-NEXT: store ptr null, ptr [[TMP31]], align 8 -// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds [6 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 6, ptr [[TMP32]], ptr [[TMP33]], ptr [[TMP34]], ptr @.offload_maptypes.2, ptr null, ptr null) -// CHECK-NEXT: [[TMP35:%.*]] = load ptr, ptr [[TMP16]], align 8 -// CHECK-NEXT: store ptr [[TMP35]], ptr [[TMP]], align 8 -// CHECK-NEXT: [[TMP36:%.*]] = load ptr, ptr [[TMP19]], align 8 -// CHECK-NEXT: store ptr [[TMP36]], ptr [[_TMP11]], align 8 -// CHECK-NEXT: [[TMP37:%.*]] = load ptr, ptr [[TMP22]], align 8 -// CHECK-NEXT: store ptr [[TMP37]], ptr [[_TMP12]], align 8 -// CHECK-NEXT: [[TMP38:%.*]] = load ptr, ptr [[TMP19]], align 8 -// CHECK-NEXT: store ptr [[TMP38]], ptr [[_TMP13]], align 8 -// CHECK-NEXT: [[TMP39:%.*]] = load ptr, ptr [[TMP28]], align 8 -// CHECK-NEXT: store ptr [[TMP39]], ptr [[_TMP14]], align 8 -// CHECK-NEXT: [[TMP40:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META3]], !align [[META4]] -// CHECK-NEXT: [[TMP41:%.*]] = load i32, ptr [[TMP40]], align 4 -// CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP41]], 1 -// CHECK-NEXT: store i32 [[INC]], ptr [[TMP40]], align 4 -// CHECK-NEXT: [[TMP42:%.*]] = load ptr, ptr [[_TMP13]], align 8, !nonnull [[META3]], !align [[META5:![0-9]+]] -// CHECK-NEXT: [[TMP43:%.*]] = load ptr, ptr [[TMP42]], align 8 -// CHECK-NEXT: [[TMP44:%.*]] = load i32, ptr [[TMP43]], align 4 -// CHECK-NEXT: [[INC15:%.*]] = add nsw i32 [[TMP44]], 1 -// CHECK-NEXT: store i32 [[INC15]], ptr [[TMP43]], align 4 -// CHECK-NEXT: [[TMP45:%.*]] = load ptr, ptr [[_TMP12]], align 8, !nonnull [[META3]], !align [[META4]] +// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[TMP10]], ptr [[TMP28]], align 8 +// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[ARRAYIDX7]], ptr [[TMP29]], align 8 +// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 +// CHECK-NEXT: store ptr null, ptr [[TMP30]], align 8 +// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5 +// CHECK-NEXT: store ptr [[TMP12]], ptr [[TMP31]], align 8 +// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 5 +// CHECK-NEXT: store ptr [[ARRAYIDX10]], ptr [[TMP32]], align 8 +// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5 +// CHECK-NEXT: store ptr null, ptr [[TMP33]], align 8 +// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6 +// CHECK-NEXT: store ptr [[PTR8]], ptr [[TMP34]], align 8 +// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 6 +// CHECK-NEXT: store ptr [[ARRAYIDX10]], ptr [[TMP35]], align 8 +// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 6 +// CHECK-NEXT: store ptr null, ptr [[TMP36]], align 8 +// CHECK-NEXT: [[TMP37:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP38:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP39:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 7, ptr [[TMP37]], ptr [[TMP38]], ptr [[TMP39]], ptr @.offload_maptypes.2, ptr null, ptr null) +// CHECK-NEXT: [[TMP40:%.*]] = load ptr, ptr [[TMP18]], align 8 +// CHECK-NEXT: store ptr [[TMP40]], ptr [[TMP]], align 8 +// CHECK-NEXT: [[TMP41:%.*]] = load ptr, ptr [[TMP28]], align 8 +// CHECK-NEXT: store ptr [[TMP41]], ptr [[_TMP11]], align 8 +// CHECK-NEXT: [[TMP42:%.*]] = load ptr, ptr [[TMP21]], align 8 +// CHECK-NEXT: store ptr [[TMP42]], ptr [[_TMP12]], align 8 +// CHECK-NEXT: [[TMP43:%.*]] = load ptr, ptr [[TMP28]], align 8 +// CHECK-NEXT: store ptr [[TMP43]], ptr [[_TMP13]], align 8 +// CHECK-NEXT: [[TMP44:%.*]] = load ptr, ptr [[TMP24]], align 8 +// CHECK-NEXT: store ptr [[TMP44]], ptr [[_TMP14]], align 8 +// CHECK-NEXT: [[TMP45:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META3]], !align [[META4]] // CHECK-NEXT: [[TMP46:%.*]] = load i32, ptr [[TMP45]], align 4 -// CHECK-NEXT: [[INC16:%.*]] = add nsw i32 [[TMP46]], 1 -// CHECK-NEXT: store i32 [[INC16]], ptr [[TMP45]], align 4 -// CHECK-NEXT: [[TMP47:%.*]] = load ptr, ptr [[_TMP14]], align 8, !nonnull [[META3]], !align [[META4]] -// CHECK-NEXT: [[ARRAYIDX17:%.*]] = getelementptr inbounds [4 x i32], ptr [[TMP47]], i64 0, i64 0 -// CHECK-NEXT: [[TMP48:%.*]] = load i32, ptr [[ARRAYIDX17]], align 4 -// CHECK-NEXT: [[INC18:%.*]] = add nsw i32 [[TMP48]], 1 +// CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP46]], 1 +// CHECK-NEXT: store i32 [[INC]], ptr [[TMP45]], align 4 +// CHECK-NEXT: [[TMP47:%.*]] = load ptr, ptr [[_TMP13]], align 8, !nonnull [[META3]], !align [[META5:![0-9]+]] +// CHECK-NEXT: [[TMP48:%.*]] = load ptr, ptr [[TMP47]], align 8 +// CHECK-NEXT: [[TMP49:%.*]] = load i32, ptr [[TMP48]], align 4 +// CHECK-NEXT: [[INC15:%.*]] = add nsw i32 [[TMP49]], 1 +// CHECK-NEXT: store i32 [[INC15]], ptr [[TMP48]], align 4 +// CHECK-NEXT: [[TMP50:%.*]] = load ptr, ptr [[_TMP12]], align 8, !nonnull [[META3]], !align [[META4]] +// CHECK-NEXT: [[TMP51:%.*]] = load i32, ptr [[TMP50]], align 4 +// CHECK-NEXT: [[INC16:%.*]] = add nsw i32 [[TMP51]], 1 +// CHECK-NEXT: store i32 [[INC16]], ptr [[TMP50]], align 4 +// CHECK-NEXT: [[TMP52:%.*]] = load ptr, ptr [[_TMP14]], align 8, !nonnull [[META3]], !align [[META4]] +// CHECK-NEXT: [[ARRAYIDX17:%.*]] = getelementptr inbounds [4 x i32], ptr [[TMP52]], i64 0, i64 0 +// CHECK-NEXT: [[TMP53:%.*]] = load i32, ptr [[ARRAYIDX17]], align 4 +// CHECK-NEXT: [[INC18:%.*]] = add nsw i32 [[TMP53]], 1 // CHECK-NEXT: store i32 [[INC18]], ptr [[ARRAYIDX17]], align 4 -// CHECK-NEXT: [[TMP49:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP50:%.*]] = getelementptr inbounds [6 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP51:%.*]] = getelementptr inbounds [6 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 6, ptr [[TMP49]], ptr [[TMP50]], ptr [[TMP51]], ptr @.offload_maptypes.2, ptr null, ptr null) +// CHECK-NEXT: [[TMP54:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP55:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP56:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 7, ptr [[TMP54]], ptr [[TMP55]], ptr [[TMP56]], ptr @.offload_maptypes.2, ptr null, ptr null) // CHECK-NEXT: ret void // // @@ -350,10 +390,10 @@ int main() { // OMP60-NEXT: [[SAVED_STACK:%.*]] = alloca ptr, align 8 // OMP60-NEXT: [[__VLA_EXPR0:%.*]] = alloca i64, align 8 // OMP60-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 8 -// OMP60-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [9 x ptr], align 8 -// OMP60-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [9 x ptr], align 8 -// OMP60-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [9 x ptr], align 8 -// OMP60-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [9 x i64], align 8 +// OMP60-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [10 x ptr], align 8 +// OMP60-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [10 x ptr], align 8 +// OMP60-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [10 x ptr], align 8 +// OMP60-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [10 x i64], align 8 // OMP60-NEXT: [[TMP:%.*]] = alloca ptr, align 8 // OMP60-NEXT: store i32 0, ptr [[RETVAL]], align 4 // OMP60-NEXT: store i32 [[ARGC]], ptr [[ARGC_ADDR]], align 4 @@ -371,122 +411,132 @@ int main() { // OMP60-NEXT: call void @_ZN1SC1Ev(ptr noundef nonnull align 8 dereferenceable(40) [[S]]) // OMP60-NEXT: call void @_ZN1S3fooEv(ptr noundef nonnull align 8 dereferenceable(40) [[S]]) // OMP60-NEXT: [[TMP3:%.*]] = load ptr, ptr [[PTR]], align 8 -// OMP60-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw float, ptr [[TMP3]], i64 3 // OMP60-NEXT: [[TMP4:%.*]] = load ptr, ptr [[PTR]], align 8 -// OMP60-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds float, ptr [[TMP4]], i64 0 +// OMP60-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw float, ptr [[TMP4]], i64 3 // OMP60-NEXT: [[TMP5:%.*]] = load ptr, ptr [[PTR]], align 8 -// OMP60-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds nuw float, ptr [[TMP5]], i64 0 -// OMP60-NEXT: [[TMP6:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3:![0-9]+]], !align [[META4:![0-9]+]] -// OMP60-NEXT: [[TMP7:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3]], !align [[META4]] +// OMP60-NEXT: [[TMP6:%.*]] = load ptr, ptr [[PTR]], align 8 +// OMP60-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds float, ptr [[TMP6]], i64 0 +// OMP60-NEXT: [[TMP7:%.*]] = load ptr, ptr [[PTR]], align 8 +// OMP60-NEXT: [[TMP8:%.*]] = load ptr, ptr [[PTR]], align 8 +// OMP60-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds nuw float, ptr [[TMP8]], i64 0 +// OMP60-NEXT: [[TMP9:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3:![0-9]+]], !align [[META4:![0-9]+]] +// OMP60-NEXT: [[TMP10:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3]], !align [[META4]] // OMP60-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds nuw [4 x float], ptr [[ARR]], i64 0, i64 0 -// OMP60-NEXT: [[TMP8:%.*]] = load float, ptr [[A]], align 4 -// OMP60-NEXT: [[CONV4:%.*]] = fptosi float [[TMP8]] to i32 +// OMP60-NEXT: [[TMP11:%.*]] = load float, ptr [[A]], align 4 +// OMP60-NEXT: [[CONV4:%.*]] = fptosi float [[TMP11]] to i32 // OMP60-NEXT: [[CONV5:%.*]] = sext i32 [[CONV4]] to i64 -// OMP60-NEXT: [[TMP9:%.*]] = mul nuw i64 [[CONV5]], 4 +// OMP60-NEXT: [[TMP12:%.*]] = mul nuw i64 [[CONV5]], 4 // OMP60-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds float, ptr [[VLA]], i64 0 -// OMP60-NEXT: [[TMP10:%.*]] = load ptr, ptr [[ARGV_ADDR]], align 8 -// OMP60-NEXT: [[TMP11:%.*]] = load ptr, ptr [[ARGV_ADDR]], align 8 -// OMP60-NEXT: [[ARRAYIDX7:%.*]] = getelementptr inbounds ptr, ptr [[TMP11]], i64 0 -// OMP60-NEXT: [[TMP12:%.*]] = load ptr, ptr [[ARGV_ADDR]], align 8 -// OMP60-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds ptr, ptr [[TMP12]], i64 0 -// OMP60-NEXT: [[TMP13:%.*]] = load ptr, ptr [[ARRAYIDX8]], align 8 -// OMP60-NEXT: [[ARRAYIDX9:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP13]], i64 0 -// OMP60-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes, i64 72, i1 false) -// OMP60-NEXT: [[TMP14:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// OMP60-NEXT: store ptr [[A]], ptr [[TMP14]], align 8 -// OMP60-NEXT: [[TMP15:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// OMP60-NEXT: store ptr [[A]], ptr [[TMP15]], align 8 -// OMP60-NEXT: [[TMP16:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 -// OMP60-NEXT: store ptr null, ptr [[TMP16]], align 8 -// OMP60-NEXT: [[TMP17:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// OMP60-NEXT: store ptr [[PTR]], ptr [[TMP17]], align 8 -// OMP60-NEXT: [[TMP18:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// OMP60-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP18]], align 8 -// OMP60-NEXT: [[TMP19:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// OMP60-NEXT: store ptr null, ptr [[TMP19]], align 8 -// OMP60-NEXT: [[TMP20:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// OMP60-NEXT: store ptr [[PTR]], ptr [[TMP20]], align 8 -// OMP60-NEXT: [[TMP21:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// OMP60-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP21]], align 8 -// OMP60-NEXT: [[TMP22:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// OMP60-NEXT: store ptr null, ptr [[TMP22]], align 8 -// OMP60-NEXT: [[TMP23:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 -// OMP60-NEXT: store ptr [[PTR]], ptr [[TMP23]], align 8 -// OMP60-NEXT: [[TMP24:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 -// OMP60-NEXT: store ptr [[ARRAYIDX2]], ptr [[TMP24]], align 8 -// OMP60-NEXT: [[TMP25:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 -// OMP60-NEXT: store ptr null, ptr [[TMP25]], align 8 -// OMP60-NEXT: [[TMP26:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 -// OMP60-NEXT: store ptr [[TMP6]], ptr [[TMP26]], align 8 -// OMP60-NEXT: [[TMP27:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// OMP60-NEXT: [[TMP13:%.*]] = load ptr, ptr [[ARGV_ADDR]], align 8 +// OMP60-NEXT: [[ARRAYIDX7:%.*]] = getelementptr inbounds ptr, ptr [[TMP13]], i64 0 +// OMP60-NEXT: [[TMP14:%.*]] = load ptr, ptr [[ARRAYIDX7]], align 8 +// OMP60-NEXT: [[TMP15:%.*]] = load ptr, ptr [[ARGV_ADDR]], align 8 +// OMP60-NEXT: [[TMP16:%.*]] = load ptr, ptr [[ARGV_ADDR]], align 8 +// OMP60-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds ptr, ptr [[TMP16]], i64 0 +// OMP60-NEXT: [[TMP17:%.*]] = load ptr, ptr [[ARRAYIDX8]], align 8 +// OMP60-NEXT: [[ARRAYIDX9:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP17]], i64 0 +// OMP60-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes, i64 80, i1 false) +// OMP60-NEXT: [[TMP18:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// OMP60-NEXT: store ptr [[A]], ptr [[TMP18]], align 8 +// OMP60-NEXT: [[TMP19:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// OMP60-NEXT: store ptr [[A]], ptr [[TMP19]], align 8 +// OMP60-NEXT: [[TMP20:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// OMP60-NEXT: store ptr null, ptr [[TMP20]], align 8 +// OMP60-NEXT: [[TMP21:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// OMP60-NEXT: store ptr [[TMP3]], ptr [[TMP21]], align 8 +// OMP60-NEXT: [[TMP22:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// OMP60-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP22]], align 8 +// OMP60-NEXT: [[TMP23:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// OMP60-NEXT: store ptr null, ptr [[TMP23]], align 8 +// OMP60-NEXT: [[TMP24:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// OMP60-NEXT: store ptr [[TMP5]], ptr [[TMP24]], align 8 +// OMP60-NEXT: [[TMP25:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// OMP60-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP25]], align 8 +// OMP60-NEXT: [[TMP26:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// OMP60-NEXT: store ptr null, ptr [[TMP26]], align 8 +// OMP60-NEXT: [[TMP27:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 // OMP60-NEXT: store ptr [[TMP7]], ptr [[TMP27]], align 8 -// OMP60-NEXT: [[TMP28:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 -// OMP60-NEXT: store ptr null, ptr [[TMP28]], align 8 -// OMP60-NEXT: [[TMP29:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5 -// OMP60-NEXT: store ptr [[ARR]], ptr [[TMP29]], align 8 -// OMP60-NEXT: [[TMP30:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 5 -// OMP60-NEXT: store ptr [[ARRAYIDX3]], ptr [[TMP30]], align 8 -// OMP60-NEXT: [[TMP31:%.*]] = getelementptr inbounds [9 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 5 -// OMP60-NEXT: store i64 [[TMP9]], ptr [[TMP31]], align 8 -// OMP60-NEXT: [[TMP32:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5 +// OMP60-NEXT: [[TMP28:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 +// OMP60-NEXT: store ptr [[ARRAYIDX2]], ptr [[TMP28]], align 8 +// OMP60-NEXT: [[TMP29:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 +// OMP60-NEXT: store ptr null, ptr [[TMP29]], align 8 +// OMP60-NEXT: [[TMP30:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 +// OMP60-NEXT: store ptr [[PTR]], ptr [[TMP30]], align 8 +// OMP60-NEXT: [[TMP31:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// OMP60-NEXT: store ptr [[ARRAYIDX2]], ptr [[TMP31]], align 8 +// OMP60-NEXT: [[TMP32:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 // OMP60-NEXT: store ptr null, ptr [[TMP32]], align 8 -// OMP60-NEXT: [[TMP33:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6 -// OMP60-NEXT: store ptr [[VLA]], ptr [[TMP33]], align 8 -// OMP60-NEXT: [[TMP34:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 6 -// OMP60-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP34]], align 8 -// OMP60-NEXT: [[TMP35:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 6 +// OMP60-NEXT: [[TMP33:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5 +// OMP60-NEXT: store ptr [[TMP9]], ptr [[TMP33]], align 8 +// OMP60-NEXT: [[TMP34:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 5 +// OMP60-NEXT: store ptr [[TMP10]], ptr [[TMP34]], align 8 +// OMP60-NEXT: [[TMP35:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5 // OMP60-NEXT: store ptr null, ptr [[TMP35]], align 8 -// OMP60-NEXT: [[TMP36:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 7 -// OMP60-NEXT: store ptr [[TMP10]], ptr [[TMP36]], align 8 -// OMP60-NEXT: [[TMP37:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 7 -// OMP60-NEXT: store ptr [[ARRAYIDX7]], ptr [[TMP37]], align 8 -// OMP60-NEXT: [[TMP38:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 7 -// OMP60-NEXT: store ptr null, ptr [[TMP38]], align 8 -// OMP60-NEXT: [[TMP39:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 8 -// OMP60-NEXT: store ptr [[ARRAYIDX7]], ptr [[TMP39]], align 8 -// OMP60-NEXT: [[TMP40:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 8 -// OMP60-NEXT: store ptr [[ARRAYIDX9]], ptr [[TMP40]], align 8 -// OMP60-NEXT: [[TMP41:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 8 -// OMP60-NEXT: store ptr null, ptr [[TMP41]], align 8 -// OMP60-NEXT: [[TMP42:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// OMP60-NEXT: [[TMP43:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// OMP60-NEXT: [[TMP44:%.*]] = getelementptr inbounds [9 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// OMP60-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 9, ptr [[TMP42]], ptr [[TMP43]], ptr [[TMP44]], ptr @.offload_maptypes, ptr null, ptr null) -// OMP60-NEXT: [[TMP45:%.*]] = load ptr, ptr [[TMP14]], align 8 -// OMP60-NEXT: [[TMP46:%.*]] = load ptr, ptr [[TMP26]], align 8 -// OMP60-NEXT: store ptr [[TMP46]], ptr [[TMP]], align 8 -// OMP60-NEXT: [[TMP47:%.*]] = load ptr, ptr [[TMP29]], align 8 -// OMP60-NEXT: [[TMP48:%.*]] = load ptr, ptr [[TMP33]], align 8 -// OMP60-NEXT: [[TMP49:%.*]] = load float, ptr [[TMP45]], align 4 -// OMP60-NEXT: [[INC:%.*]] = fadd float [[TMP49]], 1.000000e+00 -// OMP60-NEXT: store float [[INC]], ptr [[TMP45]], align 4 -// OMP60-NEXT: [[TMP50:%.*]] = load ptr, ptr [[TMP17]], align 8 -// OMP60-NEXT: [[TMP51:%.*]] = load float, ptr [[TMP50]], align 4 -// OMP60-NEXT: [[INC10:%.*]] = fadd float [[TMP51]], 1.000000e+00 -// OMP60-NEXT: store float [[INC10]], ptr [[TMP50]], align 4 -// OMP60-NEXT: [[TMP52:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META3]], !align [[META4]] -// OMP60-NEXT: [[TMP53:%.*]] = load float, ptr [[TMP52]], align 4 -// OMP60-NEXT: [[INC11:%.*]] = fadd float [[TMP53]], 1.000000e+00 -// OMP60-NEXT: store float [[INC11]], ptr [[TMP52]], align 4 -// OMP60-NEXT: [[ARRAYIDX12:%.*]] = getelementptr inbounds [4 x float], ptr [[TMP47]], i64 0, i64 0 -// OMP60-NEXT: [[TMP54:%.*]] = load float, ptr [[ARRAYIDX12]], align 4 -// OMP60-NEXT: [[INC13:%.*]] = fadd float [[TMP54]], 1.000000e+00 +// OMP60-NEXT: [[TMP36:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6 +// OMP60-NEXT: store ptr [[ARR]], ptr [[TMP36]], align 8 +// OMP60-NEXT: [[TMP37:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 6 +// OMP60-NEXT: store ptr [[ARRAYIDX3]], ptr [[TMP37]], align 8 +// OMP60-NEXT: [[TMP38:%.*]] = getelementptr inbounds [10 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 6 +// OMP60-NEXT: store i64 [[TMP12]], ptr [[TMP38]], align 8 +// OMP60-NEXT: [[TMP39:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 6 +// OMP60-NEXT: store ptr null, ptr [[TMP39]], align 8 +// OMP60-NEXT: [[TMP40:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 7 +// OMP60-NEXT: store ptr [[VLA]], ptr [[TMP40]], align 8 +// OMP60-NEXT: [[TMP41:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 7 +// OMP60-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP41]], align 8 +// OMP60-NEXT: [[TMP42:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 7 +// OMP60-NEXT: store ptr null, ptr [[TMP42]], align 8 +// OMP60-NEXT: [[TMP43:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 8 +// OMP60-NEXT: store ptr [[TMP14]], ptr [[TMP43]], align 8 +// OMP60-NEXT: [[TMP44:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 8 +// OMP60-NEXT: store ptr [[ARRAYIDX9]], ptr [[TMP44]], align 8 +// OMP60-NEXT: [[TMP45:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 8 +// OMP60-NEXT: store ptr null, ptr [[TMP45]], align 8 +// OMP60-NEXT: [[TMP46:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 9 +// OMP60-NEXT: store ptr [[ARRAYIDX7]], ptr [[TMP46]], align 8 +// OMP60-NEXT: [[TMP47:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 9 +// OMP60-NEXT: store ptr [[ARRAYIDX9]], ptr [[TMP47]], align 8 +// OMP60-NEXT: [[TMP48:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 9 +// OMP60-NEXT: store ptr null, ptr [[TMP48]], align 8 +// OMP60-NEXT: [[TMP49:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// OMP60-NEXT: [[TMP50:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// OMP60-NEXT: [[TMP51:%.*]] = getelementptr inbounds [10 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// OMP60-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 10, ptr [[TMP49]], ptr [[TMP50]], ptr [[TMP51]], ptr @.offload_maptypes, ptr null, ptr null) +// OMP60-NEXT: [[TMP52:%.*]] = load ptr, ptr [[TMP18]], align 8 +// OMP60-NEXT: [[TMP53:%.*]] = load ptr, ptr [[TMP33]], align 8 +// OMP60-NEXT: store ptr [[TMP53]], ptr [[TMP]], align 8 +// OMP60-NEXT: [[TMP54:%.*]] = load ptr, ptr [[TMP36]], align 8 +// OMP60-NEXT: [[TMP55:%.*]] = load ptr, ptr [[TMP40]], align 8 +// OMP60-NEXT: [[TMP56:%.*]] = load float, ptr [[TMP52]], align 4 +// OMP60-NEXT: [[INC:%.*]] = fadd float [[TMP56]], 1.000000e+00 +// OMP60-NEXT: store float [[INC]], ptr [[TMP52]], align 4 +// OMP60-NEXT: [[TMP57:%.*]] = load ptr, ptr [[TMP21]], align 8 +// OMP60-NEXT: [[TMP58:%.*]] = load float, ptr [[TMP57]], align 4 +// OMP60-NEXT: [[INC10:%.*]] = fadd float [[TMP58]], 1.000000e+00 +// OMP60-NEXT: store float [[INC10]], ptr [[TMP57]], align 4 +// OMP60-NEXT: [[TMP59:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META3]], !align [[META4]] +// OMP60-NEXT: [[TMP60:%.*]] = load float, ptr [[TMP59]], align 4 +// OMP60-NEXT: [[INC11:%.*]] = fadd float [[TMP60]], 1.000000e+00 +// OMP60-NEXT: store float [[INC11]], ptr [[TMP59]], align 4 +// OMP60-NEXT: [[ARRAYIDX12:%.*]] = getelementptr inbounds [4 x float], ptr [[TMP54]], i64 0, i64 0 +// OMP60-NEXT: [[TMP61:%.*]] = load float, ptr [[ARRAYIDX12]], align 4 +// OMP60-NEXT: [[INC13:%.*]] = fadd float [[TMP61]], 1.000000e+00 // OMP60-NEXT: store float [[INC13]], ptr [[ARRAYIDX12]], align 4 -// OMP60-NEXT: [[ARRAYIDX14:%.*]] = getelementptr inbounds float, ptr [[TMP48]], i64 0 -// OMP60-NEXT: [[TMP55:%.*]] = load float, ptr [[ARRAYIDX14]], align 4 -// OMP60-NEXT: [[INC15:%.*]] = fadd float [[TMP55]], 1.000000e+00 +// OMP60-NEXT: [[ARRAYIDX14:%.*]] = getelementptr inbounds float, ptr [[TMP55]], i64 0 +// OMP60-NEXT: [[TMP62:%.*]] = load float, ptr [[ARRAYIDX14]], align 4 +// OMP60-NEXT: [[INC15:%.*]] = fadd float [[TMP62]], 1.000000e+00 // OMP60-NEXT: store float [[INC15]], ptr [[ARRAYIDX14]], align 4 -// OMP60-NEXT: [[TMP56:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// OMP60-NEXT: [[TMP57:%.*]] = getelementptr inbounds [9 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// OMP60-NEXT: [[TMP58:%.*]] = getelementptr inbounds [9 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// OMP60-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 9, ptr [[TMP56]], ptr [[TMP57]], ptr [[TMP58]], ptr @.offload_maptypes, ptr null, ptr null) -// OMP60-NEXT: [[TMP59:%.*]] = load float, ptr [[A]], align 4 -// OMP60-NEXT: [[CONV16:%.*]] = fptosi float [[TMP59]] to i32 +// OMP60-NEXT: [[TMP63:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// OMP60-NEXT: [[TMP64:%.*]] = getelementptr inbounds [10 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// OMP60-NEXT: [[TMP65:%.*]] = getelementptr inbounds [10 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// OMP60-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 10, ptr [[TMP63]], ptr [[TMP64]], ptr [[TMP65]], ptr @.offload_maptypes, ptr null, ptr null) +// OMP60-NEXT: [[TMP66:%.*]] = load float, ptr [[A]], align 4 +// OMP60-NEXT: [[CONV16:%.*]] = fptosi float [[TMP66]] to i32 // OMP60-NEXT: store i32 [[CONV16]], ptr [[RETVAL]], align 4 -// OMP60-NEXT: [[TMP60:%.*]] = load ptr, ptr [[SAVED_STACK]], align 8 -// OMP60-NEXT: call void @llvm.stackrestore.p0(ptr [[TMP60]]) -// OMP60-NEXT: [[TMP61:%.*]] = load i32, ptr [[RETVAL]], align 4 -// OMP60-NEXT: ret i32 [[TMP61]] +// OMP60-NEXT: [[TMP67:%.*]] = load ptr, ptr [[SAVED_STACK]], align 8 +// OMP60-NEXT: call void @llvm.stackrestore.p0(ptr [[TMP67]]) +// OMP60-NEXT: [[TMP68:%.*]] = load i32, ptr [[RETVAL]], align 4 +// OMP60-NEXT: ret i32 [[TMP68]] // // // OMP60-LABEL: define linkonce_odr void @_ZN1SC1Ev( @@ -503,10 +553,10 @@ int main() { // OMP60-SAME: ptr noundef nonnull align 8 dereferenceable(40) [[THIS:%.*]]) #[[ATTR2]] comdat { // OMP60-NEXT: [[ENTRY:.*:]] // OMP60-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, align 8 -// OMP60-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [7 x ptr], align 8 -// OMP60-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [7 x ptr], align 8 -// OMP60-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [7 x ptr], align 8 -// OMP60-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [7 x i64], align 8 +// OMP60-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [8 x ptr], align 8 +// OMP60-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [8 x ptr], align 8 +// OMP60-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [8 x ptr], align 8 +// OMP60-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [8 x i64], align 8 // OMP60-NEXT: [[TMP:%.*]] = alloca ptr, align 8 // OMP60-NEXT: [[_TMP14:%.*]] = alloca ptr, align 8 // OMP60-NEXT: [[_TMP15:%.*]] = alloca ptr, align 8 @@ -516,122 +566,131 @@ int main() { // OMP60-NEXT: store ptr [[THIS]], ptr [[THIS_ADDR]], align 8 // OMP60-NEXT: [[THIS1:%.*]] = load ptr, ptr [[THIS_ADDR]], align 8 // OMP60-NEXT: [[A:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[THIS1]], i32 0, i32 0 -// OMP60-NEXT: [[PTR:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// OMP60-NEXT: [[PTR2:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// OMP60-NEXT: [[TMP0:%.*]] = load ptr, ptr [[PTR2]], align 8 -// OMP60-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP0]], i64 3 // OMP60-NEXT: [[REF:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 2 -// OMP60-NEXT: [[TMP1:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3]], !align [[META4]] -// OMP60-NEXT: [[PTR3:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// OMP60-NEXT: [[PTR4:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// OMP60-NEXT: [[TMP2:%.*]] = load ptr, ptr [[PTR4]], align 8 -// OMP60-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds i32, ptr [[TMP2]], i64 0 +// OMP60-NEXT: [[TMP0:%.*]] = load ptr, ptr [[REF]], align 8, !nonnull [[META3]], !align [[META4]] // OMP60-NEXT: [[ARR:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 3 -// OMP60-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[ARR]], i64 0, i64 0 -// OMP60-NEXT: [[A7:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 0 -// OMP60-NEXT: [[TMP3:%.*]] = load i32, ptr [[A7]], align 8 -// OMP60-NEXT: [[CONV:%.*]] = sext i32 [[TMP3]] to i64 -// OMP60-NEXT: [[TMP4:%.*]] = mul nuw i64 [[CONV]], 4 -// OMP60-NEXT: [[A8:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 0 -// OMP60-NEXT: [[TMP5:%.*]] = load i32, ptr [[A8]], align 8 -// OMP60-NEXT: [[TMP6:%.*]] = sext i32 [[TMP5]] to i64 -// OMP60-NEXT: [[LB_ADD_LEN:%.*]] = add nsw i64 -1, [[TMP6]] -// OMP60-NEXT: [[ARR9:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 3 -// OMP60-NEXT: [[ARRAYIDX10:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[ARR9]], i64 0, i64 [[LB_ADD_LEN]] +// OMP60-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[ARR]], i64 0, i64 0 +// OMP60-NEXT: [[A2:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 0 +// OMP60-NEXT: [[TMP1:%.*]] = load i32, ptr [[A2]], align 8 +// OMP60-NEXT: [[CONV:%.*]] = sext i32 [[TMP1]] to i64 +// OMP60-NEXT: [[TMP2:%.*]] = mul nuw i64 [[CONV]], 4 +// OMP60-NEXT: [[A3:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 0 +// OMP60-NEXT: [[TMP3:%.*]] = load i32, ptr [[A3]], align 8 +// OMP60-NEXT: [[TMP4:%.*]] = sext i32 [[TMP3]] to i64 +// OMP60-NEXT: [[LB_ADD_LEN:%.*]] = add nsw i64 -1, [[TMP4]] +// OMP60-NEXT: [[ARR4:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 3 +// OMP60-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[ARR4]], i64 0, i64 [[LB_ADD_LEN]] +// OMP60-NEXT: [[TMP5:%.*]] = getelementptr i32, ptr [[ARRAYIDX5]], i32 1 +// OMP60-NEXT: [[TMP6:%.*]] = ptrtoint ptr [[TMP5]] to i64 +// OMP60-NEXT: [[TMP7:%.*]] = ptrtoint ptr [[A]] to i64 +// OMP60-NEXT: [[TMP8:%.*]] = sub i64 [[TMP6]], [[TMP7]] +// OMP60-NEXT: [[TMP9:%.*]] = sdiv exact i64 [[TMP8]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) +// OMP60-NEXT: [[PTR:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// OMP60-NEXT: [[TMP10:%.*]] = load ptr, ptr [[PTR]], align 8 +// OMP60-NEXT: [[PTR6:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// OMP60-NEXT: [[TMP11:%.*]] = load ptr, ptr [[PTR6]], align 8 +// OMP60-NEXT: [[ARRAYIDX7:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP11]], i64 3 +// OMP60-NEXT: [[PTR8:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// OMP60-NEXT: [[TMP12:%.*]] = load ptr, ptr [[PTR8]], align 8 +// OMP60-NEXT: [[PTR9:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// OMP60-NEXT: [[TMP13:%.*]] = load ptr, ptr [[PTR9]], align 8 +// OMP60-NEXT: [[ARRAYIDX10:%.*]] = getelementptr inbounds i32, ptr [[TMP13]], i64 0 // OMP60-NEXT: [[PTR11:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 +// OMP60-NEXT: [[TMP14:%.*]] = load ptr, ptr [[PTR11]], align 8 // OMP60-NEXT: [[PTR12:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[THIS1]], i32 0, i32 1 -// OMP60-NEXT: [[TMP7:%.*]] = load ptr, ptr [[PTR12]], align 8 -// OMP60-NEXT: [[ARRAYIDX13:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP7]], i64 0 -// OMP60-NEXT: [[TMP8:%.*]] = getelementptr i32, ptr [[ARRAYIDX10]], i32 1 -// OMP60-NEXT: [[TMP9:%.*]] = ptrtoint ptr [[TMP8]] to i64 -// OMP60-NEXT: [[TMP10:%.*]] = ptrtoint ptr [[A]] to i64 -// OMP60-NEXT: [[TMP11:%.*]] = sub i64 [[TMP9]], [[TMP10]] -// OMP60-NEXT: [[TMP12:%.*]] = sdiv exact i64 [[TMP11]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// OMP60-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes.1, i64 56, i1 false) -// OMP60-NEXT: [[TMP13:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// OMP60-NEXT: store ptr [[THIS1]], ptr [[TMP13]], align 8 -// OMP60-NEXT: [[TMP14:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// OMP60-NEXT: store ptr [[A]], ptr [[TMP14]], align 8 -// OMP60-NEXT: [[TMP15:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// OMP60-NEXT: store i64 [[TMP12]], ptr [[TMP15]], align 8 -// OMP60-NEXT: [[TMP16:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 -// OMP60-NEXT: store ptr null, ptr [[TMP16]], align 8 -// OMP60-NEXT: [[TMP17:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// OMP60-NEXT: store ptr [[THIS1]], ptr [[TMP17]], align 8 -// OMP60-NEXT: [[TMP18:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// OMP60-NEXT: store ptr [[A]], ptr [[TMP18]], align 8 -// OMP60-NEXT: [[TMP19:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// OMP60-NEXT: [[TMP15:%.*]] = load ptr, ptr [[PTR12]], align 8 +// OMP60-NEXT: [[ARRAYIDX13:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP15]], i64 0 +// OMP60-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes.1, i64 64, i1 false) +// OMP60-NEXT: [[TMP16:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// OMP60-NEXT: store ptr [[THIS1]], ptr [[TMP16]], align 8 +// OMP60-NEXT: [[TMP17:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// OMP60-NEXT: store ptr [[A]], ptr [[TMP17]], align 8 +// OMP60-NEXT: [[TMP18:%.*]] = getelementptr inbounds [8 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// OMP60-NEXT: store i64 [[TMP9]], ptr [[TMP18]], align 8 +// OMP60-NEXT: [[TMP19:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 // OMP60-NEXT: store ptr null, ptr [[TMP19]], align 8 -// OMP60-NEXT: [[TMP20:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// OMP60-NEXT: store ptr [[PTR]], ptr [[TMP20]], align 8 -// OMP60-NEXT: [[TMP21:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// OMP60-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP21]], align 8 -// OMP60-NEXT: [[TMP22:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// OMP60-NEXT: [[TMP20:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// OMP60-NEXT: store ptr [[THIS1]], ptr [[TMP20]], align 8 +// OMP60-NEXT: [[TMP21:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// OMP60-NEXT: store ptr [[A]], ptr [[TMP21]], align 8 +// OMP60-NEXT: [[TMP22:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 // OMP60-NEXT: store ptr null, ptr [[TMP22]], align 8 -// OMP60-NEXT: [[TMP23:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 +// OMP60-NEXT: [[TMP23:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 // OMP60-NEXT: store ptr [[THIS1]], ptr [[TMP23]], align 8 -// OMP60-NEXT: [[TMP24:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 -// OMP60-NEXT: store ptr [[TMP1]], ptr [[TMP24]], align 8 -// OMP60-NEXT: [[TMP25:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 +// OMP60-NEXT: [[TMP24:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// OMP60-NEXT: store ptr [[TMP0]], ptr [[TMP24]], align 8 +// OMP60-NEXT: [[TMP25:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 // OMP60-NEXT: store ptr null, ptr [[TMP25]], align 8 -// OMP60-NEXT: [[TMP26:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 -// OMP60-NEXT: store ptr [[PTR3]], ptr [[TMP26]], align 8 -// OMP60-NEXT: [[TMP27:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 -// OMP60-NEXT: store ptr [[ARRAYIDX5]], ptr [[TMP27]], align 8 -// OMP60-NEXT: [[TMP28:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 -// OMP60-NEXT: store ptr null, ptr [[TMP28]], align 8 -// OMP60-NEXT: [[TMP29:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5 -// OMP60-NEXT: store ptr [[THIS1]], ptr [[TMP29]], align 8 -// OMP60-NEXT: [[TMP30:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 5 -// OMP60-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP30]], align 8 -// OMP60-NEXT: [[TMP31:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 5 -// OMP60-NEXT: store i64 [[TMP4]], ptr [[TMP31]], align 8 -// OMP60-NEXT: [[TMP32:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5 +// OMP60-NEXT: [[TMP26:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 +// OMP60-NEXT: store ptr [[THIS1]], ptr [[TMP26]], align 8 +// OMP60-NEXT: [[TMP27:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 +// OMP60-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP27]], align 8 +// OMP60-NEXT: [[TMP28:%.*]] = getelementptr inbounds [8 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 3 +// OMP60-NEXT: store i64 [[TMP2]], ptr [[TMP28]], align 8 +// OMP60-NEXT: [[TMP29:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 +// OMP60-NEXT: store ptr null, ptr [[TMP29]], align 8 +// OMP60-NEXT: [[TMP30:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 +// OMP60-NEXT: store ptr [[TMP10]], ptr [[TMP30]], align 8 +// OMP60-NEXT: [[TMP31:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// OMP60-NEXT: store ptr [[ARRAYIDX7]], ptr [[TMP31]], align 8 +// OMP60-NEXT: [[TMP32:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 // OMP60-NEXT: store ptr null, ptr [[TMP32]], align 8 -// OMP60-NEXT: [[TMP33:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6 -// OMP60-NEXT: store ptr [[PTR11]], ptr [[TMP33]], align 8 -// OMP60-NEXT: [[TMP34:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 6 -// OMP60-NEXT: store ptr [[ARRAYIDX13]], ptr [[TMP34]], align 8 -// OMP60-NEXT: [[TMP35:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 6 +// OMP60-NEXT: [[TMP33:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5 +// OMP60-NEXT: store ptr [[TMP12]], ptr [[TMP33]], align 8 +// OMP60-NEXT: [[TMP34:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 5 +// OMP60-NEXT: store ptr [[ARRAYIDX10]], ptr [[TMP34]], align 8 +// OMP60-NEXT: [[TMP35:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5 // OMP60-NEXT: store ptr null, ptr [[TMP35]], align 8 -// OMP60-NEXT: [[TMP36:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// OMP60-NEXT: [[TMP37:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// OMP60-NEXT: [[TMP38:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// OMP60-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 7, ptr [[TMP36]], ptr [[TMP37]], ptr [[TMP38]], ptr @.offload_maptypes.2, ptr null, ptr null) -// OMP60-NEXT: [[TMP39:%.*]] = load ptr, ptr [[TMP17]], align 8 -// OMP60-NEXT: store ptr [[TMP39]], ptr [[TMP]], align 8 -// OMP60-NEXT: [[TMP40:%.*]] = load ptr, ptr [[TMP20]], align 8 -// OMP60-NEXT: store ptr [[TMP40]], ptr [[_TMP14]], align 8 -// OMP60-NEXT: [[TMP41:%.*]] = load ptr, ptr [[TMP23]], align 8 -// OMP60-NEXT: store ptr [[TMP41]], ptr [[_TMP15]], align 8 -// OMP60-NEXT: [[TMP42:%.*]] = load ptr, ptr [[TMP20]], align 8 -// OMP60-NEXT: store ptr [[TMP42]], ptr [[_TMP16]], align 8 -// OMP60-NEXT: [[TMP43:%.*]] = load ptr, ptr [[TMP29]], align 8 -// OMP60-NEXT: store ptr [[TMP43]], ptr [[_TMP17]], align 8 -// OMP60-NEXT: [[TMP44:%.*]] = load ptr, ptr [[TMP20]], align 8 -// OMP60-NEXT: store ptr [[TMP44]], ptr [[_TMP18]], align 8 -// OMP60-NEXT: [[TMP45:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META3]], !align [[META4]] -// OMP60-NEXT: [[TMP46:%.*]] = load i32, ptr [[TMP45]], align 4 -// OMP60-NEXT: [[INC:%.*]] = add nsw i32 [[TMP46]], 1 -// OMP60-NEXT: store i32 [[INC]], ptr [[TMP45]], align 4 -// OMP60-NEXT: [[TMP47:%.*]] = load ptr, ptr [[_TMP18]], align 8, !nonnull [[META3]], !align [[META5:![0-9]+]] -// OMP60-NEXT: [[TMP48:%.*]] = load ptr, ptr [[TMP47]], align 8 -// OMP60-NEXT: [[TMP49:%.*]] = load i32, ptr [[TMP48]], align 4 -// OMP60-NEXT: [[INC19:%.*]] = add nsw i32 [[TMP49]], 1 -// OMP60-NEXT: store i32 [[INC19]], ptr [[TMP48]], align 4 -// OMP60-NEXT: [[TMP50:%.*]] = load ptr, ptr [[_TMP15]], align 8, !nonnull [[META3]], !align [[META4]] -// OMP60-NEXT: [[TMP51:%.*]] = load i32, ptr [[TMP50]], align 4 -// OMP60-NEXT: [[INC20:%.*]] = add nsw i32 [[TMP51]], 1 -// OMP60-NEXT: store i32 [[INC20]], ptr [[TMP50]], align 4 -// OMP60-NEXT: [[TMP52:%.*]] = load ptr, ptr [[_TMP17]], align 8, !nonnull [[META3]], !align [[META4]] -// OMP60-NEXT: [[ARRAYIDX21:%.*]] = getelementptr inbounds [4 x i32], ptr [[TMP52]], i64 0, i64 0 -// OMP60-NEXT: [[TMP53:%.*]] = load i32, ptr [[ARRAYIDX21]], align 4 -// OMP60-NEXT: [[INC22:%.*]] = add nsw i32 [[TMP53]], 1 +// OMP60-NEXT: [[TMP36:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6 +// OMP60-NEXT: store ptr [[TMP14]], ptr [[TMP36]], align 8 +// OMP60-NEXT: [[TMP37:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 6 +// OMP60-NEXT: store ptr [[ARRAYIDX13]], ptr [[TMP37]], align 8 +// OMP60-NEXT: [[TMP38:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 6 +// OMP60-NEXT: store ptr null, ptr [[TMP38]], align 8 +// OMP60-NEXT: [[TMP39:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 7 +// OMP60-NEXT: store ptr [[PTR11]], ptr [[TMP39]], align 8 +// OMP60-NEXT: [[TMP40:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 7 +// OMP60-NEXT: store ptr [[ARRAYIDX13]], ptr [[TMP40]], align 8 +// OMP60-NEXT: [[TMP41:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 7 +// OMP60-NEXT: store ptr null, ptr [[TMP41]], align 8 +// OMP60-NEXT: [[TMP42:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// OMP60-NEXT: [[TMP43:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// OMP60-NEXT: [[TMP44:%.*]] = getelementptr inbounds [8 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// OMP60-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 8, ptr [[TMP42]], ptr [[TMP43]], ptr [[TMP44]], ptr @.offload_maptypes.2, ptr null, ptr null) +// OMP60-NEXT: [[TMP45:%.*]] = load ptr, ptr [[TMP20]], align 8 +// OMP60-NEXT: store ptr [[TMP45]], ptr [[TMP]], align 8 +// OMP60-NEXT: [[TMP46:%.*]] = load ptr, ptr [[TMP30]], align 8 +// OMP60-NEXT: store ptr [[TMP46]], ptr [[_TMP14]], align 8 +// OMP60-NEXT: [[TMP47:%.*]] = load ptr, ptr [[TMP23]], align 8 +// OMP60-NEXT: store ptr [[TMP47]], ptr [[_TMP15]], align 8 +// OMP60-NEXT: [[TMP48:%.*]] = load ptr, ptr [[TMP30]], align 8 +// OMP60-NEXT: store ptr [[TMP48]], ptr [[_TMP16]], align 8 +// OMP60-NEXT: [[TMP49:%.*]] = load ptr, ptr [[TMP26]], align 8 +// OMP60-NEXT: store ptr [[TMP49]], ptr [[_TMP17]], align 8 +// OMP60-NEXT: [[TMP50:%.*]] = load ptr, ptr [[TMP30]], align 8 +// OMP60-NEXT: store ptr [[TMP50]], ptr [[_TMP18]], align 8 +// OMP60-NEXT: [[TMP51:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META3]], !align [[META4]] +// OMP60-NEXT: [[TMP52:%.*]] = load i32, ptr [[TMP51]], align 4 +// OMP60-NEXT: [[INC:%.*]] = add nsw i32 [[TMP52]], 1 +// OMP60-NEXT: store i32 [[INC]], ptr [[TMP51]], align 4 +// OMP60-NEXT: [[TMP53:%.*]] = load ptr, ptr [[_TMP18]], align 8, !nonnull [[META3]], !align [[META5:![0-9]+]] +// OMP60-NEXT: [[TMP54:%.*]] = load ptr, ptr [[TMP53]], align 8 +// OMP60-NEXT: [[TMP55:%.*]] = load i32, ptr [[TMP54]], align 4 +// OMP60-NEXT: [[INC19:%.*]] = add nsw i32 [[TMP55]], 1 +// OMP60-NEXT: store i32 [[INC19]], ptr [[TMP54]], align 4 +// OMP60-NEXT: [[TMP56:%.*]] = load ptr, ptr [[_TMP15]], align 8, !nonnull [[META3]], !align [[META4]] +// OMP60-NEXT: [[TMP57:%.*]] = load i32, ptr [[TMP56]], align 4 +// OMP60-NEXT: [[INC20:%.*]] = add nsw i32 [[TMP57]], 1 +// OMP60-NEXT: store i32 [[INC20]], ptr [[TMP56]], align 4 +// OMP60-NEXT: [[TMP58:%.*]] = load ptr, ptr [[_TMP17]], align 8, !nonnull [[META3]], !align [[META4]] +// OMP60-NEXT: [[ARRAYIDX21:%.*]] = getelementptr inbounds [4 x i32], ptr [[TMP58]], i64 0, i64 0 +// OMP60-NEXT: [[TMP59:%.*]] = load i32, ptr [[ARRAYIDX21]], align 4 +// OMP60-NEXT: [[INC22:%.*]] = add nsw i32 [[TMP59]], 1 // OMP60-NEXT: store i32 [[INC22]], ptr [[ARRAYIDX21]], align 4 -// OMP60-NEXT: [[TMP54:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// OMP60-NEXT: [[TMP55:%.*]] = getelementptr inbounds [7 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// OMP60-NEXT: [[TMP56:%.*]] = getelementptr inbounds [7 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// OMP60-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 7, ptr [[TMP54]], ptr [[TMP55]], ptr [[TMP56]], ptr @.offload_maptypes.2, ptr null, ptr null) +// OMP60-NEXT: [[TMP60:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// OMP60-NEXT: [[TMP61:%.*]] = getelementptr inbounds [8 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// OMP60-NEXT: [[TMP62:%.*]] = getelementptr inbounds [8 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// OMP60-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 8, ptr [[TMP60]], ptr [[TMP61]], ptr [[TMP62]], ptr @.offload_maptypes.2, ptr null, ptr null) // OMP60-NEXT: ret void // // @@ -932,20 +991,3 @@ int main() { // SIMD-ONLY0-OMP60-NEXT: store ptr [[A3]], ptr [[REF]], align 8 // SIMD-ONLY0-OMP60-NEXT: ret void // -//. -// CHECK: [[META3]] = !{} -// CHECK: [[META4]] = !{i64 4} -// CHECK: [[META5]] = !{i64 8} -//. -// OMP60: [[META3]] = !{} -// OMP60: [[META4]] = !{i64 4} -// OMP60: [[META5]] = !{i64 8} -//. -// SIMD-ONLY0: [[META2]] = !{} -// SIMD-ONLY0: [[META3]] = !{i64 4} -// SIMD-ONLY0: [[META4]] = !{i64 8} -//. -// SIMD-ONLY0-OMP60: [[META2]] = !{} -// SIMD-ONLY0-OMP60: [[META3]] = !{i64 4} -// SIMD-ONLY0-OMP60: [[META4]] = !{i64 8} -//. diff --git a/clang/test/OpenMP/target_data_use_device_ptr_addr_messages.cpp b/clang/test/OpenMP/target_data_use_device_ptr_addr_messages.cpp index deeef0a5859f0..70b054051b166 100644 --- a/clang/test/OpenMP/target_data_use_device_ptr_addr_messages.cpp +++ b/clang/test/OpenMP/target_data_use_device_ptr_addr_messages.cpp @@ -15,7 +15,9 @@ struct SA { int &j = i; int *k = &j; int *&z = k; + int **pp = &k; int aa[10]; + int aa2d[10][10]; void func(int arg) { #pragma omp target data map(i) use_device_ptr // expected-error {{expected '(' after 'use_device_ptr'}} {} @@ -77,6 +79,14 @@ struct SA { {} #pragma omp target data map(i) use_device_addr(da) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} {} +#pragma omp target data map(i) use_device_addr(pp[1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} +#pragma omp target data map(i) use_device_addr(pp[1][1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} omp51-error {{base-pointer is not a variable name or data member of current class}} + {} +#pragma omp target data map(i) use_device_addr(aa[1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} +#pragma omp target data map(i) use_device_addr(aa2d[1][1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} return; } }; @@ -162,7 +172,9 @@ T tmain(T argc) { T &j = i; T *k = &j; T *&z = k; + T **pp = &k; T aa[10]; + T aa2d[10][10]; #pragma omp target data map(i) use_device_ptr // expected-error {{expected '(' after 'use_device_ptr'}} {} #pragma omp target data map(i) use_device_ptr( // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected expression}} @@ -223,6 +235,14 @@ T tmain(T argc) { {} #pragma omp target data map(i) use_device_addr(da) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} {} +#pragma omp target data map(i) use_device_addr(pp[1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} +#pragma omp target data map(i) use_device_addr(pp[1][1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} omp51-error {{base-pointer is not a variable name}} + {} +#pragma omp target data map(i) use_device_addr(aa[1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} +#pragma omp target data map(i) use_device_addr(aa2d[1][1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} return 0; } @@ -235,7 +255,9 @@ int main(int argc, char **argv) { int &j = i; int *k = &j; int *&z = k; + int **pp = &k; int aa[10]; + int aa2d[10][10]; #pragma omp target data map(i) use_device_ptr // expected-error {{expected '(' after 'use_device_ptr'}} {} #pragma omp target data map(i) use_device_ptr( // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected expression}} @@ -296,5 +318,13 @@ int main(int argc, char **argv) { {} #pragma omp target data map(i) use_device_addr(da) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} {} +#pragma omp target data map(i) use_device_addr(pp[1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} +#pragma omp target data map(i) use_device_addr(pp[1][1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} omp51-error {{base-pointer is not a variable name}} + {} +#pragma omp target data map(i) use_device_addr(aa[1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} +#pragma omp target data map(i) use_device_addr(aa2d[1][1]) // omp45-error {{unexpected OpenMP clause 'use_device_addr' in directive '#pragma omp target data'}} + {} return tmain(argc); // expected-note {{in instantiation of function template specialization 'tmain' requested here}} } diff --git a/clang/test/OpenMP/target_data_use_device_ptr_codegen.cpp b/clang/test/OpenMP/target_data_use_device_ptr_codegen.cpp index 6d1c0213d648c..f1c318a65af0e 100644 --- a/clang/test/OpenMP/target_data_use_device_ptr_codegen.cpp +++ b/clang/test/OpenMP/target_data_use_device_ptr_codegen.cpp @@ -22,18 +22,18 @@ double *g; // CK1: @g ={{.*}} global ptr -// CK1: [[MTYPE00:@.+]] = {{.*}}constant [2 x i64] [i64 19, i64 64] -// CK1: [[MTYPE01:@.+]] = {{.*}}constant [1 x i64] [i64 67] -// CK1: [[MTYPE03:@.+]] = {{.*}}constant [1 x i64] [i64 67] -// CK1: [[MTYPE04:@.+]] = {{.*}}constant [1 x i64] [i64 67] -// CK1: [[MTYPE05:@.+]] = {{.*}}constant [1 x i64] [i64 67] -// CK1: [[MTYPE06:@.+]] = {{.*}}constant [1 x i64] [i64 67] -// CK1: [[MTYPE07:@.+]] = {{.*}}constant [1 x i64] [i64 67] -// CK1: [[MTYPE08:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 3] -// CK1: [[MTYPE09:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 67] -// CK1: [[MTYPE10:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 67] -// CK1: [[MTYPE11:@.+]] = {{.*}}constant [2 x i64] [i64 3, i64 64] -// CK1: [[MTYPE12:@.+]] = {{.*}}constant [2 x i64] [i64 3, i64 64] +// CK1: [[MTYPE00:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 16384] +// CK1: [[MTYPE01:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 16384] +// CK1: [[MTYPE03:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 16384] +// CK1: [[MTYPE04:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 16384] +// CK1: [[MTYPE05:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 16384] +// CK1: [[MTYPE06:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 16384] +// CK1: [[MTYPE07:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 16384] +// CK1: [[MTYPE08:@.+]] = {{.*}}constant [4 x i64] [i64 67, i64 16384, i64 3, i64 16384] +// CK1: [[MTYPE09:@.+]] = {{.*}}constant [4 x i64] [i64 67, i64 16384, i64 67, i64 16384] +// CK1: [[MTYPE10:@.+]] = {{.*}}constant [4 x i64] [i64 67, i64 16384, i64 67, i64 16384] +// CK1: [[MTYPE11:@.+]] = {{.*}}constant [3 x i64] [i64 3, i64 16384, i64 64] +// CK1: [[MTYPE12:@.+]] = {{.*}}constant [3 x i64] [i64 3, i64 16384, i64 64] // CK1-LABEL: @_Z3foo template @@ -41,8 +41,11 @@ void foo(float *&lr, T *&tr) { float *l; T *t; + // &g[0], &g[0], 10 * sizeof(g[0]), TO | FROM | RETURN_PARAM + // &g, &g[0], sizeof(void*), ATTACH + // // CK1: [[T:%.+]] = load ptr, ptr [[DECL:@g]], - // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 1 + // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK1: store ptr [[T]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE00]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -50,7 +53,7 @@ void foo(float *&lr, T *&tr) { // CK1: store ptr [[VAL]], ptr [[PVT:%.+]], // CK1: [[TT:%.+]] = load ptr, ptr [[PVT]], // CK1: getelementptr inbounds nuw double, ptr [[TT]], i32 1 - #pragma omp target data map(g[:10]) use_device_ptr(g) + #pragma omp target data map(g[0:10]) use_device_ptr(g) { ++g; } @@ -59,8 +62,11 @@ void foo(float *&lr, T *&tr) { // CK1: getelementptr inbounds nuw double, ptr [[TTT]], i32 1 ++g; + // &l[0], &l[0], 10 * sizeof(l[0]), TO | FROM | RETURN_PARAM + // &l, &l[0], sizeof(void*), ATTACH + // // CK1: [[T1:%.+]] = load ptr, ptr [[DECL:%.+]], - // CK1: [[BP:%.+]] = getelementptr inbounds [1 x ptr], ptr %{{.+}}, i32 0, i32 0 + // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE01]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -68,7 +74,7 @@ void foo(float *&lr, T *&tr) { // CK1: store ptr [[VAL]], ptr [[PVT:%.+]], // CK1: [[TT1:%.+]] = load ptr, ptr [[PVT]], // CK1: getelementptr inbounds nuw float, ptr [[TT1]], i32 1 - #pragma omp target data map(l[:10]) use_device_ptr(l) + #pragma omp target data map(l[0:10]) use_device_ptr(l) { ++l; } @@ -90,7 +96,7 @@ void foo(float *&lr, T *&tr) { ++l; // CK1: [[T1:%.+]] = load ptr, ptr [[DECL:%.+]], - // CK1: [[BP:%.+]] = getelementptr inbounds [1 x ptr], ptr %{{.+}}, i32 0, i32 0 + // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE03]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -112,7 +118,7 @@ void foo(float *&lr, T *&tr) { // CK1: [[BTHEN]]: // CK1: [[T1:%.+]] = load ptr, ptr [[DECL:%.+]], - // CK1: [[BP:%.+]] = getelementptr inbounds [1 x ptr], ptr %{{.+}}, i32 0, i32 0 + // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE04]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -145,9 +151,12 @@ void foo(float *&lr, T *&tr) { // CK1: getelementptr inbounds nuw float, ptr [[TTT]], i32 1 ++l; + // &(ptee(lr)[0]), &(ptee(lr)[0]), 10 * sizeof(lr[0]), TO | FROM | RETURN_PARAM + // &(ptee(lr)), &(ptee(lr)[0]), sizeof(void*), ATTACH + // // CK1: [[T2:%.+]] = load ptr, ptr [[DECL:%.+]], // CK1: [[T1:%.+]] = load ptr, ptr [[T2]], - // CK1: [[BP:%.+]] = getelementptr inbounds [1 x ptr], ptr %{{.+}}, i32 0, i32 0 + // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE05]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -167,8 +176,11 @@ void foo(float *&lr, T *&tr) { // CK1: getelementptr inbounds nuw float, ptr [[TTTT]], i32 1 ++lr; + // &t[0], &t[0], 10 * sizeof(t[0]), TO | FROM | RETURN_PARAM + // &t, &t[1], sizeof(void*), ATTACH + // // CK1: [[T1:%.+]] = load ptr, ptr [[DECL:%.+]], - // CK1: [[BP:%.+]] = getelementptr inbounds [1 x ptr], ptr %{{.+}}, i32 0, i32 0 + // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE06]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -185,9 +197,12 @@ void foo(float *&lr, T *&tr) { // CK1: getelementptr inbounds nuw i32, ptr [[TTT]], i32 1 ++t; + // &(ptee(tr)[0]), &(ptee(tr)[0]), 10 * sizeof(tr[0]), TO | FROM | RETURN_PARAM + // &(ptee(tr)), &(ptee(tr)[0]), sizeof(void*), ATTACH + // // CK1: [[T2:%.+]] = load ptr, ptr [[DECL:%.+]], // CK1: [[T1:%.+]] = load ptr, ptr [[T2]], - // CK1: [[BP:%.+]] = getelementptr inbounds [1 x ptr], ptr %{{.+}}, i32 0, i32 0 + // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE07]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -207,8 +222,13 @@ void foo(float *&lr, T *&tr) { // CK1: getelementptr inbounds nuw i32, ptr [[TTTT]], i32 1 ++tr; + // &l[0], &l[0], 10 * sizeof(l[0]), TO | FROM | RETURN_PARAM + // &l, &l[0], sizeof(void*), ATTACH + // &t[0], &t[0], 10 * sizeof(t[0]), TO | FROM + // &t, &t[0], sizeof(void*), ATTACH + // // CK1: [[T1:%.+]] = load ptr, ptr [[DECL:%.+]], - // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 + // CK1: [[BP:%.+]] = getelementptr inbounds [4 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE08]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -226,6 +246,11 @@ void foo(float *&lr, T *&tr) { ++l; ++t; + // &l[0], &l[0], 10 * sizeof(l[0]), TO | FROM | RETURN_PARAM + // &l, &l[0], sizeof(void*), ATTACH + // &t[0], &t[0], 10 * sizeof(t[0]), TO | FROM | RETURN_PARAM + // &t, &t[0], sizeof(void*), ATTACH + // // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE09]] // CK1: [[_VAL:%.+]] = load ptr, ptr {{%.+}}, // CK1: store ptr [[_VAL]], ptr [[_PVT:%.+]], @@ -266,8 +291,12 @@ void foo(float *&lr, T *&tr) { // CK1: getelementptr inbounds nuw i32, ptr [[TTT]], i32 1 ++l; ++t; + // &l[0], &l[0], 10 * sizeof(l[0]), TO | FROM + // &l, &l[0], sizeof(void*), ATTACH + // &t[0], &t[0], 0, RETURN_PARAM + // // CK1: [[T1:%.+]] = load ptr, ptr [[DECL:%.+]], - // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 1 + // CK1: [[BP:%.+]] = getelementptr inbounds [3 x ptr], ptr %{{.+}}, i32 0, i32 2 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE11]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -284,9 +313,13 @@ void foo(float *&lr, T *&tr) { // CK1: getelementptr inbounds nuw i32, ptr [[TTT]], i32 1 ++l; ++t; + // &l[0], &l[0], 10 * sizeof(l[0]), TO | FROM + // &l, &l[0], sizeof(void*), ATTACH + // &ref_ptee(tr)[0], &ref_ptee(tr)[0], 0, RETURN_PARAM + // // CK1: [[T2:%.+]] = load ptr, ptr [[DECL:%.+]], // CK1: [[T1:%.+]] = load ptr, ptr [[T2]], - // CK1: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 1 + // CK1: [[BP:%.+]] = getelementptr inbounds [3 x ptr], ptr %{{.+}}, i32 0, i32 2 // CK1: store ptr [[T1]], ptr [[BP]], // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE12]] // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -331,10 +364,10 @@ void bar(float *&a, int *&b) { #ifdef CK2 // CK2: [[ST:%.+]] = type { ptr, ptr } -// CK2: [[MTYPE00:@.+]] = {{.*}}constant [2 x i64] [i64 0, i64 281474976710739] -// CK2: [[MTYPE01:@.+]] = {{.*}}constant [2 x i64] [i64 0, i64 281474976710739] -// CK2: [[MTYPE02:@.+]] = {{.*}}constant [3 x i64] [i64 3, i64 0, i64 562949953421392] -// CK2: [[MTYPE03:@.+]] = {{.*}}constant [3 x i64] [i64 0, i64 281474976710739, i64 281474976710736] +// CK2: [[MTYPE00:@.+]] = {{.*}}constant [2 x i64] [i64 [[#0x43]], i64 [[#0x4000]]] +// CK2: [[MTYPE01:@.+]] = {{.*}}constant [2 x i64] [i64 [[#0x43]], i64 [[#0x4000]]] +// CK2: [[MTYPE02:@.+]] = {{.*}}constant [3 x i64] [i64 3, i64 [[#0x4000]], i64 [[#0x40]]] +// CK2: [[MTYPE03:@.+]] = {{.*}}constant [3 x i64] [i64 [[#0x43]], i64 [[#0x4000]], i64 [[#0x40]]] template struct ST { @@ -346,7 +379,10 @@ struct ST { void foo(double *&arg) { int *la = 0; - // CK2: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 1 + // &a[0], &a[0], 10 * sizeof(a[0]), TO | FROM | RETURN_PARAM + // &a, &a[0], sizeof(void*), ATTACH + // + // CK2: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK2: store ptr [[RVAL:%.+]], ptr [[BP]], // CK2: call void @__tgt_target_data_begin{{.+}}[[MTYPE00]] // CK2: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -365,7 +401,10 @@ struct ST { // CK2: getelementptr inbounds nuw double, ptr [[TTT]], i32 1 a++; - // CK2: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 1 + // &ptee(b)[0], &ptee(b)[0], 10 * sizeof(ptee(b)[0]), TO | FROM | RETURN_PARAM + // &ptee(b), &ptee(b)[0], sizeof(void*), ATTACH + // + // CK2: [[BP:%.+]] = getelementptr inbounds [2 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK2: store ptr [[RVAL:%.+]], ptr [[BP]], // CK2: call void @__tgt_target_data_begin{{.+}}[[MTYPE01]] // CK2: [[VAL:%.+]] = load ptr, ptr [[BP]], @@ -385,6 +424,10 @@ struct ST { // CK2: getelementptr inbounds nuw double, ptr [[TTTT]], i32 1 b++; + // &la[0], &la[0], 10 * sizeof(la[0]), TO | FROM + // &la, &la[0], sizeof(void*), ATTACH + // &a[0], &a[0], sizeof(this[0].a), RETURN_PARAM + // // CK2: [[BP:%.+]] = getelementptr inbounds [3 x ptr], ptr %{{.+}}, i32 0, i32 2 // CK2: store ptr [[RVAL:%.+]], ptr [[BP]], // CK2: call void @__tgt_target_data_begin{{.+}}[[MTYPE02]] @@ -406,7 +449,11 @@ struct ST { a++; la++; - // CK2: [[BP1:%.+]] = getelementptr inbounds [3 x ptr], ptr %{{.+}}, i32 0, i32 1 + // &ptee(b)[0], &ptee(b)[0], 10 * sizeof(ptee(b)[0]), TO | FROM | RETURN_PARAM + // &ptee(b), &ptee(b)[0], sizeof(void*), ATTACH + // &a[0], &a[0], 0, RETURN_PARAM + // + // CK2: [[BP1:%.+]] = getelementptr inbounds [3 x ptr], ptr %{{.+}}, i32 0, i32 0 // CK2: store ptr [[RVAL1:%.+]], ptr [[BP1]], // CK2: [[BP2:%.+]] = getelementptr inbounds [3 x ptr], ptr %{{.+}}, i32 0, i32 2 // CK2: store ptr [[RVAL2:%.+]], ptr [[BP2]], diff --git a/clang/test/OpenMP/target_data_use_device_ptr_if_codegen.cpp b/clang/test/OpenMP/target_data_use_device_ptr_if_codegen.cpp index 5da5806752cee..364ea28b7a90c 100644 --- a/clang/test/OpenMP/target_data_use_device_ptr_if_codegen.cpp +++ b/clang/test/OpenMP/target_data_use_device_ptr_if_codegen.cpp @@ -18,22 +18,39 @@ // SIMD-ONLY1-NOT: {{__kmpc|__tgt}} #ifdef CK1 -// CK1: [[MTYPE00:@.+]] = {{.*}}constant [1 x i64] [i64 67] +// CK1: [[MYSIZE00:@.+]] = {{.*}}constant [2 x i64] [i64 4, i64 {{8|4}}] +// CK1: [[MTYPE00:@.+]] = {{.*}}constant [2 x i64] [i64 67, i64 16384] // CK1: [[MTYPE01:@.+]] = {{.*}}constant [1 x i64] [i64 288] // CK1: [[MTYPE02:@.+]] = {{.*}}constant [1 x i64] [i64 288] void add_one(float *b, int dm) { - // CK1: [[BP:%.+]] = getelementptr inbounds [1 x ptr], ptr %{{.+}}, i32 0, i32 0 - // CK1: store ptr [[B_ADDR:%.+]], ptr [[BP]] - // CK1: call void @__tgt_target_data_begin{{.+}}[[MTYPE00]] - // CK1: [[VAL:%.+]] = load ptr, ptr [[BP]], + // &B[0], &B[0], 1 * sizeof(B[0]), PARAM | TO | FROM + // &B, &B[0], sizeof(B), ATTACH + + // CK1: [[RB_1:%.*]] = load ptr, ptr [[B:%b.addr]] + // CK1: [[RB_2:%.*]] = load ptr, ptr [[B]] + // CK1: [[RB0_1:%.*]] = getelementptr inbounds nuw float, ptr [[RB_2]], i{{.*}} 0 + + // CK1: [[BP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP:%.offload_baseptrs.*]], i32 0, i32 0 + // CK1: store ptr [[RB_1]], ptr [[BP0]] + // CK1: [[P0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P:%.offload_ptrs.*]], i32 0, i32 0 + // CK1: store ptr [[RB0_1]], ptr [[P0]] + + // CK1: [[BP1:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP]], i32 0, i32 1 + // CK1: store ptr [[B]], ptr [[BP1]] + // CK1: [[P1:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P]], i32 0, i32 1 + // CK1: store ptr [[RB0_1]], ptr [[P1]] + + // CK1: call void @__tgt_target_data_begin{{.+}}ptr [[MYSIZE00]], ptr [[MTYPE00]] + + // CK1: [[VAL:%.+]] = load ptr, ptr [[BP0]], // CK1-NOT: store ptr [[VAL]], ptr {{%.+}}, // CK1: store ptr [[VAL]], ptr [[PVT:%.+]], // CK1: [[TT:%.+]] = load ptr, ptr [[PVT]], // CK1: call i32 @__tgt_target{{.+}} // CK1: call i32 @__tgt_target{{.+}} - // CK1: call void @__tgt_target_data_end{{.+}}[[MTYPE00]] + // CK1: call void @__tgt_target_data_end{{.+}}ptr [[MYSIZE00]], ptr [[MTYPE00]] #pragma omp target data map(tofrom:b[:1]) use_device_ptr(b) if(dm == 0) { #pragma omp target is_device_ptr(b) diff --git a/clang/test/OpenMP/target_data_use_device_ptr_inheritance_codegen.cpp b/clang/test/OpenMP/target_data_use_device_ptr_inheritance_codegen.cpp index a407070ef69e4..09fd956b179b1 100644 --- a/clang/test/OpenMP/target_data_use_device_ptr_inheritance_codegen.cpp +++ b/clang/test/OpenMP/target_data_use_device_ptr_inheritance_codegen.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-globals --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" --global-hex-value-regex ".offload_maptypes.*" // RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK1 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s -Wno-openmp-mapping // RUN: %clang_cc1 -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK1 @@ -21,6 +21,7 @@ class B : public A { }; void B::foo() { +// &ptr[0], &ptr[0], 0, RETURN_PARAM #pragma omp target data use_device_ptr(A::ptr) { } @@ -103,42 +104,41 @@ void foo() { // CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [[CLASS_A:%.*]], ptr [[THIS1]], i32 0, i32 1 // CHECK-NEXT: store ptr null, ptr [[PTR]], align 8 // CHECK-NEXT: ret void +//. +// CHECK1: @.offload_sizes = private unnamed_addr constant [1 x i64] zeroinitializer +// CHECK1: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x40]]] +//. +// CHECK2: @.offload_sizes = private unnamed_addr constant [1 x i64] zeroinitializer +// CHECK2: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x40]]] +//. // CHECK1-LABEL: define {{[^@]+}}@_ZN1B3fooEv // CHECK1-SAME: (ptr noundef nonnull align 8 dereferenceable(16) [[THIS:%.*]]) unnamed_addr #[[ATTR0:[0-9]+]] { // CHECK1-NEXT: entry: // CHECK1-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [2 x ptr], align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [2 x ptr], align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [2 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [1 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [1 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [1 x ptr], align 8 // CHECK1-NEXT: [[TMP0:%.*]] = alloca ptr, align 8 // CHECK1-NEXT: [[TMP:%.*]] = alloca ptr, align 8 // CHECK1-NEXT: store ptr [[THIS]], ptr [[THIS_ADDR]], align 8 // CHECK1-NEXT: [[THIS1:%.*]] = load ptr, ptr [[THIS_ADDR]], align 8 // CHECK1-NEXT: [[PTR:%.*]] = getelementptr inbounds nuw [[CLASS_A:%.*]], ptr [[THIS1]], i32 0, i32 1 -// CHECK1-NEXT: [[PTR2:%.*]] = getelementptr inbounds nuw [[CLASS_A]], ptr [[THIS1]], i32 0, i32 1 -// CHECK1-NEXT: [[PTR3:%.*]] = getelementptr inbounds nuw [[CLASS_A]], ptr [[THIS1]], i32 0, i32 1 -// CHECK1-NEXT: [[TMP1:%.*]] = load ptr, ptr [[PTR3]], align 8 -// CHECK1-NEXT: [[TMP2:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK1-NEXT: store ptr [[THIS1]], ptr [[TMP2]], align 8 -// CHECK1-NEXT: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK1-NEXT: store ptr [[THIS1]], ptr [[TMP3]], align 8 -// CHECK1-NEXT: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK1-NEXT: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 +// CHECK1-NEXT: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK1-NEXT: store ptr [[TMP1]], ptr [[TMP2]], align 8 +// CHECK1-NEXT: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK1-NEXT: store ptr [[TMP1]], ptr [[TMP3]], align 8 +// CHECK1-NEXT: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 // CHECK1-NEXT: store ptr null, ptr [[TMP4]], align 8 -// CHECK1-NEXT: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK1-NEXT: store ptr [[PTR2]], ptr [[TMP5]], align 8 -// CHECK1-NEXT: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK1-NEXT: store ptr [[TMP1]], ptr [[TMP6]], align 8 -// CHECK1-NEXT: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK1-NEXT: store ptr null, ptr [[TMP7]], align 8 -// CHECK1-NEXT: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK1-NEXT: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK1-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 2, ptr [[TMP8]], ptr [[TMP9]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) -// CHECK1-NEXT: [[TMP10:%.*]] = load ptr, ptr [[TMP5]], align 8 -// CHECK1-NEXT: store ptr [[TMP10]], ptr [[TMP0]], align 8 +// CHECK1-NEXT: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK1-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 1, ptr [[TMP5]], ptr [[TMP6]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK1-NEXT: [[TMP7:%.*]] = load ptr, ptr [[TMP2]], align 8 +// CHECK1-NEXT: store ptr [[TMP7]], ptr [[TMP0]], align 8 // CHECK1-NEXT: store ptr [[TMP0]], ptr [[TMP]], align 8 -// CHECK1-NEXT: [[TMP11:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK1-NEXT: [[TMP12:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK1-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 2, ptr [[TMP11]], ptr [[TMP12]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK1-NEXT: [[TMP8:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP9:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK1-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP8]], ptr [[TMP9]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) // CHECK1-NEXT: ret void // // @@ -188,38 +188,30 @@ void foo() { // CHECK2-SAME: (ptr noundef nonnull align 4 dereferenceable(8) [[THIS:%.*]]) unnamed_addr #[[ATTR0:[0-9]+]] align 2 { // CHECK2-NEXT: entry: // CHECK2-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [2 x ptr], align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [2 x ptr], align 4 -// CHECK2-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [2 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [1 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [1 x ptr], align 4 +// CHECK2-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [1 x ptr], align 4 // CHECK2-NEXT: [[TMP0:%.*]] = alloca ptr, align 4 // CHECK2-NEXT: [[TMP:%.*]] = alloca ptr, align 4 // CHECK2-NEXT: store ptr [[THIS]], ptr [[THIS_ADDR]], align 4 // CHECK2-NEXT: [[THIS1:%.*]] = load ptr, ptr [[THIS_ADDR]], align 4 // CHECK2-NEXT: [[PTR:%.*]] = getelementptr inbounds nuw [[CLASS_A:%.*]], ptr [[THIS1]], i32 0, i32 1 -// CHECK2-NEXT: [[PTR2:%.*]] = getelementptr inbounds nuw [[CLASS_A]], ptr [[THIS1]], i32 0, i32 1 -// CHECK2-NEXT: [[PTR3:%.*]] = getelementptr inbounds nuw [[CLASS_A]], ptr [[THIS1]], i32 0, i32 1 -// CHECK2-NEXT: [[TMP1:%.*]] = load ptr, ptr [[PTR3]], align 4 -// CHECK2-NEXT: [[TMP2:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK2-NEXT: store ptr [[THIS1]], ptr [[TMP2]], align 4 -// CHECK2-NEXT: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK2-NEXT: store ptr [[THIS1]], ptr [[TMP3]], align 4 -// CHECK2-NEXT: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 4 +// CHECK2-NEXT: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK2-NEXT: store ptr [[TMP1]], ptr [[TMP2]], align 4 +// CHECK2-NEXT: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK2-NEXT: store ptr [[TMP1]], ptr [[TMP3]], align 4 +// CHECK2-NEXT: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0 // CHECK2-NEXT: store ptr null, ptr [[TMP4]], align 4 -// CHECK2-NEXT: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK2-NEXT: store ptr [[PTR2]], ptr [[TMP5]], align 4 -// CHECK2-NEXT: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK2-NEXT: store ptr [[TMP1]], ptr [[TMP6]], align 4 -// CHECK2-NEXT: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1 -// CHECK2-NEXT: store ptr null, ptr [[TMP7]], align 4 -// CHECK2-NEXT: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK2-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 2, ptr [[TMP8]], ptr [[TMP9]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) -// CHECK2-NEXT: [[TMP10:%.*]] = load ptr, ptr [[TMP5]], align 4 -// CHECK2-NEXT: store ptr [[TMP10]], ptr [[TMP0]], align 4 +// CHECK2-NEXT: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK2-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 1, ptr [[TMP5]], ptr [[TMP6]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK2-NEXT: [[TMP7:%.*]] = load ptr, ptr [[TMP2]], align 4 +// CHECK2-NEXT: store ptr [[TMP7]], ptr [[TMP0]], align 4 // CHECK2-NEXT: store ptr [[TMP0]], ptr [[TMP]], align 4 -// CHECK2-NEXT: [[TMP11:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK2-NEXT: [[TMP12:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK2-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 2, ptr [[TMP11]], ptr [[TMP12]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK2-NEXT: [[TMP8:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK2-NEXT: [[TMP9:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK2-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP8]], ptr [[TMP9]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) // CHECK2-NEXT: ret void // // diff --git a/clang/test/OpenMP/target_enter_data_codegen.cpp b/clang/test/OpenMP/target_enter_data_codegen.cpp index 5ac2b559592b0..dee43cba2e7da 100644 --- a/clang/test/OpenMP/target_enter_data_codegen.cpp +++ b/clang/test/OpenMP/target_enter_data_codegen.cpp @@ -44,8 +44,8 @@ double gc[100]; // CK1: [[MTYPE03:@.+]] = {{.+}}constant [1 x i64] [i64 5] -// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] +// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 24, i64 {{4|8}}] +// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 1, i64 [[#0x4000]]] // CK1: [[MTYPE05:@.+]] = {{.+}}constant [1 x i64] [i64 1025] @@ -134,26 +134,26 @@ void foo(int arg) { {++arg;} // Region 04 - // CK1-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE04]]{{.+}}, ptr null) + + // &gb.b[0], &gb.b[0], 3 * sizeof(gb.b[0]), TO + // &gb.b, &gb.b[0], sizeof(void*), ATTACH + + // CK1-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE04]], ptr [[MTYPE04]]{{.*}}, ptr null) // CK1-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK1-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK1-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]] // CK1-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK1-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK1-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 - // CK1-DAG: store ptr @gb, ptr [[BP0]] - // CK1-DAG: store ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), ptr [[P0]] - // CK1-DAG: [[DIV:%.+]] = sdiv exact i64 sub (i64 ptrtoint (ptr getelementptr (ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), i32 1) to i64), i64 ptrtoint (ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) to i64)), ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) - // CK1-DAG: store i64 [[DIV]], ptr [[S0]], - + // CK1-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK1-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK1-DAG: [[VAR0]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i{{.*}} 0, i{{.*}} 1) + // CK1-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:%.+]], i{{.*}} 0 + // CK1-DAG: [[SEC00]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i{{.*}} 0, i{{.*}} 1) // CK1-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK1-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 // CK1-DAG: store ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), ptr [[BP1]] - // CK1-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] - // CK1-DAG: [[SEC1]] = getelementptr inbounds {{.+}}ptr [[SEC11:%[^,]+]], i{{.+}} 0 - // CK1-DAG: [[SEC11]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), + // CK1-DAG: store ptr [[SEC0]], ptr [[P1]] // CK1: %{{.+}} = add nsw i32 %{{[^,]+}}, 1 // CK1-NOT: __tgt_target_data_end @@ -331,8 +331,8 @@ struct ST { } }; -// CK2: [[SIZES:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK2: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710677] +// CK2: [[SIZES:@.+]] = {{.+}}constant [2 x i64] [i64 24, i64 {{4|8}}] +// CK2: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 5, i64 [[#0x4000]]] // CK2-LABEL: _Z3bari int bar(int arg){ @@ -341,30 +341,32 @@ int bar(int arg){ } // Region 00 + +// &b[0], &b[1], 3 * sizeof(b[0]), TO | ALWAYS +// &b, &b[1], sizeof(void*), ATTACH + // CK2: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK2: [[IFTHEN]] -// CK2-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) +// CK2-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZES]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK2-DAG: [[DEV]] = sext i32 [[DEVi32:%[^,]+]] to i64 // CK2-DAG: [[DEVi32]] = load i32, ptr %{{[^,]+}}, // CK2-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK2-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK2-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]] // CK2-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK2-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK2-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 // CK2-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] // CK2-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK2-DAG: store i64 {{%.+}}, ptr [[PS0]], -// CK2-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK2-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%[^,]+]] +// CK2-DAG: [[VAR00]] = getelementptr inbounds nuw [[ST]], ptr %{{.*}}, i32 0, i32 1 +// CK2-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:%.+]], i{{.+}} 1 +// CK2-DAG: [[SEC00]] = load ptr, ptr [[SEC000:%[^,]+]] +// CK2-DAG: [[SEC000]] = getelementptr inbounds nuw [[ST]], ptr %{{.*}}, i32 0, i32 1 // CK2-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK2-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK2-DAG: store ptr [[SEC0]], ptr [[BP1]] -// CK2-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] -// CK2-DAG: [[SEC1]] = getelementptr inbounds {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 1 -// CK2-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK2-DAG: [[SEC111]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK2-DAG: store ptr [[VAR00]], ptr [[BP1]] +// CK2-DAG: store ptr [[SEC0]], ptr [[P1]] // CK2: br label %[[IFEND:[^,]+]] @@ -478,8 +480,8 @@ struct STT { } }; -// CK5: [[SIZES:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK5: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976711701] +// CK5: [[SIZES:@.+]] = {{.+}}constant [2 x i64] [i64 24, i64 {{4|8}}] +// CK5: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 [[#0x405]], i64 [[#0x4000]]] // CK5-LABEL: _Z3bari int bar(int arg){ @@ -488,30 +490,32 @@ int bar(int arg){ } // Region 00 + +// &b[0], &b[1], 3 * sizeof(b[0]), TO | ALWAYS | CLOSE +// &b, &b[1], sizeof(void*), ATTACH + // CK5: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK5: [[IFTHEN]] -// CK5-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) +// CK5-DAG: call void @__tgt_target_data_begin_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZES]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK5-DAG: [[DEV]] = sext i32 [[DEVi32:%[^,]+]] to i64 // CK5-DAG: [[DEVi32]] = load i32, ptr %{{[^,]+}}, // CK5-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK5-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK5-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]] // CK5-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK5-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK5-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 // CK5-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] // CK5-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK5-DAG: store i64 {{%.+}}, ptr [[PS0]], -// CK5-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK5-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%[^,]+]] +// CK5-DAG: [[VAR00]] = getelementptr inbounds nuw [[STT]], ptr %{{.*}}, i32 0, i32 1 +// CK5-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:%.+]], i{{.+}} 1 +// CK5-DAG: [[SEC00]] = load ptr, ptr [[SEC000:%[^,]+]] +// CK5-DAG: [[SEC000]] = getelementptr inbounds nuw [[STT]], ptr %{{.*}}, i32 0, i32 1 // CK5-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK5-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK5-DAG: store ptr [[SEC0]], ptr [[BP1]] -// CK5-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] -// CK5-DAG: [[SEC1]] = getelementptr inbounds {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 1 -// CK5-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK5-DAG: [[SEC111]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK5-DAG: store ptr [[VAR00]], ptr [[BP1]] +// CK5-DAG: store ptr [[SEC0]], ptr [[P1]] // CK5: br label %[[IFEND:[^,]+]] diff --git a/clang/test/OpenMP/target_enter_data_depend_codegen.cpp b/clang/test/OpenMP/target_enter_data_depend_codegen.cpp index f2ac8bed8a925..2d537366bea67 100644 --- a/clang/test/OpenMP/target_enter_data_depend_codegen.cpp +++ b/clang/test/OpenMP/target_enter_data_depend_codegen.cpp @@ -37,8 +37,8 @@ double gc[100]; // CK1: [[MTYPE03:@.+]] = {{.+}}constant [1 x i64] zeroinitializer -// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] +// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 24, i64 {{4|8}}] +// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 1, i64 [[#0x4000]]] // CK1-LABEL: _Z3fooi void foo(int arg) { @@ -238,20 +238,23 @@ void foo(int arg) { {++arg;} // Region 04 - // CK1: [[DIV:%.+]] = sdiv exact i64 sub (i64 ptrtoint (ptr getelementptr (ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), i32 1) to i64), i64 ptrtoint (ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) to i64)), ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) + + // &gb.b[0], &gb.b[0], 3 * sizeof(gb.b[0]), TO + // &gb.b, &gb.b[0], sizeof(void*), ATTACH + + // CK1: [[B:%.+]] = load ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) + // CK1: [[B1:%.+]] = load ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) + // CK1: [[BGEP0:%.+]] = getelementptr inbounds nuw double, ptr [[B1]], i[[sz]] 0 // CK1: [[BP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP:%.+]], i32 0, i32 0 - // CK1: store ptr @gb, ptr [[BP0]], + // CK1: store ptr [[B]], ptr [[BP0]], // CK1: [[P0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P:%.+]], i32 0, i32 0 - // CK1: store ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), ptr [[P0]], - // CK1: [[PS0:%.+]] = getelementptr inbounds [2 x i64], ptr [[PS:%.+]], i32 0, i32 0 - // CK1: store i64 [[DIV]], ptr [[PS0]], + // CK1: store ptr [[BGEP0]], ptr [[P0]], // CK1: [[BP1:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP]], i32 0, i32 1 // CK1: store ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), ptr [[BP1]], // CK1: [[P1:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P]], i32 0, i32 1 - // CK1: store ptr %{{.+}}, ptr [[P1]], + // CK1: store ptr [[BGEP0]], ptr [[P1]], // CK1: [[GEPBP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP]], i32 0, i32 0 // CK1: [[GEPP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P]], i32 0, i32 0 - // CK1: [[GEPS0:%.+]] = getelementptr inbounds [2 x i64], ptr [[PS]], i32 0, i32 0 // CK1: [[RES:%.+]] = call ptr @__kmpc_omp_task_alloc(ptr {{.+}}, i32 {{.+}}, i32 1, i[[sz]] {{88|52}}, i[[sz]] 1, ptr [[TASK_ENTRY4:@.+]]) // CK1: [[TASK_T:%.+]] = getelementptr inbounds nuw %struct.kmp_task_t_with_privates{{.+}}, ptr [[RES]], i32 0, i32 0 // CK1: [[PRIVS:%.+]] = getelementptr inbounds nuw %struct.kmp_task_t_with_privates{{.+}}, ptr [[RES]], i32 0, i32 1 @@ -260,9 +263,9 @@ void foo(int arg) { // CK1-64: [[PRIVS_PTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 1 // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_PTRS]], ptr align {{8|4}} [[GEPP0]], i[[sz]] {{16|8}}, i1 false) // CK1-64: [[PRIVS_SIZES:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 2 - // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[GEPS0]], i[[sz]] {{16|8}}, i1 false) + // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[SIZE04]], i[[sz]] {{16|8}}, i1 false) // CK1-32: [[PRIVS_SIZES:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 0 - // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[GEPS0]], i[[sz]] {{16|8}}, i1 false) + // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[SIZE04]], i[[sz]] {{16|8}}, i1 false) // CK1-32: [[PRIVS_BASEPTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 1 // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_BASEPTRS]], ptr align {{8|4}} [[GEPBP0]], i[[sz]] {{16|8}}, i1 false) // CK1-32: [[PRIVS_PTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 2 diff --git a/clang/test/OpenMP/target_exit_data_codegen.cpp b/clang/test/OpenMP/target_exit_data_codegen.cpp index 48139bbe489d9..724135353ecf5 100644 --- a/clang/test/OpenMP/target_exit_data_codegen.cpp +++ b/clang/test/OpenMP/target_exit_data_codegen.cpp @@ -43,8 +43,8 @@ double gc[100]; // CK1: [[MTYPE03:@.+]] = {{.+}}constant [1 x i64] [i64 6] -// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710672] +// CK1: [[SIZE04:@.+]] = {{.+}}constant [1 x i64] [i64 24] +// CK1: [[MTYPE04:@.+]] = {{.+}}constant [1 x i64] zeroinitializer // CK1: [[MTYPE05:@.+]] = {{.+}}constant [1 x i64] [i64 1026] @@ -132,27 +132,21 @@ void foo(int arg) { {++arg;} // Region 04 + + // &gb.b[0], &gb.b[0], 3 * sizeof(gb.b[0]), RELEASE + // CK1-NOT: __tgt_target_data_begin - // CK1-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE04]]{{.+}}, ptr null) + // CK1-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE04]], ptr [[MTYPE04]]{{.+}}, ptr null) // CK1-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK1-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK1-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]] // CK1-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK1-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK1-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 - // CK1-DAG: store ptr @gb, ptr [[BP0]] - // CK1-DAG: store ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), ptr [[P0]] - // CK1-DAG: [[DIV:%.+]] = sdiv exact i64 sub (i64 ptrtoint (ptr getelementptr (ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), i32 1) to i64), i64 ptrtoint (ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) to i64)), ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) - // CK1-DAG: store i64 [[DIV]], ptr [[PS0]], - - - // CK1-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK1-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK1-DAG: store ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), ptr [[BP1]] - // CK1-DAG: store ptr [[SEC1:%[^,]+]], ptr [[P1]] - // CK1-DAG: [[SEC1]] = getelementptr inbounds {{.+}}ptr [[SEC11:%[^,]+]], i{{.+}} 0 - // CK1-DAG: [[SEC11]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), + // CK1-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK1-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK1-DAG: [[VAR0]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i{{.*}} 0, i{{.*}} 1) + // CK1-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:%.+]], i{{.*}} 0 + // CK1-DAG: [[SEC00]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i{{.*}} 0, i{{.*}} 1) // CK1: %{{.+}} = add nsw i32 %{{[^,]+}}, 1 #pragma omp target exit data map(release: gb.b[:3]) @@ -246,8 +240,8 @@ struct ST { } }; -// CK2: [[SIZES:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK2: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710676] +// CK2: [[SIZES:@.+]] = {{.+}}constant [1 x i64] [i64 24] +// CK2: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 4] // CK2-LABEL: _Z3bari int bar(int arg){ @@ -256,31 +250,27 @@ int bar(int arg){ } // Region 00 + +// &b[0], &b[1], 3 * sizeof(b[0]), ALWAYS + // CK2-NOT: __tgt_target_data_begin // CK2: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK2: [[IFTHEN]] -// CK2-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) +// CK2-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZES]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK2-DAG: [[DEV]] = sext i32 [[DEVi32:%[^,]+]] to i64 // CK2-DAG: [[DEVi32]] = load i32, ptr %{{[^,]+}}, // CK2-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK2-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK2-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]] // CK2-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK2-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK2-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 // CK2-DAG: store ptr [[VAR0:%[^,]+]], ptr [[BP0]] // CK2-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] -// CK2-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[PS0]], -// CK2-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 - -// CK2-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 -// CK2-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK2-DAG: store ptr [[SEC0]], ptr [[BP1]] -// CK2-DAG: store ptr [[SEC1:%[^,]+]], ptr [[P1]] -// CK2-DAG: [[SEC1]] = getelementptr inbounds {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 1 -// CK2-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK2-DAG: [[SEC111]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK2-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%[^,]+]] +// CK2-DAG: [[VAR00]] = getelementptr inbounds nuw [[ST]], ptr %{{.*}}, i32 0, i32 1 +// CK2-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:%.+]], i{{.+}} 1 +// CK2-DAG: [[SEC00]] = load ptr, ptr [[SEC000:%[^,]+]] +// CK2-DAG: [[SEC000]] = getelementptr inbounds nuw [[ST]], ptr %{{.*}}, i32 0, i32 1 // CK2: br label %[[IFEND:[^,]+]] @@ -347,8 +337,8 @@ struct STT { } }; -// CK4: [[SIZES:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK4: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976711700] +// CK4: [[SIZES:@.+]] = {{.+}}constant [1 x i64] [i64 24] +// CK4: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 [[#0x404]]] // CK4-LABEL: _Z3bari int bar(int arg){ @@ -357,31 +347,27 @@ int bar(int arg){ } // Region 00 + +// &b[0], &b[1], 3 * sizeof(b[0]), ALWAYS | CLOSE + // CK4-NOT: __tgt_target_data_begin // CK4: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK4: [[IFTHEN]] -// CK4-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) +// CK4-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZES]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK4-DAG: [[DEV]] = sext i32 [[DEVi32:%[^,]+]] to i64 // CK4-DAG: [[DEVi32]] = load i32, ptr %{{[^,]+}}, // CK4-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK4-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK4-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]] // CK4-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK4-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK4-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 -// CK4-DAG: store ptr [[VAR0:%[^,]+]], ptr [[BP0]] -// CK4-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] -// CK4-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[PS0]], -// CK4-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 - -// CK4-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 -// CK4-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK4-DAG: store ptr [[SEC0]], ptr [[BP1]] -// CK4-DAG: store ptr [[SEC1:%[^,]+]], ptr [[P1]] -// CK4-DAG: [[SEC1]] = getelementptr inbounds {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 1 -// CK4-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK4-DAG: [[SEC111]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK4-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] +// CK4-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] +// CK4-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%[^,]+]] +// CK4-DAG: [[VAR00]] = getelementptr inbounds nuw [[STT]], ptr %{{.*}}, i32 0, i32 1 +// CK4-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:%.+]], i{{.+}} 1 +// CK4-DAG: [[SEC00]] = load ptr, ptr [[SEC000:%[^,]+]] +// CK4-DAG: [[SEC000]] = getelementptr inbounds nuw [[STT]], ptr %{{.*}}, i32 0, i32 1 // CK4: br label %[[IFEND:[^,]+]] diff --git a/clang/test/OpenMP/target_exit_data_depend_codegen.cpp b/clang/test/OpenMP/target_exit_data_depend_codegen.cpp index 5414551db7f0a..670d64ef470a2 100644 --- a/clang/test/OpenMP/target_exit_data_depend_codegen.cpp +++ b/clang/test/OpenMP/target_exit_data_depend_codegen.cpp @@ -37,8 +37,8 @@ double gc[100]; // CK1: [[MTYPE03:@.+]] = {{.+}}constant [1 x i64] [i64 2] -// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710674] +// CK1: [[SIZE04:@.+]] = {{.+}}constant [1 x i64] [i64 24] +// CK1: [[MTYPE04:@.+]] = {{.+}}constant [1 x i64] [i64 2] // CK1-LABEL: _Z3fooi void foo(int arg) { @@ -238,21 +238,19 @@ void foo(int arg) { {++arg;} // Region 04 - // CK1: [[DIV:%.+]] = sdiv exact i64 sub (i64 ptrtoint (ptr getelementptr (ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), i32 1) to i64), i64 ptrtoint (ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) to i64)), ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) - // CK1: [[BP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP:%.+]], i32 0, i32 0 - // CK1: store ptr @gb, ptr [[BP0]], - // CK1: [[P0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P:%.+]], i32 0, i32 0 - // CK1: store ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), ptr [[P0]], - // CK1: [[PS0:%.+]] = getelementptr inbounds [2 x i64], ptr [[PS:%.+]], i32 0, i32 0 - // CK1: store i64 [[DIV]], ptr [[PS0]], - // CK1: [[BP1:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP]], i32 0, i32 1 - // CK1: store ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), ptr [[BP1]], - // CK1: [[P1:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P]], i32 0, i32 1 - // CK1: store ptr %{{.+}}, ptr [[P1]], - // CK1: [[GEPBP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP]], i32 0, i32 0 - // CK1: [[GEPP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P]], i32 0, i32 0 - // CK1: [[GEPS0:%.+]] = getelementptr inbounds [2 x i64], ptr [[PS]], i32 0, i32 0 - // CK1: [[RES:%.+]] = call ptr @__kmpc_omp_task_alloc(ptr {{.+}}, i32 {{.+}}, i32 1, i[[sz]] {{88|52}}, i[[sz]] 1, ptr [[TASK_ENTRY4:@.+]]) + + // &gb.b[0], &gb.b[0], 3 * sizeof(gb.b[0]), FROM + + // CK1: [[B:%.+]] = load ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) + // CK1: [[B1:%.+]] = load ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) + // CK1: [[BGEP0:%.+]] = getelementptr inbounds nuw double, ptr [[B1]], i[[sz]] 0 + // CK1: [[BP0:%.+]] = getelementptr inbounds [1 x ptr], ptr [[BP:%.+]], i32 0, i32 0 + // CK1: store ptr [[B]], ptr [[BP0]], + // CK1: [[P0:%.+]] = getelementptr inbounds [1 x ptr], ptr [[P:%.+]], i32 0, i32 0 + // CK1: store ptr [[BGEP0]], ptr [[P0]], + // CK1: [[GEPBP0:%.+]] = getelementptr inbounds [1 x ptr], ptr [[BP]], i32 0, i32 0 + // CK1: [[GEPP0:%.+]] = getelementptr inbounds [1 x ptr], ptr [[P]], i32 0, i32 0 + // CK1: [[RES:%.+]] = call ptr @__kmpc_omp_task_alloc(ptr {{.+}}, i32 {{.+}}, i32 1, i[[sz]] {{64|36}}, i[[sz]] 1, ptr [[TASK_ENTRY4:@.+]]) // CK1: [[TASK_T:%.+]] = getelementptr inbounds nuw %struct.kmp_task_t_with_privates{{.+}}, ptr [[RES]], i32 0, i32 0 // CK1: [[PRIVS:%.+]] = getelementptr inbounds nuw %struct.kmp_task_t_with_privates{{.+}}, ptr [[RES]], i32 0, i32 1 // CK1-64: [[PRIVS_BASEPTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 0 @@ -260,13 +258,13 @@ void foo(int arg) { // CK1-64: [[PRIVS_PTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 1 // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_PTRS]], ptr align {{8|4}} [[GEPP0]], i[[sz]] {{16|8}}, i1 false) // CK1-64: [[PRIVS_SIZES:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 2 - // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[GEPS0]], i[[sz]] {{16|8}}, i1 false) + // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[SIZE04]], i[[sz]] {{16|8}}, i1 false) // CK1-32: [[PRIVS_SIZES:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 0 - // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[GEPS0]], i[[sz]] {{16|8}}, i1 false) + // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[SIZE04]], i[[sz]] {{16|8}}, i1 false) // CK1-32: [[PRIVS_BASEPTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 1 - // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_BASEPTRS]], ptr align {{8|4}} [[GEPBP0]], i[[sz]] {{16|8}}, i1 false) + // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_BASEPTRS]], ptr align {{8|4}} [[GEPBP0]], i[[sz]] {{8|4}}, i1 false) // CK1-32: [[PRIVS_PTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 2 - // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_PTRS]], ptr align {{8|4}} [[GEPP0]], i[[sz]] {{16|8}}, i1 false) + // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_PTRS]], ptr align {{8|4}} [[GEPP0]], i[[sz]] {{8|4}}, i1 false) // CK1: %{{.+}} = sub nuw // CK1: [[BC_ADR:%.+]] = ptrtoint ptr %{{.+}} to i[[sz]] // CK1: [[DEP:%.+]] = getelementptr %struct.kmp_depend_info, ptr [[MAIN_DEP:%.+]], i[[sz]] 0 @@ -346,7 +344,7 @@ void foo(int arg) { // CK1: } // CK1: define internal{{.*}} i32 [[TASK_ENTRY4]](i32{{.*}}, ptr noalias noundef %1) -// CK1-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[BP:%.+]], ptr [[P:%.+]], ptr [[S:%.+]], ptr [[MTYPE04]]{{.+}}, ptr null) +// CK1-DAG: call void @__tgt_target_data_end_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[BP:%.+]], ptr [[P:%.+]], ptr [[S:%.+]], ptr [[MTYPE04]]{{.+}}, ptr null) // CK1-DAG: [[BP]] = load ptr, ptr [[BP_PRIV:%[^,]+]], // CK1-DAG: [[P]] = load ptr, ptr [[P_PRIV:%[^,]+]], // CK1-DAG: [[S]] = load ptr, ptr [[S_PRIV:%[^,]+]], diff --git a/clang/test/OpenMP/target_map_array_section_no_length_codegen.cpp b/clang/test/OpenMP/target_map_array_section_no_length_codegen.cpp index 43fd509be8bcb..4699db6e273be 100644 --- a/clang/test/OpenMP/target_map_array_section_no_length_codegen.cpp +++ b/clang/test/OpenMP/target_map_array_section_no_length_codegen.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --version 5 +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals all --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" --global-hex-value-regex ".offload_maptypes.*" --version 5 // RUN: %clang_cc1 -verify -triple i386-unknown-unknown -fopenmp -fopenmp-version=60 -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -verify -triple i386-unknown-unknown -fopenmp -fopenmp-version=60 -fopenmp-targets=i386-pc-linux-gnu -emit-pch -o %t %s @@ -11,51 +11,75 @@ void array_section_no_length_map_clause(float *d, int index) { float **f; + // &d[0], &d[0], sizeof(d[0]), TO | FROM | PARAM + // &d, &d[0], sizeof(void*), ATTACH #pragma omp target map(tofrom : d[:]) { d[3] += 2; } + // &d[0], &d[2], 0, TO | PARAM + // &d, &d[2], sizeof(void*), ATTACH #pragma omp target map(to : d[2:]) { d[3] += 3; } + // &f[0], &f[0], 0, PARAM | IMPLICIT + // &f[index][0], &f[index][0], sizeof(f[index][0]), ALLOC + // &f[index], &f[index][0], sizeof(void*), ATTACH + // (void*) index, (void*) index, sizeof(void*), LITERAL #pragma omp target map(alloc : f[index][:]) { f[index][2] += 4; } + // &f[0], &f[0], 0, PARAM | IMPLICIT + // &f[index][0], &f[index][index+1], (index+1)*4 < 4? + // 4 - (index+1)*4: + // 0, TO | FROM + // &f[index], &f[index][index+1], sizeof(void*), ATTACH + // (void*) index, (void*) index, sizeof(void*), IMPLICIT | LITERAL | PARAM #pragma omp target map(tofrom : f[index][index+1:]) { f[index][index] += 5; } } #endif +//. +// CHECK: @.offload_sizes = private unnamed_addr constant [2 x i64] [i64 4, i64 4] +// CHECK: @.offload_maptypes = private unnamed_addr constant [2 x i64] [i64 [[#0x23]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [2 x i64] [i64 0, i64 4] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [2 x i64] [i64 [[#0x21]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [4 x i64] [i64 0, i64 4, i64 4, i64 4] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [4 x i64] [i64 [[#0x220]], i64 [[#0x0]], i64 [[#0x4000]], i64 [[#0x320]]] +// CHECK: @.offload_sizes.5 = private unnamed_addr constant [4 x i64] [i64 0, i64 0, i64 4, i64 4] +// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [4 x i64] [i64 [[#0x220]], i64 [[#0x3]], i64 [[#0x4000]], i64 [[#0x320]]] +//. // CHECK-LABEL: define dso_local void @_Z34array_section_no_length_map_clausePfi( // CHECK-SAME: ptr noundef [[D:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[D_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[F:%.*]] = alloca ptr, align 4 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [1 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [1 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [1 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [2 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [2 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [2 x ptr], align 4 // CHECK-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS2:%.*]] = alloca [1 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS3:%.*]] = alloca [1 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS4:%.*]] = alloca [1 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS2:%.*]] = alloca [2 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS3:%.*]] = alloca [2 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS4:%.*]] = alloca [2 x ptr], align 4 // CHECK-NEXT: [[KERNEL_ARGS5:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8 // CHECK-NEXT: [[INDEX_CASTED:%.*]] = alloca i32, align 4 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS11:%.*]] = alloca [3 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS12:%.*]] = alloca [3 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS13:%.*]] = alloca [3 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS11:%.*]] = alloca [4 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS12:%.*]] = alloca [4 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS13:%.*]] = alloca [4 x ptr], align 4 // CHECK-NEXT: [[KERNEL_ARGS14:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8 // CHECK-NEXT: [[INDEX_CASTED17:%.*]] = alloca i32, align 4 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS22:%.*]] = alloca [3 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS23:%.*]] = alloca [3 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS24:%.*]] = alloca [3 x ptr], align 4 -// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS22:%.*]] = alloca [4 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS23:%.*]] = alloca [4 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS24:%.*]] = alloca [4 x ptr], align 4 +// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [4 x i64], align 4 // CHECK-NEXT: [[KERNEL_ARGS25:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8 // CHECK-NEXT: store ptr [[D]], ptr [[D_ADDR]], align 4 // CHECK-NEXT: store i32 [[INDEX]], ptr [[INDEX_ADDR]], align 4 @@ -63,241 +87,267 @@ void array_section_no_length_map_clause(float *d, int index) { // CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[D_ADDR]], align 4 // CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[D_ADDR]], align 4 // CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw float, ptr [[TMP2]], i32 0 -// CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 // CHECK-NEXT: store ptr [[TMP1]], ptr [[TMP3]], align 4 -// CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 // CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP4]], align 4 -// CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0 // CHECK-NEXT: store ptr null, ptr [[TMP5]], align 4 -// CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP8]], align 4 -// CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 -// CHECK-NEXT: store i32 1, ptr [[TMP9]], align 4 -// CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP6]], ptr [[TMP10]], align 4 -// CHECK-NEXT: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP7]], ptr [[TMP11]], align 4 -// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 -// CHECK-NEXT: store ptr @.offload_sizes, ptr [[TMP12]], align 4 -// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes, ptr [[TMP13]], align 4 -// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP14]], align 4 -// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP15]], align 4 -// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP16]], align 8 -// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP17]], align 8 -// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP18]], align 4 -// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP19]], align 4 -// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP20]], align 4 -// CHECK-NEXT: [[TMP21:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l14.region_id, ptr [[KERNEL_ARGS]]) -// CHECK-NEXT: [[TMP22:%.*]] = icmp ne i32 [[TMP21]], 0 -// CHECK-NEXT: br i1 [[TMP22]], label %[[OMP_OFFLOAD_FAILED:.*]], label %[[OMP_OFFLOAD_CONT:.*]] +// CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[D_ADDR]], ptr [[TMP6]], align 4 +// CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP7]], align 4 +// CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1 +// CHECK-NEXT: store ptr null, ptr [[TMP8]], align 4 +// CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP11]], align 4 +// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 +// CHECK-NEXT: store i32 2, ptr [[TMP12]], align 4 +// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP9]], ptr [[TMP13]], align 4 +// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP10]], ptr [[TMP14]], align 4 +// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 +// CHECK-NEXT: store ptr @.offload_sizes, ptr [[TMP15]], align 4 +// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes, ptr [[TMP16]], align 4 +// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP17]], align 4 +// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP18]], align 4 +// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP19]], align 8 +// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP20]], align 8 +// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP21]], align 4 +// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP22]], align 4 +// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP23]], align 4 +// CHECK-NEXT: [[TMP24:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l16.region_id, ptr [[KERNEL_ARGS]]) +// CHECK-NEXT: [[TMP25:%.*]] = icmp ne i32 [[TMP24]], 0 +// CHECK-NEXT: br i1 [[TMP25]], label %[[OMP_OFFLOAD_FAILED:.*]], label %[[OMP_OFFLOAD_CONT:.*]] // CHECK: [[OMP_OFFLOAD_FAILED]]: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l14(ptr [[TMP0]]) #[[ATTR2:[0-9]+]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l16(ptr [[TMP0]]) #[[ATTR2:[0-9]+]] // CHECK-NEXT: br label %[[OMP_OFFLOAD_CONT]] // CHECK: [[OMP_OFFLOAD_CONT]]: -// CHECK-NEXT: [[TMP23:%.*]] = load ptr, ptr [[D_ADDR]], align 4 -// CHECK-NEXT: [[TMP24:%.*]] = load ptr, ptr [[D_ADDR]], align 4 -// CHECK-NEXT: [[TMP25:%.*]] = load ptr, ptr [[D_ADDR]], align 4 -// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds nuw float, ptr [[TMP25]], i32 2 -// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP24]], ptr [[TMP26]], align 4 -// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP27]], align 4 -// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS4]], i32 0, i32 0 -// CHECK-NEXT: store ptr null, ptr [[TMP28]], align 4 -// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 0 -// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 0 -// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP31]], align 4 -// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 1 -// CHECK-NEXT: store i32 1, ptr [[TMP32]], align 4 -// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP29]], ptr [[TMP33]], align 4 -// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP30]], ptr [[TMP34]], align 4 -// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 4 -// CHECK-NEXT: store ptr @.offload_sizes.1, ptr [[TMP35]], align 4 -// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP36]], align 4 -// CHECK-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP37]], align 4 -// CHECK-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP38]], align 4 -// CHECK-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP39]], align 8 -// CHECK-NEXT: [[TMP40:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP40]], align 8 -// CHECK-NEXT: [[TMP41:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP41]], align 4 -// CHECK-NEXT: [[TMP42:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP42]], align 4 -// CHECK-NEXT: [[TMP43:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP43]], align 4 -// CHECK-NEXT: [[TMP44:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l19.region_id, ptr [[KERNEL_ARGS5]]) -// CHECK-NEXT: [[TMP45:%.*]] = icmp ne i32 [[TMP44]], 0 -// CHECK-NEXT: br i1 [[TMP45]], label %[[OMP_OFFLOAD_FAILED6:.*]], label %[[OMP_OFFLOAD_CONT7:.*]] +// CHECK-NEXT: [[TMP26:%.*]] = load ptr, ptr [[D_ADDR]], align 4 +// CHECK-NEXT: [[TMP27:%.*]] = load ptr, ptr [[D_ADDR]], align 4 +// CHECK-NEXT: [[TMP28:%.*]] = load ptr, ptr [[D_ADDR]], align 4 +// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds nuw float, ptr [[TMP28]], i32 2 +// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP27]], ptr [[TMP29]], align 4 +// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP30]], align 4 +// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS4]], i32 0, i32 0 +// CHECK-NEXT: store ptr null, ptr [[TMP31]], align 4 +// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[D_ADDR]], ptr [[TMP32]], align 4 +// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP33]], align 4 +// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS4]], i32 0, i32 1 +// CHECK-NEXT: store ptr null, ptr [[TMP34]], align 4 +// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 0 +// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 0 +// CHECK-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP37]], align 4 +// CHECK-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 1 +// CHECK-NEXT: store i32 2, ptr [[TMP38]], align 4 +// CHECK-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP35]], ptr [[TMP39]], align 4 +// CHECK-NEXT: [[TMP40:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP36]], ptr [[TMP40]], align 4 +// CHECK-NEXT: [[TMP41:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 4 +// CHECK-NEXT: store ptr @.offload_sizes.1, ptr [[TMP41]], align 4 +// CHECK-NEXT: [[TMP42:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP42]], align 4 +// CHECK-NEXT: [[TMP43:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP43]], align 4 +// CHECK-NEXT: [[TMP44:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP44]], align 4 +// CHECK-NEXT: [[TMP45:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP45]], align 8 +// CHECK-NEXT: [[TMP46:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP46]], align 8 +// CHECK-NEXT: [[TMP47:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP47]], align 4 +// CHECK-NEXT: [[TMP48:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP48]], align 4 +// CHECK-NEXT: [[TMP49:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP49]], align 4 +// CHECK-NEXT: [[TMP50:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l23.region_id, ptr [[KERNEL_ARGS5]]) +// CHECK-NEXT: [[TMP51:%.*]] = icmp ne i32 [[TMP50]], 0 +// CHECK-NEXT: br i1 [[TMP51]], label %[[OMP_OFFLOAD_FAILED6:.*]], label %[[OMP_OFFLOAD_CONT7:.*]] // CHECK: [[OMP_OFFLOAD_FAILED6]]: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l19(ptr [[TMP23]]) #[[ATTR2]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l23(ptr [[TMP26]]) #[[ATTR2]] // CHECK-NEXT: br label %[[OMP_OFFLOAD_CONT7]] // CHECK: [[OMP_OFFLOAD_CONT7]]: -// CHECK-NEXT: [[TMP46:%.*]] = load ptr, ptr [[F]], align 4 -// CHECK-NEXT: [[TMP47:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 -// CHECK-NEXT: store i32 [[TMP47]], ptr [[INDEX_CASTED]], align 4 -// CHECK-NEXT: [[TMP48:%.*]] = load i32, ptr [[INDEX_CASTED]], align 4 -// CHECK-NEXT: [[TMP49:%.*]] = load ptr, ptr [[F]], align 4 -// CHECK-NEXT: [[TMP50:%.*]] = load ptr, ptr [[F]], align 4 -// CHECK-NEXT: [[TMP51:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 -// CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds ptr, ptr [[TMP50]], i32 [[TMP51]] // CHECK-NEXT: [[TMP52:%.*]] = load ptr, ptr [[F]], align 4 // CHECK-NEXT: [[TMP53:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 -// CHECK-NEXT: [[ARRAYIDX9:%.*]] = getelementptr inbounds ptr, ptr [[TMP52]], i32 [[TMP53]] -// CHECK-NEXT: [[TMP54:%.*]] = load ptr, ptr [[ARRAYIDX9]], align 4 -// CHECK-NEXT: [[ARRAYIDX10:%.*]] = getelementptr inbounds nuw float, ptr [[TMP54]], i32 0 -// CHECK-NEXT: [[TMP55:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP49]], ptr [[TMP55]], align 4 -// CHECK-NEXT: [[TMP56:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[ARRAYIDX8]], ptr [[TMP56]], align 4 -// CHECK-NEXT: [[TMP57:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS13]], i32 0, i32 0 -// CHECK-NEXT: store ptr null, ptr [[TMP57]], align 4 -// CHECK-NEXT: [[TMP58:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ARRAYIDX8]], ptr [[TMP58]], align 4 -// CHECK-NEXT: [[TMP59:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ARRAYIDX10]], ptr [[TMP59]], align 4 -// CHECK-NEXT: [[TMP60:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS13]], i32 0, i32 1 -// CHECK-NEXT: store ptr null, ptr [[TMP60]], align 4 -// CHECK-NEXT: [[TMP61:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 2 -// CHECK-NEXT: store i32 [[TMP48]], ptr [[TMP61]], align 4 -// CHECK-NEXT: [[TMP62:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 2 -// CHECK-NEXT: store i32 [[TMP48]], ptr [[TMP62]], align 4 -// CHECK-NEXT: [[TMP63:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS13]], i32 0, i32 2 -// CHECK-NEXT: store ptr null, ptr [[TMP63]], align 4 -// CHECK-NEXT: [[TMP64:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 0 -// CHECK-NEXT: [[TMP65:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 0 -// CHECK-NEXT: [[TMP66:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP66]], align 4 -// CHECK-NEXT: [[TMP67:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 1 -// CHECK-NEXT: store i32 3, ptr [[TMP67]], align 4 -// CHECK-NEXT: [[TMP68:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP64]], ptr [[TMP68]], align 4 -// CHECK-NEXT: [[TMP69:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP65]], ptr [[TMP69]], align 4 -// CHECK-NEXT: [[TMP70:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 4 -// CHECK-NEXT: store ptr @.offload_sizes.3, ptr [[TMP70]], align 4 -// CHECK-NEXT: [[TMP71:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP71]], align 4 -// CHECK-NEXT: [[TMP72:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP72]], align 4 -// CHECK-NEXT: [[TMP73:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 7 +// CHECK-NEXT: store i32 [[TMP53]], ptr [[INDEX_CASTED]], align 4 +// CHECK-NEXT: [[TMP54:%.*]] = load i32, ptr [[INDEX_CASTED]], align 4 +// CHECK-NEXT: [[TMP55:%.*]] = load ptr, ptr [[F]], align 4 +// CHECK-NEXT: [[TMP56:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 +// CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds ptr, ptr [[TMP55]], i32 [[TMP56]] +// CHECK-NEXT: [[TMP57:%.*]] = load ptr, ptr [[ARRAYIDX8]], align 4 +// CHECK-NEXT: [[TMP58:%.*]] = load ptr, ptr [[F]], align 4 +// CHECK-NEXT: [[TMP59:%.*]] = load ptr, ptr [[F]], align 4 +// CHECK-NEXT: [[TMP60:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 +// CHECK-NEXT: [[ARRAYIDX9:%.*]] = getelementptr inbounds ptr, ptr [[TMP59]], i32 [[TMP60]] +// CHECK-NEXT: [[TMP61:%.*]] = load ptr, ptr [[ARRAYIDX9]], align 4 +// CHECK-NEXT: [[ARRAYIDX10:%.*]] = getelementptr inbounds nuw float, ptr [[TMP61]], i32 0 +// CHECK-NEXT: [[TMP62:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP52]], ptr [[TMP62]], align 4 +// CHECK-NEXT: [[TMP63:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP52]], ptr [[TMP63]], align 4 +// CHECK-NEXT: [[TMP64:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS13]], i32 0, i32 0 +// CHECK-NEXT: store ptr null, ptr [[TMP64]], align 4 +// CHECK-NEXT: [[TMP65:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP57]], ptr [[TMP65]], align 4 +// CHECK-NEXT: [[TMP66:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX10]], ptr [[TMP66]], align 4 +// CHECK-NEXT: [[TMP67:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS13]], i32 0, i32 1 +// CHECK-NEXT: store ptr null, ptr [[TMP67]], align 4 +// CHECK-NEXT: [[TMP68:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX8]], ptr [[TMP68]], align 4 +// CHECK-NEXT: [[TMP69:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX10]], ptr [[TMP69]], align 4 +// CHECK-NEXT: [[TMP70:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS13]], i32 0, i32 2 +// CHECK-NEXT: store ptr null, ptr [[TMP70]], align 4 +// CHECK-NEXT: [[TMP71:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 3 +// CHECK-NEXT: store i32 [[TMP54]], ptr [[TMP71]], align 4 +// CHECK-NEXT: [[TMP72:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 3 +// CHECK-NEXT: store i32 [[TMP54]], ptr [[TMP72]], align 4 +// CHECK-NEXT: [[TMP73:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS13]], i32 0, i32 3 // CHECK-NEXT: store ptr null, ptr [[TMP73]], align 4 -// CHECK-NEXT: [[TMP74:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP74]], align 8 -// CHECK-NEXT: [[TMP75:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP75]], align 8 -// CHECK-NEXT: [[TMP76:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP76]], align 4 -// CHECK-NEXT: [[TMP77:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP77]], align 4 -// CHECK-NEXT: [[TMP78:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP78]], align 4 -// CHECK-NEXT: [[TMP79:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l24.region_id, ptr [[KERNEL_ARGS14]]) -// CHECK-NEXT: [[TMP80:%.*]] = icmp ne i32 [[TMP79]], 0 -// CHECK-NEXT: br i1 [[TMP80]], label %[[OMP_OFFLOAD_FAILED15:.*]], label %[[OMP_OFFLOAD_CONT16:.*]] +// CHECK-NEXT: [[TMP74:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS11]], i32 0, i32 0 +// CHECK-NEXT: [[TMP75:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS12]], i32 0, i32 0 +// CHECK-NEXT: [[TMP76:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP76]], align 4 +// CHECK-NEXT: [[TMP77:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 1 +// CHECK-NEXT: store i32 4, ptr [[TMP77]], align 4 +// CHECK-NEXT: [[TMP78:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP74]], ptr [[TMP78]], align 4 +// CHECK-NEXT: [[TMP79:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP75]], ptr [[TMP79]], align 4 +// CHECK-NEXT: [[TMP80:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 4 +// CHECK-NEXT: store ptr @.offload_sizes.3, ptr [[TMP80]], align 4 +// CHECK-NEXT: [[TMP81:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP81]], align 4 +// CHECK-NEXT: [[TMP82:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP82]], align 4 +// CHECK-NEXT: [[TMP83:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP83]], align 4 +// CHECK-NEXT: [[TMP84:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP84]], align 8 +// CHECK-NEXT: [[TMP85:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP85]], align 8 +// CHECK-NEXT: [[TMP86:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP86]], align 4 +// CHECK-NEXT: [[TMP87:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP87]], align 4 +// CHECK-NEXT: [[TMP88:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS14]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP88]], align 4 +// CHECK-NEXT: [[TMP89:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l32.region_id, ptr [[KERNEL_ARGS14]]) +// CHECK-NEXT: [[TMP90:%.*]] = icmp ne i32 [[TMP89]], 0 +// CHECK-NEXT: br i1 [[TMP90]], label %[[OMP_OFFLOAD_FAILED15:.*]], label %[[OMP_OFFLOAD_CONT16:.*]] // CHECK: [[OMP_OFFLOAD_FAILED15]]: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l24(ptr [[TMP46]], i32 [[TMP48]]) #[[ATTR2]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l32(ptr [[TMP52]], i32 [[TMP54]]) #[[ATTR2]] // CHECK-NEXT: br label %[[OMP_OFFLOAD_CONT16]] // CHECK: [[OMP_OFFLOAD_CONT16]]: -// CHECK-NEXT: [[TMP81:%.*]] = load ptr, ptr [[F]], align 4 -// CHECK-NEXT: [[TMP82:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 -// CHECK-NEXT: store i32 [[TMP82]], ptr [[INDEX_CASTED17]], align 4 -// CHECK-NEXT: [[TMP83:%.*]] = load i32, ptr [[INDEX_CASTED17]], align 4 -// CHECK-NEXT: [[TMP84:%.*]] = load ptr, ptr [[F]], align 4 -// CHECK-NEXT: [[TMP85:%.*]] = load ptr, ptr [[F]], align 4 -// CHECK-NEXT: [[TMP86:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 -// CHECK-NEXT: [[ARRAYIDX18:%.*]] = getelementptr inbounds ptr, ptr [[TMP85]], i32 [[TMP86]] -// CHECK-NEXT: [[TMP87:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 -// CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP87]], 1 -// CHECK-NEXT: [[TMP88:%.*]] = load ptr, ptr [[F]], align 4 -// CHECK-NEXT: [[TMP89:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 -// CHECK-NEXT: [[ARRAYIDX19:%.*]] = getelementptr inbounds ptr, ptr [[TMP88]], i32 [[TMP89]] -// CHECK-NEXT: [[TMP90:%.*]] = load ptr, ptr [[ARRAYIDX19]], align 4 -// CHECK-NEXT: [[ARRAYIDX20:%.*]] = getelementptr inbounds nuw float, ptr [[TMP90]], i32 [[ADD]] -// CHECK-NEXT: [[TMP91:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 -// CHECK-NEXT: [[ADD21:%.*]] = add nsw i32 [[TMP91]], 1 -// CHECK-NEXT: [[TMP92:%.*]] = mul nuw i32 [[ADD21]], 4 -// CHECK-NEXT: [[TMP93:%.*]] = icmp ugt i32 4, [[TMP92]] -// CHECK-NEXT: [[TMP94:%.*]] = sub nuw i32 4, [[TMP92]] -// CHECK-NEXT: [[TMP95:%.*]] = select i1 [[TMP93]], i32 [[TMP94]], i32 0 -// CHECK-NEXT: [[TMP96:%.*]] = sext i32 [[TMP95]] to i64 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[DOTOFFLOAD_SIZES]], ptr align 4 @.offload_sizes.5, i32 24, i1 false) -// CHECK-NEXT: [[TMP97:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP84]], ptr [[TMP97]], align 4 -// CHECK-NEXT: [[TMP98:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[ARRAYIDX18]], ptr [[TMP98]], align 4 -// CHECK-NEXT: [[TMP99:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS24]], i32 0, i32 0 -// CHECK-NEXT: store ptr null, ptr [[TMP99]], align 4 -// CHECK-NEXT: [[TMP100:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ARRAYIDX18]], ptr [[TMP100]], align 4 -// CHECK-NEXT: [[TMP101:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ARRAYIDX20]], ptr [[TMP101]], align 4 -// CHECK-NEXT: [[TMP102:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 1 -// CHECK-NEXT: store i64 [[TMP96]], ptr [[TMP102]], align 4 -// CHECK-NEXT: [[TMP103:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS24]], i32 0, i32 1 -// CHECK-NEXT: store ptr null, ptr [[TMP103]], align 4 -// CHECK-NEXT: [[TMP104:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 2 -// CHECK-NEXT: store i32 [[TMP83]], ptr [[TMP104]], align 4 -// CHECK-NEXT: [[TMP105:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 2 -// CHECK-NEXT: store i32 [[TMP83]], ptr [[TMP105]], align 4 -// CHECK-NEXT: [[TMP106:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS24]], i32 0, i32 2 -// CHECK-NEXT: store ptr null, ptr [[TMP106]], align 4 -// CHECK-NEXT: [[TMP107:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 0 -// CHECK-NEXT: [[TMP108:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 0 -// CHECK-NEXT: [[TMP109:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: [[TMP110:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP110]], align 4 -// CHECK-NEXT: [[TMP111:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 1 -// CHECK-NEXT: store i32 3, ptr [[TMP111]], align 4 -// CHECK-NEXT: [[TMP112:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP107]], ptr [[TMP112]], align 4 -// CHECK-NEXT: [[TMP113:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP108]], ptr [[TMP113]], align 4 -// CHECK-NEXT: [[TMP114:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 4 -// CHECK-NEXT: store ptr [[TMP109]], ptr [[TMP114]], align 4 -// CHECK-NEXT: [[TMP115:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.6, ptr [[TMP115]], align 4 -// CHECK-NEXT: [[TMP116:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP116]], align 4 -// CHECK-NEXT: [[TMP117:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 7 +// CHECK-NEXT: [[TMP91:%.*]] = load ptr, ptr [[F]], align 4 +// CHECK-NEXT: [[TMP92:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 +// CHECK-NEXT: store i32 [[TMP92]], ptr [[INDEX_CASTED17]], align 4 +// CHECK-NEXT: [[TMP93:%.*]] = load i32, ptr [[INDEX_CASTED17]], align 4 +// CHECK-NEXT: [[TMP94:%.*]] = load ptr, ptr [[F]], align 4 +// CHECK-NEXT: [[TMP95:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 +// CHECK-NEXT: [[ARRAYIDX18:%.*]] = getelementptr inbounds ptr, ptr [[TMP94]], i32 [[TMP95]] +// CHECK-NEXT: [[TMP96:%.*]] = load ptr, ptr [[ARRAYIDX18]], align 4 +// CHECK-NEXT: [[TMP97:%.*]] = load ptr, ptr [[F]], align 4 +// CHECK-NEXT: [[TMP98:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 +// CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP98]], 1 +// CHECK-NEXT: [[TMP99:%.*]] = load ptr, ptr [[F]], align 4 +// CHECK-NEXT: [[TMP100:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 +// CHECK-NEXT: [[ARRAYIDX19:%.*]] = getelementptr inbounds ptr, ptr [[TMP99]], i32 [[TMP100]] +// CHECK-NEXT: [[TMP101:%.*]] = load ptr, ptr [[ARRAYIDX19]], align 4 +// CHECK-NEXT: [[ARRAYIDX20:%.*]] = getelementptr inbounds nuw float, ptr [[TMP101]], i32 [[ADD]] +// CHECK-NEXT: [[TMP102:%.*]] = load i32, ptr [[INDEX_ADDR]], align 4 +// CHECK-NEXT: [[ADD21:%.*]] = add nsw i32 [[TMP102]], 1 +// CHECK-NEXT: [[TMP103:%.*]] = mul nuw i32 [[ADD21]], 4 +// CHECK-NEXT: [[TMP104:%.*]] = icmp ugt i32 4, [[TMP103]] +// CHECK-NEXT: [[TMP105:%.*]] = sub nuw i32 4, [[TMP103]] +// CHECK-NEXT: [[TMP106:%.*]] = select i1 [[TMP104]], i32 [[TMP105]], i32 0 +// CHECK-NEXT: [[TMP107:%.*]] = sext i32 [[TMP106]] to i64 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[DOTOFFLOAD_SIZES]], ptr align 4 @.offload_sizes.5, i32 32, i1 false) +// CHECK-NEXT: [[TMP108:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP91]], ptr [[TMP108]], align 4 +// CHECK-NEXT: [[TMP109:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP91]], ptr [[TMP109]], align 4 +// CHECK-NEXT: [[TMP110:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS24]], i32 0, i32 0 +// CHECK-NEXT: store ptr null, ptr [[TMP110]], align 4 +// CHECK-NEXT: [[TMP111:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP96]], ptr [[TMP111]], align 4 +// CHECK-NEXT: [[TMP112:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX20]], ptr [[TMP112]], align 4 +// CHECK-NEXT: [[TMP113:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 1 +// CHECK-NEXT: store i64 [[TMP107]], ptr [[TMP113]], align 4 +// CHECK-NEXT: [[TMP114:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS24]], i32 0, i32 1 +// CHECK-NEXT: store ptr null, ptr [[TMP114]], align 4 +// CHECK-NEXT: [[TMP115:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX18]], ptr [[TMP115]], align 4 +// CHECK-NEXT: [[TMP116:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX20]], ptr [[TMP116]], align 4 +// CHECK-NEXT: [[TMP117:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS24]], i32 0, i32 2 // CHECK-NEXT: store ptr null, ptr [[TMP117]], align 4 -// CHECK-NEXT: [[TMP118:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP118]], align 8 -// CHECK-NEXT: [[TMP119:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP119]], align 8 -// CHECK-NEXT: [[TMP120:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP120]], align 4 -// CHECK-NEXT: [[TMP121:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP121]], align 4 -// CHECK-NEXT: [[TMP122:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP122]], align 4 -// CHECK-NEXT: [[TMP123:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l29.region_id, ptr [[KERNEL_ARGS25]]) -// CHECK-NEXT: [[TMP124:%.*]] = icmp ne i32 [[TMP123]], 0 -// CHECK-NEXT: br i1 [[TMP124]], label %[[OMP_OFFLOAD_FAILED26:.*]], label %[[OMP_OFFLOAD_CONT27:.*]] +// CHECK-NEXT: [[TMP118:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 3 +// CHECK-NEXT: store i32 [[TMP93]], ptr [[TMP118]], align 4 +// CHECK-NEXT: [[TMP119:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 3 +// CHECK-NEXT: store i32 [[TMP93]], ptr [[TMP119]], align 4 +// CHECK-NEXT: [[TMP120:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS24]], i32 0, i32 3 +// CHECK-NEXT: store ptr null, ptr [[TMP120]], align 4 +// CHECK-NEXT: [[TMP121:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS22]], i32 0, i32 0 +// CHECK-NEXT: [[TMP122:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS23]], i32 0, i32 0 +// CHECK-NEXT: [[TMP123:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: [[TMP124:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP124]], align 4 +// CHECK-NEXT: [[TMP125:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 1 +// CHECK-NEXT: store i32 4, ptr [[TMP125]], align 4 +// CHECK-NEXT: [[TMP126:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP121]], ptr [[TMP126]], align 4 +// CHECK-NEXT: [[TMP127:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP122]], ptr [[TMP127]], align 4 +// CHECK-NEXT: [[TMP128:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 4 +// CHECK-NEXT: store ptr [[TMP123]], ptr [[TMP128]], align 4 +// CHECK-NEXT: [[TMP129:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.6, ptr [[TMP129]], align 4 +// CHECK-NEXT: [[TMP130:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP130]], align 4 +// CHECK-NEXT: [[TMP131:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP131]], align 4 +// CHECK-NEXT: [[TMP132:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP132]], align 8 +// CHECK-NEXT: [[TMP133:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP133]], align 8 +// CHECK-NEXT: [[TMP134:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP134]], align 4 +// CHECK-NEXT: [[TMP135:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP135]], align 4 +// CHECK-NEXT: [[TMP136:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS25]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP136]], align 4 +// CHECK-NEXT: [[TMP137:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l43.region_id, ptr [[KERNEL_ARGS25]]) +// CHECK-NEXT: [[TMP138:%.*]] = icmp ne i32 [[TMP137]], 0 +// CHECK-NEXT: br i1 [[TMP138]], label %[[OMP_OFFLOAD_FAILED26:.*]], label %[[OMP_OFFLOAD_CONT27:.*]] // CHECK: [[OMP_OFFLOAD_FAILED26]]: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l29(ptr [[TMP81]], i32 [[TMP83]]) #[[ATTR2]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l43(ptr [[TMP91]], i32 [[TMP93]]) #[[ATTR2]] // CHECK-NEXT: br label %[[OMP_OFFLOAD_CONT27]] // CHECK: [[OMP_OFFLOAD_CONT27]]: // CHECK-NEXT: ret void // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l14( +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l16( // CHECK-SAME: ptr noundef [[D:%.*]]) #[[ATTR1:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[D_ADDR:%.*]] = alloca ptr, align 4 @@ -310,7 +360,7 @@ void array_section_no_length_map_clause(float *d, int index) { // CHECK-NEXT: ret void // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l19( +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l23( // CHECK-SAME: ptr noundef [[D:%.*]]) #[[ATTR1]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[D_ADDR:%.*]] = alloca ptr, align 4 @@ -323,7 +373,7 @@ void array_section_no_length_map_clause(float *d, int index) { // CHECK-NEXT: ret void // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l24( +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l32( // CHECK-SAME: ptr noundef [[F:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR1]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[F_ADDR:%.*]] = alloca ptr, align 4 @@ -341,7 +391,7 @@ void array_section_no_length_map_clause(float *d, int index) { // CHECK-NEXT: ret void // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l29( +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z34array_section_no_length_map_clausePfi_l43( // CHECK-SAME: ptr noundef [[F:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR1]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[F_ADDR:%.*]] = alloca ptr, align 4 diff --git a/clang/test/OpenMP/target_map_both_pointer_pointee_codegen.cpp b/clang/test/OpenMP/target_map_both_pointer_pointee_codegen.cpp index 4264e58dd2152..19382d8d54e10 100644 --- a/clang/test/OpenMP/target_map_both_pointer_pointee_codegen.cpp +++ b/clang/test/OpenMP/target_map_both_pointer_pointee_codegen.cpp @@ -17,43 +17,52 @@ void f1() { void f2() { int *ptr; // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM + // &ptr, &ptr[2], sizeof(ptr), ATTACH #pragma omp target map(ptr[2]) ptr[1] = 6; } void f3() { int *ptr; - // &ptr, &ptr[0], sizeof(ptr[0:2]), TO | FROM | PARAM | PTR_AND_OBJ + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[0], 2 * sizeof(ptr[0]), TO | FROM + // &ptr, &ptr[0], sizeof(ptr), ATTACH #pragma omp target map(ptr, ptr[0:2]) ptr[1] = 7; } void f4() { int *ptr; - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM + // &ptr, &ptr[2], sizeof(ptr), ATTACH #pragma omp target map(ptr, ptr[2]) ptr[2] = 8; } void f5() { int *ptr; - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ - #pragma omp target map(ptr[2], ptr) + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM + // &ptr, &ptr[2], sizeof(ptr), ATTACH + #pragma omp target map(ptr[2], ptr) ptr[2] = 9; } void f6() { int *ptr; - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ - // TODO: PARAM should not be needed here. + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM + // &ptr, &ptr[2], sizeof(ptr), ATTACH #pragma omp target data map(ptr, ptr[2]) ptr[2] = 10; } void f7() { int *ptr; - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ - // TODO: PARAM should not be needed here. + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM + // &ptr, &ptr[2], sizeof(ptr), ATTACH #pragma omp target data map(ptr[2], ptr) ptr[2] = 11; } @@ -61,18 +70,18 @@ void f7() { //. // CHECK: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 8] // CHECK: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x23]]] -// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x23]]] -// CHECK: @.offload_sizes.3 = private unnamed_addr constant [1 x i64] [i64 8] -// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.5 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.7 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.8 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.9 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.10 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.11 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.12 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [2 x i64] [i64 [[#0x23]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 8, i64 8, i64 8] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.5 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.7 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.8 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.9 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.10 = private unnamed_addr constant [3 x i64] [i64 [[#0x3]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.11 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.12 = private unnamed_addr constant [3 x i64] [i64 [[#0x3]], i64 [[#0x3]], i64 [[#0x4000]]] //. // CHECK-LABEL: define {{[^@]+}}@_Z2f1v // CHECK-SAME: () #[[ATTR0:[0-9]+]] { @@ -106,18 +115,24 @@ void f7() { // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 // CHECK: [[TMP2:%.*]] = load ptr, ptr [[PTR]], align 8 // CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP2]], i64 2 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[TMP1]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[ARRAYIDX]], ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP5]], align 8 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[PTR]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l20 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l21 // CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 @@ -133,23 +148,36 @@ void f7() { // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 // CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP1]], i64 0 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[PTR]], ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PTR]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l27 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l30 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 1 // CHECK: store i32 7, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // @@ -160,23 +188,36 @@ void f7() { // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 // CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[PTR]], ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PTR]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l34 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l39 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 // CHECK: store i32 8, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // @@ -187,23 +228,36 @@ void f7() { // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 // CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[PTR]], ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PTR]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f5v_l41 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f5v_l48 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 // CHECK: store i32 9, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // @@ -212,22 +266,35 @@ void f7() { // CHECK-SAME: () #[[ATTR0]] { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR:%.*]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 -// CHECK: [[TMP1:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[PTR]], ptr [[TMP1]], align 8 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 1, ptr [[TMP4]], ptr [[TMP5]], ptr @.offload_sizes.9, ptr @.offload_maptypes.10, ptr null, ptr null) -// CHECK: [[TMP6:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP6]], i64 2 +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PTR]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 3, ptr [[TMP11]], ptr [[TMP12]], ptr @.offload_sizes.9, ptr @.offload_maptypes.10, ptr null, ptr null) +// CHECK: [[TMP13:%.*]] = load ptr, ptr [[PTR]], align 8 +// CHECK: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP13]], i64 2 // CHECK: store i32 10, ptr [[ARRAYIDX1]], align 4 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP7]], ptr [[TMP8]], ptr @.offload_sizes.9, ptr @.offload_maptypes.10, ptr null, ptr null) +// CHECK: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 3, ptr [[TMP14]], ptr [[TMP15]], ptr @.offload_sizes.9, ptr @.offload_maptypes.10, ptr null, ptr null) // CHECK: ret void // // @@ -235,21 +302,34 @@ void f7() { // CHECK-SAME: () #[[ATTR0]] { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR:%.*]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 -// CHECK: [[TMP1:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[PTR]], ptr [[TMP1]], align 8 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP4]], ptr [[TMP5]], ptr @.offload_sizes.11, ptr @.offload_maptypes.12, ptr null, ptr null) -// CHECK: [[TMP6:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP6]], i64 2 +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PTR]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 3, ptr [[TMP11]], ptr [[TMP12]], ptr @.offload_sizes.11, ptr @.offload_maptypes.12, ptr null, ptr null) +// CHECK: [[TMP13:%.*]] = load ptr, ptr [[PTR]], align 8 +// CHECK: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP13]], i64 2 // CHECK: store i32 11, ptr [[ARRAYIDX1]], align 4 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP7]], ptr [[TMP8]], ptr @.offload_sizes.11, ptr @.offload_maptypes.12, ptr null, ptr null) +// CHECK: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 3, ptr [[TMP14]], ptr [[TMP15]], ptr @.offload_sizes.11, ptr @.offload_maptypes.12, ptr null, ptr null) // CHECK: ret void // diff --git a/clang/test/OpenMP/target_map_both_pointer_pointee_codegen_global.cpp b/clang/test/OpenMP/target_map_both_pointer_pointee_codegen_global.cpp index ee9cb9af4d3ca..eb1c876ecc7ba 100644 --- a/clang/test/OpenMP/target_map_both_pointer_pointee_codegen_global.cpp +++ b/clang/test/OpenMP/target_map_both_pointer_pointee_codegen_global.cpp @@ -16,39 +16,48 @@ void f1() { } void f2() { - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM + // &ptr, &ptr[2], sizeof(ptr), ATTACH #pragma omp target map(ptr[2]) ptr[1] = 6; } void f3() { - // &ptr, &ptr[0], sizeof(ptr[0:2]), TO | FROM | PARAM | PTR_AND_OBJ + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[0], 2 * sizeof(ptr[0]), TO | FROM + // &ptr, &ptr[0], sizeof(ptr), ATTACH #pragma omp target map(ptr, ptr[0:2]) ptr[1] = 7; } void f4() { - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM + // &ptr, &ptr[2], sizeof(ptr), ATTACH #pragma omp target map(ptr, ptr[2]) ptr[2] = 8; } void f5() { - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ - #pragma omp target map(ptr[2], ptr) + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM + // &ptr, &ptr[2], sizeof(ptr), ATTACH + #pragma omp target map(ptr[2], ptr) ptr[2] = 9; } void f6() { - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ - // TODO: PARAM should not be needed here. + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM + // &ptr, &ptr[2], sizeof(ptr), ATTACH #pragma omp target data map(ptr, ptr[2]) ptr[2] = 10; } void f7() { - // &ptr, &ptr[2], sizeof(ptr[2]), TO | FROM | PARAM | PTR_AND_OBJ - // TODO: PARAM should not be needed here. + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[2], sizeof(ptr[2]), TO | FROM + // &ptr, &ptr[2], sizeof(ptr), ATTACH #pragma omp target data map(ptr[2], ptr) ptr[2] = 11; } @@ -56,18 +65,18 @@ void f7() { //. // CHECK: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 8] // CHECK: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x23]]] -// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.3 = private unnamed_addr constant [1 x i64] [i64 8] -// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.5 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.7 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.8 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.9 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.10 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.11 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.12 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [2 x i64] [i64 [[#0x23]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 8, i64 8, i64 8] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.5 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.7 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.8 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.9 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.10 = private unnamed_addr constant [3 x i64] [i64 [[#0x3]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.11 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.12 = private unnamed_addr constant [3 x i64] [i64 [[#0x3]], i64 [[#0x3]], i64 [[#0x4000]]] //. // CHECK-LABEL: define {{[^@]+}}@_Z2f1v // CHECK-SAME: () #[[ATTR0:[0-9]+]] { @@ -99,19 +108,26 @@ void f7() { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr @ptr, ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = load ptr, ptr @ptr, align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP2]], i64 2 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[TMP1]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr @ptr, ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l20 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l21 // CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 @@ -127,23 +143,36 @@ void f7() { // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP1]], i64 0 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr @ptr, ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ptr, ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ptr, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l26 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l29 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 1 // CHECK: store i32 7, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // @@ -154,23 +183,36 @@ void f7() { // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr @ptr, ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ptr, ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ptr, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l32 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l37 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 // CHECK: store i32 8, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // @@ -181,23 +223,36 @@ void f7() { // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr @ptr, ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ptr, ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ptr, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f5v_l38 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f5v_l45 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 // CHECK: store i32 9, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // @@ -206,22 +261,35 @@ void f7() { // CHECK-SAME: () #[[ATTR0]] { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 -// CHECK: [[TMP1:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr @ptr, ptr [[TMP1]], align 8 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 1, ptr [[TMP4]], ptr [[TMP5]], ptr @.offload_sizes.9, ptr @.offload_maptypes.10, ptr null, ptr null) -// CHECK: [[TMP6:%.*]] = load ptr, ptr @ptr, align 8 -// CHECK: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP6]], i64 2 +// CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ptr, ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ptr, ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ptr, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 3, ptr [[TMP11]], ptr [[TMP12]], ptr @.offload_sizes.9, ptr @.offload_maptypes.10, ptr null, ptr null) +// CHECK: [[TMP13:%.*]] = load ptr, ptr @ptr, align 8 +// CHECK: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP13]], i64 2 // CHECK: store i32 10, ptr [[ARRAYIDX1]], align 4 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP7]], ptr [[TMP8]], ptr @.offload_sizes.9, ptr @.offload_maptypes.10, ptr null, ptr null) +// CHECK: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 3, ptr [[TMP14]], ptr [[TMP15]], ptr @.offload_sizes.9, ptr @.offload_maptypes.10, ptr null, ptr null) // CHECK: ret void // // @@ -229,21 +297,34 @@ void f7() { // CHECK-SAME: () #[[ATTR0]] { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 -// CHECK: [[TMP1:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr @ptr, ptr [[TMP1]], align 8 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP4]], ptr [[TMP5]], ptr @.offload_sizes.11, ptr @.offload_maptypes.12, ptr null, ptr null) -// CHECK: [[TMP6:%.*]] = load ptr, ptr @ptr, align 8 -// CHECK: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP6]], i64 2 +// CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ptr, ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ptr, ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ptr, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[ARRAYIDX]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 3, ptr [[TMP11]], ptr [[TMP12]], ptr @.offload_sizes.11, ptr @.offload_maptypes.12, ptr null, ptr null) +// CHECK: [[TMP13:%.*]] = load ptr, ptr @ptr, align 8 +// CHECK: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[TMP13]], i64 2 // CHECK: store i32 11, ptr [[ARRAYIDX1]], align 4 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP7]], ptr [[TMP8]], ptr @.offload_sizes.11, ptr @.offload_maptypes.12, ptr null, ptr null) +// CHECK: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 3, ptr [[TMP14]], ptr [[TMP15]], ptr @.offload_sizes.11, ptr @.offload_maptypes.12, ptr null, ptr null) // CHECK: ret void // diff --git a/clang/test/OpenMP/target_map_codegen_18.inc b/clang/test/OpenMP/target_map_codegen_18.inc index 2930521975da8..092eb949be8da 100644 --- a/clang/test/OpenMP/target_map_codegen_18.inc +++ b/clang/test/OpenMP/target_map_codegen_18.inc @@ -63,32 +63,34 @@ // CK19-NOUSE: [[MTYPE09:@.+]] = private {{.*}}constant [1 x i64] [i64 2] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19: [[SIZE10:@.+]] = private {{.*}}constant [1 x i64] [i64 240] -// CK19-USE: [[MTYPE10:@.+]] = private {{.*}}constant [1 x i64] [i64 35] -// CK19-NOUSE: [[MTYPE10:@.+]] = private {{.*}}constant [1 x i64] [i64 3] +// CK19: [[SIZE10:@.+]] = private {{.*}}constant [2 x i64] [i64 240, i64 {{4|8}}] +// CK19-USE: [[MTYPE10:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] +// CK19-NOUSE: [[MTYPE10:@.+]] = private {{.*}}constant [2 x i64] [i64 3, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19: [[SIZE11:@.+]] = private {{.*}}constant [1 x i64] [i64 240] -// CK19-USE: [[MTYPE11:@.+]] = private {{.*}}constant [1 x i64] [i64 32] -// CK19-NOUSE: [[MTYPE11:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer +// CK19: [[SIZE11:@.+]] = private {{.*}}constant [2 x i64] [i64 240, i64 {{4|8}}] +// CK19-USE: [[MTYPE11:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 16384] +// CK19-NOUSE: [[MTYPE11:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19: [[SIZE12:@.+]] = private {{.*}}constant [1 x i64] [i64 4] -// CK19-USE: [[MTYPE12:@.+]] = private {{.*}}constant [1 x i64] [i64 33] -// CK19-NOUSE: [[MTYPE12:@.+]] = private {{.*}}constant [1 x i64] [i64 1] +// CK19: [[SIZE12:@.+]] = private {{.*}}constant [2 x i64] [i64 4, i64 {{4|8}}] +// CK19-USE: [[MTYPE12:@.+]] = private {{.*}}constant [2 x i64] [i64 33, i64 16384] +// CK19-NOUSE: [[MTYPE12:@.+]] = private {{.*}}constant [2 x i64] [i64 1, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19-USE: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i64] [i64 32] -// CK19-NOUSE: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer +// CK19: [[SIZE13:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 {{4|8}}] +// CK19-USE: [[MTYPE13:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 16384] +// CK19-NOUSE: [[MTYPE13:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19-USE: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i64] [i64 33] -// CK19-NOUSE: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i64] [i64 1] +// CK19: [[SIZE14:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 {{4|8}}] +// CK19-USE: [[MTYPE14:@.+]] = private {{.*}}constant [2 x i64] [i64 33, i64 16384] +// CK19-NOUSE: [[MTYPE14:@.+]] = private {{.*}}constant [2 x i64] [i64 1, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19: [[SIZE15:@.+]] = private {{.*}}constant [1 x i64] [i64 4] -// CK19-USE: [[MTYPE15:@.+]] = private {{.*}}constant [1 x i64] [i64 34] -// CK19-NOUSE: [[MTYPE15:@.+]] = private {{.*}}constant [1 x i64] [i64 2] +// CK19: [[SIZE15:@.+]] = private {{.*}}constant [2 x i64] [i64 4, i64 {{4|8}}] +// CK19-USE: [[MTYPE15:@.+]] = private {{.*}}constant [2 x i64] [i64 34, i64 16384] +// CK19-NOUSE: [[MTYPE15:@.+]] = private {{.*}}constant [2 x i64] [i64 2, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 // CK19-USE: [[SIZE16:@.+]] = private {{.*}}constant [2 x i64] [i64 {{8|4}}, i64 0] @@ -155,14 +157,16 @@ // CK19-NOUSE: [[MTYPE27:@.+]] = private {{.*}}constant [1 x i64] [i64 3] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19: [[SIZE28:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 16] -// CK19-USE: [[MTYPE28:@.+]] = private {{.*}}constant [3 x i64] [i64 35, i64 16, i64 19] -// CK19-NOUSE: [[MTYPE28:@.+]] = private {{.*}}constant [3 x i64] [i64 3, i64 16, i64 19] +// CK19-USE: [[SIZE28:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 16, i64 {{4|8}}] +// CK19-USE: [[MTYPE28:@.+]] = private {{.*}}constant [3 x i64] [i64 544, i64 3, i64 16384] +// CK19-NOUSE: [[SIZE28:@.+]] = private {{.*}}constant [2 x i64] [i64 16, i64 {{4|8}}] +// CK19-NOUSE: [[MTYPE28:@.+]] = private {{.*}}constant [2 x i64] [i64 3, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19: [[SIZE29:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 4] -// CK19-USE: [[MTYPE29:@.+]] = private {{.*}}constant [3 x i64] [i64 35, i64 16, i64 19] -// CK19-NOUSE: [[MTYPE29:@.+]] = private {{.*}}constant [3 x i64] [i64 3, i64 16, i64 19] +// CK19-USE: [[SIZE29:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 4, i64 {{4|8}}] +// CK19-USE: [[MTYPE29:@.+]] = private {{.*}}constant [3 x i64] [i64 544, i64 3, i64 16384] +// CK19-NOUSE: [[SIZE29:@.+]] = private {{.*}}constant [2 x i64] [i64 4, i64 {{4|8}}] +// CK19-NOUSE: [[MTYPE29:@.+]] = private {{.*}}constant [2 x i64] [i64 3, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 // CK19-USE: [[SIZE30:@.+]] = private {{.*}}constant [4 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 {{8|4}}, i64 0] @@ -226,9 +230,10 @@ // CK19-NOUSE: [[MTYPE41:@.+]] = private {{.*}}constant [1 x i64] [i64 3] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK19: [[SIZE42:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 104] -// CK19-USE: [[MTYPE42:@.+]] = private {{.*}}constant [3 x i64] [i64 35, i64 16, i64 19] -// CK19-NOUSE: [[MTYPE42:@.+]] = private {{.*}}constant [3 x i64] [i64 3, i64 16, i64 19] +// CK19-USE: [[SIZE42:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 104, i64 {{4|8}}] +// CK19-USE: [[MTYPE42:@.+]] = private {{.*}}constant [3 x i64] [i64 544, i64 3, i64 16384] +// CK19-NOUSE: [[SIZE42:@.+]] = private {{.*}}constant [2 x i64] [i64 104, i64 {{4|8}}] +// CK19-NOUSE: [[MTYPE42:@.+]] = private {{.*}}constant [2 x i64] [i64 3, i64 16384] // CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 // CK19-USE: [[MTYPE43:@.+]] = private {{.*}}constant [1 x i64] [i64 35] @@ -527,6 +532,10 @@ void explicit_maps_single (int ii){ } // Region 10 + + // &pa[0], &pa[20], 60 * sizeof(pa[0]), TO | FROM [| PARAM] + // &pa, &pa[20], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -543,6 +552,14 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 20 // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: store ptr [[VAR0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 20 + // CK19-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK19-USE: call void [[CALL10:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL10:@.+]]() #pragma omp target map(tofrom:pa[20:60]) @@ -553,6 +570,10 @@ void explicit_maps_single (int ii){ } // Region 11 + + // &pa[0], &pa[/*lb=*/0], 60 * sizeof(pa[0]), ALLOC [| PARAM] + // &pa, &pa[/*lb=*/0], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -569,6 +590,14 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 0 // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: store ptr [[VAR0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 0 + // CK19-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK19-USE: call void [[CALL11:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL11:@.+]]() #pragma omp target map(alloc:pa[:60]) @@ -579,6 +608,10 @@ void explicit_maps_single (int ii){ } // Region 12 + + // &pa[0], &pa[15], 1 * sizeof(pa[0]), TO [| PARAM] + // &pa, &pa[15], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -595,6 +628,14 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 15 // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: store ptr [[VAR0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 15 + // CK19-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK19-USE: call void [[CALL12:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL12:@.+]]() #pragma omp target map(to:pa[15]) @@ -605,6 +646,10 @@ void explicit_maps_single (int ii){ } // Region 13 + + // &pa[0], &pa[ii-23], ii * sizeof(pa[0]), ALLOC [| PARAM] + // &pa, &pa[ii-23], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -627,6 +672,14 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} %{{.*}} // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: store ptr [[VAR0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} %{{.*}} + // CK19-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK19-USE: call void [[CALL13:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL13:@.+]]() #pragma omp target map(alloc:pa[ii-23:ii]) @@ -637,6 +690,10 @@ void explicit_maps_single (int ii){ } // Region 14 + + // &pa[0], &pa[/*lb=*/0], ii * sizeof(pa[0]), ALLOC [| PARAM] + // &pa, &pa[/*lb=*/0], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -659,6 +716,14 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 0 // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: store ptr [[VAR0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 0 + // CK19-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK19-USE: call void [[CALL14:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL14:@.+]]() #pragma omp target map(to:pa[:ii]) @@ -669,6 +734,10 @@ void explicit_maps_single (int ii){ } // Region 15 + + // &pa[0], &pa[ii + 12], 1 * sizeof(pa[0]), TO [| PARAM] + // &pa, &pa[ii + 12], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -685,6 +754,14 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} %{{.*}} // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 + // CK19-DAG: store ptr [[VAR0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} %{{.*}} + // CK19-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK19-USE: call void [[CALL15:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL15:@.+]]() #pragma omp target map(from:pa[ii+12]) @@ -1097,6 +1174,11 @@ void explicit_maps_single (int ii){ } // Region 28 + + // [ &mptr[0], &mptr[0], 0, IMPLICIT | PARAM ] + // &mptr[1][2][0], &mptr[1][2][2], sizeof(mptr[1][2][2:4]), TO | FROM + // &mptr[1][2], &mptr[1][2][2], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -1107,31 +1189,34 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] - // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] - // CK19-DAG: [[VAR0]] = load ptr, ptr [[PTR:%[^,]+]], - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC00]] = load ptr, ptr [[PTR]], + // CK19-USE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-USE-DAG: store ptr [[VAR0]], ptr [[P0]] + // CK19-USE-DAG: [[VAR0]] = load ptr, ptr [[PTR:%mptr]] // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-DAG: store ptr [[SEC0]], ptr [[BP1]] - // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] - // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], - // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC1111]] = load ptr, ptr [[PTR]], - - // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: store ptr [[SEC1]], ptr [[BP2]] - // CK19-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] - // CK19-DAG: [[SEC2]] = getelementptr {{.*}}ptr [[SEC22:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC22]] = load ptr, ptr [[SEC222:%[^,]+]], - // CK19-DAG: [[SEC222]] = getelementptr {{.*}}ptr [[SEC2222:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC2222]] = load ptr, ptr [[SEC22222:%[^,]+]], - // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}ptr [[SEC222222:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC222222]] = load ptr, ptr [[PTR]], + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-NOUSE-DAG: store ptr [[VAR1:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC1:%.+]], ptr [[P0]] + // CK19-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]] + // CK19-DAG: [[VAR11]] = getelementptr {{.*}}ptr [[VAR111:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[VAR111]] = load ptr, ptr [[VAR1111:%[^,]+]], + // CK19-DAG: [[VAR1111]] = getelementptr {{.*}}ptr [[VAR11111:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[VAR11111]] = load ptr, ptr [[PTR:%mptr]] + // CK19-DAG: [[SEC1:%.+]] = getelementptr {{.*}}i32, ptr [[SEC11:%.+]], i{{.*}} 2 + // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]] + // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC1111]] = load ptr, ptr [[SEC11111:%[^,]+]], + // CK19-DAG: [[SEC11111]] = getelementptr {{.*}}ptr [[SEC111111:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[SEC111111]] = load ptr, ptr [[PTR]] + + // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 + // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 + // CK19-USE-DAG: store ptr [[VAR11]], ptr [[BP2]] + // CK19-USE-DAG: store ptr [[SEC1]], ptr [[P2]] + // CK19-NOUSE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-NOUSE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] // CK19-USE: call void [[CALL28:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL28:@.+]]() @@ -1143,6 +1228,11 @@ void explicit_maps_single (int ii){ } // Region 29 + + // [ &mptr[0], &mptr[0], 0, IMPLICIT | PARAM ] + // &mptr[1][2][0], &mptr[1][2][3], sizeof(mptr[1][2][3]), TO | FROM + // &mptr[1][2], &mptr[1][2][3], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -1153,31 +1243,34 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] - // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] - // CK19-DAG: [[VAR0]] = load ptr, ptr [[PTR:%[^,]+]], - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC00]] = load ptr, ptr [[PTR]], + // CK19-USE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-USE-DAG: store ptr [[VAR0]], ptr [[P0]] + // CK19-USE-DAG: [[VAR0]] = load ptr, ptr [[PTR:%mptr]] // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-DAG: store ptr [[SEC0]], ptr [[BP1]] - // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] - // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], - // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC1111]] = load ptr, ptr [[PTR]], - - // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: store ptr [[SEC1]], ptr [[BP2]] - // CK19-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] - // CK19-DAG: [[SEC2]] = getelementptr {{.*}}ptr [[SEC22:[^,]+]], i{{.+}} 3 - // CK19-DAG: [[SEC22]] = load ptr, ptr [[SEC222:%[^,]+]], - // CK19-DAG: [[SEC222]] = getelementptr {{.*}}ptr [[SEC2222:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC2222]] = load ptr, ptr [[SEC22222:%[^,]+]], - // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}ptr [[SEC222222:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC222222]] = load ptr, ptr [[PTR]], + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-NOUSE-DAG: store ptr [[VAR1:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC1:%.+]], ptr [[P0]] + // CK19-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]] + // CK19-DAG: [[VAR11]] = getelementptr {{.*}}ptr [[VAR111:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[VAR111]] = load ptr, ptr [[VAR1111:%[^,]+]], + // CK19-DAG: [[VAR1111]] = getelementptr {{.*}}ptr [[VAR11111:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[VAR11111]] = load ptr, ptr [[PTR:%mptr]] + // CK19-DAG: [[SEC1:%.+]] = getelementptr {{.*}}i32, ptr [[SEC11:%.+]], i{{.*}} 3 + // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]] + // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC1111]] = load ptr, ptr [[SEC11111:%[^,]+]], + // CK19-DAG: [[SEC11111]] = getelementptr {{.*}}ptr [[SEC111111:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[SEC111111]] = load ptr, ptr [[PTR]] + + // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 + // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 + // CK19-USE-DAG: store ptr [[VAR11]], ptr [[BP2]] + // CK19-USE-DAG: store ptr [[SEC1]], ptr [[P2]] + // CK19-NOUSE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-NOUSE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] // CK19-USE: call void [[CALL29:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL29:@.+]]() @@ -1680,6 +1773,11 @@ void explicit_maps_single (int ii){ } // Region 42 + + // [ &mptras[0], &mptras[0], 0, IMPLICIT | PARAM ] + // &mptras[0][2][0], &mptras[0][2][0], sizeof(mptras[:1][2][:13]), TO | FROM + // &mptr[0][2], &mptr[0][2][0], sizeof(void*), ATTACH + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -1690,31 +1788,34 @@ void explicit_maps_single (int ii){ // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] - // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] - // CK19-DAG: [[VAR0]] = load ptr, ptr [[PTR:%[^,]+]], - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC00]] = load ptr, ptr [[PTR]], + // CK19-USE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-USE-DAG: store ptr [[VAR0]], ptr [[P0]] + // CK19-USE-DAG: [[VAR0]] = load ptr, ptr [[PTR:%mptras]] // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-DAG: store ptr [[SEC0]], ptr [[BP1]] - // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] - // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], - // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC1111]] = load ptr, ptr [[PTR]], - - // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: store ptr [[SEC1]], ptr [[BP2]] - // CK19-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] - // CK19-DAG: [[SEC2]] = getelementptr {{.*}}ptr [[SEC22:[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC22]] = load ptr, ptr [[SEC222:%[^,]+]], - // CK19-DAG: [[SEC222]] = getelementptr {{.*}}ptr [[SEC2222:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC2222]] = load ptr, ptr [[SEC22222:%[^,]+]], - // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}ptr [[SEC222222:[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC222222]] = load ptr, ptr [[PTR]], + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-NOUSE-DAG: store ptr [[VAR1:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC1:%.+]], ptr [[P0]] + // CK19-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]] + // CK19-DAG: [[VAR11]] = getelementptr {{.*}}ptr [[VAR111:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[VAR111]] = load ptr, ptr [[VAR1111:%[^,]+]], + // CK19-DAG: [[VAR1111]] = getelementptr {{.*}}ptr [[VAR11111:[^,]+]], i{{.+}} 0 + // CK19-DAG: [[VAR11111]] = load ptr, ptr [[PTR:%mptras]], + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:[^,]+]], i{{.+}} 0 + // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]] + // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC1111]] = load ptr, ptr [[SEC11111:%[^,]+]], + // CK19-DAG: [[SEC11111]] = getelementptr {{.*}}ptr [[SEC111111:[^,]+]], i{{.+}} 0 + // CK19-DAG: [[SEC111111]] = load ptr, ptr [[PTR]], + + // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 + // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 + // CK19-USE-DAG: store ptr [[VAR11]], ptr [[BP2]] + // CK19-USE-DAG: store ptr [[SEC1]], ptr [[P2]] + // CK19-NOUSE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-NOUSE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] // CK19-USE: call void [[CALL42:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL42:@.+]]() diff --git a/clang/test/OpenMP/target_map_codegen_19.cpp b/clang/test/OpenMP/target_map_codegen_19.cpp index 1d6c781a09905..4b1b897dfc215 100644 --- a/clang/test/OpenMP/target_map_codegen_19.cpp +++ b/clang/test/OpenMP/target_map_codegen_19.cpp @@ -46,8 +46,8 @@ // CK20: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i64] [i64 34] // CK20-LABEL: @.__omp_offloading_{{.*}}explicit_maps_references_and_function_args{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK20: [[SIZE03:@.+]] = private {{.*}}constant [1 x i64] [i64 12] -// CK20: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i64] [i64 34] +// CK20: [[SIZE03:@.+]] = private {{.*}}constant [2 x i64] [i64 12, i64 {{4|8}}] +// CK20: [[MTYPE03:@.+]] = private {{.*}}constant [2 x i64] [i64 34, i64 16384] // CK20-LABEL: explicit_maps_references_and_function_args{{.*}}( void explicit_maps_references_and_function_args (int a, float b, int (&c)[10], float *d){ @@ -126,6 +126,10 @@ void explicit_maps_references_and_function_args (int a, float b, int (&c)[10], f } // Region 03 + +// &d[0], &d[2], 3 * sizeof(d[0]), FROM | PARAM +// &d, &d[2], sizeof(d), ATTACH + // CK20-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK20-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK20-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -142,6 +146,13 @@ void explicit_maps_references_and_function_args (int a, float b, int (&c)[10], f // CK20-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 2 // CK20-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] +// CK20-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK20-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK20-DAG: store ptr [[VAR0]], ptr [[BP1]] +// CK20-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK20-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 2 +// CK20-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK20: call void [[CALL03:@.+]](ptr {{[^,]+}}) #pragma omp target map(from \ : d [2:3]) diff --git a/clang/test/OpenMP/target_map_codegen_20.cpp b/clang/test/OpenMP/target_map_codegen_20.cpp index 7ad2019b56ba4..d3c36a6cf8aac 100644 --- a/clang/test/OpenMP/target_map_codegen_20.cpp +++ b/clang/test/OpenMP/target_map_codegen_20.cpp @@ -69,14 +69,15 @@ // CK21-NOUSE: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i64] [i64 3] // CK21-LABEL: @.__omp_offloading_{{.*}}foo{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK21: [[SIZE01:@.+]] = private {{.*}}constant [1 x i64] [i64 492] -// CK21-USE: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i64] [i64 35] -// CK21-NOUSE: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i64] [i64 3] +// CK21: [[SIZE01:@.+]] = private {{.*}}constant [2 x i64] [i64 492, i64 {{4|8}}] +// CK21-USE: [[MTYPE01:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] +// CK21-NOUSE: [[MTYPE01:@.+]] = private {{.*}}constant [2 x i64] [i64 3, i64 16384] // CK21-LABEL: @.__omp_offloading_{{.*}}foo{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK21: [[SIZE02:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 500] -// CK21-USE: [[MTYPE02:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 281474976710674] -// CK21-NOUSE: [[MTYPE02:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 281474976710674] +// CK21-USE: [[SIZE02:@.+]] = private {{.*}}constant [3 x i64] [i64 {{4|8}}, i64 500, i64 {{4|8}}] +// CK21-NOUSE: [[SIZE02:@.+]] = private {{.*}}constant [2 x i64] [i64 500, i64 {{4|8}}] +// CK21-USE: [[MTYPE02:@.+]] = private {{.*}}constant [3 x i64] [i64 547, i64 2, i64 16384] +// CK21-NOUSE: [[MTYPE02:@.+]] = private {{.*}}constant [2 x i64] [i64 2, i64 16384] // CK21-LABEL: @.__omp_offloading_{{.*}}foo{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 // CK21: [[SIZE03:@.+]] = private {{.*}}constant [1 x i64] [i64 492] @@ -130,6 +131,10 @@ struct CC { } // Region 01 + +// &lb[0], &lb[/*lower_bound=*/0], X * sizeof(T), (TO | FROM) / (TO | FROM | PARAM) +// &lb, &lb[/*lower_bound=*/0], sizeof(T*), ATTACH + // CK21-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK21-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK21-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -140,11 +145,18 @@ struct CC { // CK21-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK21-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK21-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] -// CK21-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK21-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] -// CK21-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 0 -// CK21-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] +// CK21-DAG: store ptr [[RLB:%.+]], ptr [[BP0]] +// CK21-DAG: store ptr [[RLB0:%.+]], ptr [[P0]] +// CK21-DAG: [[RLB]] = load ptr, ptr %lb +// CK21-DAG: [[RLB0]] = getelementptr {{.*}}ptr [[RLB_1:%.+]], i{{.+}} 0 +// CK21-DAG: [[RLB_1]] = load ptr, ptr %lb + +// CK21-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK21-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK21-DAG: store ptr %lb, ptr [[BP1]] +// CK21-DAG: store ptr [[RLB0_1:%.+]], ptr [[P1]] +// CK21-DAG: [[RLB0_1]] = getelementptr {{.*}}ptr [[RLB_2:%.+]], i{{.+}} 0 +// CK21-DAG: [[RLB_2]] = load ptr, ptr %lb // CK21-USE: call void [[CALL01:@.+]](ptr {{[^,]+}}) // CK21-NOUSE: call void [[CALL01:@.+]]() @@ -156,32 +168,44 @@ struct CC { } // Region 02 + +// [&this[0], &this[0].B, sizeof(B), PARAM | ALLOC | IMPLICIT] +// &B[0], &B[X], 2 * sizeof(T), FROM +// &B, &B[X], sizeof(T*), ATTACH + // CK21-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK21-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK21-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK21-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK21-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK21-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK21-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK21-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK21-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK21-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK21-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK21-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK21-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 -// CK21-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK21-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK21-DAG: store i64 {{%.+}}, ptr [[S0]] -// CK21-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 2 +// CK21-USE-DAG: store ptr [[THIS:%.+]], ptr [[BP0]] +// CK21-USE-DAG: store ptr [[B:%.+]], ptr [[P0]] +// CK21-USE-DAG: [[B:%B]] = getelementptr inbounds {{.*}}[[THIS]], i{{.*}} 0, i{{.*}} 2 // CK21-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK21-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK21-DAG: store ptr [[SEC0]], ptr [[BP1]] -// CK21-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] -// CK21-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%[^,]+]], i{{.+}} 123 -// CK21-DAG: [[RVAR1]] = load ptr, ptr [[SEC1_:%[^,]+]] -// CK21-DAG: [[SEC1_]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 2 +// CK21-USE-DAG: store ptr [[VAR0:%.+]], ptr [[BP1]] +// CK21-USE-DAG: store ptr [[SEC0:%.+]], ptr [[P1]] +// CK21-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] +// CK21-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + +// CK21-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%[^,]+]] +// CK21-DAG: [[VAR00]] = getelementptr inbounds nuw %struct.CC, ptr [[THIS:%.+]], i{{.*}} 0, i{{.*}} 2 +// CK21-DAG: [[SEC0]] = getelementptr inbounds nuw float, ptr [[SEC00:%.+]], i{{.*}} 123 +// CK21-DAG: [[SEC00]] = load ptr, ptr [[SEC000:%[^,]+]] +// CK21-DAG: [[SEC000]] = getelementptr inbounds nuw %struct.CC, ptr [[THIS]], i{{.*}} 0, i{{.*}} 2 + +// CK21-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 +// CK21-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 +// CK21-USE-DAG: store ptr [[VAR00:%.+]], ptr [[BP2]] +// CK21-USE-DAG: store ptr [[SEC0:%.+]], ptr [[P2]] +// CK21-NOUSE-DAG: store ptr [[VAR00]], ptr [[BP1]] +// CK21-NOUSE-DAG: store ptr [[SEC0]], ptr [[P1]] // CK21-USE: call void [[CALL02:@.+]](ptr {{[^,]+}}) // CK21-NOUSE: call void [[CALL02:@.+]]() diff --git a/clang/test/OpenMP/target_map_codegen_21.cpp b/clang/test/OpenMP/target_map_codegen_21.cpp index f5c517692d8c8..1f76918f77ac8 100644 --- a/clang/test/OpenMP/target_map_codegen_21.cpp +++ b/clang/test/OpenMP/target_map_codegen_21.cpp @@ -53,8 +53,8 @@ // CK22: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i64] [i64 35] // CK22-LABEL: @.__omp_offloading_{{.*}}explicit_maps_globals{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK22: [[SIZE04:@.+]] = private {{.*}}constant [1 x i64] [i64 20] -// CK22: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i64] [i64 51] +// CK22: [[SIZE04:@.+]] = private {{.*}}constant [2 x i64] [i64 20, i64 {{4|8}}] +// CK22: [[MTYPE04:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK22-LABEL: @.__omp_offloading_{{.*}}explicit_maps_globals{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 // CK22: [[SIZE05:@.+]] = private {{.*}}constant [1 x i64] [i64 4] @@ -73,8 +73,8 @@ // CK22: [[MTYPE08:@.+]] = private {{.*}}constant [1 x i64] [i64 35] // CK22-LABEL: @.__omp_offloading_{{.*}}explicit_maps_globals{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK22: [[SIZE09:@.+]] = private {{.*}}constant [1 x i64] [i64 20] -// CK22: [[MTYPE09:@.+]] = private {{.*}}constant [1 x i64] [i64 51] +// CK22: [[SIZE09:@.+]] = private {{.*}}constant [2 x i64] [i64 20, i64 {{4|8}}] +// CK22: [[MTYPE09:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK22-LABEL: @.__omp_offloading_{{.*}}explicit_maps_globals{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 // CK22: [[SIZE10:@.+]] = private {{.*}}constant [1 x i64] [i64 4] @@ -93,8 +93,8 @@ // CK22: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i64] [i64 35] // CK22-LABEL: @.__omp_offloading_{{.*}}explicit_maps_globals{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK22: [[SIZE14:@.+]] = private {{.*}}constant [1 x i64] [i64 20] -// CK22: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i64] [i64 51] +// CK22: [[SIZE14:@.+]] = private {{.*}}constant [2 x i64] [i64 20, i64 {{4|8}}] +// CK22: [[MTYPE14:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] int a; int c[100]; @@ -192,6 +192,10 @@ int explicit_maps_globals(void){ { c[3]+=1; } // Region 04 + +// &d[0], &d[2], 5 * sizeof(d[0]), TO | FROM | PARAM +// &d, &d[2], sizeof(d), ATTACH + // CK22-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK22-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK22-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -202,11 +206,19 @@ int explicit_maps_globals(void){ // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK22-DAG: store ptr @d, ptr [[BP0]] +// CK22-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] // CK22-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] +// CK22-DAG: [[RVAR0]] = load ptr, ptr @d // CK22-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 2 // CK22-DAG: [[RVAR00]] = load ptr, ptr @d +// CK22-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK22-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK22-DAG: store ptr @d, ptr [[BP1]] +// CK22-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK22-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 2 +// CK22-DAG: [[RVAR1]] = load ptr, ptr @d + // CK22: call void [[CALL04:@.+]](ptr {{[^,]+}}) #pragma omp target map(d [2:5]) { d[3]+=1; } @@ -284,6 +296,10 @@ int explicit_maps_globals(void){ { sc[3].fa+=1; } // Region 09 + +// &sd[0], &sd[2], 5 * sizeof(sd[0]), TO | FROM | ATTACH +// &sd, &sd[2], sizeof(sd), ATTACH + // CK22-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK22-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK22-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -294,11 +310,19 @@ int explicit_maps_globals(void){ // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK22-DAG: store ptr @sd, ptr [[BP0]] +// CK22-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] // CK22-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] +// CK22-DAG: [[RVAR0]] = load ptr, ptr @sd // CK22-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 2 // CK22-DAG: [[RVAR00]] = load ptr, ptr @sd +// CK22-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK22-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK22-DAG: store ptr @sd, ptr [[BP1]] +// CK22-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK22-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 2 +// CK22-DAG: [[RVAR1]] = load ptr, ptr @sd + // CK22: call void [[CALL09:@.+]](ptr {{[^,]+}}) #pragma omp target map(sd [2:5]) { sd[3].fa+=1; } @@ -376,6 +400,10 @@ int explicit_maps_globals(void){ { stc[3].fa+=1; } // Region 14 + +// &std[0], &std[2], 5 * sizeof(std[0]), TO | FROM | ATTACH +// &std, &std[2], sizeof(std), ATTACH + // CK22-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK22-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK22-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -386,11 +414,19 @@ int explicit_maps_globals(void){ // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK22-DAG: store ptr @std, ptr [[BP0]] +// CK22-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] // CK22-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] +// CK22-DAG: [[RVAR0]] = load ptr, ptr @std // CK22-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 2 // CK22-DAG: [[RVAR00]] = load ptr, ptr @std +// CK22-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK22-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK22-DAG: store ptr @std, ptr [[BP1]] +// CK22-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK22-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 2 +// CK22-DAG: [[RVAR1]] = load ptr, ptr @std + // CK22: call void [[CALL14:@.+]](ptr {{[^,]+}}) #pragma omp target map(std [2:5]) { std[3].fa+=1; } diff --git a/clang/test/OpenMP/target_map_codegen_22.cpp b/clang/test/OpenMP/target_map_codegen_22.cpp index 06028b23e9378..049a2b45fd197 100644 --- a/clang/test/OpenMP/target_map_codegen_22.cpp +++ b/clang/test/OpenMP/target_map_codegen_22.cpp @@ -54,8 +54,8 @@ // CK23: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i64] [i64 35] // CK23-LABEL: @.__omp_offloading_{{.*}}explicit_maps_inside_captured{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK23: [[SIZE05:@.+]] = private {{.*}}constant [1 x i64] [i64 16] -// CK23: [[MTYPE05:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK23: [[SIZE05:@.+]] = private {{.*}}constant [2 x i64] [i64 16, i64 {{4|8}}] +// CK23: [[MTYPE05:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK23-LABEL: explicit_maps_inside_captured{{.*}}( int explicit_maps_inside_captured(int a){ @@ -175,6 +175,10 @@ int explicit_maps_inside_captured(int a){ { c[3]+=1; } // Region 05 + +// &d[0], &d[2], 4 * sizeof(d[0]), TO | FROM +// &d, &d[2], sizeof(d), ATTACH + // CK23-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK23-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK23-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -195,6 +199,16 @@ int explicit_maps_inside_captured(int a){ // CK23-DAG: [[VAR00]] = load ptr, ptr [[CAP00:%[^,]+]] // CK23-DAG: [[CAP00]] = getelementptr inbounds nuw %class.anon, +// CK23-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK23-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK23-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] +// CK23-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK23-DAG: [[VAR1]] = load ptr, ptr [[CAP1:%[^,]+]] +// CK23-DAG: [[CAP1]] = getelementptr inbounds nuw %class.anon, +// CK23-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 2 +// CK23-DAG: [[RVAR1]] = load ptr, ptr [[VAR11:%[^,]+]] +// CK23-DAG: [[VAR11]] = load ptr, ptr [[CAP11:%[^,]+]] +// CK23-DAG: [[CAP11]] = getelementptr inbounds nuw %class.anon, // CK23: call void [[CALL05:@.+]](ptr {{[^,]+}}) #pragma omp target map(d [2:4]) { d[3]+=1; } diff --git a/clang/test/OpenMP/target_map_codegen_23.cpp b/clang/test/OpenMP/target_map_codegen_23.cpp index 7e9acdafad2f8..980190a22c30d 100644 --- a/clang/test/OpenMP/target_map_codegen_23.cpp +++ b/clang/test/OpenMP/target_map_codegen_23.cpp @@ -61,52 +61,52 @@ struct SC{ // CK24: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i64] [i64 35] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE13:@.+]] = private {{.*}}constant [1 x i64] [i64 4] -// CK24: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK24: [[SIZE13:@.+]] = private {{.*}}constant [2 x i64] [i64 4, i64 {{4|8}}] +// CK24: [[MTYPE13:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE14:@.+]] = private {{.*}}constant [1 x i64] [i64 {{48|56}}] -// CK24: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK24: [[SIZE14:@.+]] = private {{.*}}constant [2 x i64] [i64 {{48|56}}, i64 {{4|8}}] +// CK24: [[MTYPE14:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE15:@.+]] = private {{.*}}constant [1 x i64] [i64 4] -// CK24: [[MTYPE15:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK24: [[SIZE15:@.+]] = private {{.*}}constant [2 x i64] [i64 4, i64 {{4|8}}] +// CK24: [[MTYPE15:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE16:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 20] -// CK24: [[MTYPE16:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 281474976710659] +// CK24: [[SIZE16:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 20, i64 {{4|8}}] +// CK24: [[MTYPE16:@.+]] = private {{.*}}constant [3 x i64] [i64 32, i64 281474976710659, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE17:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 {{3560|2880}}] -// CK24: [[MTYPE17:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 281474976710675] +// CK24: [[SIZE17:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 {{3560|2880}}, i64 {{4|8}}] +// CK24: [[MTYPE17:@.+]] = private {{.*}}constant [3 x i64] [i64 544, i64 3, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE18:@.+]] = private {{.*}}constant [1 x i64] [i64 4] -// CK24: [[MTYPE18:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK24: [[SIZE18:@.+]] = private {{.*}}constant [2 x i64] [i64 4, i64 {{4|8}}] +// CK24: [[MTYPE18:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE19:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 {{8|4}}, i64 4] -// CK24: [[MTYPE19:@.+]] = private {{.*}}constant [3 x i64] [i64 32, i64 281474976710659, i64 281474976710675] +// CK24: [[SIZE19:@.+]] = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 {{4|8}}] +// CK24: [[MTYPE19:@.+]] = private unnamed_addr constant [3 x i64] [i64 544, i64 3, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE20:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 4] -// CK24: [[MTYPE20:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 281474976710675] +// CK24: [[SIZE20:@.+]] = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 {{4|8}}] +// CK24: [[MTYPE20:@.+]] = private unnamed_addr constant [3 x i64] [i64 544, i64 3, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE21:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 {{8|4}}, i64 4] -// CK24: [[MTYPE21:@.+]] = private {{.*}}constant [3 x i64] [i64 32, i64 281474976710659, i64 281474976710675] +// CK24: [[SIZE21:@.+]] = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 {{4|8}}] +// CK24: [[MTYPE21:@.+]] = private unnamed_addr constant [3 x i64] [i64 544, i64 3, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE22:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 8] -// CK24: [[MTYPE22:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 281474976710659] +// CK24: [[SIZE22:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 8, i64 {{4|8}}] +// CK24: [[MTYPE22:@.+]] = private {{.*}}constant [3 x i64] [i64 32, i64 281474976710659, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE23:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 {{8|4}}, i64 8] -// CK24: [[MTYPE23:@.+]] = private {{.*}}constant [3 x i64] [i64 32, i64 281474976710659, i64 281474976710675] +// CK24: [[SIZE23:@.+]] = private unnamed_addr constant [4 x i64] [i64 0, i64 0, i64 8, i64 {{4|8}}] +// CK24: [[MTYPE23:@.+]] = private unnamed_addr constant [4 x i64] [i64 544, i64 0, i64 562949953421315, i64 16384] // CK24-LABEL: @.__omp_offloading_{{.*}}explicit_maps_struct_fields{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK24: [[SIZE24:@.+]] = private {{.*}}constant [4 x i64] [i64 0, i64 {{8|4}}, i64 {{8|4}}, i64 4] -// CK24: [[MTYPE24:@.+]] = private {{.*}}constant [4 x i64] [i64 32, i64 281474976710672, i64 16, i64 19] +// CK24: [[SIZE24:@.+]] = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 {{4|8}}] +// CK24: [[MTYPE24:@.+]] = private unnamed_addr constant [3 x i64] [i64 544, i64 3, i64 16384] // CK24-LABEL: explicit_maps_struct_fields int explicit_maps_struct_fields(int a){ @@ -134,8 +134,12 @@ int explicit_maps_struct_fields(int a){ // // Same thing but starting from a pointer. -// + // Region 13 + +// &p[0], &p->a, sizeof(p->a), TO | FROM | PARAM +// &p, &p->a, sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -150,14 +154,26 @@ int explicit_maps_struct_fields(int a){ // CK24-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] // CK24-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR:[^,]+]], ptr [[BP1]] +// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[VAR1:%.+]], i{{.+}} 0, i{{.+}} 0 + +// CK24-DAG: [[VAR0]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR00]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR]] + // CK24: call void [[CALL13:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->a) { p->a++; } // Region 14 + +// &p[0], &p->s.s, sizeof(p->s.s), TO | FROM | PARAM +// &p, &p->s.s, sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -173,14 +189,25 @@ int explicit_maps_struct_fields(int a){ // CK24-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 1 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR:%[^,]+]], ptr [[BP1]] +// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[SEC11]] = getelementptr {{.*}}ptr [[VAR1:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[VAR0]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR00]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR]] // CK24: call void [[CALL14:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->s.s) { p->a++; } // Region 15 + +// &p[0], &p->s.s.a, sizeof(p->s.s.a), TO | FROM | PARAM +// &p, &p->s.s.a, sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -197,14 +224,28 @@ int explicit_maps_struct_fields(int a){ // CK24-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 1 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR:%[^,]+]], ptr [[BP1]] +// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 0 +// CK24-DAG: [[SEC11]] = getelementptr {{.*}}ptr [[SEC111:%[^,]+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[VAR1:%.+]], i{{.+}} 0, i{{.+}} 1 + +// CK24-DAG: [[VAR0]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR00]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR]] // CK24: call void [[CALL15:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->s.s.a) { p->a++; } // Region 16 + +// &p[0], &p->b[0], sizeof(p->b[0:5]), ALLOC | PARAM +// &p[0], &p->b[0], sizeof(p->b[0:5]), TO | FROM +// &p, &p->b[0], sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -230,50 +271,64 @@ int explicit_maps_struct_fields(int a){ // CK24-DAG: store ptr [[VAR0]], ptr [[BP1]] // CK24-DAG: store ptr [[SEC0]], ptr [[P1]] -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: store ptr [[VAR:%[^,]+]], ptr [[BP2]] +// CK24-DAG: store ptr [[SEC0]], ptr [[P2]] + +// CK24-DAG: [[VAR0]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR00]] = load ptr, ptr [[VAR]] // CK24: call void [[CALL16:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->b[:5]) { p->a++; } // Region 17 + +// &p[0], &p[0], 0, IMPLICIT | PARAM +// &p->p[0], &p->p[/*lb=*/0], sizeof(p->p[0:5]), TO | FROM +// &p->p, &p->p[/*lb=*/0], sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK24-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK24-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK24-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK24-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK24-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK24-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK24-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK24-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK24-DAG: store i64 {{%.+}}, ptr [[S0]] -// CK24-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: store ptr [[VAR0]], ptr [[P0]] +// CK24-DAG: [[VAR0]] = load ptr, ptr %p // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: store ptr [[SEC0]], ptr [[BP1]] +// CK24-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] // CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] -// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0 +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]], +// CK24-DAG: [[VAR11]] = getelementptr {{.*}}%struct.SC, ptr [[VAR111:%.+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[VAR111]] = load ptr, ptr %p +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}%struct.SB, ptr [[SEC11:%[^,]+]], i{{.+}} 0 // CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK24-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[SEC111]] = getelementptr {{.*}}%struct.SC, ptr [[SEC1111:%.+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[SEC1111]] = load ptr, ptr %p -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR000]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: store ptr [[VAR11]], ptr [[BP2]] +// CK24-DAG: store ptr [[SEC1]], ptr [[P2]] // CK24: call void [[CALL17:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->p[:5]) { p->a++; } // Region 18 + +// &p[0], &p->s.sa[3].a, sizeof(p->s.sa[3].a), TO | FROM | PARAM +// &p, &p->s.sa[3].a sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -291,138 +346,160 @@ int explicit_maps_struct_fields(int a){ // CK24-DAG: [[SEC000]] = getelementptr {{.*}}ptr [[SEC0000:%[^,]+]], i{{.+}} 0, i{{.+}} 2 // CK24-DAG: [[SEC0000]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR:%[^,]+]], ptr [[BP1]] +// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 0 +// CK24-DAG: [[SEC11]] = getelementptr {{.*}}ptr [[SEC111:%[^,]+]], i{{.+}} 0, i{{.+}} 3 +// CK24-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:%[^,]+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[SEC1111]] = getelementptr {{.*}}ptr [[VAR11:%.+]], i{{.+}} 0, i{{.+}} 1 + +// CK24-DAG: [[VAR0]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR00]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR11]] = load ptr, ptr [[VAR]] // CK24: call void [[CALL18:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->s.sa[3].a) { p->a++; } // Region 19 + +// &p[0], &p[0], 0, IMPLICIT | PARAM +// &p->s.sp[3][0], &p->s.sp[3]->a, sizeof(p->s.sp[3]->a), TO | FROM +// &p->s.sp[3], &p->s.sp[3]->a, sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK24-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK24-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK24-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK24-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK24-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK24-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK24-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK24-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK24-DAG: store i64 {{%.+}}, ptr [[S0]] -// CK24-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 3 -// CK24-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 3 -// CK24-DAG: [[SEC000]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR0]], ptr [[P0]] +// CK24-DAG: [[VAR0]] = load ptr, ptr %p // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: store ptr [[VAR0]], ptr [[BP1]] -// CK24-DAG: store ptr [[SEC0]], ptr [[P1]] +// CK24-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] +// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]] +// CK24-DAG: [[VAR11]] = getelementptr {{.*}}[10 x ptr], ptr [[VAR111:%[^,]+]], i{{.+}} 0, i{{.+}} 3 +// CK24-DAG: [[VAR111]] = getelementptr {{.*}}%struct.SB, ptr [[VAR1111:%[^,]+]], i{{.+}} 0, i{{.+}} 3 +// CK24-DAG: [[VAR1111]] = getelementptr {{.*}}%struct.SC, ptr [[VAR11111:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[VAR11111]] = load ptr, ptr %p + +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}%struct.SA, ptr [[SEC11:%.+]], i{{.*}} 0, i{{.*}} 0 +// CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]] +// CK24-DAG: [[SEC111]] = getelementptr {{.*}}[10 x ptr], ptr [[SEC1111:%[^,]+]], i{{.+}} 0, i{{.+}} 3 +// CK24-DAG: [[SEC1111]] = getelementptr {{.*}}%struct.SB, ptr [[SEC11111:%[^,]+]], i{{.+}} 0, i{{.+}} 3 +// CK24-DAG: [[SEC11111]] = getelementptr {{.*}}%struct.SC, ptr [[SEC111111:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[SEC111111]] = load ptr, ptr %p // CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 -// CK24-DAG: store ptr [[SEC0]], ptr [[BP2]] -// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P2]] -// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK24-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:%[^,]+]], i{{.+}} 0, i{{.+}} 3 -// CK24-DAG: [[SEC1111]] = getelementptr {{.*}}ptr [[SEC11111:%[^,]+]], i{{.+}} 0, i{{.+}} 3 -// CK24-DAG: [[SEC11111]] = getelementptr {{.*}}ptr [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 1 - -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR000]] = load ptr, ptr %{{.+}} +// CK24-DAG: store ptr [[VAR11]], ptr [[BP2]] +// CK24-DAG: store ptr [[SEC1]], ptr [[P2]] // CK24: call void [[CALL19:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->s.sp[3]->a) { p->a++; } // Region 20 + +// &p[0], &p[0], 0, IMPLICIT | PARAM +// &p->p[0], &p->p->a, sizeof(p->p->a), TO | FROM +// &p->p, &p->p->a, sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK24-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK24-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK24-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK24-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK24-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK24-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK24-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK24-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK24-DAG: store i64 {{%.+}}, ptr [[S0]] -// CK24-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: store ptr [[VAR0]], ptr [[P0]] +// CK24-DAG: [[VAR0]] = load ptr, ptr %p // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: store ptr [[SEC0]], ptr [[BP1]] +// CK24-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] // CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] -// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0 -// CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK24-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]] +// CK24-DAG: [[VAR11]] = getelementptr {{.*}}%struct.SC, ptr [[VAR111:.+]], i{{.*}} 0, i{{.*}} 2 +// CK24-DAG: [[VAR111]] = load ptr, ptr %p -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR000]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}%struct.SB, ptr [[SEC11:%[^,]+]], i{{.+}} 0 +// CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]] +// CK24-DAG: [[SEC111]] = getelementptr {{.*}}%struct.SC, ptr [[SEC1111:.+]], i{{.*}} 0, i{{.*}} 2 +// CK24-DAG: [[SEC1111]] = load ptr, ptr %p + +// CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: store ptr [[VAR11]], ptr [[BP2]] +// CK24-DAG: store ptr [[SEC1]], ptr [[P2]] // CK24: call void [[CALL20:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->p->a) { p->a++; } // Region 21 + +// &p[0], &p[0], 0, IMPLICIT | PARAM +// &p->s.p[0], &p->s.p->a, sizeof(p->s.p->a), TO | FROM +// &p->s.p, &p->s.p->a, sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK24-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK24-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK24-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK24-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK24-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK24-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK24-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK24-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK24-DAG: store i64 {{%.+}}, ptr [[S0]] -// CK24-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 4 -// CK24-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR0]], ptr [[P0]] +// CK24-DAG: [[VAR0]] = load ptr, ptr %p // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: store ptr [[VAR0]], ptr [[BP1]] -// CK24-DAG: store ptr [[SEC0]], ptr [[P1]] +// CK24-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] +// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]] +// CK24-DAG: [[VAR11]] = getelementptr {{.*}}%struct.SB, ptr [[VAR111:[^,]+]], i{{.+}} 0, i{{.+}} 4 +// CK24-DAG: [[VAR111]] = getelementptr {{.*}}%struct.SC, ptr [[VAR1111:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[VAR1111]] = load ptr, ptr %p +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}%struct.SA, ptr [[SEC11:%[^,]+]], i{{.+}} 0 +// CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]] +// CK24-DAG: [[SEC111]] = getelementptr {{.*}}%struct.SB, ptr [[SEC1111:[^,]+]], i{{.+}} 0, i{{.+}} 4 +// CK24-DAG: [[SEC1111]] = getelementptr {{.*}}%struct.SC, ptr [[SEC11111:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: [[SEC11111]] = load ptr, ptr %p // CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 -// CK24-DAG: store ptr [[SEC0]], ptr [[BP2]] -// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P2]] -// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0 -// CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK24-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 0, i{{.+}} 4 -// CK24-DAG: [[SEC1111]] = getelementptr {{.*}}ptr [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 1 - -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR000]] = load ptr, ptr %{{.+}} +// CK24-DAG: store ptr [[VAR11]], ptr [[BP2]] +// CK24-DAG: store ptr [[SEC1]], ptr [[P2]] // CK24: call void [[CALL21:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->s.p->a) { p->a++; } // Region 22 + +// &p[0], &p->s.s.b[0], sizeof(p->s.s.b[0:2]), ALLOC | PARAM +// &p[0], &p->s.s.b[0], sizeof(p->s.s.b[0:2]), TO | FROM +// &p, &p->s.s.b[0], sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -450,14 +527,25 @@ int explicit_maps_struct_fields(int a){ // CK24-DAG: store ptr [[VAR0]], ptr [[BP1]] // CK24-DAG: store ptr [[SEC0]], ptr [[P1]] -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: store ptr [[VAR:%[^,]+]], ptr [[BP2]] +// CK24-DAG: store ptr [[SEC0]], ptr [[P2]] + +// CK24-DAG: [[VAR0]] = load ptr, ptr [[VAR]] +// CK24-DAG: [[VAR00]] = load ptr, ptr [[VAR]] // CK24: call void [[CALL22:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->s.s.b[:2]) { p->a++; } // Region 23 + +// &p[0], &p[0], 0, IMPLICIT | PARAM +// &p->s.p[0], &p->s.p->b[0], sizeof(p->s.p->b[:2]), ALLOC +// &p->s.p[0], &p->s.p->b[0], sizeof(p->s.p->b[:2]), MEMBER_OF_1 | TO | FROM +// &p->s.p, &p->s.p->b[0], sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -471,91 +559,87 @@ int explicit_maps_struct_fields(int a){ // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK24-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK24-DAG: store i64 {{%.+}}, ptr [[S0]] -// CK24-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 4 -// CK24-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR0]], ptr [[P0]] +// CK24-DAG: [[VAR0]] = load ptr, ptr %p // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: store ptr [[VAR0]], ptr [[BP1]] -// CK24-DAG: store ptr [[SEC0]], ptr [[P1]] +// CK24-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] +// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK24-DAG: store i64 {{%.+}}, ptr [[S1]] +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]] +// CK24-DAG: [[VAR11]] = getelementptr {{.*}}%struct.SB, ptr [[VAR111:%.+]], i{{.*}} 0, i{{.*}} 4 +// CK24-DAG: [[VAR111]] = getelementptr {{.*}}%struct.SC, ptr [[VAR1111:%.+]], i{{.*}} 0, i{{.*}} 1 +// CK24-DAG: [[VAR1111]] = load ptr, ptr %p + +// CK24-DAG: [[SEC1]] = getelementptr {{.*}}[10 x i{{.*}}], ptr [[SEC11:%.+]], i{{.*}} 0, i{{.*}} 0 +// CK24-DAG: [[SEC11]] = getelementptr {{.*}}%struct.SA, ptr [[SEC111:%.+]], i{{.*}} 0, i{{.*}} 2 +// CK24-DAG: [[SEC111]] = load ptr, ptr [[SEC1111:%[^,]+]] +// CK24-DAG: [[SEC1111]] = getelementptr {{.*}}%struct.SB, ptr [[SEC11111:%.+]], i{{.*}} 0, i{{.*}} 4 +// CK24-DAG: [[SEC11111]] = getelementptr {{.*}}%struct.SC, ptr [[SEC111111:%.+]], i{{.*}} 0, i{{.*}} 1 +// CK24-DAG: [[SEC111111]] = load ptr, ptr %p // CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 -// CK24-DAG: store ptr [[SEC0]], ptr [[BP2]] -// CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P2]] -// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[SEC11]] = getelementptr {{.*}}ptr [[SEC111:%[^,]+]], i{{.+}} 0, i{{.+}} 2 -// CK24-DAG: [[SEC111]] = load ptr, ptr [[SEC1111:%[^,]+]], -// CK24-DAG: [[SEC1111]] = getelementptr {{.*}}ptr [[SEC11111:%[^,]+]], i{{.+}} 0, i{{.+}} 4 -// CK24-DAG: [[SEC11111]] = getelementptr {{.*}}ptr [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 1 +// CK24-DAG: store ptr [[VAR1]], ptr [[BP2]] +// CK24-DAG: store ptr [[SEC1]], ptr [[P2]] -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR000]] = load ptr, ptr %{{.+}} +// CK24-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3 +// CK24-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3 +// CK24-DAG: store ptr [[VAR11]], ptr [[BP3]] +// CK24-DAG: store ptr [[SEC1]], ptr [[P3]] // CK24: call void [[CALL23:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->s.p->b[:2]) { p->a++; } // Region 24 + +// &p[0], &p[0], 0, IMPLICIT | PARAM +// &p->p->p->p[0], &p->p->p->p->a, sizeof(p->p->p->p->a), TO | FROM +// &p->p->p->p, &p->p->p->p->a, sizeof(p), ATTACH + // CK24-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK24-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK24-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK24-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK24-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK24-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK24-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK24-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK24-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK24-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 // CK24-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK24-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] -// CK24-DAG: store i64 {{%.+}}, ptr [[S0]] -// CK24-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: store ptr [[VAR0]], ptr [[P0]] +// CK24-DAG: [[VAR0]] = load ptr, ptr %p // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: store ptr [[SEC0]], ptr [[BP1]] +// CK24-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] // CK24-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] -// CK24-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 4 -// CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK24-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 2 +// CK24-DAG: [[VAR1]] = load ptr, ptr [[VAR11:%[^,]+]] +// CK24-DAG: [[VAR11]] = getelementptr {{.*}}%struct.SA, ptr [[VAR111:%.+]], i{{.*}} 0, i{{.*}} 1 +// CK24-DAG: [[VAR111]] = load ptr, ptr [[VAR1111:%[^,]+]] +// CK24-DAG: [[VAR1111]] = getelementptr {{.*}}%struct.SB, ptr [[VAR11111:%.+]], i{{.*}} 0, i{{.*}} 4 +// CK24-DAG: [[VAR11111]] = load ptr, ptr [[VAR111111:%[^,]+]] +// CK24-DAG: [[VAR111111]] = getelementptr {{.*}}%struct.SC, ptr [[VAR1111111:%.+]], i{{.*}} 0, i{{.*}} 2 +// CK24-DAG: [[VAR1111111]] = load ptr, ptr %p + +// CK24-DAG: [[SEC1:%.+]] = getelementptr {{.*}}%struct.SA, ptr [[SEC11:%.+]], i{{.*}} 0, i{{.*}} 0 +// CK24-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]] +// CK24-DAG: [[SEC111]] = getelementptr {{.*}}%struct.SA, ptr [[SEC1111:%.+]], i{{.*}} 0, i{{.*}} 1 +// CK24-DAG: [[SEC1111]] = load ptr, ptr [[SEC11111:%[^,]+]] +// CK24-DAG: [[SEC11111]] = getelementptr {{.*}}%struct.SB, ptr [[SEC111111:%.+]], i{{.*}} 0, i{{.*}} 4 +// CK24-DAG: [[SEC111111]] = load ptr, ptr [[SEC1111111:%[^,]+]] +// CK24-DAG: [[SEC1111111]] = getelementptr {{.*}}%struct.SC, ptr [[SEC11111111:%.+]], i{{.*}} 0, i{{.*}} 2 +// CK24-DAG: [[SEC11111111]] = load ptr, ptr %p // CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 -// CK24-DAG: store ptr [[SEC1]], ptr [[BP2]] -// CK24-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] -// CK24-DAG: [[SEC2]] = getelementptr {{.*}}ptr [[SEC22:%[^,]+]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: [[SEC22]] = load ptr, ptr [[SEC222:%[^,]+]], -// CK24-DAG: [[SEC222]] = getelementptr {{.*}}ptr [[SEC2222:%[^,]+]], i{{.+}} 0, i{{.+}} 4 -// CK24-DAG: [[SEC2222]] = load ptr, ptr [[SEC22222:%[^,]+]], -// CK24-DAG: [[SEC22222]] = getelementptr {{.*}}ptr [[VAR0000:%.+]], i{{.+}} 0, i{{.+}} 2 - -// CK24-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3 -// CK24-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3 -// CK24-DAG: store ptr [[SEC2]], ptr [[BP3]] -// CK24-DAG: store ptr [[SEC3:%.+]], ptr [[P3]] -// CK24-DAG: [[SEC3]] = getelementptr {{.*}}ptr [[SEC33:%[^,]+]], i{{.+}} 0, i{{.+}} 0 -// CK24-DAG: [[SEC33]] = load ptr, ptr [[SEC333:%[^,]+]], -// CK24-DAG: [[SEC333]] = getelementptr {{.*}}ptr [[SEC3333:%[^,]+]], i{{.+}} 0, i{{.+}} 1 -// CK24-DAG: [[SEC3333]] = load ptr, ptr [[SEC33333:%[^,]+]], -// CK24-DAG: [[SEC33333]] = getelementptr {{.*}}ptr [[SEC333333:%[^,]+]], i{{.+}} 0, i{{.+}} 4 -// CK24-DAG: [[SEC333333]] = load ptr, ptr [[SEC3333333:%[^,]+]], -// CK24-DAG: [[SEC3333333]] = getelementptr {{.*}}ptr [[VAR00000:%.+]], i{{.+}} 0, i{{.+}} 2 - -// CK24-DAG: [[VAR0]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR000]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR0000]] = load ptr, ptr %{{.+}} -// CK24-DAG: [[VAR00000]] = load ptr, ptr %{{.+}} +// CK24-DAG: store ptr [[VAR11]], ptr [[BP2]] +// CK24-DAG: store ptr [[SEC1]], ptr [[P2]] // CK24: call void [[CALL24:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->p->p->p->a) diff --git a/clang/test/OpenMP/target_map_codegen_26.cpp b/clang/test/OpenMP/target_map_codegen_26.cpp index 2bc1092685ac3..255c4a0c5e1f1 100644 --- a/clang/test/OpenMP/target_map_codegen_26.cpp +++ b/clang/test/OpenMP/target_map_codegen_26.cpp @@ -38,16 +38,16 @@ // CK27: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i64] [i64 544] // CK27-LABEL: @.__omp_offloading_{{.*}}zero_size_section_and_private_maps{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK27: [[SIZE01:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer -// CK27: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK27: [[SIZE01:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 {{8|4}}] +// CK27: [[MTYPE01:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK27-LABEL: @.__omp_offloading_{{.*}}zero_size_section_and_private_maps{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK27: [[SIZE02:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer -// CK27: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK27: [[SIZE02:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 {{8|4}}] +// CK27: [[MTYPE02:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK27-LABEL: @.__omp_offloading_{{.*}}zero_size_section_and_private_maps{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK27: [[SIZE03:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer -// CK27: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK27: [[SIZE03:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 {{8|4}}] +// CK27: [[MTYPE03:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK27-LABEL: @.__omp_offloading_{{.*}}zero_size_section_and_private_maps{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 // CK27-LABEL: @.__omp_offloading_{{.*}}zero_size_section_and_private_maps{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 @@ -71,6 +71,12 @@ void zero_size_section_and_private_maps (int ii){ int *pa; // Region 00 + +// &pa, &pa, sizeof(pa), IMPLICIT | PARAM +// +// FIXME: This looks like a bug. The implicit map on a pointer +// should be identical to pa[0:0] + // CK27-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK27-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK27-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -91,6 +97,10 @@ void zero_size_section_and_private_maps (int ii){ } // Region 01 + +// &(pa[0]), &pa[/*lb=*/0], /*size=*/0, TO | FROM | PARAM +// &pa, &pa[/*lb=*/0], sizeof(pa), ATTACH + // CK27-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK27-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK27-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -107,6 +117,13 @@ void zero_size_section_and_private_maps (int ii){ // CK27-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 0 // CK27-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] +// CK27-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK27-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK27-DAG: store ptr [[VAR0]], ptr [[BP1]] +// CK27-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK27-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 0 +// CK27-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK27: call void [[CALL01:@.+]](ptr {{[^,]+}}) #pragma omp target map(pa[:0]) { @@ -114,6 +131,10 @@ void zero_size_section_and_private_maps (int ii){ } // Region 02 + +// &(pa[0]), &pa[/*lb=*/0], /*size=*/0, TO | FROM | PARAM +// &pa, &pa[/*lb=*/0], sizeof(pa), ATTACH + // CK27-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK27-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK27-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -130,6 +151,13 @@ void zero_size_section_and_private_maps (int ii){ // CK27-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 0 // CK27-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] +// CK27-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK27-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK27-DAG: store ptr [[VAR0]], ptr [[BP1]] +// CK27-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK27-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} 0 +// CK27-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK27: call void [[CALL02:@.+]](ptr {{[^,]+}}) #pragma omp target map(pa [0:0]) { @@ -137,6 +165,10 @@ void zero_size_section_and_private_maps (int ii){ } // Region 03 + +// &pa[0], &pa[ii], /*size=*/0, TO | FROM | PARAM +// &pa, &pa[ii], sizeof(pa), ATTACH + // CK27-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK27-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK27-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -153,6 +185,13 @@ void zero_size_section_and_private_maps (int ii){ // CK27-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} %{{.+}} // CK27-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] +// CK27-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK27-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK27-DAG: store ptr [[VAR0]], ptr [[BP1]] +// CK27-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] +// CK27-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[RVAR1:%.+]], i{{.+}} %{{.+}} +// CK27-DAG: [[RVAR1]] = load ptr, ptr [[VAR0]] + // CK27: call void [[CALL03:@.+]](ptr {{[^,]+}}) #pragma omp target map(pa [ii:0]) { diff --git a/clang/test/OpenMP/target_map_codegen_27.cpp b/clang/test/OpenMP/target_map_codegen_27.cpp index bfe75bca481be..d0720fa6a4066 100644 --- a/clang/test/OpenMP/target_map_codegen_27.cpp +++ b/clang/test/OpenMP/target_map_codegen_27.cpp @@ -38,8 +38,8 @@ // CK28: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i64] [i64 35] // CK28-LABEL: @.__omp_offloading_{{.*}}explicit_maps_pointer_references{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK28: [[SIZE01:@.+]] = private {{.*}}constant [1 x i64] [i64 400] -// CK28: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i64] [i64 35] +// CK28: [[SIZE01:@.+]] = private {{.*}}constant [2 x i64] [i64 400, i64 {{4|8}}] +// CK28: [[MTYPE01:@.+]] = private {{.*}}constant [2 x i64] [i64 35, i64 16384] // CK28-LABEL: explicit_maps_pointer_references{{.*}}( void explicit_maps_pointer_references (int *p){ @@ -68,6 +68,10 @@ void explicit_maps_pointer_references (int *p){ } // Region 01 + +// &(ref_ptee(a)[0]), &(ref_ptee(a)[2]), 100 * sizeof(int), TO | FROM | PARAM +// &(ref_ptee(a)), &(ref_ptee(a)[2]), sizeof(ref_ptee(a)), ATTACH + // CK28-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK28-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK28-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -78,13 +82,22 @@ void explicit_maps_pointer_references (int *p){ // CK28-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK28-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK28-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK28-DAG: store ptr [[VAR1:%.+]], ptr [[P0]] -// CK28-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%.+]], -// CK28-DAG: [[VAR00]] = load ptr, ptr [[VAR000:%.+]], -// CK28-DAG: [[VAR1]] = getelementptr inbounds nuw i32, ptr [[VAR11:%.+]], i{{64|32}} 2 -// CK28-DAG: [[VAR11]] = load ptr, ptr [[VAR111:%.+]], -// CK28-DAG: [[VAR111]] = load ptr, ptr [[VAR1111:%.+]], +// CK28-DAG: store ptr [[RRA:%.+]], ptr [[BP0]] +// CK28-DAG: store ptr [[RRA2:%.+]], ptr [[P0]] +// CK28-DAG: [[RRA]] = load ptr, ptr [[RA:%.+]], +// CK28-DAG: [[RA]] = load ptr, ptr [[A:%.+]], +// CK28-DAG: [[RRA2]] = getelementptr inbounds nuw i32, ptr [[RRA_1:%.+]], i{{64|32}} 2 +// CK28-DAG: [[RRA_1]] = load ptr, ptr [[RA_1:%.+]], +// CK28-DAG: [[RA_1]] = load ptr, ptr [[A]] + +// CK28-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK28-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK28-DAG: store ptr [[RA_2:%.+]], ptr [[BP1]] +// CK28-DAG: store ptr [[RRA2_2:%.+]], ptr [[P1]] +// CK28-DAG: [[RA_2]] = load ptr, ptr [[A]] +// CK28-DAG: [[RRA2_2]] = getelementptr inbounds nuw i32, ptr [[RRA_2:%.+]], i{{64|32}} 2 +// CK28-DAG: [[RRA_2]] = load ptr, ptr [[RA_3:%.+]], +// CK28-DAG: [[RA_3]] = load ptr, ptr [[A]] // CK28: call void [[CALL01:@.+]](ptr {{[^,]+}}) #pragma omp target map(a [2:100]) diff --git a/clang/test/OpenMP/target_map_codegen_28.cpp b/clang/test/OpenMP/target_map_codegen_28.cpp index 67ea72d791d03..caf15c56164be 100644 --- a/clang/test/OpenMP/target_map_codegen_28.cpp +++ b/clang/test/OpenMP/target_map_codegen_28.cpp @@ -37,16 +37,16 @@ // CK29: [[SSB:%.+]] = type { ptr, ptr } // CK29-LABEL: @.__omp_offloading_{{.*}}foo{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK29: [[SIZE00:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 80] -// CK29: [[MTYPE00:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 281474976710675] +// CK29: [[SIZE00:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|16}}, i64 80, i64 {{4|8}}] +// CK29: [[MTYPE00:@.+]] = private {{.*}}constant [3 x i64] [i64 [[#0x223]], i64 3, i64 [[#0x4000]]] // CK29-LABEL: @.__omp_offloading_{{.*}}foo{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK29: [[SIZE01:@.+]] = private {{.*}}constant [3 x i64] [i64 0, i64 {{8|4}}, i64 80] -// CK29: [[MTYPE01:@.+]] = private {{.*}}constant [3 x i64] [i64 32, i64 281474976710672, i64 19] +// CK29: [[SIZE01:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|16}}, i64 80, i64 {{4|8}}] +// CK29: [[MTYPE01:@.+]] = private {{.*}}constant [3 x i64] [i64 [[#0x223]], i64 3, i64 [[#0x4000]]] // CK29-LABEL: @.__omp_offloading_{{.*}}foo{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK29: [[SIZE02:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 80] -// CK29: [[MTYPE02:@.+]] = private {{.*}}constant [2 x i64] [i64 32, i64 281474976710675] +// CK29: [[SIZE02:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|16}}, i64 80, i64 {{4|8}}] +// CK29: [[MTYPE02:@.+]] = private {{.*}}constant [3 x i64] [i64 [[#0x223]], i64 3, i64 [[#0x4000]]] struct SSA{ double *p; @@ -63,34 +63,47 @@ struct SSB{ void foo() { // Region 00 + +// &this[0], &this[0], sizeof(this[0]), TO | FROM | IMPLICIT +// &p->pr[0], &p->pr[0], 10 * sizeof(p->pr[0]), TO | FROM +// &p->pr, &p->pr[0], sizeof(void*), ATTACH + // CK29-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK29-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK29-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK29-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK29-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK29-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK29-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK29-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK29-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK29-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK29-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK29-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK29-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 -// CK29-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] -// CK29-DAG: store ptr [[VAR00:%.+]], ptr [[P0]] -// CK29-DAG: store i64 %{{.+}}, ptr [[S0]] -// CK29-DAG: [[VAR0]] = load ptr, ptr % -// CK29-DAG: [[VAR00]] = getelementptr inbounds nuw [[SSB]], ptr [[VAR0]], i32 0, i32 0 - -// CK29-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 -// CK29-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK29-DAG: store ptr [[VAR1:%.+]], ptr [[BP2]] -// CK29-DAG: store ptr [[VAR2:%.+]], ptr [[P2]] -// CK29-DAG: [[VAR1]] = getelementptr inbounds nuw [[SSA]], ptr %{{.+}}, i32 0, i32 1 -// CK29-DAG: [[VAR2]] = getelementptr inbounds nuw double, ptr [[VAR22:%.+]], i{{.+}} 0 -// CK29-DAG: [[VAR22]] = load ptr, ptr %{{.+}}, +// CK29-DAG: store ptr [[THIS:%.+]], ptr [[BP0]] +// CK29-DAG: store ptr [[THIS]], ptr [[P0]] + +// CK29-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK29-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK29-DAG: store ptr [[PR_DEREF_LOAD:%.+]], ptr [[BP1]] +// CK29-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + +// CK29-DAG: [[PR_DEREF_LOAD]] = load ptr, ptr [[PR_DEREF:%[^,]+]] +// CK29-DAG: [[PR_DEREF]] = load ptr, ptr [[PR:%[^,]+]] +// CK29-DAG: [[PR]] = getelementptr inbounds nuw %struct.SSA, ptr [[P_LOAD:%.+]], i32 0, i32 1 +// CK29-DAG: [[P_LOAD]] = load ptr, ptr [[THIS_P:%[^,]+]] +// CK29-DAG: [[THIS_P]] = getelementptr inbounds nuw %struct.SSB, ptr [[THIS]], i32 0, i32 0 + +// CK29-DAG: [[SEC1]] = getelementptr inbounds nuw double, ptr [[PR_DEREF_LOAD1:%.+]], i{{.*}} 0 +// CK29-DAG: [[PR_DEREF_LOAD1]] = load ptr, ptr [[PR_DEREF1:%[^,]+]] +// CK29-DAG: [[PR_DEREF]] = load ptr, ptr [[PR1:%[^,]+]] +// CK29-DAG: [[PR1]] = getelementptr inbounds nuw %struct.SSA, ptr [[P_LOAD1:%.+]], i32 0, i32 1 +// CK29-DAG: [[P_LOAD1]] = load ptr, ptr [[THIS_P1:%[^,]+]] +// CK29-DAG: [[THIS_P1]] = getelementptr inbounds nuw %struct.SSB, ptr [[THIS]], i32 0, i32 0 + +// CK29-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 +// CK29-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 +// CK29-DAG: store ptr [[PR_DEREF:%.+]], ptr [[BP2]] +// CK29-DAG: store ptr [[SEC1:%.+]], ptr [[P2]] // CK29: call void [[CALL00:@.+]](ptr {{[^,]+}}) #pragma omp target map(p->pr[:10]) @@ -99,38 +112,47 @@ struct SSB{ } // Region 01 + +// &this[0], &this[0], sizeof(this[0]), TO | FROM | IMPLICIT +// &pr->p[0], &pr->p[0], 10 * sizeof(pr->p[0]), TO | FROM +// &pr->p, &pr->p[0], sizeof(void*), ATTACH + // CK29-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK29-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK29-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK29-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK29-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK29-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK29-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK29-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK29-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK29-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK29-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK29-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK29-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 -// CK29-DAG: store ptr [[VAR0]], ptr [[BP0]] -// CK29-DAG: store ptr [[VAR000:%.+]], ptr [[P0]] -// CK29-DAG: store i64 %{{.+}}, ptr [[S0]] -// CK29-DAG: [[VAR000]] = getelementptr inbounds nuw [[SSB]], ptr [[VAR0]], i32 0, i32 1 +// CK29-DAG: store ptr [[THIS:%.+]], ptr [[BP0]] +// CK29-DAG: store ptr [[THIS]], ptr [[P0]] // CK29-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK29-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK29-DAG: store ptr [[VAR000]], ptr [[BP1]] -// CK29-DAG: store ptr [[VAR1:%.+]], ptr [[P1]] -// CK29-DAG: [[VAR1]] = getelementptr inbounds nuw [[SSA]], ptr %{{.+}}, i32 0, i32 0 +// CK29-DAG: store ptr [[PR_P_LOAD:%.+]], ptr [[BP1]] +// CK29-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + +// CK29-DAG: [[PR_P_LOAD]] = load ptr, ptr [[PR_P:%[^,]+]] +// CK29-DAG: [[PR_P]] = getelementptr inbounds nuw %struct.SSA, ptr [[PR_DEREF_LOAD:%.+]], i32 0, i32 0 +// CK29-DAG: [[PR_DEREF_LOAD]] = load ptr, ptr [[PR_DEREF:%[^,]+]] +// CK29-DAG: [[PR_DEREF]] = load ptr, ptr [[PR:%[^,]+]] +// CK29-DAG: [[PR]] = getelementptr inbounds nuw %struct.SSB, ptr [[THIS]], i32 0, i32 1 + +// CK29-DAG: [[SEC1]] = getelementptr inbounds nuw double, ptr [[PR_P_LOAD1:%.+]], i{{.*}} 0 +// CK29-DAG: [[PR_P_LOAD1]] = load ptr, ptr [[PR_P1:%[^,]+]] +// CK29-DAG: [[PR_P1]] = getelementptr inbounds nuw %struct.SSA, ptr [[PR_DEREF_LOAD1:%.+]], i32 0, i32 0 +// CK29-DAG: [[PR_DEREF_LOAD1]] = load ptr, ptr [[PR_DEREF1:%[^,]+]] +// CK29-DAG: [[PR_DEREF1]] = load ptr, ptr [[PR1:%[^,]+]] +// CK29-DAG: [[PR1]] = getelementptr inbounds nuw %struct.SSB, ptr [[THIS]], 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 ptr [[VAR1]], ptr [[BP2]] -// CK29-DAG: store ptr [[VAR2:%.+]], ptr [[P2]] -// CK29-DAG: [[VAR2]] = getelementptr inbounds nuw double, ptr [[VAR22:%.+]], i{{.+}} 0 -// CK29-DAG: [[VAR22]] = load ptr, ptr %{{.+}}, +// CK29-DAG: store ptr [[PR_P]], ptr [[BP2]] +// CK29-DAG: store ptr [[SEC1:%.+]], ptr [[P2]] // CK29: call void [[CALL00:@.+]](ptr {{[^,]+}}) #pragma omp target map(pr->p[:10]) @@ -139,33 +161,49 @@ struct SSB{ } // Region 02 + +// &this[0], &this[0], sizeof(this[0]), TO | FROM | IMPLICIT +// &pr->pr[0], &pr->pr[0], 10 * sizeof(pr->pr[0]), TO | FROM +// &pr->pr, &pr->pr[0], sizeof(void*), ATTACH + // CK29-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK29-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK29-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK29-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK29-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK29-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK29-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK29-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK29-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK29-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK29-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK29-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK29-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 -// CK29-DAG: store ptr [[VAR0]], ptr [[BP0]] -// CK29-DAG: store ptr [[VAR000:%.+]], ptr [[P0]] -// CK29-DAG: store i64 %{{.+}}, ptr [[S0]] -// CK29-DAG: [[VAR000]] = getelementptr inbounds nuw [[SSB]], ptr [[VAR0]], i32 0, i32 1 - -// CK29-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 -// CK29-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK29-DAG: store ptr [[VAR1:%.+]], ptr [[BP2]] -// CK29-DAG: store ptr [[VAR2:%.+]], ptr [[P2]] -// CK29-DAG: [[VAR1]] = getelementptr inbounds nuw [[SSA]], ptr %{{.+}}, i32 0, i32 1 -// CK29-DAG: [[VAR2]] = getelementptr inbounds nuw double, ptr [[VAR22:%.+]], i{{.+}} 0 -// CK29-DAG: [[VAR22]] = load ptr, ptr %{{.+}}, +// CK29-DAG: store ptr [[THIS:%.+]], ptr [[BP0]] +// CK29-DAG: store ptr [[THIS]], ptr [[P0]] + +// CK29-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK29-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 +// CK29-DAG: store ptr [[PR_PR_DEREF_LOAD:%.+]], ptr [[BP1]] +// CK29-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + +// CK29-DAG: [[PR_PR_DEREF_LOAD]] = load ptr, ptr [[PR_PR_DEREF:%[^,]+]] +// CK29-DAG: [[PR_PR_DEREF]] = load ptr, ptr [[PR_PR:%[^,]+]] +// CK29-DAG: [[PR_PR]] = getelementptr inbounds nuw %struct.SSA, ptr [[PR_DEREF_LOAD:%.+]], i32 0, i32 1 +// CK29-DAG: [[PR_DEREF_LOAD]] = load ptr, ptr [[PR_DEREF:%[^,]+]] +// CK29-DAG: [[PR_DEREF]] = load ptr, ptr [[PR:%[^,]+]] +// CK29-DAG: [[PR]] = getelementptr inbounds nuw %struct.SSB, ptr [[THIS]], i32 0, i32 1 + +// CK29-DAG: [[SEC1]] = getelementptr inbounds nuw double, ptr [[PR_PR_DEREF_LOAD1:%.+]], i{{.*}} 0 +// CK29-DAG: [[PR_PR_DEREF_LOAD1]] = load ptr, ptr [[PR_PR_DEREF1:%[^,]+]] +// CK29-DAG: [[PR_PR_DEREF1]] = load ptr, ptr [[PR_PR1:%[^,]+]] +// CK29-DAG: [[PR_PR1]] = getelementptr inbounds nuw %struct.SSA, ptr [[PR_DEREF_LOAD1:%.+]], i32 0, i32 1 +// CK29-DAG: [[PR_DEREF_LOAD1]] = load ptr, ptr [[PR_DEREF1:%[^,]+]] +// CK29-DAG: [[PR_DEREF1]] = load ptr, ptr [[PR1:%[^,]+]] +// CK29-DAG: [[PR1]] = getelementptr inbounds nuw %struct.SSB, ptr [[THIS]], 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 ptr [[PR_PR_DEREF:%.+]], ptr [[BP2]] +// CK29-DAG: store ptr [[SEC1:%.+]], ptr [[P2]] // CK29: call void [[CALL00:@.+]](ptr {{[^,]+}}) #pragma omp target map(pr->pr[:10]) diff --git a/clang/test/OpenMP/target_map_codegen_29.cpp b/clang/test/OpenMP/target_map_codegen_29.cpp index 3ca7b228d26c2..5381e7423cf25 100644 --- a/clang/test/OpenMP/target_map_codegen_29.cpp +++ b/clang/test/OpenMP/target_map_codegen_29.cpp @@ -36,12 +36,15 @@ // CK30-DAG: [[BASE:%.+]] = type { ptr, i32, ptr } // CK30-DAG: [[STRUCT:%.+]] = type { [[BASE]], ptr, ptr, i32, ptr } +// &s, &s, sizeof(s), TO | FROM | PARAM +// &s.ptr1[0], &s.ptr1[0], sizeof(s.ptr1[0]), TO | FROM +// &s.ptr1, &s.ptr1[0], sizeof(void*), ATTACH +// &s.ptrBase1[0], &s.ptrBase1[0], sizeof(s.ptrBase1[0]), TO | FROM +// &s.ptrBase1, &s.ptrBase1[0], sizeof(void*), ATTACH + // CK30-LABEL: @.__omp_offloading_{{.*}}map_with_deep_copy{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 -// CK30: [[SIZE00:@.+]] = private unnamed_addr constant [4 x i64] [i64 0, i64 {{56|28}}, i64 4, i64 4] -// The first element: 0x20 - OMP_MAP_TARGET_PARAM -// 2: 0x1000000000003 - OMP_MAP_MEMBER_OF(0) | OMP_MAP_TO | OMP_MAP_FROM - copies all the data in structs excluding deep-copied elements (from &s to end of s). -// 3-4: 0x1000000000013 - OMP_MAP_MEMBER_OF(0) | OMP_MAP_PTR_AND_OBJ | OMP_MAP_TO | OMP_MAP_FROM - deep copy of the pointers + pointee. -// CK30: [[MTYPE00:@.+]] = private {{.*}}constant [4 x i64] [i64 32, i64 281474976710659, i64 281474976710675, i64 281474976710675] +// CK30: [[SIZE00:@.+]] = private unnamed_addr constant [5 x i64] [i64 {{56|28}}, i64 4, i64 {{4|8}}, i64 4, i64 {{4|8}}] +// CK30: [[MTYPE00:@.+]] = private unnamed_addr constant [5 x i64] [i64 [[#0x23]], i64 3, i64 [[#0x4000]], i64 3, i64 [[#0x4000]]] typedef struct { int *ptrBase; @@ -61,46 +64,44 @@ typedef struct StructWithPtrTag : public Base { // CK30-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK30-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 // CK30-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] -// CK30-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 -// CK30-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] -// CK30-DAG: [[SIZES]] = getelementptr inbounds [4 x i{{64|32}}], ptr [[SIZES:%.+]], i32 0, i32 0 -// CK30-DAG: [[PGEP]] = getelementptr inbounds [4 x ptr], ptr [[PTRS:%.+]], i32 0, i32 0 -// CK30-DAG: [[BPGEP]] = getelementptr inbounds [4 x ptr], ptr [[BASES:%.+]], i32 0, i32 0 +// CK30-DAG: [[PGEP]] = getelementptr inbounds [5 x ptr], ptr [[PTRS:%.+]], i32 0, i32 0 +// CK30-DAG: [[BPGEP]] = getelementptr inbounds [5 x ptr], ptr [[BASES:%.+]], i32 0, i32 0 -// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [4 x ptr], ptr [[BASES]], i32 0, i32 0 +// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[BASES]], i32 0, i32 0 // CK30-DAG: store ptr [[S:%.+]], ptr [[BASE_PTR]], -// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [4 x ptr], ptr [[PTRS]], i32 0, i32 0 -// CK30-DAG: store ptr [[S]], ptr [[PTR]], -// CK30-DAG: [[SIZE:%.+]] = getelementptr inbounds [4 x i{{64|32}}], ptr [[SIZES]], i32 0, i32 0 -// CK30-DAG: store i64 [[S_ALLOC_SIZE:%.+]], ptr [[SIZE]], -// CK30-DAG: [[S_ALLOC_SIZE]] = sdiv exact i64 [[DIFF:%.+]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CK30-DAG: [[DIFF]] = sub i64 [[S_END_BC:%.+]], [[S_BEGIN_BC:%.+]] -// CK30-DAG: [[S_BEGIN_BC]] = ptrtoint ptr [[S_BEGIN:%.+]] to i64 -// CK30-DAG: [[S_END_BC]] = ptrtoint ptr [[S_END:%.+]] to i64 -// CK30-DAG: [[REAL_S_END:%.+]] = getelementptr [[STRUCT]], ptr [[S]], i32 1 - -// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [4 x ptr], ptr [[BASES]], i32 0, i32 1 -// CK30-DAG: store ptr [[S]], ptr [[BASE_PTR]], -// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [4 x ptr], ptr [[PTRS]], i32 0, i32 1 +// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[PTRS]], i32 0, i32 0 // CK30-DAG: store ptr [[S]], ptr [[PTR]], -// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [4 x ptr], ptr [[BASES]], i32 0, i32 2 -// CK30-DAG: store ptr [[S_PTR1:%.+]], ptr [[BASE_PTR]], -// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [4 x ptr], ptr [[PTRS]], i32 0, i32 2 +// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[BASES]], i32 0, i32 1 +// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[PTRS]], i32 0, i32 1 +// CK30-DAG: store ptr [[S_PTR1_REF:%.+]], ptr [[BASE_PTR]], // CK30-DAG: store ptr [[S_PTR1_BEGIN:%.+]], ptr [[PTR]], +// CK30-DAG: [[S_PTR1_REF]] = load ptr, ptr [[S_PTR1:%.+]], // CK30-DAG: [[S_PTR1]] = getelementptr inbounds nuw [[STRUCT]], ptr [[S]], i32 0, i32 4 -// CK30-DAG: [[S_PTR1_BEGIN]] = getelementptr inbounds nuw i32, ptr [[S_PTR1_BEGIN_REF:%.+]], i{{64|32}} 0 -// CK30-DAG: [[S_PTR1_BEGIN_REF]] = load ptr, ptr [[S_PTR1:%.+]], -// CK30-DAG: [[S_PTR1]] = getelementptr inbounds nuw [[STRUCT]], ptr [[S]], i32 0, i32 4 +// CK30-DAG: [[S_PTR1_BEGIN]] = getelementptr inbounds nuw i32, ptr [[S_PTR1_REF1:%.+]], i{{64|32}} 0 +// CK30-DAG: [[S_PTR1_REF1]] = load ptr, ptr [[S_PTR11:%.+]], +// CK30-DAG: [[S_PTR11]] = getelementptr inbounds nuw [[STRUCT]], ptr [[S]], i32 0, i32 4 + +// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[BASES]], i32 0, i32 2 +// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[PTRS]], i32 0, i32 2 +// CK30-DAG: store ptr [[S_PTR1]], ptr [[BASE_PTR]], +// CK30-DAG: store ptr [[S_PTR1_BEGIN]], ptr [[PTR]], -// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [4 x ptr], ptr [[BASES]], i32 0, i32 3 -// CK30-DAG: store ptr [[S_PTRBASE1:%.+]], ptr [[BASE_PTR]], -// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [4 x ptr], ptr [[PTRS]], i32 0, i32 3 +// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[BASES]], i32 0, i32 3 +// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[PTRS]], i32 0, i32 3 +// CK30-DAG: store ptr [[S_PTRBASE1_REF:%.+]], ptr [[BASE_PTR]], // CK30-DAG: store ptr [[S_PTRBASE1_BEGIN:%.+]], ptr [[PTR]], +// CK30-DAG: [[S_PTRBASE1_REF]] = load ptr, ptr [[S_PTRBASE1:%.+]], // CK30-DAG: [[S_PTRBASE1]] = getelementptr inbounds nuw [[BASE]], ptr [[S_BASE:%.+]], i32 0, i32 2 -// CK30-DAG: [[S_PTRBASE1_BEGIN]] = getelementptr inbounds nuw i32, ptr [[S_PTRBASE1_BEGIN_REF:%.+]], i{{64|32}} 0 -// CK30-DAG: [[S_PTRBASE1_BEGIN_REF]] = load ptr, ptr [[S_PTRBASE1:%.+]], -// CK30-DAG: [[S_PTRBASE1]] = getelementptr inbounds nuw [[BASE]], ptr [[S_BASE:%.+]], i32 0, i32 2 +// CK30-DAG: [[S_PTRBASE1_BEGIN]] = getelementptr inbounds nuw i32, ptr [[S_PTRBASE1_REF1:%.+]], i{{64|32}} 0 +// CK30-DAG: [[S_PTRBASE1_REF1]] = load ptr, ptr [[S_PTRBASE11:%.+]], +// CK30-DAG: [[S_PTRBASE11]] = getelementptr inbounds nuw [[BASE]], ptr [[S_BASE:%.+]], i32 0, i32 2 + +// CK30-DAG: [[BASE_PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[BASES]], i32 0, i32 4 +// CK30-DAG: [[PTR:%.+]] = getelementptr inbounds [5 x ptr], ptr [[PTRS]], i32 0, i32 4 +// CK30-DAG: store ptr [[S_PTRBASE1]], ptr [[BASE_PTR]], +// CK30-DAG: store ptr [[S_PTRBASE1_BEGIN]], ptr [[PTR]], + void map_with_deep_copy() { StructWithPtr s; #pragma omp target map(s, s.ptr1 [0:1], s.ptrBase1 [0:1]) diff --git a/clang/test/OpenMP/target_map_codegen_33.cpp b/clang/test/OpenMP/target_map_codegen_33.cpp index 7d4f7fa2e7483..5ac0da6b79b70 100644 --- a/clang/test/OpenMP/target_map_codegen_33.cpp +++ b/clang/test/OpenMP/target_map_codegen_33.cpp @@ -19,11 +19,15 @@ // SIMD-ONLY32-NOT: {{__kmpc|__tgt}} #ifdef CK32 -// CK32-DAG: [[MTYPE_TO:@.+]] = {{.+}}constant [1 x i64] [i64 33] -// CK32-DAG: [[MTYPE_FROM:@.+]] = {{.+}}constant [1 x i64] [i64 34] +// CK32-DAG: [[MTYPE_TO:@.+]] = {{.+}}constant [2 x i64] [i64 33, i64 16384] +// CK32-DAG: [[MTYPE_FROM:@.+]] = {{.+}}constant [2 x i64] [i64 34, i64 16384] void array_shaping(float *f, int sa) { +// Region 01 +// &f[0], &f[0], , PARAM | TO +// &f, &f[0], sizeof(f), ATTACH +// // CK32-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK32-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK32-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -39,12 +43,17 @@ void array_shaping(float *f, int sa) { // CK32-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK32-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK32-DAG: store ptr [[F1:%.+]], ptr [[BP0]], // CK32-DAG: store ptr [[F2:%.+]], ptr [[P0]], // CK32-DAG: store i64 [[SIZE:%.+]], ptr [[S0]], -// CK32-DAG: [[F1]] = load ptr, ptr [[F_ADDR:%.+]], +// CK32-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK32-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 + +// CK32-DAG: store ptr [[F_ADDR:%.+]], ptr [[BP1]], +// CK32-DAG: store ptr [[F2]], ptr [[P1]], + +// CK32-DAG: [[F1]] = load ptr, ptr [[F_ADDR]], // CK32-DAG: [[F2]] = load ptr, ptr [[F_ADDR]], // CK32-64-DAG: [[SIZE]] = mul nuw i64 [[SZ1:%.+]], 4 // CK32-64-DAG: [[SZ1]] = mul nuw i64 12, %{{.+}} @@ -55,6 +64,11 @@ void array_shaping(float *f, int sa) { : ([3][sa][4])f) f[0] = 1; sa = 1; + +// Region 02 +// &f[0], &f[0], , PARAM | FROM +// &f, &f[0], sizeof(f), ATTACH +// // CK32-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK32-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 // CK32-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] @@ -70,12 +84,17 @@ void array_shaping(float *f, int sa) { // CK32-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK32-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK32-DAG: store ptr [[F1:%.+]], ptr [[BP0]], // CK32-DAG: store ptr [[F2:%.+]], ptr [[P0]], // CK32-DAG: store i64 [[SIZE:%.+]], ptr [[S0]], -// CK32-DAG: [[F1]] = load ptr, ptr [[F_ADDR:%.+]], +// CK32-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 +// CK32-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 + +// CK32-DAG: store ptr [[F_ADDR:%.+]], ptr [[BP1]], +// CK32-DAG: store ptr [[F2]], ptr [[P1]], + +// CK32-DAG: [[F1]] = load ptr, ptr [[F_ADDR]], // CK32-DAG: [[F2]] = load ptr, ptr [[F_ADDR]], // CK32-64-DAG: [[SIZE]] = mul nuw i64 [[SZ1:%.+]], 5 // CK32-64-DAG: [[SZ1]] = mul nuw i64 4, %{{.+}} diff --git a/clang/test/OpenMP/target_map_deref_array_codegen.cpp b/clang/test/OpenMP/target_map_deref_array_codegen.cpp index e61fc7296332b..aa122d3dd83f8 100644 --- a/clang/test/OpenMP/target_map_deref_array_codegen.cpp +++ b/clang/test/OpenMP/target_map_deref_array_codegen.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-globals --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" --global-hex-value-regex ".offload_maptypes.*" // RUN: %clang_cc1 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -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 @@ -14,37 +14,56 @@ void foo(int **t1d) *t1d = (int *) malloc(3 * sizeof(int)); for (int j=0; j < 3; j++) (*t1d)[j] = 1; + // &t1d[0], &t1d[0], 0, IMPLICIT | PARAM + // &t1d[0][0], &t1d[0][0], 3 * sizeof(t1d[0][0]), TO + // &t1d[0], &t1d[0][0], sizeof(void*), ATTACH #pragma omp target map(to: (*t1d)[0:3]) (*t1d)[2] = 2; + // &t1d[0], &t1d[0], 0, IMPLICIT | PARAM + // &t1d[0][0], &t1d[0][0], sizeof(t1d[0][0]), TO | FROM + // &t1d[0], &t1d[0][0], sizeof(void*), ATTACH #pragma omp target map(tofrom : (**t1d)) (*t1d)[0] = 3; int a = 0, b = 0; + // &t1d[0], &t1d[0], 0, IMPLICIT | PARAM + // &t1d[a][0], &t1d[a][b], sizeof(t1d[a][b]), TO | FROM + // &t1d[a], &t1d[a][b], sizeof(void*), ATTACH + // (void*)a, (void*)a, sizeof(void*), LITERAL | PARAM + // (void*)b, (void*)b, sizeof(void*), LITERAL | PARAM #pragma omp target map(tofrom : (*(*(t1d+a)+b))) *(*(t1d+a)+b) = 4; } #endif +//. +// CHECK: @.offload_sizes = private unnamed_addr constant [3 x i64] [i64 0, i64 12, i64 8] +// CHECK: @.offload_maptypes = private unnamed_addr constant [3 x i64] [i64 [[#0x220]], i64 [[#0x1]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [3 x i64] [i64 [[#0x220]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [5 x i64] [i64 0, i64 4, i64 8, i64 4, i64 4] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [5 x i64] [i64 [[#0x220]], i64 [[#0x3]], i64 [[#0x4000]], i64 [[#0x320]], i64 [[#0x320]]] +//. // CHECK-LABEL: define {{[^@]+}}@_Z3fooPPi // CHECK-SAME: (ptr noundef [[T1D:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[T1D_ADDR:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[J:%.*]] = alloca i32, align 4 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [2 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [2 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [2 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x ptr], align 8 // CHECK-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS2:%.*]] = alloca [2 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS3:%.*]] = alloca [2 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS4:%.*]] = alloca [2 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS2:%.*]] = alloca [3 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS3:%.*]] = alloca [3 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS4:%.*]] = alloca [3 x ptr], align 8 // CHECK-NEXT: [[KERNEL_ARGS5:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8 // CHECK-NEXT: [[A:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[B:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[A_CASTED:%.*]] = alloca i64, align 8 // CHECK-NEXT: [[B_CASTED:%.*]] = alloca i64, align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS12:%.*]] = alloca [4 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS13:%.*]] = alloca [4 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS14:%.*]] = alloca [4 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS12:%.*]] = alloca [5 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS13:%.*]] = alloca [5 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS14:%.*]] = alloca [5 x ptr], align 8 // CHECK-NEXT: [[KERNEL_ARGS15:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8 // CHECK-NEXT: store ptr [[T1D]], ptr [[T1D_ADDR]], align 8 // CHECK-NEXT: [[CALL:%.*]] = call noalias noundef ptr @_Z6malloci(i32 noundef signext 12) #[[ATTR3:[0-9]+]] @@ -68,198 +87,219 @@ void foo(int **t1d) // CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[J]], align 4 // CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP5]], 1 // CHECK-NEXT: store i32 [[INC]], ptr [[J]], align 4 -// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP6:![0-9]+]] +// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP9:![0-9]+]] // CHECK: for.end: // CHECK-NEXT: [[TMP6:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 // CHECK-NEXT: [[TMP7:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP8:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP8:%.*]] = load ptr, ptr [[TMP7]], align 8 // CHECK-NEXT: [[TMP9:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP10:%.*]] = load ptr, ptr [[TMP9]], align 8 -// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP10]], i64 0 -// CHECK-NEXT: [[TMP11:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP7]], ptr [[TMP11]], align 8 -// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP8]], ptr [[TMP12]], align 8 -// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP13]], align 8 -// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[TMP8]], ptr [[TMP14]], align 8 -// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP15]], align 8 -// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK-NEXT: store ptr null, ptr [[TMP16]], align 8 -// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP19]], align 4 -// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 -// CHECK-NEXT: store i32 2, ptr [[TMP20]], align 4 -// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP17]], ptr [[TMP21]], align 8 -// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP18]], ptr [[TMP22]], align 8 -// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 -// CHECK-NEXT: store ptr @.offload_sizes, ptr [[TMP23]], align 8 -// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes, ptr [[TMP24]], align 8 -// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP25]], align 8 -// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP26]], align 8 -// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP27]], align 8 -// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP28]], align 8 -// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP29]], align 4 -// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP30]], align 4 -// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP31]], align 4 -// CHECK-NEXT: [[TMP32:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l17.region_id, ptr [[KERNEL_ARGS]]) -// CHECK-NEXT: [[TMP33:%.*]] = icmp ne i32 [[TMP32]], 0 -// CHECK-NEXT: br i1 [[TMP33]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] +// CHECK-NEXT: [[TMP10:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP11:%.*]] = load ptr, ptr [[TMP10]], align 8 +// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP11]], i64 0 +// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP6]], ptr [[TMP12]], align 8 +// CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP6]], ptr [[TMP13]], align 8 +// CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP14]], align 8 +// CHECK-NEXT: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP8]], ptr [[TMP15]], align 8 +// CHECK-NEXT: [[TMP16:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP16]], align 8 +// CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP17]], align 8 +// CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP7]], ptr [[TMP18]], align 8 +// CHECK-NEXT: [[TMP19:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX1]], ptr [[TMP19]], align 8 +// CHECK-NEXT: [[TMP20:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK-NEXT: store ptr null, ptr [[TMP20]], align 8 +// CHECK-NEXT: [[TMP21:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP23]], align 4 +// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 +// CHECK-NEXT: store i32 3, ptr [[TMP24]], align 4 +// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP21]], ptr [[TMP25]], align 8 +// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP22]], ptr [[TMP26]], align 8 +// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 +// CHECK-NEXT: store ptr @.offload_sizes, ptr [[TMP27]], align 8 +// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes, ptr [[TMP28]], align 8 +// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP29]], align 8 +// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP30]], align 8 +// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP31]], align 8 +// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP32]], align 8 +// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP33]], align 4 +// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP34]], align 4 +// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP35]], align 4 +// CHECK-NEXT: [[TMP36:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l20.region_id, ptr [[KERNEL_ARGS]]) +// CHECK-NEXT: [[TMP37:%.*]] = icmp ne i32 [[TMP36]], 0 +// CHECK-NEXT: br i1 [[TMP37]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] // CHECK: omp_offload.failed: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l17(ptr [[TMP6]]) #[[ATTR3]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l20(ptr [[TMP6]]) #[[ATTR3]] // CHECK-NEXT: br label [[OMP_OFFLOAD_CONT]] // CHECK: omp_offload.cont: -// CHECK-NEXT: [[TMP34:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP35:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP36:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP37:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP38:%.*]] = load ptr, ptr [[TMP37]], align 8 -// CHECK-NEXT: [[TMP39:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP35]], ptr [[TMP39]], align 8 -// CHECK-NEXT: [[TMP40:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP36]], ptr [[TMP40]], align 8 -// CHECK-NEXT: [[TMP41:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS4]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP41]], align 8 -// CHECK-NEXT: [[TMP42:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[TMP36]], ptr [[TMP42]], align 8 -// CHECK-NEXT: [[TMP43:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[TMP38]], ptr [[TMP43]], align 8 -// CHECK-NEXT: [[TMP44:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS4]], i64 0, i64 1 -// CHECK-NEXT: store ptr null, ptr [[TMP44]], align 8 -// CHECK-NEXT: [[TMP45:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 0 -// CHECK-NEXT: [[TMP46:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 0 -// CHECK-NEXT: [[TMP47:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP47]], align 4 -// CHECK-NEXT: [[TMP48:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 1 -// CHECK-NEXT: store i32 2, ptr [[TMP48]], align 4 -// CHECK-NEXT: [[TMP49:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP45]], ptr [[TMP49]], align 8 -// CHECK-NEXT: [[TMP50:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP46]], ptr [[TMP50]], align 8 -// CHECK-NEXT: [[TMP51:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 4 -// CHECK-NEXT: store ptr @.offload_sizes.1, ptr [[TMP51]], align 8 -// CHECK-NEXT: [[TMP52:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP52]], align 8 -// CHECK-NEXT: [[TMP53:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 6 -// CHECK-NEXT: store ptr null, ptr [[TMP53]], align 8 -// CHECK-NEXT: [[TMP54:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP54]], align 8 -// CHECK-NEXT: [[TMP55:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP55]], align 8 -// CHECK-NEXT: [[TMP56:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP56]], align 8 -// CHECK-NEXT: [[TMP57:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP57]], align 4 -// CHECK-NEXT: [[TMP58:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP58]], align 4 -// CHECK-NEXT: [[TMP59:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP59]], align 4 -// CHECK-NEXT: [[TMP60:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l19.region_id, ptr [[KERNEL_ARGS5]]) -// CHECK-NEXT: [[TMP61:%.*]] = icmp ne i32 [[TMP60]], 0 -// CHECK-NEXT: br i1 [[TMP61]], label [[OMP_OFFLOAD_FAILED6:%.*]], label [[OMP_OFFLOAD_CONT7:%.*]] +// CHECK-NEXT: [[TMP38:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP39:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP40:%.*]] = load ptr, ptr [[TMP39]], align 8 +// CHECK-NEXT: [[TMP41:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP42:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP43:%.*]] = load ptr, ptr [[TMP42]], align 8 +// CHECK-NEXT: [[TMP44:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP38]], ptr [[TMP44]], align 8 +// CHECK-NEXT: [[TMP45:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP38]], ptr [[TMP45]], align 8 +// CHECK-NEXT: [[TMP46:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS4]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP46]], align 8 +// CHECK-NEXT: [[TMP47:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP40]], ptr [[TMP47]], align 8 +// CHECK-NEXT: [[TMP48:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP43]], ptr [[TMP48]], align 8 +// CHECK-NEXT: [[TMP49:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS4]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP49]], align 8 +// CHECK-NEXT: [[TMP50:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP39]], ptr [[TMP50]], align 8 +// CHECK-NEXT: [[TMP51:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP43]], ptr [[TMP51]], align 8 +// CHECK-NEXT: [[TMP52:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS4]], i64 0, i64 2 +// CHECK-NEXT: store ptr null, ptr [[TMP52]], align 8 +// CHECK-NEXT: [[TMP53:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS2]], i32 0, i32 0 +// CHECK-NEXT: [[TMP54:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS3]], i32 0, i32 0 +// CHECK-NEXT: [[TMP55:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP55]], align 4 +// CHECK-NEXT: [[TMP56:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 1 +// CHECK-NEXT: store i32 3, ptr [[TMP56]], align 4 +// CHECK-NEXT: [[TMP57:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP53]], ptr [[TMP57]], align 8 +// CHECK-NEXT: [[TMP58:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP54]], ptr [[TMP58]], align 8 +// CHECK-NEXT: [[TMP59:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 4 +// CHECK-NEXT: store ptr @.offload_sizes.1, ptr [[TMP59]], align 8 +// CHECK-NEXT: [[TMP60:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.2, ptr [[TMP60]], align 8 +// CHECK-NEXT: [[TMP61:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP61]], align 8 +// CHECK-NEXT: [[TMP62:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP62]], align 8 +// CHECK-NEXT: [[TMP63:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP63]], align 8 +// CHECK-NEXT: [[TMP64:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP64]], align 8 +// CHECK-NEXT: [[TMP65:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP65]], align 4 +// CHECK-NEXT: [[TMP66:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP66]], align 4 +// CHECK-NEXT: [[TMP67:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS5]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP67]], align 4 +// CHECK-NEXT: [[TMP68:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l25.region_id, ptr [[KERNEL_ARGS5]]) +// CHECK-NEXT: [[TMP69:%.*]] = icmp ne i32 [[TMP68]], 0 +// CHECK-NEXT: br i1 [[TMP69]], label [[OMP_OFFLOAD_FAILED6:%.*]], label [[OMP_OFFLOAD_CONT7:%.*]] // CHECK: omp_offload.failed6: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l19(ptr [[TMP34]]) #[[ATTR3]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l25(ptr [[TMP38]]) #[[ATTR3]] // CHECK-NEXT: br label [[OMP_OFFLOAD_CONT7]] // CHECK: omp_offload.cont7: // CHECK-NEXT: store i32 0, ptr [[A]], align 4 // CHECK-NEXT: store i32 0, ptr [[B]], align 4 -// CHECK-NEXT: [[TMP62:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP63:%.*]] = load i32, ptr [[A]], align 4 -// CHECK-NEXT: store i32 [[TMP63]], ptr [[A_CASTED]], align 4 -// CHECK-NEXT: [[TMP64:%.*]] = load i64, ptr [[A_CASTED]], align 8 -// CHECK-NEXT: [[TMP65:%.*]] = load i32, ptr [[B]], align 4 -// CHECK-NEXT: store i32 [[TMP65]], ptr [[B_CASTED]], align 4 -// CHECK-NEXT: [[TMP66:%.*]] = load i64, ptr [[B_CASTED]], align 8 -// CHECK-NEXT: [[TMP67:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP68:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 -// CHECK-NEXT: [[TMP69:%.*]] = load i32, ptr [[A]], align 4 -// CHECK-NEXT: [[IDX_EXT:%.*]] = sext i32 [[TMP69]] to i64 -// CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds ptr, ptr [[TMP68]], i64 [[IDX_EXT]] // CHECK-NEXT: [[TMP70:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 // CHECK-NEXT: [[TMP71:%.*]] = load i32, ptr [[A]], align 4 -// CHECK-NEXT: [[IDX_EXT8:%.*]] = sext i32 [[TMP71]] to i64 -// CHECK-NEXT: [[ADD_PTR9:%.*]] = getelementptr inbounds ptr, ptr [[TMP70]], i64 [[IDX_EXT8]] -// CHECK-NEXT: [[TMP72:%.*]] = load ptr, ptr [[ADD_PTR9]], align 8 +// CHECK-NEXT: store i32 [[TMP71]], ptr [[A_CASTED]], align 4 +// CHECK-NEXT: [[TMP72:%.*]] = load i64, ptr [[A_CASTED]], align 8 // CHECK-NEXT: [[TMP73:%.*]] = load i32, ptr [[B]], align 4 -// CHECK-NEXT: [[IDX_EXT10:%.*]] = sext i32 [[TMP73]] to i64 -// CHECK-NEXT: [[ADD_PTR11:%.*]] = getelementptr inbounds i32, ptr [[TMP72]], i64 [[IDX_EXT10]] -// CHECK-NEXT: [[TMP74:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP67]], ptr [[TMP74]], align 8 -// CHECK-NEXT: [[TMP75:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[ADD_PTR]], ptr [[TMP75]], align 8 -// CHECK-NEXT: [[TMP76:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP76]], align 8 -// CHECK-NEXT: [[TMP77:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ADD_PTR]], ptr [[TMP77]], align 8 -// CHECK-NEXT: [[TMP78:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ADD_PTR11]], ptr [[TMP78]], align 8 -// CHECK-NEXT: [[TMP79:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 1 -// CHECK-NEXT: store ptr null, ptr [[TMP79]], align 8 -// CHECK-NEXT: [[TMP80:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 2 -// CHECK-NEXT: store i64 [[TMP64]], ptr [[TMP80]], align 8 -// CHECK-NEXT: [[TMP81:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 2 -// CHECK-NEXT: store i64 [[TMP64]], ptr [[TMP81]], align 8 -// CHECK-NEXT: [[TMP82:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 2 -// CHECK-NEXT: store ptr null, ptr [[TMP82]], align 8 -// CHECK-NEXT: [[TMP83:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 3 -// CHECK-NEXT: store i64 [[TMP66]], ptr [[TMP83]], align 8 -// CHECK-NEXT: [[TMP84:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 3 -// CHECK-NEXT: store i64 [[TMP66]], ptr [[TMP84]], align 8 -// CHECK-NEXT: [[TMP85:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 3 +// CHECK-NEXT: store i32 [[TMP73]], ptr [[B_CASTED]], align 4 +// CHECK-NEXT: [[TMP74:%.*]] = load i64, ptr [[B_CASTED]], align 8 +// CHECK-NEXT: [[TMP75:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP76:%.*]] = load i32, ptr [[A]], align 4 +// CHECK-NEXT: [[IDX_EXT:%.*]] = sext i32 [[TMP76]] to i64 +// CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds ptr, ptr [[TMP75]], i64 [[IDX_EXT]] +// CHECK-NEXT: [[TMP77:%.*]] = load ptr, ptr [[ADD_PTR]], align 8 +// CHECK-NEXT: [[TMP78:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP79:%.*]] = load ptr, ptr [[T1D_ADDR]], align 8 +// CHECK-NEXT: [[TMP80:%.*]] = load i32, ptr [[A]], align 4 +// CHECK-NEXT: [[IDX_EXT8:%.*]] = sext i32 [[TMP80]] to i64 +// CHECK-NEXT: [[ADD_PTR9:%.*]] = getelementptr inbounds ptr, ptr [[TMP79]], i64 [[IDX_EXT8]] +// CHECK-NEXT: [[TMP81:%.*]] = load ptr, ptr [[ADD_PTR9]], align 8 +// CHECK-NEXT: [[TMP82:%.*]] = load i32, ptr [[B]], align 4 +// CHECK-NEXT: [[IDX_EXT10:%.*]] = sext i32 [[TMP82]] to i64 +// CHECK-NEXT: [[ADD_PTR11:%.*]] = getelementptr inbounds i32, ptr [[TMP81]], i64 [[IDX_EXT10]] +// CHECK-NEXT: [[TMP83:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP70]], ptr [[TMP83]], align 8 +// CHECK-NEXT: [[TMP84:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP70]], ptr [[TMP84]], align 8 +// CHECK-NEXT: [[TMP85:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 0 // CHECK-NEXT: store ptr null, ptr [[TMP85]], align 8 -// CHECK-NEXT: [[TMP86:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 0 -// CHECK-NEXT: [[TMP87:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 0 -// CHECK-NEXT: [[TMP88:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP88]], align 4 -// CHECK-NEXT: [[TMP89:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 1 -// CHECK-NEXT: store i32 4, ptr [[TMP89]], align 4 -// CHECK-NEXT: [[TMP90:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[TMP86]], ptr [[TMP90]], align 8 -// CHECK-NEXT: [[TMP91:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP87]], ptr [[TMP91]], align 8 -// CHECK-NEXT: [[TMP92:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 4 -// CHECK-NEXT: store ptr @.offload_sizes.3, ptr [[TMP92]], align 8 -// CHECK-NEXT: [[TMP93:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP93]], align 8 -// CHECK-NEXT: [[TMP94:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 6 +// CHECK-NEXT: [[TMP86:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP77]], ptr [[TMP86]], align 8 +// CHECK-NEXT: [[TMP87:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ADD_PTR11]], ptr [[TMP87]], align 8 +// CHECK-NEXT: [[TMP88:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP88]], align 8 +// CHECK-NEXT: [[TMP89:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ADD_PTR]], ptr [[TMP89]], align 8 +// CHECK-NEXT: [[TMP90:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ADD_PTR11]], ptr [[TMP90]], align 8 +// CHECK-NEXT: [[TMP91:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 2 +// CHECK-NEXT: store ptr null, ptr [[TMP91]], align 8 +// CHECK-NEXT: [[TMP92:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 3 +// CHECK-NEXT: store i64 [[TMP72]], ptr [[TMP92]], align 8 +// CHECK-NEXT: [[TMP93:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 3 +// CHECK-NEXT: store i64 [[TMP72]], ptr [[TMP93]], align 8 +// CHECK-NEXT: [[TMP94:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 3 // CHECK-NEXT: store ptr null, ptr [[TMP94]], align 8 -// CHECK-NEXT: [[TMP95:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP95]], align 8 -// CHECK-NEXT: [[TMP96:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 8 -// CHECK-NEXT: store i64 0, ptr [[TMP96]], align 8 -// CHECK-NEXT: [[TMP97:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP97]], align 8 -// CHECK-NEXT: [[TMP98:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP98]], align 4 -// CHECK-NEXT: [[TMP99:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP99]], align 4 -// CHECK-NEXT: [[TMP100:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP100]], align 4 -// CHECK-NEXT: [[TMP101:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l22.region_id, ptr [[KERNEL_ARGS15]]) -// CHECK-NEXT: [[TMP102:%.*]] = icmp ne i32 [[TMP101]], 0 -// CHECK-NEXT: br i1 [[TMP102]], label [[OMP_OFFLOAD_FAILED16:%.*]], label [[OMP_OFFLOAD_CONT17:%.*]] +// CHECK-NEXT: [[TMP95:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 4 +// CHECK-NEXT: store i64 [[TMP74]], ptr [[TMP95]], align 8 +// CHECK-NEXT: [[TMP96:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 4 +// CHECK-NEXT: store i64 [[TMP74]], ptr [[TMP96]], align 8 +// CHECK-NEXT: [[TMP97:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS14]], i64 0, i64 4 +// CHECK-NEXT: store ptr null, ptr [[TMP97]], align 8 +// CHECK-NEXT: [[TMP98:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS12]], i32 0, i32 0 +// CHECK-NEXT: [[TMP99:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS13]], i32 0, i32 0 +// CHECK-NEXT: [[TMP100:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP100]], align 4 +// CHECK-NEXT: [[TMP101:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 1 +// CHECK-NEXT: store i32 5, ptr [[TMP101]], align 4 +// CHECK-NEXT: [[TMP102:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP98]], ptr [[TMP102]], align 8 +// CHECK-NEXT: [[TMP103:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[TMP99]], ptr [[TMP103]], align 8 +// CHECK-NEXT: [[TMP104:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 4 +// CHECK-NEXT: store ptr @.offload_sizes.3, ptr [[TMP104]], align 8 +// CHECK-NEXT: [[TMP105:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP105]], align 8 +// CHECK-NEXT: [[TMP106:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP106]], align 8 +// CHECK-NEXT: [[TMP107:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 7 +// CHECK-NEXT: store ptr null, ptr [[TMP107]], align 8 +// CHECK-NEXT: [[TMP108:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP108]], align 8 +// CHECK-NEXT: [[TMP109:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 9 +// CHECK-NEXT: store i64 0, ptr [[TMP109]], align 8 +// CHECK-NEXT: [[TMP110:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP110]], align 4 +// CHECK-NEXT: [[TMP111:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP111]], align 4 +// CHECK-NEXT: [[TMP112:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS15]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP112]], align 4 +// CHECK-NEXT: [[TMP113:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l33.region_id, ptr [[KERNEL_ARGS15]]) +// CHECK-NEXT: [[TMP114:%.*]] = icmp ne i32 [[TMP113]], 0 +// CHECK-NEXT: br i1 [[TMP114]], label [[OMP_OFFLOAD_FAILED16:%.*]], label [[OMP_OFFLOAD_CONT17:%.*]] // CHECK: omp_offload.failed16: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l22(ptr [[TMP62]], i64 [[TMP64]], i64 [[TMP66]]) #[[ATTR3]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l33(ptr [[TMP70]], i64 [[TMP72]], i64 [[TMP74]]) #[[ATTR3]] // CHECK-NEXT: br label [[OMP_OFFLOAD_CONT17]] // CHECK: omp_offload.cont17: // CHECK-NEXT: ret void // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l17 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l20 // CHECK-SAME: (ptr noundef [[T1D:%.*]]) #[[ATTR2:[0-9]+]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[T1D_ADDR:%.*]] = alloca ptr, align 8 @@ -271,7 +311,7 @@ void foo(int **t1d) // CHECK-NEXT: ret void // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l19 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l25 // CHECK-SAME: (ptr noundef [[T1D:%.*]]) #[[ATTR2]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[T1D_ADDR:%.*]] = alloca ptr, align 8 @@ -283,7 +323,7 @@ void foo(int **t1d) // CHECK-NEXT: ret void // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l22 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3fooPPi_l33 // CHECK-SAME: (ptr noundef [[T1D:%.*]], i64 noundef [[A:%.*]], i64 noundef [[B:%.*]]) #[[ATTR2]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[T1D_ADDR:%.*]] = alloca ptr, align 8 diff --git a/clang/test/OpenMP/target_map_member_expr_codegen.cpp b/clang/test/OpenMP/target_map_member_expr_codegen.cpp index fb36ba7b78d5b..5139995ebf3d7 100644 --- a/clang/test/OpenMP/target_map_member_expr_codegen.cpp +++ b/clang/test/OpenMP/target_map_member_expr_codegen.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-globals --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" --global-hex-value-regex ".offload_maptypes.*" // RUN: %clang_cc1 -verify -fopenmp -fopenmp-targets=x86_64-pc-linux-gnu \ // RUN: -x c++ -triple x86_64-unknown-linux-gnu -emit-llvm %s -o - \ // RUN: | FileCheck %s @@ -22,6 +22,10 @@ class B : public A { int res; B (int x, int y) : A(x,y), res{0} {} void run (void) { + // &this[0], &this[0], sizeof(this[0]), PARAM | ALLOC + // &this[0], &this[0].res, sizeof(this[0].res), TO | FROM | IMPLICIT | MEMBER_OF_1 + // &this[0], &this[0].X, sizeof(this[0].X), TO | FROM | IMPLICIT | MEMBER_OF_1 + // &this[0], &this[0].Y, sizeof(this[0].Y), TO | FROM | IMPLICIT | MEMBER_OF_1 #pragma omp target res = X + Y; } @@ -50,12 +54,22 @@ class C : public BASE { auto Asize = d.M * d.K; auto Csize = d.M * d.N; + // &d.A[0], &d.A[0], Asize * sizeof(d.A[0]), TO + // &d.A, &d.A[0], sizeof(void*), ATTACH + // &d.C[0], &d.C[0], Csize * sizeof(d.C[0]), FROM + // &d.C, &d.C[0], sizeof(void*), ATTACH #pragma omp target data map(to:d.A[0:Asize]) map(from:d.C[0:Csize]) { + // Csize, Csize, sizeof(intptr_t), LITERAL | PARAM + // &d, &d, sizeof(d), IMPLICIT | PARAM | TO | FROM #pragma omp target teams firstprivate(Csize) for (int i = 0; i < Csize; ++i) d.C[i] = 1; } + // Csize, Csize, sizeof(intptr_t), IMPLICIT | LITERAL | PARAM + // &d, &d.C, sizeof(d.C), IMPLICIT | PARAM | TO | FROM + // &d.C[0], &d.C[0], Csize * sizeof(d.C[0]), FROM + // &d.C, &d.C[0], sizeof(void*), ATTACH #pragma omp target map(from:d.C[0:Csize]) for (int i = 0; i < Csize; ++i) d.C[i] = 1; @@ -70,6 +84,16 @@ void foo() { c.bar(d); } +//. +// CHECK: @.offload_sizes = private unnamed_addr constant [4 x i64] [i64 12, i64 4, i64 4, i64 4] +// CHECK: @.offload_maptypes = private unnamed_addr constant [4 x i64] [i64 [[#0x20]], i64 [[#0x1000000000203]], i64 [[#0x1000000000203]], i64 [[#0x1000000000203]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [4 x i64] [i64 0, i64 8, i64 0, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [4 x i64] [i64 [[#0x1]], i64 [[#0x4000]], i64 [[#0x2]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [2 x i64] [i64 4, i64 40] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [2 x i64] [i64 [[#0x120]], i64 [[#0x223]]] +// CHECK: @.offload_sizes.5 = private unnamed_addr constant [4 x i64] [i64 4, i64 8, i64 0, i64 8] +// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [4 x i64] [i64 [[#0x320]], i64 [[#0x223]], i64 [[#0x2]], i64 [[#0x4000]]] +//. // CHECK-LABEL: define {{[^@]+}}@_Z3foov // CHECK-SAME: () #[[ATTR0:[0-9]+]] { // CHECK-NEXT: entry: @@ -163,11 +187,11 @@ void foo() { // CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP25]], align 4 // CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 // CHECK-NEXT: store i32 0, ptr [[TMP26]], align 4 -// CHECK-NEXT: [[TMP27:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1B3runEv_l25.region_id, ptr [[KERNEL_ARGS]]) +// CHECK-NEXT: [[TMP27:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1B3runEv_l29.region_id, ptr [[KERNEL_ARGS]]) // CHECK-NEXT: [[TMP28:%.*]] = icmp ne i32 [[TMP27]], 0 // CHECK-NEXT: br i1 [[TMP28]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] // CHECK: omp_offload.failed: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1B3runEv_l25(ptr [[THIS1]]) #[[ATTR2:[0-9]+]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1B3runEv_l29(ptr [[THIS1]]) #[[ATTR2:[0-9]+]] // CHECK-NEXT: br label [[OMP_OFFLOAD_CONT]] // CHECK: omp_offload.cont: // CHECK-NEXT: ret void @@ -180,10 +204,10 @@ void foo() { // CHECK-NEXT: [[D_ADDR:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[ASIZE:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[CSIZE:%.*]] = alloca i32, align 4 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [4 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [4 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [4 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [4 x i64], align 8 // CHECK-NEXT: [[TMP:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[_TMP8:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[CSIZE_CASTED:%.*]] = alloca i64, align 8 @@ -193,224 +217,229 @@ void foo() { // CHECK-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8 // CHECK-NEXT: [[_TMP12:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[CSIZE_CASTED13:%.*]] = alloca i64, align 8 -// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS18:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_PTRS19:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS20:%.*]] = alloca [3 x ptr], align 8 -// CHECK-NEXT: [[DOTOFFLOAD_SIZES21:%.*]] = alloca [3 x i64], align 8 -// CHECK-NEXT: [[KERNEL_ARGS22:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_BASEPTRS19:%.*]] = alloca [4 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_PTRS20:%.*]] = alloca [4 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_MAPPERS21:%.*]] = alloca [4 x ptr], align 8 +// CHECK-NEXT: [[DOTOFFLOAD_SIZES22:%.*]] = alloca [4 x i64], align 8 +// CHECK-NEXT: [[KERNEL_ARGS23:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8 // CHECK-NEXT: store ptr [[THIS]], ptr [[THIS_ADDR]], align 8 // CHECK-NEXT: store ptr [[D]], ptr [[D_ADDR]], align 8 // CHECK-NEXT: [[THIS1:%.*]] = load ptr, ptr [[THIS_ADDR]], align 8 -// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[D_ADDR]], align 8 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9:![0-9]+]], !align [[META10:![0-9]+]] // CHECK-NEXT: [[M:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR:%.*]], ptr [[TMP0]], i32 0, i32 3 // CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[M]], align 8 -// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[D_ADDR]], align 8 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: [[K:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP2]], i32 0, i32 4 // CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[K]], align 4 // CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TMP1]], [[TMP3]] // CHECK-NEXT: store i32 [[MUL]], ptr [[ASIZE]], align 4 -// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[D_ADDR]], align 8 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: [[M2:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP4]], i32 0, i32 3 // CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[M2]], align 8 -// CHECK-NEXT: [[TMP6:%.*]] = load ptr, ptr [[D_ADDR]], align 8 +// CHECK-NEXT: [[TMP6:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: [[N:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP6]], i32 0, i32 5 // CHECK-NEXT: [[TMP7:%.*]] = load i32, ptr [[N]], align 8 // CHECK-NEXT: [[MUL3:%.*]] = mul i32 [[TMP5]], [[TMP7]] // CHECK-NEXT: store i32 [[MUL3]], ptr [[CSIZE]], align 4 -// CHECK-NEXT: [[TMP8:%.*]] = load ptr, ptr [[D_ADDR]], align 8 -// CHECK-NEXT: [[TMP9:%.*]] = load ptr, ptr [[D_ADDR]], align 8 -// CHECK-NEXT: [[A:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP9]], i32 0, i32 0 -// CHECK-NEXT: [[TMP10:%.*]] = load ptr, ptr [[D_ADDR]], align 8 -// CHECK-NEXT: [[A4:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP10]], i32 0, i32 0 -// CHECK-NEXT: [[TMP11:%.*]] = load ptr, ptr [[A4]], align 8 -// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw float, ptr [[TMP11]], i64 0 -// CHECK-NEXT: [[TMP12:%.*]] = load i32, ptr [[ASIZE]], align 4 -// CHECK-NEXT: [[CONV:%.*]] = zext i32 [[TMP12]] to i64 -// CHECK-NEXT: [[TMP13:%.*]] = mul nuw i64 [[CONV]], 4 -// CHECK-NEXT: [[TMP14:%.*]] = load ptr, ptr [[D_ADDR]], align 8 -// CHECK-NEXT: [[TMP15:%.*]] = load ptr, ptr [[D_ADDR]], align 8 +// CHECK-NEXT: [[TMP8:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[A:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP8]], i32 0, i32 0 +// CHECK-NEXT: [[TMP9:%.*]] = load ptr, ptr [[A]], align 8 +// CHECK-NEXT: [[TMP10:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[TMP11:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[A4:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP11]], i32 0, i32 0 +// CHECK-NEXT: [[TMP12:%.*]] = load ptr, ptr [[A4]], align 8 +// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw float, ptr [[TMP12]], i64 0 +// CHECK-NEXT: [[TMP13:%.*]] = load i32, ptr [[ASIZE]], align 4 +// CHECK-NEXT: [[CONV:%.*]] = zext i32 [[TMP13]] to i64 +// CHECK-NEXT: [[TMP14:%.*]] = mul nuw i64 [[CONV]], 4 +// CHECK-NEXT: [[TMP15:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: [[C:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP15]], i32 0, i32 1 -// CHECK-NEXT: [[TMP16:%.*]] = load ptr, ptr [[D_ADDR]], align 8 -// CHECK-NEXT: [[C5:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP16]], i32 0, i32 1 -// CHECK-NEXT: [[TMP17:%.*]] = load ptr, ptr [[C5]], align 8 -// CHECK-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds nuw float, ptr [[TMP17]], i64 0 -// CHECK-NEXT: [[TMP18:%.*]] = load i32, ptr [[CSIZE]], align 4 -// CHECK-NEXT: [[CONV7:%.*]] = zext i32 [[TMP18]] to i64 -// CHECK-NEXT: [[TMP19:%.*]] = mul nuw i64 [[CONV7]], 4 -// CHECK-NEXT: [[TMP20:%.*]] = getelementptr ptr, ptr [[C]], i32 1 -// CHECK-NEXT: [[TMP21:%.*]] = ptrtoint ptr [[TMP20]] to i64 -// CHECK-NEXT: [[TMP22:%.*]] = ptrtoint ptr [[A]] to i64 -// CHECK-NEXT: [[TMP23:%.*]] = sub i64 [[TMP21]], [[TMP22]] -// CHECK-NEXT: [[TMP24:%.*]] = sdiv exact i64 [[TMP23]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: store ptr [[TMP8]], ptr [[TMP25]], align 8 -// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP16:%.*]] = load ptr, ptr [[C]], align 8 +// CHECK-NEXT: [[TMP17:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[TMP18:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[C5:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP18]], i32 0, i32 1 +// CHECK-NEXT: [[TMP19:%.*]] = load ptr, ptr [[C5]], align 8 +// CHECK-NEXT: [[ARRAYIDX6:%.*]] = getelementptr inbounds nuw float, ptr [[TMP19]], i64 0 +// CHECK-NEXT: [[TMP20:%.*]] = load i32, ptr [[CSIZE]], align 4 +// CHECK-NEXT: [[CONV7:%.*]] = zext i32 [[TMP20]] to i64 +// CHECK-NEXT: [[TMP21:%.*]] = mul nuw i64 [[CONV7]], 4 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES]], ptr align 8 @.offload_sizes.1, i64 32, i1 false) +// CHECK-NEXT: [[TMP22:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[TMP9]], ptr [[TMP22]], align 8 +// CHECK-NEXT: [[TMP23:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP23]], align 8 +// CHECK-NEXT: [[TMP24:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: store i64 [[TMP14]], ptr [[TMP24]], align 8 +// CHECK-NEXT: [[TMP25:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP25]], align 8 +// CHECK-NEXT: [[TMP26:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 // CHECK-NEXT: store ptr [[A]], ptr [[TMP26]], align 8 -// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP24]], ptr [[TMP27]], align 8 -// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK-NEXT: [[TMP27:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP27]], align 8 +// CHECK-NEXT: [[TMP28:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 // CHECK-NEXT: store ptr null, ptr [[TMP28]], align 8 -// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[A]], ptr [[TMP29]], align 8 -// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP30]], align 8 -// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 1 -// CHECK-NEXT: store i64 [[TMP13]], ptr [[TMP31]], align 8 -// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK-NEXT: [[TMP29:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP16]], ptr [[TMP29]], align 8 +// CHECK-NEXT: [[TMP30:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP30]], align 8 +// CHECK-NEXT: [[TMP31:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 2 +// CHECK-NEXT: store i64 [[TMP21]], ptr [[TMP31]], align 8 +// CHECK-NEXT: [[TMP32:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 // CHECK-NEXT: store ptr null, ptr [[TMP32]], align 8 -// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK-NEXT: [[TMP33:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 // CHECK-NEXT: store ptr [[C]], ptr [[TMP33]], align 8 -// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK-NEXT: [[TMP34:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 // CHECK-NEXT: store ptr [[ARRAYIDX6]], ptr [[TMP34]], align 8 -// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 2 -// CHECK-NEXT: store i64 [[TMP19]], ptr [[TMP35]], align 8 -// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK-NEXT: store ptr null, ptr [[TMP36]], align 8 -// CHECK-NEXT: [[TMP37:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP38:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP39:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 3, ptr [[TMP37]], ptr [[TMP38]], ptr [[TMP39]], ptr @.offload_maptypes.1, ptr null, ptr null) -// CHECK-NEXT: [[TMP40:%.*]] = load ptr, ptr [[D_ADDR]], align 8 -// CHECK-NEXT: store ptr [[TMP40]], ptr [[TMP]], align 8 -// CHECK-NEXT: [[TMP41:%.*]] = load ptr, ptr [[TMP]], align 8 -// CHECK-NEXT: store ptr [[TMP41]], ptr [[_TMP8]], align 8 -// CHECK-NEXT: [[TMP42:%.*]] = load i32, ptr [[CSIZE]], align 4 -// CHECK-NEXT: store i32 [[TMP42]], ptr [[CSIZE_CASTED]], align 4 -// CHECK-NEXT: [[TMP43:%.*]] = load i64, ptr [[CSIZE_CASTED]], align 8 -// CHECK-NEXT: [[TMP44:%.*]] = load ptr, ptr [[_TMP8]], align 8 -// CHECK-NEXT: [[TMP45:%.*]] = load ptr, ptr [[_TMP8]], align 8 -// CHECK-NEXT: [[TMP46:%.*]] = load ptr, ptr [[_TMP8]], align 8 -// CHECK-NEXT: [[TMP47:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS9]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP43]], ptr [[TMP47]], align 8 -// CHECK-NEXT: [[TMP48:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS10]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP43]], ptr [[TMP48]], align 8 -// CHECK-NEXT: [[TMP49:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS11]], i64 0, i64 0 -// CHECK-NEXT: store ptr null, ptr [[TMP49]], align 8 -// CHECK-NEXT: [[TMP50:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS9]], i32 0, i32 1 +// CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 +// CHECK-NEXT: store ptr null, ptr [[TMP35]], align 8 +// CHECK-NEXT: [[TMP36:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP37:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP38:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 4, ptr [[TMP36]], ptr [[TMP37]], ptr [[TMP38]], ptr @.offload_maptypes.2, ptr null, ptr null) +// CHECK-NEXT: [[TMP39:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: store ptr [[TMP39]], ptr [[TMP]], align 8 +// CHECK-NEXT: [[TMP40:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: store ptr [[TMP40]], ptr [[_TMP8]], align 8 +// CHECK-NEXT: [[TMP41:%.*]] = load i32, ptr [[CSIZE]], align 4 +// CHECK-NEXT: store i32 [[TMP41]], ptr [[CSIZE_CASTED]], align 4 +// CHECK-NEXT: [[TMP42:%.*]] = load i64, ptr [[CSIZE_CASTED]], align 8 +// CHECK-NEXT: [[TMP43:%.*]] = load ptr, ptr [[_TMP8]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[TMP44:%.*]] = load ptr, ptr [[_TMP8]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[TMP45:%.*]] = load ptr, ptr [[_TMP8]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[TMP46:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS9]], i32 0, i32 0 +// CHECK-NEXT: store i64 [[TMP42]], ptr [[TMP46]], align 8 +// CHECK-NEXT: [[TMP47:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS10]], i32 0, i32 0 +// CHECK-NEXT: store i64 [[TMP42]], ptr [[TMP47]], align 8 +// CHECK-NEXT: [[TMP48:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS11]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP48]], align 8 +// CHECK-NEXT: [[TMP49:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS9]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP44]], ptr [[TMP49]], align 8 +// CHECK-NEXT: [[TMP50:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS10]], i32 0, i32 1 // CHECK-NEXT: store ptr [[TMP45]], ptr [[TMP50]], align 8 -// CHECK-NEXT: [[TMP51:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS10]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[TMP46]], ptr [[TMP51]], align 8 -// CHECK-NEXT: [[TMP52:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS11]], i64 0, i64 1 -// CHECK-NEXT: store ptr null, ptr [[TMP52]], align 8 -// CHECK-NEXT: [[TMP53:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS9]], i32 0, i32 0 -// CHECK-NEXT: [[TMP54:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS10]], i32 0, i32 0 -// CHECK-NEXT: [[TMP55:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP55]], align 4 -// CHECK-NEXT: [[TMP56:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 -// CHECK-NEXT: store i32 2, ptr [[TMP56]], align 4 -// CHECK-NEXT: [[TMP57:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK-NEXT: [[TMP51:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS11]], i64 0, i64 1 +// CHECK-NEXT: store ptr null, ptr [[TMP51]], align 8 +// CHECK-NEXT: [[TMP52:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS9]], i32 0, i32 0 +// CHECK-NEXT: [[TMP53:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS10]], i32 0, i32 0 +// CHECK-NEXT: [[TMP54:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP54]], align 4 +// CHECK-NEXT: [[TMP55:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 +// CHECK-NEXT: store i32 2, ptr [[TMP55]], align 4 +// CHECK-NEXT: [[TMP56:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP52]], ptr [[TMP56]], align 8 +// CHECK-NEXT: [[TMP57:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 // CHECK-NEXT: store ptr [[TMP53]], ptr [[TMP57]], align 8 -// CHECK-NEXT: [[TMP58:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 -// CHECK-NEXT: store ptr [[TMP54]], ptr [[TMP58]], align 8 -// CHECK-NEXT: [[TMP59:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 -// CHECK-NEXT: store ptr @.offload_sizes.2, ptr [[TMP59]], align 8 -// CHECK-NEXT: [[TMP60:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.3, ptr [[TMP60]], align 8 -// CHECK-NEXT: [[TMP61:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK-NEXT: [[TMP58:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 +// CHECK-NEXT: store ptr @.offload_sizes.3, ptr [[TMP58]], align 8 +// CHECK-NEXT: [[TMP59:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP59]], align 8 +// CHECK-NEXT: [[TMP60:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP60]], align 8 +// CHECK-NEXT: [[TMP61:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 // CHECK-NEXT: store ptr null, ptr [[TMP61]], align 8 -// CHECK-NEXT: [[TMP62:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP62]], align 8 -// CHECK-NEXT: [[TMP63:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK-NEXT: [[TMP62:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP62]], align 8 +// CHECK-NEXT: [[TMP63:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 // CHECK-NEXT: store i64 0, ptr [[TMP63]], align 8 -// CHECK-NEXT: [[TMP64:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP64]], align 8 -// CHECK-NEXT: [[TMP65:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK-NEXT: [[TMP64:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP64]], align 4 +// CHECK-NEXT: [[TMP65:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 // CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP65]], align 4 -// CHECK-NEXT: [[TMP66:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP66]], align 4 -// CHECK-NEXT: [[TMP67:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP67]], align 4 -// CHECK-NEXT: [[TMP68:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 0, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l55.region_id, ptr [[KERNEL_ARGS]]) -// CHECK-NEXT: [[TMP69:%.*]] = icmp ne i32 [[TMP68]], 0 -// CHECK-NEXT: br i1 [[TMP69]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] +// CHECK-NEXT: [[TMP66:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP66]], align 4 +// CHECK-NEXT: [[TMP67:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 0, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l65.region_id, ptr [[KERNEL_ARGS]]) +// CHECK-NEXT: [[TMP68:%.*]] = icmp ne i32 [[TMP67]], 0 +// CHECK-NEXT: br i1 [[TMP68]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] // CHECK: omp_offload.failed: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l55(i64 [[TMP43]], ptr [[TMP44]]) #[[ATTR2]] +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l65(i64 [[TMP42]], ptr [[TMP43]]) #[[ATTR2]] // CHECK-NEXT: br label [[OMP_OFFLOAD_CONT]] // CHECK: omp_offload.cont: -// CHECK-NEXT: [[TMP70:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP71:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP72:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 3, ptr [[TMP70]], ptr [[TMP71]], ptr [[TMP72]], ptr @.offload_maptypes.1, ptr null, ptr null) -// CHECK-NEXT: [[TMP73:%.*]] = load ptr, ptr [[D_ADDR]], align 8 -// CHECK-NEXT: store ptr [[TMP73]], ptr [[_TMP12]], align 8 -// CHECK-NEXT: [[TMP74:%.*]] = load i32, ptr [[CSIZE]], align 4 -// CHECK-NEXT: store i32 [[TMP74]], ptr [[CSIZE_CASTED13]], align 4 -// CHECK-NEXT: [[TMP75:%.*]] = load i64, ptr [[CSIZE_CASTED13]], align 8 -// CHECK-NEXT: [[TMP76:%.*]] = load ptr, ptr [[_TMP12]], align 8 -// CHECK-NEXT: [[TMP77:%.*]] = load ptr, ptr [[_TMP12]], align 8 -// CHECK-NEXT: [[TMP78:%.*]] = load ptr, ptr [[_TMP12]], align 8 -// CHECK-NEXT: [[C14:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP78]], i32 0, i32 1 -// CHECK-NEXT: [[TMP79:%.*]] = load ptr, ptr [[_TMP12]], align 8 -// CHECK-NEXT: [[C15:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP79]], i32 0, i32 1 -// CHECK-NEXT: [[TMP80:%.*]] = load ptr, ptr [[C15]], align 8 -// CHECK-NEXT: [[ARRAYIDX16:%.*]] = getelementptr inbounds nuw float, ptr [[TMP80]], i64 0 -// CHECK-NEXT: [[TMP81:%.*]] = load i32, ptr [[CSIZE]], align 4 -// CHECK-NEXT: [[CONV17:%.*]] = zext i32 [[TMP81]] to i64 -// CHECK-NEXT: [[TMP82:%.*]] = mul nuw i64 [[CONV17]], 4 -// CHECK-NEXT: [[TMP83:%.*]] = getelementptr ptr, ptr [[C14]], i32 1 -// CHECK-NEXT: [[TMP84:%.*]] = ptrtoint ptr [[TMP83]] to i64 -// CHECK-NEXT: [[TMP85:%.*]] = ptrtoint ptr [[C14]] to i64 -// CHECK-NEXT: [[TMP86:%.*]] = sub i64 [[TMP84]], [[TMP85]] -// CHECK-NEXT: [[TMP87:%.*]] = sdiv exact i64 [[TMP86]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES21]], ptr align 8 @.offload_sizes.4, i64 24, i1 false) -// CHECK-NEXT: [[TMP88:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS18]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP75]], ptr [[TMP88]], align 8 -// CHECK-NEXT: [[TMP89:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS19]], i32 0, i32 0 -// CHECK-NEXT: store i64 [[TMP75]], ptr [[TMP89]], align 8 -// CHECK-NEXT: [[TMP90:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS20]], i64 0, i64 0 +// CHECK-NEXT: [[TMP69:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP70:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK-NEXT: [[TMP71:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 4, ptr [[TMP69]], ptr [[TMP70]], ptr [[TMP71]], ptr @.offload_maptypes.2, ptr null, ptr null) +// CHECK-NEXT: [[TMP72:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: store ptr [[TMP72]], ptr [[_TMP12]], align 8 +// CHECK-NEXT: [[TMP73:%.*]] = load i32, ptr [[CSIZE]], align 4 +// CHECK-NEXT: store i32 [[TMP73]], ptr [[CSIZE_CASTED13]], align 4 +// CHECK-NEXT: [[TMP74:%.*]] = load i64, ptr [[CSIZE_CASTED13]], align 8 +// CHECK-NEXT: [[TMP75:%.*]] = load ptr, ptr [[_TMP12]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[TMP76:%.*]] = load ptr, ptr [[_TMP12]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[TMP77:%.*]] = load ptr, ptr [[_TMP12]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[C14:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP77]], i32 0, i32 1 +// CHECK-NEXT: [[TMP78:%.*]] = load ptr, ptr [[_TMP12]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[C15:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP78]], i32 0, i32 1 +// CHECK-NEXT: [[TMP79:%.*]] = load ptr, ptr [[C15]], align 8 +// CHECK-NEXT: [[TMP80:%.*]] = load ptr, ptr [[_TMP12]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[TMP81:%.*]] = load ptr, ptr [[_TMP12]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: [[C16:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR]], ptr [[TMP81]], i32 0, i32 1 +// CHECK-NEXT: [[TMP82:%.*]] = load ptr, ptr [[C16]], align 8 +// CHECK-NEXT: [[ARRAYIDX17:%.*]] = getelementptr inbounds nuw float, ptr [[TMP82]], i64 0 +// CHECK-NEXT: [[TMP83:%.*]] = load i32, ptr [[CSIZE]], align 4 +// CHECK-NEXT: [[CONV18:%.*]] = zext i32 [[TMP83]] to i64 +// CHECK-NEXT: [[TMP84:%.*]] = mul nuw i64 [[CONV18]], 4 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES22]], ptr align 8 @.offload_sizes.5, i64 32, i1 false) +// CHECK-NEXT: [[TMP85:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS19]], i32 0, i32 0 +// CHECK-NEXT: store i64 [[TMP74]], ptr [[TMP85]], align 8 +// CHECK-NEXT: [[TMP86:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS20]], i32 0, i32 0 +// CHECK-NEXT: store i64 [[TMP74]], ptr [[TMP86]], align 8 +// CHECK-NEXT: [[TMP87:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS21]], i64 0, i64 0 +// CHECK-NEXT: store ptr null, ptr [[TMP87]], align 8 +// CHECK-NEXT: [[TMP88:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS19]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[TMP76]], ptr [[TMP88]], align 8 +// CHECK-NEXT: [[TMP89:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS20]], i32 0, i32 1 +// CHECK-NEXT: store ptr [[C14]], ptr [[TMP89]], align 8 +// CHECK-NEXT: [[TMP90:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS21]], i64 0, i64 1 // CHECK-NEXT: store ptr null, ptr [[TMP90]], align 8 -// CHECK-NEXT: [[TMP91:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS18]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[TMP77]], ptr [[TMP91]], align 8 -// CHECK-NEXT: [[TMP92:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS19]], i32 0, i32 1 -// CHECK-NEXT: store ptr [[C14]], ptr [[TMP92]], align 8 -// CHECK-NEXT: [[TMP93:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES21]], i32 0, i32 1 -// CHECK-NEXT: store i64 [[TMP87]], ptr [[TMP93]], align 8 -// CHECK-NEXT: [[TMP94:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS20]], i64 0, i64 1 +// CHECK-NEXT: [[TMP91:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS19]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP79]], ptr [[TMP91]], align 8 +// CHECK-NEXT: [[TMP92:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS20]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[ARRAYIDX17]], ptr [[TMP92]], align 8 +// CHECK-NEXT: [[TMP93:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES22]], i32 0, i32 2 +// CHECK-NEXT: store i64 [[TMP84]], ptr [[TMP93]], align 8 +// CHECK-NEXT: [[TMP94:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS21]], i64 0, i64 2 // CHECK-NEXT: store ptr null, ptr [[TMP94]], align 8 -// CHECK-NEXT: [[TMP95:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS18]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[C14]], ptr [[TMP95]], align 8 -// CHECK-NEXT: [[TMP96:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS19]], i32 0, i32 2 -// CHECK-NEXT: store ptr [[ARRAYIDX16]], ptr [[TMP96]], align 8 -// CHECK-NEXT: [[TMP97:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES21]], i32 0, i32 2 -// CHECK-NEXT: store i64 [[TMP82]], ptr [[TMP97]], align 8 -// CHECK-NEXT: [[TMP98:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS20]], i64 0, i64 2 -// CHECK-NEXT: store ptr null, ptr [[TMP98]], align 8 -// CHECK-NEXT: [[TMP99:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS18]], i32 0, i32 0 -// CHECK-NEXT: [[TMP100:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS19]], i32 0, i32 0 -// CHECK-NEXT: [[TMP101:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES21]], i32 0, i32 0 -// CHECK-NEXT: [[TMP102:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 0 -// CHECK-NEXT: store i32 3, ptr [[TMP102]], align 4 -// CHECK-NEXT: [[TMP103:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 1 -// CHECK-NEXT: store i32 3, ptr [[TMP103]], align 4 -// CHECK-NEXT: [[TMP104:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 2 +// CHECK-NEXT: [[TMP95:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS19]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[C15]], ptr [[TMP95]], align 8 +// CHECK-NEXT: [[TMP96:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS20]], i32 0, i32 3 +// CHECK-NEXT: store ptr [[ARRAYIDX17]], ptr [[TMP96]], align 8 +// CHECK-NEXT: [[TMP97:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS21]], i64 0, i64 3 +// CHECK-NEXT: store ptr null, ptr [[TMP97]], align 8 +// CHECK-NEXT: [[TMP98:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS19]], i32 0, i32 0 +// CHECK-NEXT: [[TMP99:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS20]], i32 0, i32 0 +// CHECK-NEXT: [[TMP100:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES22]], i32 0, i32 0 +// CHECK-NEXT: [[TMP101:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 0 +// CHECK-NEXT: store i32 3, ptr [[TMP101]], align 4 +// CHECK-NEXT: [[TMP102:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 1 +// CHECK-NEXT: store i32 4, ptr [[TMP102]], align 4 +// CHECK-NEXT: [[TMP103:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 2 +// CHECK-NEXT: store ptr [[TMP98]], ptr [[TMP103]], align 8 +// CHECK-NEXT: [[TMP104:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 3 // CHECK-NEXT: store ptr [[TMP99]], ptr [[TMP104]], align 8 -// CHECK-NEXT: [[TMP105:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 3 +// CHECK-NEXT: [[TMP105:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 4 // CHECK-NEXT: store ptr [[TMP100]], ptr [[TMP105]], align 8 -// CHECK-NEXT: [[TMP106:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 4 -// CHECK-NEXT: store ptr [[TMP101]], ptr [[TMP106]], align 8 -// CHECK-NEXT: [[TMP107:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 5 -// CHECK-NEXT: store ptr @.offload_maptypes.5, ptr [[TMP107]], align 8 -// CHECK-NEXT: [[TMP108:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 6 +// CHECK-NEXT: [[TMP106:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 5 +// CHECK-NEXT: store ptr @.offload_maptypes.6, ptr [[TMP106]], align 8 +// CHECK-NEXT: [[TMP107:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 6 +// CHECK-NEXT: store ptr null, ptr [[TMP107]], align 8 +// CHECK-NEXT: [[TMP108:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 7 // CHECK-NEXT: store ptr null, ptr [[TMP108]], align 8 -// CHECK-NEXT: [[TMP109:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 7 -// CHECK-NEXT: store ptr null, ptr [[TMP109]], align 8 -// CHECK-NEXT: [[TMP110:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 8 +// CHECK-NEXT: [[TMP109:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 8 +// CHECK-NEXT: store i64 0, ptr [[TMP109]], align 8 +// CHECK-NEXT: [[TMP110:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 9 // CHECK-NEXT: store i64 0, ptr [[TMP110]], align 8 -// CHECK-NEXT: [[TMP111:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 9 -// CHECK-NEXT: store i64 0, ptr [[TMP111]], align 8 -// CHECK-NEXT: [[TMP112:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 10 -// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP112]], align 4 -// CHECK-NEXT: [[TMP113:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 11 -// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP113]], align 4 -// CHECK-NEXT: [[TMP114:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS22]], i32 0, i32 12 -// CHECK-NEXT: store i32 0, ptr [[TMP114]], align 4 -// CHECK-NEXT: [[TMP115:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l59.region_id, ptr [[KERNEL_ARGS22]]) -// CHECK-NEXT: [[TMP116:%.*]] = icmp ne i32 [[TMP115]], 0 -// CHECK-NEXT: br i1 [[TMP116]], label [[OMP_OFFLOAD_FAILED23:%.*]], label [[OMP_OFFLOAD_CONT24:%.*]] -// CHECK: omp_offload.failed23: -// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l59(i64 [[TMP75]], ptr [[TMP76]]) #[[ATTR2]] -// CHECK-NEXT: br label [[OMP_OFFLOAD_CONT24]] -// CHECK: omp_offload.cont24: +// CHECK-NEXT: [[TMP111:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 10 +// CHECK-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP111]], align 4 +// CHECK-NEXT: [[TMP112:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 11 +// CHECK-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP112]], align 4 +// CHECK-NEXT: [[TMP113:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS23]], i32 0, i32 12 +// CHECK-NEXT: store i32 0, ptr [[TMP113]], align 4 +// CHECK-NEXT: [[TMP114:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l73.region_id, ptr [[KERNEL_ARGS23]]) +// CHECK-NEXT: [[TMP115:%.*]] = icmp ne i32 [[TMP114]], 0 +// CHECK-NEXT: br i1 [[TMP115]], label [[OMP_OFFLOAD_FAILED24:%.*]], label [[OMP_OFFLOAD_CONT25:%.*]] +// CHECK: omp_offload.failed24: +// CHECK-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l73(i64 [[TMP74]], ptr [[TMP75]]) #[[ATTR2]] +// CHECK-NEXT: br label [[OMP_OFFLOAD_CONT25]] +// CHECK: omp_offload.cont25: // CHECK-NEXT: ret void // // @@ -451,7 +480,7 @@ void foo() { // CHECK-NEXT: ret void // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1B3runEv_l25 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1B3runEv_l29 // CHECK-SAME: (ptr noundef [[THIS:%.*]]) #[[ATTR1:[0-9]+]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, align 8 @@ -467,7 +496,7 @@ void foo() { // CHECK-NEXT: ret void // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l55 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l65 // CHECK-SAME: (i64 noundef [[CSIZE:%.*]], ptr noundef nonnull align 8 dereferenceable(40) [[D:%.*]]) #[[ATTR1]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[CSIZE_ADDR:%.*]] = alloca i64, align 8 @@ -476,17 +505,17 @@ void foo() { // CHECK-NEXT: [[CSIZE_CASTED:%.*]] = alloca i64, align 8 // CHECK-NEXT: store i64 [[CSIZE]], ptr [[CSIZE_ADDR]], align 8 // CHECK-NEXT: store ptr [[D]], ptr [[D_ADDR]], align 8 -// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[D_ADDR]], align 8 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: store ptr [[TMP0]], ptr [[TMP]], align 8 // CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[CSIZE_ADDR]], align 4 // CHECK-NEXT: store i32 [[TMP1]], ptr [[CSIZE_CASTED]], align 4 // CHECK-NEXT: [[TMP2:%.*]] = load i64, ptr [[CSIZE_CASTED]], align 8 -// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TMP]], align 8 -// CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_teams(ptr @[[GLOB1]], i32 2, ptr @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l55.omp_outlined, i64 [[TMP2]], ptr [[TMP3]]) +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META9]], !align [[META10]] +// CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_teams(ptr @[[GLOB1]], i32 2, ptr @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l65.omp_outlined, i64 [[TMP2]], ptr [[TMP3]]) // CHECK-NEXT: ret void // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l55.omp_outlined +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l65.omp_outlined // CHECK-SAME: (ptr noalias noundef [[DOTGLOBAL_TID_:%.*]], ptr noalias noundef [[DOTBOUND_TID_:%.*]], i64 noundef [[CSIZE:%.*]], ptr noundef nonnull align 8 dereferenceable(40) [[D:%.*]]) #[[ATTR1]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[DOTGLOBAL_TID__ADDR:%.*]] = alloca ptr, align 8 @@ -499,7 +528,7 @@ void foo() { // CHECK-NEXT: store ptr [[DOTBOUND_TID_]], ptr [[DOTBOUND_TID__ADDR]], align 8 // CHECK-NEXT: store i64 [[CSIZE]], ptr [[CSIZE_ADDR]], align 8 // CHECK-NEXT: store ptr [[D]], ptr [[D_ADDR]], align 8 -// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[D_ADDR]], align 8 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: store ptr [[TMP0]], ptr [[TMP]], align 8 // CHECK-NEXT: store i32 0, ptr [[I]], align 4 // CHECK-NEXT: br label [[FOR_COND:%.*]] @@ -509,7 +538,7 @@ void foo() { // CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[TMP1]], [[TMP2]] // CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK: for.body: -// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TMP]], align 8 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: [[C:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR:%.*]], ptr [[TMP3]], i32 0, i32 1 // CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[C]], align 8 // CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[I]], align 4 @@ -521,12 +550,12 @@ void foo() { // CHECK-NEXT: [[TMP6:%.*]] = load i32, ptr [[I]], align 4 // CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP6]], 1 // CHECK-NEXT: store i32 [[INC]], ptr [[I]], align 4 -// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP6:![0-9]+]] +// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP11:![0-9]+]] // CHECK: for.end: // CHECK-NEXT: ret void // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l59 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN1C3barER10descriptorIfE_l73 // CHECK-SAME: (i64 noundef [[CSIZE:%.*]], ptr noundef nonnull align 8 dereferenceable(40) [[D:%.*]]) #[[ATTR1]] { // CHECK-NEXT: entry: // CHECK-NEXT: [[CSIZE_ADDR:%.*]] = alloca i64, align 8 @@ -535,7 +564,7 @@ void foo() { // CHECK-NEXT: [[I:%.*]] = alloca i32, align 4 // CHECK-NEXT: store i64 [[CSIZE]], ptr [[CSIZE_ADDR]], align 8 // CHECK-NEXT: store ptr [[D]], ptr [[D_ADDR]], align 8 -// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[D_ADDR]], align 8 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[D_ADDR]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: store ptr [[TMP0]], ptr [[TMP]], align 8 // CHECK-NEXT: store i32 0, ptr [[I]], align 4 // CHECK-NEXT: br label [[FOR_COND:%.*]] @@ -545,7 +574,7 @@ void foo() { // CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[TMP1]], [[TMP2]] // CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] // CHECK: for.body: -// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TMP]], align 8 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TMP]], align 8, !nonnull [[META9]], !align [[META10]] // CHECK-NEXT: [[C:%.*]] = getelementptr inbounds nuw [[STRUCT_DESCRIPTOR:%.*]], ptr [[TMP3]], i32 0, i32 1 // CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[C]], align 8 // CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[I]], align 4 @@ -557,7 +586,7 @@ void foo() { // CHECK-NEXT: [[TMP6:%.*]] = load i32, ptr [[I]], align 4 // CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP6]], 1 // CHECK-NEXT: store i32 [[INC]], ptr [[I]], align 4 -// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP10:![0-9]+]] +// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP15:![0-9]+]] // CHECK: for.end: // CHECK-NEXT: ret void // diff --git a/clang/test/OpenMP/target_map_pointer_defalut_mapper_codegen.cpp b/clang/test/OpenMP/target_map_pointer_defalut_mapper_codegen.cpp index 6ab10c45beb25..93814ba7f1929 100644 --- a/clang/test/OpenMP/target_map_pointer_defalut_mapper_codegen.cpp +++ b/clang/test/OpenMP/target_map_pointer_defalut_mapper_codegen.cpp @@ -40,11 +40,28 @@ void foo() { } #endif -// CHECK: @.offload_sizes = private unnamed_addr constant [5 x i64] [i64 8, i64 0, i64 0, i64 0, i64 4] -// CHECK-NOT: @.offload_sizes = private unnamed_addr constant [6 x i64] [i64 8, i64 0, i64 0, i64 0, i64 8, i64 4] -// CHECK: @.offload_maptypes = private unnamed_addr constant [5 x i64] [i64 35, i64 16, i64 562949953421315, i64 562949953421315, i64 562949953421827] -// CHECK-NOT: .offload_maptypes = private unnamed_addr constant [6 x i64] [i64 35, i64 0, i64 562949953421315, i64 562949953421315, i64 562949953421827, i64 562949953421843] -// CHECK: @.offload_sizes.1 = private unnamed_addr constant [4 x i64] [i64 0, i64 0, i64 0, i64 4] -// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [4 x i64] [i64 32, i64 281474976710659, i64 281474976710659, i64 281474976711171] -// CHECK: @.offload_sizes.3 = private unnamed_addr constant [6 x i64] [i64 8, i64 8, i64 0, i64 0, i64 0, i64 4] -// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [6 x i64] [i64 35, i64 16, i64 16, i64 844424930131971, i64 844424930131971, i64 844424930132483] +// &spp[0], &spp[0], 0, IMPLICIT | PARAM +// &spp[0][0], &spp[0][0], sizeof(spp[0][0]), ALLOC +// &spp[0][0], &spp[0][0].e, sizeof(e), MEMBER_OF_2 | TO | FROM +// &spp[0][0], &spp[0][0].h, sizeof(h), MEMBER_OF_2 | TO | FROM +// &spp[0][0], &spp[0][0].f, sizeof(f), MEMBER_OF_2 | TO | FROM | IMPLICIT, mapper_of_c +// &spp[0], &spp[0][0], sizeof(void*), ATTACH +// CHECK: @.offload_sizes = private unnamed_addr constant [6 x i64] [i64 0, i64 0, i64 0, i64 0, i64 4, i64 8] +// CHECK: @.offload_maptypes = private unnamed_addr constant [6 x i64] [i64 [[#0x220]], i64 0, i64 [[#0x2000000000003]], i64 [[#0x2000000000003]], i64 [[#0x2000000000203]], i64 [[#0x4000]]] + +// &sp[0], &sp[0], sizeof(sp[0]), ALLOC | PARAM +// &sp[0], &sp[0].e, sizeof(e), MEMBER_OF_1 | TO | FROM +// &sp[0], &sp[0].h, sizeof(h), MEMBER_OF_1 | TO | FROM +// &sp[0], &sp[0].f, sizeof(f), MEMBER_OF_1 | TO | FROM | IMPLICIT, mapper_of_c +// &sp, &sp[0], sizeof(void*), ATTACH +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [5 x i64] [i64 0, i64 0, i64 0, i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [5 x i64] [i64 [[#0x20]], i64 [[#0x1000000000003]], i64 [[#0x1000000000003]], i64 [[#0x1000000000203]], i64 [[#0x4000]]] + +// &sppp[0], &sppp[0], 0, IMPLICIT | PARAM +// &sppp[0][0][0], &sppp[0][0][0], sizeof(sppp[0][0][0]), ALLOC +// &sppp[0][0][0], &sppp[0][0][0].e, sizeof(e), MEMBER_OF_2 | TO | FROM +// &sppp[0][0][0], &sppp[0][0][0].h, sizeof(h), MEMBER_OF_2 | TO | FROM +// &sppp[0][0][0], &sppp[0][0][0].f, sizeof(f), MEMBER_OF_2 | TO | FROM | IMPLICIT, mapper_of_c +// &sppp[0][0], &sppp[0][0][0], sizeof(void*), ATTACH +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [6 x i64] [i64 0, i64 0, i64 0, i64 0, i64 4, i64 8] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [6 x i64] [i64 [[#0x220]], i64 0, i64 [[#0x2000000000003]], i64 [[#0x2000000000003]], i64 [[#0x2000000000203]], i64 [[#0x4000]]] diff --git a/clang/test/OpenMP/target_map_ptr_and_star_global.cpp b/clang/test/OpenMP/target_map_ptr_and_star_global.cpp index 84899cb8e4fad..01159d6028471 100644 --- a/clang/test/OpenMP/target_map_ptr_and_star_global.cpp +++ b/clang/test/OpenMP/target_map_ptr_and_star_global.cpp @@ -15,21 +15,24 @@ void f1() { } void f2() { - // &ptr, &ptr[0], sizeof(ptr[0]), TO | FROM | PARAM | PTR_AND_OBJ + // &ptr[0], &ptr[0], sizeof(ptr[0]), TO | FROM | PARAM + // &ptr, &ptr[0], sizeof(ptr), ATTACH #pragma omp target map(*ptr) ptr[1] = 6; } void f3() { - // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM - // &ptr, &ptr[0], sizeof(ptr[0]), TO | FROM | PTR_AND_OBJ + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[0], sizeof(ptr[0]), TO | FROM + // &ptr, &ptr[0], sizeof(ptr), ATTACH #pragma omp target map(ptr, *ptr) ptr[1] = 6; } void f4() { - // &ptr, &ptr[0], sizeof(ptr[0]), TO | FROM | PTR_AND_OBJ | PARAM - // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr[0], &ptr[0], sizeof(ptr[0]), TO | FROM + // &ptr, &ptr[0], sizeof(ptr), ATTACH #pragma omp target map(*ptr, ptr) ptr[2] = 8; } @@ -38,12 +41,12 @@ void f4() { //. // CHECK: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 8] // CHECK: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x23]]] -// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x33]]] -// CHECK: @.offload_sizes.3 = private unnamed_addr constant [2 x i64] [i64 8, i64 4] -// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [2 x i64] [i64 [[#0x23]], i64 [[#0x13]]] -// CHECK: @.offload_sizes.5 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] -// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [2 x i64] [i64 [[#0x33]], i64 [[#0x3]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [2 x i64] [i64 [[#0x23]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.5 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] //. // CHECK-LABEL: define {{[^@]+}}@_Z2f1v // CHECK-SAME: () #[[ATTR0:[0-9]+]] { @@ -75,18 +78,25 @@ void f4() { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr @ptr, ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = load ptr, ptr @ptr, align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[TMP1]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[TMP2]], ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr @ptr, ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP2]], ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l19 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l20 // CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 @@ -101,29 +111,36 @@ void f4() { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr @ptr, ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 // CHECK: store ptr @ptr, ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr @ptr, ptr [[TMP5]], align 8 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 // CHECK: store ptr [[TMP1]], ptr [[TMP6]], align 8 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 // CHECK: store ptr null, ptr [[TMP7]], align 8 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP10:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ptr, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[TMP1]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l26 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l28 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META11]], !align [[META12]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 1 // CHECK: store i32 6, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // @@ -133,29 +150,36 @@ void f4() { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr @ptr, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ptr, align 8 -// CHECK: [[TMP2:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr @ptr, ptr [[TMP2]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ptr, ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr @ptr, ptr [[TMP5]], align 8 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr @ptr, ptr [[TMP6]], align 8 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP1]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 // CHECK: store ptr null, ptr [[TMP7]], align 8 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP10:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ptr, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[TMP1]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l33 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l36 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META11]], !align [[META12]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 // CHECK: store i32 8, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // diff --git a/clang/test/OpenMP/target_map_ptr_and_star_local.cpp b/clang/test/OpenMP/target_map_ptr_and_star_local.cpp index 246c0c5f99a68..30de7e13871fe 100644 --- a/clang/test/OpenMP/target_map_ptr_and_star_local.cpp +++ b/clang/test/OpenMP/target_map_ptr_and_star_local.cpp @@ -17,22 +17,25 @@ void f1() { void f2() { int *ptr; // &ptr[0], &ptr[0], sizeof(ptr[0]), TO | FROM | PARAM + // &ptr, &ptr[0], sizeof(ptr), ATTACH #pragma omp target map(*ptr) ptr[1] = 6; } void f3() { int *ptr; - // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM // &ptr[0], &ptr[0], sizeof(ptr[0]), TO | FROM + // &ptr, &ptr[0], sizeof(ptr), ATTACH #pragma omp target map(ptr, *ptr) ptr[1] = 6; } void f4() { int *ptr; + // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM // &ptr[0], &ptr[0], sizeof(ptr[0]), TO | FROM - // &ptr, &ptr, sizeof(ptr), TO | FROM | PARAM + // &ptr, &ptr[0], sizeof(ptr), ATTACH #pragma omp target map(*ptr, ptr) ptr[2] = 8; } @@ -41,12 +44,12 @@ void f4() { //. // CHECK: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 8] // CHECK: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x23]]] -// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x23]]] -// CHECK: @.offload_sizes.3 = private unnamed_addr constant [2 x i64] [i64 8, i64 4] -// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [2 x i64] [i64 [[#0x23]], i64 [[#0x3]]] -// CHECK: @.offload_sizes.5 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] -// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [2 x i64] [i64 [[#0x23]], i64 [[#0x3]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [2 x i64] [i64 [[#0x23]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.5 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [3 x i64] [i64 [[#0x23]], i64 [[#0x3]], i64 [[#0x4000]]] //. // CHECK-LABEL: define {{[^@]+}}@_Z2f1v // CHECK-SAME: () #[[ATTR0:[0-9]+]] { @@ -79,18 +82,24 @@ void f4() { // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 // CHECK: [[TMP2:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[TMP1]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[TMP2]], ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP5]], align 8 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[PTR]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP2]], ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l20 +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l21 // CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 @@ -105,30 +114,36 @@ void f4() { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK: [[TMP2:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[PTR]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[PTR]], ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP5]], align 8 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 // CHECK: store ptr [[TMP1]], ptr [[TMP6]], align 8 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr [[TMP2]], ptr [[TMP7]], align 8 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK: store ptr null, ptr [[TMP8]], align 8 -// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PTR]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[TMP1]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l28 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l30 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META11]], !align [[META12]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 1 // CHECK: store i32 6, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // @@ -138,30 +153,36 @@ void f4() { // CHECK: entry: // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK: [[TMP2:%.*]] = load ptr, ptr [[PTR]], align 8 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP2]], ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP5]], align 8 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr [[PTR]], ptr [[TMP6]], align 8 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr [[PTR]], ptr [[TMP7]], align 8 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK: store ptr null, ptr [[TMP8]], align 8 -// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PTR]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP1]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PTR]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[TMP1]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l36 -// CHECK-SAME: (ptr noundef [[PTR:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l39 +// CHECK-SAME: (ptr noundef nonnull align 8 dereferenceable(8) [[PTR:%.*]]) #[[ATTR1]] { // CHECK: entry: // CHECK: store ptr [[PTR]], ptr [[PTR_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8 -// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 2 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PTR_ADDR]], align 8, !nonnull [[META11]], !align [[META12]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 // CHECK: store i32 8, ptr [[ARRAYIDX]], align 4 // CHECK: ret void // diff --git a/clang/test/OpenMP/target_map_structptr_and_member_global.cpp b/clang/test/OpenMP/target_map_structptr_and_member_global.cpp index 523f88dc8dba3..2ed2067f4d699 100644 --- a/clang/test/OpenMP/target_map_structptr_and_member_global.cpp +++ b/clang/test/OpenMP/target_map_structptr_and_member_global.cpp @@ -23,31 +23,33 @@ void f1() { void f2() { // &ps[0], &ps->y, sizeof(ps->y), TO | PARAM + // &ps, &ps->y, sizeof(ps), ATTACH #pragma omp target map(to: ps->y) ps->y = 6; } void f3() { - // &ps[0], &ps[0], sizeof(ps[0]), PARAM | ALLOC - // &ps, &ps, sizeof(ps), TO | MEMBER_OF(1) - // &ps[0], &ps->y, sizeof(ps->y), TO | MEMBER_OF(1) + // &ps, &ps, sizeof(ps), TO | PARAM + // &ps[0], &ps->y, sizeof(ps->y), TO + // &ps, &ps->y, sizeof(ps), ATTACH #pragma omp target map(to: ps, ps->y) ps->y = 7; } void f4() { - // &ps[0], &ps[0], sizeof(ps[0]), PARAM | ALLOC - // &ps[0], &ps->y, sizeof(ps->y), TO | MEMBER_OF(1) - // &ps, &ps, sizeof(ps), TO | MEMBER_OF(1) + // &ps, &ps, sizeof(ps), TO | PARAM + // &ps[0], &ps->y, sizeof(ps->y), TO + // &ps, &ps->y, sizeof(ps), ATTACH #pragma omp target map(to: ps->y, ps) ps->y = 8; } void f5() { - // &ps[0], &ps[0], sizeof(ps[0]), PARAM | ALLOC - // &ps[0], &ps->y, sizeof(ps->y), TO | MEMBER_OF(1) - // &ps, &ps, sizeof(ps), TO | MEMBER_OF(1) - // &ps[0], &ps->x, sizeof(ps->x), TO | MEMBER_OF(1) + // &ps, &ps, sizeof(ps), TO | PARAM + // &ps[0], &ps[0].x, ((&ps[0].y + 1) - &ps[0].x)/8, ALLOC + // &ps[0], &ps->y, sizeof(ps->y), TO | MEMBER_OF(2) + // &ps[0], &ps->x, sizeof(ps->x), TO | MEMBER_OF(2) + // &ps, &ps[0].x, sizeof(ps), ATTACH #pragma omp target map(to: ps->y, ps, ps->x) ps->y = 9; } @@ -56,14 +58,14 @@ void f5() { //. // CHECK: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 8] // CHECK: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x21]]] -// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x21]]] -// CHECK: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 0, i64 8, i64 4] -// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x20]], i64 [[#0x1000000000001]], i64 [[#0x1000000000001]]] -// CHECK: @.offload_sizes.5 = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 8] -// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [3 x i64] [i64 [[#0x20]], i64 [[#0x1000000000001]], i64 [[#0x1000000000001]]] -// CHECK: @.offload_sizes.7 = private unnamed_addr constant [4 x i64] [i64 0, i64 4, i64 8, i64 2] -// CHECK: @.offload_maptypes.8 = private unnamed_addr constant [4 x i64] [i64 [[#0x20]], i64 [[#0x1000000000001]], i64 [[#0x1000000000001]], i64 [[#0x1000000000001]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [2 x i64] [i64 [[#0x21]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x21]], i64 [[#0x1]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.5 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [3 x i64] [i64 [[#0x21]], i64 [[#0x1]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.7 = private unnamed_addr constant [5 x i64] [i64 8, i64 0, i64 4, i64 2, i64 8] +// CHECK: @.offload_maptypes.8 = private unnamed_addr constant [5 x i64] [i64 [[#0x21]], i64 [[#0x0]], i64 [[#0x2000000000001]], i64 [[#0x2000000000001]], i64 [[#0x4000]]] //. // CHECK-LABEL: define dso_local void @_Z2f1v( // CHECK-SAME: ) #[[ATTR0:[0-9]+]] { @@ -97,18 +99,24 @@ void f5() { // CHECK: [[TMP1:%.*]] = load ptr, ptr @ps, align 8 // CHECK: [[TMP2:%.*]] = load ptr, ptr @ps, align 8 // CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP2]], i32 0, i32 1 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[TMP1]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[Y]], ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP5]], align 8 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr @ps, ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[Y]], ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l26( +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l27( // CHECK-SAME: ptr noundef [[PS:%.*]]) #[[ATTR1]] { // CHECK: [[ENTRY:.*:]] // CHECK: store ptr [[PS]], ptr [[PS_ADDR:%.*]], align 8 @@ -123,46 +131,37 @@ void f5() { // CHECK: [[ENTRY:.*:]] // CHECK: [[TMP0:%.*]] = load ptr, ptr @ps, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ps, align 8 -// CHECK: [[TMP2:%.*]] = load ptr, ptr @ps, align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP2]], i32 0, i32 1 -// CHECK: [[TMP3:%.*]] = getelementptr [[STRUCT_S]], ptr [[TMP1]], i32 1 -// CHECK: [[TMP4:%.*]] = ptrtoint ptr [[TMP3]] to i64 -// CHECK: [[TMP5:%.*]] = ptrtoint ptr [[TMP1]] to i64 -// CHECK: [[TMP6:%.*]] = sub i64 [[TMP4]], [[TMP5]] -// CHECK: [[TMP7:%.*]] = sdiv exact i64 [[TMP6]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES:%.*]], ptr align 8 @.offload_sizes.3, i64 24, i1 false) -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP8]], align 8 -// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP9]], align 8 -// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: store i64 [[TMP7]], ptr [[TMP10]], align 8 -// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP11]], align 8 -// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr @ps, ptr [[TMP12]], align 8 -// CHECK: [[TMP13:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr @ps, ptr [[TMP13]], align 8 -// CHECK: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK: store ptr null, ptr [[TMP14]], align 8 -// CHECK: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK: store ptr [[TMP1]], ptr [[TMP15]], align 8 -// CHECK: [[TMP16:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK: store ptr [[Y]], ptr [[TMP16]], align 8 -// CHECK: [[TMP17:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK: store ptr null, ptr [[TMP17]], align 8 -// CHECK: [[TMP18:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP19:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP20:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: [[TMP21:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ps, ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ps, ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[Y]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ps, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[Y]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l34( -// CHECK-SAME: ptr noundef [[PS:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l35( +// CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(8) [[PS:%.*]]) #[[ATTR1]] { // CHECK: [[ENTRY:.*:]] // CHECK: store ptr [[PS]], ptr [[PS_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP0]], i32 0, i32 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 // CHECK: store i32 7, ptr [[Y]], align 4 // CHECK: ret void // @@ -172,46 +171,37 @@ void f5() { // CHECK: [[ENTRY:.*:]] // CHECK: [[TMP0:%.*]] = load ptr, ptr @ps, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ps, align 8 -// CHECK: [[TMP2:%.*]] = load ptr, ptr @ps, align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP2]], i32 0, i32 1 -// CHECK: [[TMP3:%.*]] = getelementptr [[STRUCT_S]], ptr [[TMP1]], i32 1 -// CHECK: [[TMP4:%.*]] = ptrtoint ptr [[TMP3]] to i64 -// CHECK: [[TMP5:%.*]] = ptrtoint ptr [[TMP1]] to i64 -// CHECK: [[TMP6:%.*]] = sub i64 [[TMP4]], [[TMP5]] -// CHECK: [[TMP7:%.*]] = sdiv exact i64 [[TMP6]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES:%.*]], ptr align 8 @.offload_sizes.5, i64 24, i1 false) -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP8]], align 8 -// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP9]], align 8 -// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: store i64 [[TMP7]], ptr [[TMP10]], align 8 -// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP11]], align 8 -// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr [[TMP1]], ptr [[TMP12]], align 8 -// CHECK: [[TMP13:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr [[Y]], ptr [[TMP13]], align 8 -// CHECK: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK: store ptr null, ptr [[TMP14]], align 8 -// CHECK: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK: store ptr @ps, ptr [[TMP15]], align 8 -// CHECK: [[TMP16:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK: store ptr @ps, ptr [[TMP16]], align 8 -// CHECK: [[TMP17:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK: store ptr null, ptr [[TMP17]], align 8 -// CHECK: [[TMP18:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP19:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP20:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: [[TMP21:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ps, ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ps, ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[Y]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr @ps, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[Y]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l42( -// CHECK-SAME: ptr noundef [[PS:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l43( +// CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(8) [[PS:%.*]]) #[[ATTR1]] { // CHECK: [[ENTRY:.*:]] // CHECK: store ptr [[PS]], ptr [[PS_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP0]], i32 0, i32 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 // CHECK: store i32 8, ptr [[Y]], align 4 // CHECK: ret void // @@ -221,55 +211,61 @@ void f5() { // CHECK: [[ENTRY:.*:]] // CHECK: [[TMP0:%.*]] = load ptr, ptr @ps, align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr @ps, align 8 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 // CHECK: [[TMP2:%.*]] = load ptr, ptr @ps, align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP2]], i32 0, i32 1 // CHECK: [[TMP3:%.*]] = load ptr, ptr @ps, align 8 -// CHECK: [[TMP4:%.*]] = load ptr, ptr @ps, align 8 -// CHECK: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[TMP4]], i32 0, i32 0 -// CHECK: [[TMP5:%.*]] = getelementptr [[STRUCT_S]], ptr [[TMP1]], i32 1 -// CHECK: [[TMP6:%.*]] = ptrtoint ptr [[TMP5]] to i64 -// CHECK: [[TMP7:%.*]] = ptrtoint ptr [[TMP1]] to i64 -// CHECK: [[TMP8:%.*]] = sub i64 [[TMP6]], [[TMP7]] -// CHECK: [[TMP9:%.*]] = sdiv exact i64 [[TMP8]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES:%.*]], ptr align 8 @.offload_sizes.7, i64 32, i1 false) -// CHECK: [[TMP10:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP10]], align 8 -// CHECK: [[TMP11:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP11]], align 8 -// CHECK: [[TMP12:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: store i64 [[TMP9]], ptr [[TMP12]], align 8 -// CHECK: [[TMP13:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP13]], align 8 -// CHECK: [[TMP14:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr [[TMP1]], ptr [[TMP14]], align 8 -// CHECK: [[TMP15:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr [[Y]], ptr [[TMP15]], align 8 -// CHECK: [[TMP16:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK: store ptr null, ptr [[TMP16]], align 8 -// CHECK: [[TMP17:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK: store ptr @ps, ptr [[TMP17]], align 8 -// CHECK: [[TMP18:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK: store ptr @ps, ptr [[TMP18]], align 8 -// CHECK: [[TMP19:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK: store ptr null, ptr [[TMP19]], align 8 -// CHECK: [[TMP20:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 -// CHECK: store ptr [[TMP3]], ptr [[TMP20]], align 8 -// CHECK: [[TMP21:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 -// CHECK: store ptr [[X]], ptr [[TMP21]], align 8 -// CHECK: [[TMP22:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 -// CHECK: store ptr null, ptr [[TMP22]], align 8 -// CHECK: [[TMP23:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP24:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP25:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: [[TMP26:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[TMP3]], i32 0, i32 0 +// CHECK: [[TMP4:%.*]] = getelementptr i32, ptr [[Y]], i32 1 +// CHECK: [[TMP5:%.*]] = ptrtoint ptr [[TMP4]] to i64 +// CHECK: [[TMP6:%.*]] = ptrtoint ptr [[X]] to i64 +// CHECK: [[TMP7:%.*]] = sub i64 [[TMP5]], [[TMP6]] +// CHECK: [[TMP8:%.*]] = sdiv exact i64 [[TMP7]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) +// CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES:%.*]], ptr align 8 @.offload_sizes.7, i64 40, i1 false) +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ps, ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr @ps, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP11]], align 8 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP12]], align 8 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[X]], ptr [[TMP13]], align 8 +// CHECK: [[TMP14:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 1 +// CHECK: store i64 [[TMP8]], ptr [[TMP14]], align 8 +// CHECK: [[TMP15:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP15]], align 8 +// CHECK: [[TMP16:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[TMP0]], ptr [[TMP16]], align 8 +// CHECK: [[TMP17:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[Y]], ptr [[TMP17]], align 8 +// CHECK: [[TMP18:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP18]], align 8 +// CHECK: [[TMP19:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 +// CHECK: store ptr [[TMP2]], ptr [[TMP19]], align 8 +// CHECK: [[TMP20:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 +// CHECK: store ptr [[X]], ptr [[TMP20]], align 8 +// CHECK: [[TMP21:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 +// CHECK: store ptr null, ptr [[TMP21]], align 8 +// CHECK: [[TMP22:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 +// CHECK: store ptr @ps, ptr [[TMP22]], align 8 +// CHECK: [[TMP23:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// CHECK: store ptr [[X]], ptr [[TMP23]], align 8 +// CHECK: [[TMP24:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 +// CHECK: store ptr null, ptr [[TMP24]], align 8 +// CHECK: [[TMP25:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP26:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP27:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f5v_l51( -// CHECK-SAME: ptr noundef [[PS:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f5v_l53( +// CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(8) [[PS:%.*]]) #[[ATTR1]] { // CHECK: [[ENTRY:.*:]] // CHECK: store ptr [[PS]], ptr [[PS_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP0]], i32 0, i32 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 // CHECK: store i32 9, ptr [[Y]], align 4 // CHECK: ret void // diff --git a/clang/test/OpenMP/target_map_structptr_and_member_local.cpp b/clang/test/OpenMP/target_map_structptr_and_member_local.cpp index b366f331941b7..a5afe366746c2 100644 --- a/clang/test/OpenMP/target_map_structptr_and_member_local.cpp +++ b/clang/test/OpenMP/target_map_structptr_and_member_local.cpp @@ -23,34 +23,36 @@ void f1() { void f2() { S s, *ps; // &ps[0], &ps->y, sizeof(ps->y), TO | PARAM + // &ps, &ps->y, sizeof(ps), ATTACH #pragma omp target map(to: ps->y) ps->y = 6; } void f3() { S s, *ps; - // &ps[0], &ps[0], sizeof(ps[0]), PARAM | ALLOC - // &ps, &ps, sizeof(ps), TO | MEMBER_OF(1) - // &ps[0], &ps->y, sizeof(ps->y), TO | MEMBER_OF(1) + // &ps, &ps, sizeof(ps), TO | PARAM + // &ps[0], &ps->y, sizeof(ps->y), TO + // &ps, &ps->y, sizeof(ps), ATTACH #pragma omp target map(to: ps, ps->y) ps->y = 7; } void f4() { S s, *ps; - // &ps[0], &ps[0], sizeof(ps[0]), PARAM | ALLOC - // &ps[0], &ps->y, sizeof(ps->y), TO | MEMBER_OF(1) - // &ps, &ps, sizeof(ps), TO | MEMBER_OF(1) + // &ps, &ps, sizeof(ps), TO | PARAM + // &ps[0], &ps->y, sizeof(ps->y), TO + // &ps, &ps->y, sizeof(ps), ATTACH #pragma omp target map(to: ps->y, ps) ps->y = 8; } void f5() { S s, *ps; - // &ps[0], &ps[0], sizeof(ps[0]), PARAM | ALLOC - // &ps[0], &ps->y, sizeof(ps->y), TO | MEMBER_OF(1) - // &ps, &ps, sizeof(ps), TO | MEMBER_OF(1) - // &ps[0], &ps->x, sizeof(ps->x), TO | MEMBER_OF(1) + // &ps, &ps, sizeof(ps), TO | PARAM + // &ps[0], &ps[0].x, ((&ps[0].y + 1) - &ps[0].x)/8, ALLOC + // &ps[0], &ps->y, sizeof(ps->y), TO | MEMBER_OF(2) + // &ps[0], &ps->x, sizeof(ps->x), TO | MEMBER_OF(2) + // &ps, &ps[0].x, sizeof(ps), ATTACH #pragma omp target map(to: ps->y, ps, ps->x) ps->y = 9; } @@ -59,14 +61,14 @@ void f5() { //. // CHECK: @.offload_sizes = private unnamed_addr constant [1 x i64] [i64 8] // CHECK: @.offload_maptypes = private unnamed_addr constant [1 x i64] [i64 [[#0x21]]] -// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4] -// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x21]]] -// CHECK: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 0, i64 8, i64 4] -// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x20]], i64 [[#0x1000000000001]], i64 [[#0x1000000000001]]] -// CHECK: @.offload_sizes.5 = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 8] -// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [3 x i64] [i64 [[#0x20]], i64 [[#0x1000000000001]], i64 [[#0x1000000000001]]] -// CHECK: @.offload_sizes.7 = private unnamed_addr constant [4 x i64] [i64 0, i64 4, i64 8, i64 2] -// CHECK: @.offload_maptypes.8 = private unnamed_addr constant [4 x i64] [i64 [[#0x20]], i64 [[#0x1000000000001]], i64 [[#0x1000000000001]], i64 [[#0x1000000000001]]] +// CHECK: @.offload_sizes.1 = private unnamed_addr constant [2 x i64] [i64 4, i64 8] +// CHECK: @.offload_maptypes.2 = private unnamed_addr constant [2 x i64] [i64 [[#0x21]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x21]], i64 [[#0x1]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.5 = private unnamed_addr constant [3 x i64] [i64 8, i64 4, i64 8] +// CHECK: @.offload_maptypes.6 = private unnamed_addr constant [3 x i64] [i64 [[#0x21]], i64 [[#0x1]], i64 [[#0x4000]]] +// CHECK: @.offload_sizes.7 = private unnamed_addr constant [5 x i64] [i64 8, i64 0, i64 4, i64 2, i64 8] +// CHECK: @.offload_maptypes.8 = private unnamed_addr constant [5 x i64] [i64 [[#0x21]], i64 [[#0x0]], i64 [[#0x2000000000001]], i64 [[#0x2000000000001]], i64 [[#0x4000]]] //. // CHECK-LABEL: define dso_local void @_Z2f1v( // CHECK-SAME: ) #[[ATTR0:[0-9]+]] { @@ -100,18 +102,24 @@ void f5() { // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PS]], align 8 // CHECK: [[TMP2:%.*]] = load ptr, ptr [[PS]], align 8 // CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP2]], i32 0, i32 1 -// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[TMP1]], ptr [[TMP3]], align 8 -// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 // CHECK: store ptr [[Y]], ptr [[TMP4]], align 8 -// CHECK: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 // CHECK: store ptr null, ptr [[TMP5]], align 8 -// CHECK: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[PS]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[Y]], ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l26( +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f2v_l27( // CHECK-SAME: ptr noundef [[PS:%.*]]) #[[ATTR1]] { // CHECK: [[ENTRY:.*:]] // CHECK: store ptr [[PS]], ptr [[PS_ADDR:%.*]], align 8 @@ -126,46 +134,37 @@ void f5() { // CHECK: [[ENTRY:.*:]] // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PS]], align 8 -// CHECK: [[TMP2:%.*]] = load ptr, ptr [[PS]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP2]], i32 0, i32 1 -// CHECK: [[TMP3:%.*]] = getelementptr [[STRUCT_S]], ptr [[TMP1]], i32 1 -// CHECK: [[TMP4:%.*]] = ptrtoint ptr [[TMP3]] to i64 -// CHECK: [[TMP5:%.*]] = ptrtoint ptr [[TMP1]] to i64 -// CHECK: [[TMP6:%.*]] = sub i64 [[TMP4]], [[TMP5]] -// CHECK: [[TMP7:%.*]] = sdiv exact i64 [[TMP6]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES:%.*]], ptr align 8 @.offload_sizes.3, i64 24, i1 false) -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP8]], align 8 -// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP9]], align 8 -// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: store i64 [[TMP7]], ptr [[TMP10]], align 8 -// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP11]], align 8 -// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr [[PS]], ptr [[TMP12]], align 8 -// CHECK: [[TMP13:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr [[PS]], ptr [[TMP13]], align 8 -// CHECK: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK: store ptr null, ptr [[TMP14]], align 8 -// CHECK: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK: store ptr [[TMP1]], ptr [[TMP15]], align 8 -// CHECK: [[TMP16:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK: store ptr [[Y]], ptr [[TMP16]], align 8 -// CHECK: [[TMP17:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK: store ptr null, ptr [[TMP17]], align 8 -// CHECK: [[TMP18:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP19:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP20:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: [[TMP21:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PS]], ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PS]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[Y]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PS]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[Y]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l35( -// CHECK-SAME: ptr noundef [[PS:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f3v_l36( +// CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(8) [[PS:%.*]]) #[[ATTR1]] { // CHECK: [[ENTRY:.*:]] // CHECK: store ptr [[PS]], ptr [[PS_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP0]], i32 0, i32 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 // CHECK: store i32 7, ptr [[Y]], align 4 // CHECK: ret void // @@ -175,46 +174,37 @@ void f5() { // CHECK: [[ENTRY:.*:]] // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PS]], align 8 -// CHECK: [[TMP2:%.*]] = load ptr, ptr [[PS]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP2]], i32 0, i32 1 -// CHECK: [[TMP3:%.*]] = getelementptr [[STRUCT_S]], ptr [[TMP1]], i32 1 -// CHECK: [[TMP4:%.*]] = ptrtoint ptr [[TMP3]] to i64 -// CHECK: [[TMP5:%.*]] = ptrtoint ptr [[TMP1]] to i64 -// CHECK: [[TMP6:%.*]] = sub i64 [[TMP4]], [[TMP5]] -// CHECK: [[TMP7:%.*]] = sdiv exact i64 [[TMP6]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES:%.*]], ptr align 8 @.offload_sizes.5, i64 24, i1 false) -// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP8]], align 8 -// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP9]], align 8 -// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: store i64 [[TMP7]], ptr [[TMP10]], align 8 -// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP11]], align 8 -// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr [[TMP1]], ptr [[TMP12]], align 8 -// CHECK: [[TMP13:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr [[Y]], ptr [[TMP13]], align 8 -// CHECK: [[TMP14:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK: store ptr null, ptr [[TMP14]], align 8 -// CHECK: [[TMP15:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK: store ptr [[PS]], ptr [[TMP15]], align 8 -// CHECK: [[TMP16:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK: store ptr [[PS]], ptr [[TMP16]], align 8 -// CHECK: [[TMP17:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK: store ptr null, ptr [[TMP17]], align 8 -// CHECK: [[TMP18:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP19:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP20:%.*]] = getelementptr inbounds [3 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: [[TMP21:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 +// CHECK: [[TMP2:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PS]], ptr [[TMP2]], align 8 +// CHECK: [[TMP3:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PS]], ptr [[TMP3]], align 8 +// CHECK: [[TMP4:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP4]], align 8 +// CHECK: [[TMP5:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP5]], align 8 +// CHECK: [[TMP6:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[Y]], ptr [[TMP6]], align 8 +// CHECK: [[TMP7:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP7]], align 8 +// CHECK: [[TMP8:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[PS]], ptr [[TMP8]], align 8 +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[Y]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l44( -// CHECK-SAME: ptr noundef [[PS:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f4v_l45( +// CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(8) [[PS:%.*]]) #[[ATTR1]] { // CHECK: [[ENTRY:.*:]] // CHECK: store ptr [[PS]], ptr [[PS_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP0]], i32 0, i32 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 // CHECK: store i32 8, ptr [[Y]], align 4 // CHECK: ret void // @@ -224,55 +214,61 @@ void f5() { // CHECK: [[ENTRY:.*:]] // CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS:%.*]], align 8 // CHECK: [[TMP1:%.*]] = load ptr, ptr [[PS]], align 8 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 // CHECK: [[TMP2:%.*]] = load ptr, ptr [[PS]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP2]], i32 0, i32 1 // CHECK: [[TMP3:%.*]] = load ptr, ptr [[PS]], align 8 -// CHECK: [[TMP4:%.*]] = load ptr, ptr [[PS]], align 8 -// CHECK: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[TMP4]], i32 0, i32 0 -// CHECK: [[TMP5:%.*]] = getelementptr [[STRUCT_S]], ptr [[TMP1]], i32 1 -// CHECK: [[TMP6:%.*]] = ptrtoint ptr [[TMP5]] to i64 -// CHECK: [[TMP7:%.*]] = ptrtoint ptr [[TMP1]] to i64 -// CHECK: [[TMP8:%.*]] = sub i64 [[TMP6]], [[TMP7]] -// CHECK: [[TMP9:%.*]] = sdiv exact i64 [[TMP8]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) -// CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES:%.*]], ptr align 8 @.offload_sizes.7, i64 32, i1 false) -// CHECK: [[TMP10:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP10]], align 8 -// CHECK: [[TMP11:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 -// CHECK: store ptr [[TMP1]], ptr [[TMP11]], align 8 -// CHECK: [[TMP12:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: store i64 [[TMP9]], ptr [[TMP12]], align 8 -// CHECK: [[TMP13:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 -// CHECK: store ptr null, ptr [[TMP13]], align 8 -// CHECK: [[TMP14:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 -// CHECK: store ptr [[TMP1]], ptr [[TMP14]], align 8 -// CHECK: [[TMP15:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 -// CHECK: store ptr [[Y]], ptr [[TMP15]], align 8 -// CHECK: [[TMP16:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 -// CHECK: store ptr null, ptr [[TMP16]], align 8 -// CHECK: [[TMP17:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 -// CHECK: store ptr [[PS]], ptr [[TMP17]], align 8 -// CHECK: [[TMP18:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 -// CHECK: store ptr [[PS]], ptr [[TMP18]], align 8 -// CHECK: [[TMP19:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 -// CHECK: store ptr null, ptr [[TMP19]], align 8 -// CHECK: [[TMP20:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 -// CHECK: store ptr [[TMP3]], ptr [[TMP20]], align 8 -// CHECK: [[TMP21:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 -// CHECK: store ptr [[X]], ptr [[TMP21]], align 8 -// CHECK: [[TMP22:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 -// CHECK: store ptr null, ptr [[TMP22]], align 8 -// CHECK: [[TMP23:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK: [[TMP24:%.*]] = getelementptr inbounds [4 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK: [[TMP25:%.*]] = getelementptr inbounds [4 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 -// CHECK: [[TMP26:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 +// CHECK: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[TMP3]], i32 0, i32 0 +// CHECK: [[TMP4:%.*]] = getelementptr i32, ptr [[Y]], i32 1 +// CHECK: [[TMP5:%.*]] = ptrtoint ptr [[TMP4]] to i64 +// CHECK: [[TMP6:%.*]] = ptrtoint ptr [[X]] to i64 +// CHECK: [[TMP7:%.*]] = sub i64 [[TMP5]], [[TMP6]] +// CHECK: [[TMP8:%.*]] = sdiv exact i64 [[TMP7]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) +// CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DOTOFFLOAD_SIZES:%.*]], ptr align 8 @.offload_sizes.7, i64 40, i1 false) +// CHECK: [[TMP9:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PS]], ptr [[TMP9]], align 8 +// CHECK: [[TMP10:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS:%.*]], i32 0, i32 0 +// CHECK: store ptr [[PS]], ptr [[TMP10]], align 8 +// CHECK: [[TMP11:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS:%.*]], i64 0, i64 0 +// CHECK: store ptr null, ptr [[TMP11]], align 8 +// CHECK: [[TMP12:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK: store ptr [[TMP0]], ptr [[TMP12]], align 8 +// CHECK: [[TMP13:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK: store ptr [[X]], ptr [[TMP13]], align 8 +// CHECK: [[TMP14:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 1 +// CHECK: store i64 [[TMP8]], ptr [[TMP14]], align 8 +// CHECK: [[TMP15:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK: store ptr null, ptr [[TMP15]], align 8 +// CHECK: [[TMP16:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2 +// CHECK: store ptr [[TMP0]], ptr [[TMP16]], align 8 +// CHECK: [[TMP17:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 2 +// CHECK: store ptr [[Y]], ptr [[TMP17]], align 8 +// CHECK: [[TMP18:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2 +// CHECK: store ptr null, ptr [[TMP18]], align 8 +// CHECK: [[TMP19:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3 +// CHECK: store ptr [[TMP2]], ptr [[TMP19]], align 8 +// CHECK: [[TMP20:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 3 +// CHECK: store ptr [[X]], ptr [[TMP20]], align 8 +// CHECK: [[TMP21:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3 +// CHECK: store ptr null, ptr [[TMP21]], align 8 +// CHECK: [[TMP22:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4 +// CHECK: store ptr [[PS]], ptr [[TMP22]], align 8 +// CHECK: [[TMP23:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 4 +// CHECK: store ptr [[X]], ptr [[TMP23]], align 8 +// CHECK: [[TMP24:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4 +// CHECK: store ptr null, ptr [[TMP24]], align 8 +// CHECK: [[TMP25:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK: [[TMP26:%.*]] = getelementptr inbounds [5 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK: [[TMP27:%.*]] = getelementptr inbounds [5 x i64], ptr [[DOTOFFLOAD_SIZES]], i32 0, i32 0 +// CHECK: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], ptr [[KERNEL_ARGS:%.*]], i32 0, i32 0 // // -// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f5v_l54( -// CHECK-SAME: ptr noundef [[PS:%.*]]) #[[ATTR1]] { +// CHECK-LABEL: define internal void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z2f5v_l56( +// CHECK-SAME: ptr noundef nonnull align 8 dereferenceable(8) [[PS:%.*]]) #[[ATTR1]] { // CHECK: [[ENTRY:.*:]] // CHECK: store ptr [[PS]], ptr [[PS_ADDR:%.*]], align 8 -// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8 -// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP0]], i32 0, i32 1 +// CHECK: [[TMP0:%.*]] = load ptr, ptr [[PS_ADDR]], align 8, !nonnull [[META13]], !align [[META14]] +// CHECK: [[TMP1:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_S:%.*]], ptr [[TMP1]], i32 0, i32 1 // CHECK: store i32 9, ptr [[Y]], align 4 // CHECK: ret void // diff --git a/clang/test/OpenMP/target_task_affinity_codegen.cpp b/clang/test/OpenMP/target_task_affinity_codegen.cpp index 53960cee4b730..7bc1acb245388 100644 --- a/clang/test/OpenMP/target_task_affinity_codegen.cpp +++ b/clang/test/OpenMP/target_task_affinity_codegen.cpp @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-globals --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _ --global-value-regex "\.offload_.*" // Test host codegen. // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix=CHECK1 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s @@ -37,11 +37,11 @@ int main() { int *A; int *B; - #pragma omp target data map(tofrom: A[0:1024]) + #pragma omp target data map(tofrom: A[0:1024]) // (1) -#pragma omp target data use_device_ptr(A) + #pragma omp target data use_device_ptr(A) // (2) { - #pragma omp target defaultmap(none) is_device_ptr(A) map(tofrom: B[0:1024]) + #pragma omp target defaultmap(none) is_device_ptr(A) map(tofrom: B[0:1024]) // (3) { #pragma omp task shared(B) affinity(A[0:1024]) { @@ -56,106 +56,145 @@ int main() { } #endif + +// Expected Maps: +// (1): +// &A[0], &A[/*lb=*/0], 1024 * sizeof(A[0]), TO | FROM +// &A, &A[/*lb=*/0], sizeof(A), ATTACH +// (2): +// &A[0], &A[0], 0, RETURN_PARAM +// (3): +// &B[0], &B[/*lb=*/0], 1024 * sizeof(B[0]), TO | FROM | PARAM +// &B, &B[/*lb=*/0], sizeof(B), ATTACH +// &A[0], &A[0], sizeof(A[0]), LITERAL | PARAM + +//. +// CHECK1: @.offload_sizes = private unnamed_addr constant [2 x i64] [i64 4096, i64 8] +// CHECK1: @.offload_maptypes = private unnamed_addr constant [2 x i64] [i64 3, i64 16384] +// CHECK1: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] zeroinitializer +// CHECK1: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 64] +// CHECK1: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 4096, i64 8, i64 8] +// CHECK1: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 35, i64 16384, i64 288] +//. +// CHECK3: @.offload_sizes = private unnamed_addr constant [2 x i64] [i64 4096, i64 4] +// CHECK3: @.offload_maptypes = private unnamed_addr constant [2 x i64] [i64 3, i64 16384] +// CHECK3: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] zeroinitializer +// CHECK3: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 64] +// CHECK3: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 4096, i64 4, i64 4] +// CHECK3: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 35, i64 16384, i64 288] +//. // CHECK1-LABEL: define {{[^@]+}}@main // CHECK1-SAME: () #[[ATTR0:[0-9]+]] { // CHECK1-NEXT: entry: // CHECK1-NEXT: [[RETVAL:%.*]] = alloca i32, align 4 // CHECK1-NEXT: [[A:%.*]] = alloca ptr, align 8 // CHECK1-NEXT: [[B:%.*]] = alloca ptr, align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [1 x ptr], align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [1 x ptr], align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [1 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [2 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [2 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [2 x ptr], align 8 // CHECK1-NEXT: [[DOTOFFLOAD_BASEPTRS1:%.*]] = alloca [1 x ptr], align 8 // CHECK1-NEXT: [[DOTOFFLOAD_PTRS2:%.*]] = alloca [1 x ptr], align 8 // CHECK1-NEXT: [[DOTOFFLOAD_MAPPERS3:%.*]] = alloca [1 x ptr], align 8 // CHECK1-NEXT: [[TMP0:%.*]] = alloca ptr, align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_BASEPTRS5:%.*]] = alloca [2 x ptr], align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_PTRS6:%.*]] = alloca [2 x ptr], align 8 -// CHECK1-NEXT: [[DOTOFFLOAD_MAPPERS7:%.*]] = alloca [2 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_BASEPTRS5:%.*]] = alloca [3 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_PTRS6:%.*]] = alloca [3 x ptr], align 8 +// CHECK1-NEXT: [[DOTOFFLOAD_MAPPERS7:%.*]] = alloca [3 x ptr], align 8 // CHECK1-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8 // CHECK1-NEXT: store i32 0, ptr [[RETVAL]], align 4 // CHECK1-NEXT: [[TMP1:%.*]] = load ptr, ptr [[A]], align 8 // CHECK1-NEXT: [[TMP2:%.*]] = load ptr, ptr [[A]], align 8 // CHECK1-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP2]], i64 0 -// CHECK1-NEXT: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 // CHECK1-NEXT: store ptr [[TMP1]], ptr [[TMP3]], align 8 -// CHECK1-NEXT: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 // CHECK1-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP4]], align 8 -// CHECK1-NEXT: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 +// CHECK1-NEXT: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0 // CHECK1-NEXT: store ptr null, ptr [[TMP5]], align 8 -// CHECK1-NEXT: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK1-NEXT: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK1-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 1, ptr [[TMP6]], ptr [[TMP7]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) -// CHECK1-NEXT: [[TMP8:%.*]] = load ptr, ptr [[A]], align 8 -// CHECK1-NEXT: [[TMP9:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 -// CHECK1-NEXT: store ptr [[TMP8]], ptr [[TMP9]], align 8 -// CHECK1-NEXT: [[TMP10:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 -// CHECK1-NEXT: store ptr [[TMP8]], ptr [[TMP10]], align 8 -// CHECK1-NEXT: [[TMP11:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS3]], i64 0, i64 0 -// CHECK1-NEXT: store ptr null, ptr [[TMP11]], align 8 +// CHECK1-NEXT: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK1-NEXT: store ptr [[A]], ptr [[TMP6]], align 8 +// CHECK1-NEXT: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK1-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP7]], align 8 +// CHECK1-NEXT: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1 +// CHECK1-NEXT: store ptr null, ptr [[TMP8]], align 8 +// CHECK1-NEXT: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK1-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 2, ptr [[TMP9]], ptr [[TMP10]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK1-NEXT: [[TMP11:%.*]] = load ptr, ptr [[A]], align 8 // CHECK1-NEXT: [[TMP12:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 +// CHECK1-NEXT: store ptr [[TMP11]], ptr [[TMP12]], align 8 // CHECK1-NEXT: [[TMP13:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 -// CHECK1-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP12]], ptr [[TMP13]], ptr @.offload_sizes.1, ptr @.offload_maptypes.2, ptr null, ptr null) -// CHECK1-NEXT: [[TMP14:%.*]] = load ptr, ptr [[TMP9]], align 8 -// CHECK1-NEXT: store ptr [[TMP14]], ptr [[TMP0]], align 8 -// CHECK1-NEXT: [[TMP15:%.*]] = load ptr, ptr [[B]], align 8 -// CHECK1-NEXT: [[TMP16:%.*]] = load ptr, ptr [[TMP0]], align 8 -// CHECK1-NEXT: [[TMP17:%.*]] = load ptr, ptr [[B]], align 8 +// CHECK1-NEXT: store ptr [[TMP11]], ptr [[TMP13]], align 8 +// CHECK1-NEXT: [[TMP14:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS3]], i64 0, i64 0 +// CHECK1-NEXT: store ptr null, ptr [[TMP14]], align 8 +// CHECK1-NEXT: [[TMP15:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP16:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 +// CHECK1-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP15]], ptr [[TMP16]], ptr @.offload_sizes.1, ptr @.offload_maptypes.2, ptr null, ptr null) +// CHECK1-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP12]], align 8 +// CHECK1-NEXT: store ptr [[TMP17]], ptr [[TMP0]], align 8 // CHECK1-NEXT: [[TMP18:%.*]] = load ptr, ptr [[B]], align 8 -// CHECK1-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP18]], i64 0 -// CHECK1-NEXT: [[TMP19:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 0 -// CHECK1-NEXT: store ptr [[TMP17]], ptr [[TMP19]], align 8 -// CHECK1-NEXT: [[TMP20:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 0 -// CHECK1-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP20]], align 8 -// CHECK1-NEXT: [[TMP21:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i64 0, i64 0 -// CHECK1-NEXT: store ptr null, ptr [[TMP21]], align 8 -// CHECK1-NEXT: [[TMP22:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 1 -// CHECK1-NEXT: store ptr [[TMP16]], ptr [[TMP22]], align 8 -// CHECK1-NEXT: [[TMP23:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 1 -// CHECK1-NEXT: store ptr [[TMP16]], ptr [[TMP23]], align 8 -// CHECK1-NEXT: [[TMP24:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i64 0, i64 1 +// CHECK1-NEXT: [[TMP19:%.*]] = load ptr, ptr [[TMP0]], align 8 +// CHECK1-NEXT: [[TMP20:%.*]] = load ptr, ptr [[B]], align 8 +// CHECK1-NEXT: [[TMP21:%.*]] = load ptr, ptr [[B]], align 8 +// CHECK1-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP21]], i64 0 +// CHECK1-NEXT: [[TMP22:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 0 +// CHECK1-NEXT: store ptr [[TMP20]], ptr [[TMP22]], align 8 +// CHECK1-NEXT: [[TMP23:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 0 +// CHECK1-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP23]], align 8 +// CHECK1-NEXT: [[TMP24:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i64 0, i64 0 // CHECK1-NEXT: store ptr null, ptr [[TMP24]], align 8 -// CHECK1-NEXT: [[TMP25:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 0 -// CHECK1-NEXT: [[TMP26:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 0 -// CHECK1-NEXT: [[TMP27:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 -// CHECK1-NEXT: store i32 3, ptr [[TMP27]], align 4 -// CHECK1-NEXT: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 -// CHECK1-NEXT: store i32 2, ptr [[TMP28]], align 4 -// CHECK1-NEXT: [[TMP29:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 -// CHECK1-NEXT: store ptr [[TMP25]], ptr [[TMP29]], align 8 -// CHECK1-NEXT: [[TMP30:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 -// CHECK1-NEXT: store ptr [[TMP26]], ptr [[TMP30]], align 8 -// CHECK1-NEXT: [[TMP31:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 -// CHECK1-NEXT: store ptr @.offload_sizes.3, ptr [[TMP31]], align 8 -// CHECK1-NEXT: [[TMP32:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 -// CHECK1-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP32]], align 8 -// CHECK1-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 -// CHECK1-NEXT: store ptr null, ptr [[TMP33]], align 8 -// CHECK1-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 -// CHECK1-NEXT: store ptr null, ptr [[TMP34]], align 8 -// CHECK1-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 -// CHECK1-NEXT: store i64 0, ptr [[TMP35]], align 8 -// CHECK1-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 -// CHECK1-NEXT: store i64 0, ptr [[TMP36]], align 8 -// CHECK1-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 -// CHECK1-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP37]], align 4 -// CHECK1-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 -// CHECK1-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP38]], align 4 -// CHECK1-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 -// CHECK1-NEXT: store i32 0, ptr [[TMP39]], align 4 -// CHECK1-NEXT: [[TMP40:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_main_l44.region_id, ptr [[KERNEL_ARGS]]) -// CHECK1-NEXT: [[TMP41:%.*]] = icmp ne i32 [[TMP40]], 0 -// CHECK1-NEXT: br i1 [[TMP41]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] +// CHECK1-NEXT: [[TMP25:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 1 +// CHECK1-NEXT: store ptr [[B]], ptr [[TMP25]], align 8 +// CHECK1-NEXT: [[TMP26:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 1 +// CHECK1-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP26]], align 8 +// CHECK1-NEXT: [[TMP27:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i64 0, i64 1 +// CHECK1-NEXT: store ptr null, ptr [[TMP27]], align 8 +// CHECK1-NEXT: [[TMP28:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 2 +// CHECK1-NEXT: store ptr [[TMP19]], ptr [[TMP28]], align 8 +// CHECK1-NEXT: [[TMP29:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 2 +// CHECK1-NEXT: store ptr [[TMP19]], ptr [[TMP29]], align 8 +// CHECK1-NEXT: [[TMP30:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i64 0, i64 2 +// CHECK1-NEXT: store ptr null, ptr [[TMP30]], align 8 +// CHECK1-NEXT: [[TMP31:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP32:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 +// CHECK1-NEXT: store i32 3, ptr [[TMP33]], align 4 +// CHECK1-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 +// CHECK1-NEXT: store i32 3, ptr [[TMP34]], align 4 +// CHECK1-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK1-NEXT: store ptr [[TMP31]], ptr [[TMP35]], align 8 +// CHECK1-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 +// CHECK1-NEXT: store ptr [[TMP32]], ptr [[TMP36]], align 8 +// CHECK1-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 +// CHECK1-NEXT: store ptr @.offload_sizes.3, ptr [[TMP37]], align 8 +// CHECK1-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 +// CHECK1-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP38]], align 8 +// CHECK1-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK1-NEXT: store ptr null, ptr [[TMP39]], align 8 +// CHECK1-NEXT: [[TMP40:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 +// CHECK1-NEXT: store ptr null, ptr [[TMP40]], align 8 +// CHECK1-NEXT: [[TMP41:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK1-NEXT: store i64 0, ptr [[TMP41]], align 8 +// CHECK1-NEXT: [[TMP42:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 +// CHECK1-NEXT: store i64 0, ptr [[TMP42]], align 8 +// CHECK1-NEXT: [[TMP43:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK1-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP43]], align 4 +// CHECK1-NEXT: [[TMP44:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 +// CHECK1-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP44]], align 4 +// CHECK1-NEXT: [[TMP45:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 +// CHECK1-NEXT: store i32 0, ptr [[TMP45]], align 4 +// CHECK1-NEXT: [[TMP46:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_main_l44.region_id, ptr [[KERNEL_ARGS]]) +// CHECK1-NEXT: [[TMP47:%.*]] = icmp ne i32 [[TMP46]], 0 +// CHECK1-NEXT: br i1 [[TMP47]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] // CHECK1: omp_offload.failed: -// CHECK1-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_main_l44(ptr [[TMP15]], ptr [[TMP16]]) #[[ATTR1:[0-9]+]] +// CHECK1-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_main_l44(ptr [[TMP18]], ptr [[TMP19]]) #[[ATTR1:[0-9]+]] // CHECK1-NEXT: br label [[OMP_OFFLOAD_CONT]] // CHECK1: omp_offload.cont: -// CHECK1-NEXT: [[TMP42:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 -// CHECK1-NEXT: [[TMP43:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 -// CHECK1-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP42]], ptr [[TMP43]], ptr @.offload_sizes.1, ptr @.offload_maptypes.2, ptr null, ptr null) -// CHECK1-NEXT: [[TMP44:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK1-NEXT: [[TMP45:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK1-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP44]], ptr [[TMP45]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK1-NEXT: [[TMP48:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP49:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 +// CHECK1-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP48]], ptr [[TMP49]], ptr @.offload_sizes.1, ptr @.offload_maptypes.2, ptr null, ptr null) +// CHECK1-NEXT: [[TMP50:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK1-NEXT: [[TMP51:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK1-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 2, ptr [[TMP50]], ptr [[TMP51]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) // CHECK1-NEXT: ret i32 0 // // @@ -237,44 +276,44 @@ int main() { // CHECK1-NEXT: [[TMP6:%.*]] = getelementptr inbounds nuw [[STRUCT_KMP_TASK_T]], ptr [[TMP4]], i32 0, i32 0 // CHECK1-NEXT: [[TMP7:%.*]] = load ptr, ptr [[TMP6]], align 8 // CHECK1-NEXT: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT_KMP_TASK_T_WITH_PRIVATES]], ptr [[TMP3]], i32 0, i32 1 -// CHECK1-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META4:![0-9]+]]) -// CHECK1-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META7:![0-9]+]]) -// CHECK1-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META9:![0-9]+]]) -// CHECK1-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META11:![0-9]+]]) -// CHECK1-NEXT: store i32 [[TMP2]], ptr [[DOTGLOBAL_TID__ADDR_I]], align 4, !noalias [[META13:![0-9]+]] -// CHECK1-NEXT: store ptr [[TMP5]], ptr [[DOTPART_ID__ADDR_I]], align 8, !noalias [[META13]] -// CHECK1-NEXT: store ptr [[TMP8]], ptr [[DOTPRIVATES__ADDR_I]], align 8, !noalias [[META13]] -// CHECK1-NEXT: store ptr @.omp_task_privates_map., ptr [[DOTCOPY_FN__ADDR_I]], align 8, !noalias [[META13]] -// CHECK1-NEXT: store ptr [[TMP3]], ptr [[DOTTASK_T__ADDR_I]], align 8, !noalias [[META13]] -// CHECK1-NEXT: store ptr [[TMP7]], ptr [[__CONTEXT_ADDR_I]], align 8, !noalias [[META13]] -// CHECK1-NEXT: [[TMP9:%.*]] = load ptr, ptr [[__CONTEXT_ADDR_I]], align 8, !noalias [[META13]] -// CHECK1-NEXT: [[TMP10:%.*]] = load ptr, ptr [[DOTCOPY_FN__ADDR_I]], align 8, !noalias [[META13]] -// CHECK1-NEXT: [[TMP11:%.*]] = load ptr, ptr [[DOTPRIVATES__ADDR_I]], align 8, !noalias [[META13]] +// CHECK1-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META5:![0-9]+]]) +// CHECK1-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META8:![0-9]+]]) +// CHECK1-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META10:![0-9]+]]) +// CHECK1-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META12:![0-9]+]]) +// CHECK1-NEXT: store i32 [[TMP2]], ptr [[DOTGLOBAL_TID__ADDR_I]], align 4, !noalias [[META14:![0-9]+]] +// CHECK1-NEXT: store ptr [[TMP5]], ptr [[DOTPART_ID__ADDR_I]], align 8, !noalias [[META14]] +// CHECK1-NEXT: store ptr [[TMP8]], ptr [[DOTPRIVATES__ADDR_I]], align 8, !noalias [[META14]] +// CHECK1-NEXT: store ptr @.omp_task_privates_map., ptr [[DOTCOPY_FN__ADDR_I]], align 8, !noalias [[META14]] +// CHECK1-NEXT: store ptr [[TMP3]], ptr [[DOTTASK_T__ADDR_I]], align 8, !noalias [[META14]] +// CHECK1-NEXT: store ptr [[TMP7]], ptr [[__CONTEXT_ADDR_I]], align 8, !noalias [[META14]] +// CHECK1-NEXT: [[TMP9:%.*]] = load ptr, ptr [[__CONTEXT_ADDR_I]], align 8, !noalias [[META14]] +// CHECK1-NEXT: [[TMP10:%.*]] = load ptr, ptr [[DOTCOPY_FN__ADDR_I]], align 8, !noalias [[META14]] +// CHECK1-NEXT: [[TMP11:%.*]] = load ptr, ptr [[DOTPRIVATES__ADDR_I]], align 8, !noalias [[META14]] // CHECK1-NEXT: call void [[TMP10]](ptr [[TMP11]], ptr [[DOTFIRSTPRIV_PTR_ADDR_I]]) #[[ATTR1]] -// CHECK1-NEXT: [[TMP12:%.*]] = load ptr, ptr [[DOTFIRSTPRIV_PTR_ADDR_I]], align 8, !noalias [[META13]] -// CHECK1-NEXT: store i32 0, ptr [[I_I]], align 4, !noalias [[META13]] +// CHECK1-NEXT: [[TMP12:%.*]] = load ptr, ptr [[DOTFIRSTPRIV_PTR_ADDR_I]], align 8, !noalias [[META14]] +// CHECK1-NEXT: store i32 0, ptr [[I_I]], align 4, !noalias [[META14]] // CHECK1-NEXT: br label [[FOR_COND_I:%.*]] // CHECK1: for.cond.i: -// CHECK1-NEXT: [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META13]] +// CHECK1-NEXT: [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] // CHECK1-NEXT: [[CMP_I:%.*]] = icmp slt i32 [[TMP13]], 1024 // CHECK1-NEXT: br i1 [[CMP_I]], label [[FOR_BODY_I:%.*]], label [[DOTOMP_OUTLINED__EXIT:%.*]] // CHECK1: for.body.i: // CHECK1-NEXT: [[TMP14:%.*]] = load ptr, ptr [[TMP12]], align 8 -// CHECK1-NEXT: [[TMP15:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META13]] +// CHECK1-NEXT: [[TMP15:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] // CHECK1-NEXT: [[IDXPROM_I:%.*]] = sext i32 [[TMP15]] to i64 // CHECK1-NEXT: [[ARRAYIDX_I:%.*]] = getelementptr inbounds i32, ptr [[TMP14]], i64 [[IDXPROM_I]] // CHECK1-NEXT: [[TMP16:%.*]] = load i32, ptr [[ARRAYIDX_I]], align 4 // CHECK1-NEXT: [[MUL_I:%.*]] = mul nsw i32 2, [[TMP16]] -// CHECK1-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP9]], align 8 +// CHECK1-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP9]], align 8, !nonnull [[META15:![0-9]+]], !align [[META16:![0-9]+]] // CHECK1-NEXT: [[TMP18:%.*]] = load ptr, ptr [[TMP17]], align 8 -// CHECK1-NEXT: [[TMP19:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META13]] +// CHECK1-NEXT: [[TMP19:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] // CHECK1-NEXT: [[IDXPROM1_I:%.*]] = sext i32 [[TMP19]] to i64 // CHECK1-NEXT: [[ARRAYIDX2_I:%.*]] = getelementptr inbounds i32, ptr [[TMP18]], i64 [[IDXPROM1_I]] // CHECK1-NEXT: store i32 [[MUL_I]], ptr [[ARRAYIDX2_I]], align 4 -// CHECK1-NEXT: [[TMP20:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META13]] +// CHECK1-NEXT: [[TMP20:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] // CHECK1-NEXT: [[INC_I:%.*]] = add nsw i32 [[TMP20]], 1 -// CHECK1-NEXT: store i32 [[INC_I]], ptr [[I_I]], align 4, !noalias [[META13]] -// CHECK1-NEXT: br label [[FOR_COND_I]], !llvm.loop [[LOOP14:![0-9]+]] +// CHECK1-NEXT: store i32 [[INC_I]], ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK1-NEXT: br label [[FOR_COND_I]], !llvm.loop [[LOOP17:![0-9]+]] // CHECK1: .omp_outlined..exit: // CHECK1-NEXT: ret i32 0 // @@ -285,100 +324,112 @@ int main() { // CHECK3-NEXT: [[RETVAL:%.*]] = alloca i32, align 4 // CHECK3-NEXT: [[A:%.*]] = alloca ptr, align 4 // CHECK3-NEXT: [[B:%.*]] = alloca ptr, align 4 -// CHECK3-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [1 x ptr], align 4 -// CHECK3-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [1 x ptr], align 4 -// CHECK3-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [1 x ptr], align 4 +// CHECK3-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [2 x ptr], align 4 +// CHECK3-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [2 x ptr], align 4 +// CHECK3-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [2 x ptr], align 4 // CHECK3-NEXT: [[DOTOFFLOAD_BASEPTRS1:%.*]] = alloca [1 x ptr], align 4 // CHECK3-NEXT: [[DOTOFFLOAD_PTRS2:%.*]] = alloca [1 x ptr], align 4 // CHECK3-NEXT: [[DOTOFFLOAD_MAPPERS3:%.*]] = alloca [1 x ptr], align 4 // CHECK3-NEXT: [[TMP0:%.*]] = alloca ptr, align 4 -// CHECK3-NEXT: [[DOTOFFLOAD_BASEPTRS5:%.*]] = alloca [2 x ptr], align 4 -// CHECK3-NEXT: [[DOTOFFLOAD_PTRS6:%.*]] = alloca [2 x ptr], align 4 -// CHECK3-NEXT: [[DOTOFFLOAD_MAPPERS7:%.*]] = alloca [2 x ptr], align 4 +// CHECK3-NEXT: [[DOTOFFLOAD_BASEPTRS5:%.*]] = alloca [3 x ptr], align 4 +// CHECK3-NEXT: [[DOTOFFLOAD_PTRS6:%.*]] = alloca [3 x ptr], align 4 +// CHECK3-NEXT: [[DOTOFFLOAD_MAPPERS7:%.*]] = alloca [3 x ptr], align 4 // CHECK3-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8 // CHECK3-NEXT: store i32 0, ptr [[RETVAL]], align 4 // CHECK3-NEXT: [[TMP1:%.*]] = load ptr, ptr [[A]], align 4 // CHECK3-NEXT: [[TMP2:%.*]] = load ptr, ptr [[A]], align 4 // CHECK3-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP2]], i32 0 -// CHECK3-NEXT: [[TMP3:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP3:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 // CHECK3-NEXT: store ptr [[TMP1]], ptr [[TMP3]], align 4 -// CHECK3-NEXT: [[TMP4:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP4:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 // CHECK3-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP4]], align 4 -// CHECK3-NEXT: [[TMP5:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP5:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0 // CHECK3-NEXT: store ptr null, ptr [[TMP5]], align 4 -// CHECK3-NEXT: [[TMP6:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK3-NEXT: [[TMP7:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK3-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 1, ptr [[TMP6]], ptr [[TMP7]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) -// CHECK3-NEXT: [[TMP8:%.*]] = load ptr, ptr [[A]], align 4 -// CHECK3-NEXT: [[TMP9:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 -// CHECK3-NEXT: store ptr [[TMP8]], ptr [[TMP9]], align 4 -// CHECK3-NEXT: [[TMP10:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 -// CHECK3-NEXT: store ptr [[TMP8]], ptr [[TMP10]], align 4 -// CHECK3-NEXT: [[TMP11:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS3]], i32 0, i32 0 -// CHECK3-NEXT: store ptr null, ptr [[TMP11]], align 4 +// CHECK3-NEXT: [[TMP6:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1 +// CHECK3-NEXT: store ptr [[A]], ptr [[TMP6]], align 4 +// CHECK3-NEXT: [[TMP7:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 1 +// CHECK3-NEXT: store ptr [[ARRAYIDX]], ptr [[TMP7]], align 4 +// CHECK3-NEXT: [[TMP8:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1 +// CHECK3-NEXT: store ptr null, ptr [[TMP8]], align 4 +// CHECK3-NEXT: [[TMP9:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP10:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK3-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1:[0-9]+]], i64 -1, i32 2, ptr [[TMP9]], ptr [[TMP10]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK3-NEXT: [[TMP11:%.*]] = load ptr, ptr [[A]], align 4 // CHECK3-NEXT: [[TMP12:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 +// CHECK3-NEXT: store ptr [[TMP11]], ptr [[TMP12]], align 4 // CHECK3-NEXT: [[TMP13:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 -// CHECK3-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP12]], ptr [[TMP13]], ptr @.offload_sizes.1, ptr @.offload_maptypes.2, ptr null, ptr null) -// CHECK3-NEXT: [[TMP14:%.*]] = load ptr, ptr [[TMP9]], align 4 -// CHECK3-NEXT: store ptr [[TMP14]], ptr [[TMP0]], align 4 -// CHECK3-NEXT: [[TMP15:%.*]] = load ptr, ptr [[B]], align 4 -// CHECK3-NEXT: [[TMP16:%.*]] = load ptr, ptr [[TMP0]], align 4 -// CHECK3-NEXT: [[TMP17:%.*]] = load ptr, ptr [[B]], align 4 +// CHECK3-NEXT: store ptr [[TMP11]], ptr [[TMP13]], align 4 +// CHECK3-NEXT: [[TMP14:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_MAPPERS3]], i32 0, i32 0 +// CHECK3-NEXT: store ptr null, ptr [[TMP14]], align 4 +// CHECK3-NEXT: [[TMP15:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP16:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 +// CHECK3-NEXT: call void @__tgt_target_data_begin_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP15]], ptr [[TMP16]], ptr @.offload_sizes.1, ptr @.offload_maptypes.2, ptr null, ptr null) +// CHECK3-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP12]], align 4 +// CHECK3-NEXT: store ptr [[TMP17]], ptr [[TMP0]], align 4 // CHECK3-NEXT: [[TMP18:%.*]] = load ptr, ptr [[B]], align 4 -// CHECK3-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP18]], i32 0 -// CHECK3-NEXT: [[TMP19:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 0 -// CHECK3-NEXT: store ptr [[TMP17]], ptr [[TMP19]], align 4 -// CHECK3-NEXT: [[TMP20:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 0 -// CHECK3-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP20]], align 4 -// CHECK3-NEXT: [[TMP21:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i32 0, i32 0 -// CHECK3-NEXT: store ptr null, ptr [[TMP21]], align 4 -// CHECK3-NEXT: [[TMP22:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 1 -// CHECK3-NEXT: store ptr [[TMP16]], ptr [[TMP22]], align 4 -// CHECK3-NEXT: [[TMP23:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 1 -// CHECK3-NEXT: store ptr [[TMP16]], ptr [[TMP23]], align 4 -// CHECK3-NEXT: [[TMP24:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i32 0, i32 1 +// CHECK3-NEXT: [[TMP19:%.*]] = load ptr, ptr [[TMP0]], align 4 +// CHECK3-NEXT: [[TMP20:%.*]] = load ptr, ptr [[B]], align 4 +// CHECK3-NEXT: [[TMP21:%.*]] = load ptr, ptr [[B]], align 4 +// CHECK3-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds nuw i32, ptr [[TMP21]], i32 0 +// CHECK3-NEXT: [[TMP22:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 0 +// CHECK3-NEXT: store ptr [[TMP20]], ptr [[TMP22]], align 4 +// CHECK3-NEXT: [[TMP23:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 0 +// CHECK3-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP23]], align 4 +// CHECK3-NEXT: [[TMP24:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i32 0, i32 0 // CHECK3-NEXT: store ptr null, ptr [[TMP24]], align 4 -// CHECK3-NEXT: [[TMP25:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 0 -// CHECK3-NEXT: [[TMP26:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 0 -// CHECK3-NEXT: [[TMP27:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 -// CHECK3-NEXT: store i32 3, ptr [[TMP27]], align 4 -// CHECK3-NEXT: [[TMP28:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 -// CHECK3-NEXT: store i32 2, ptr [[TMP28]], align 4 -// CHECK3-NEXT: [[TMP29:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 -// CHECK3-NEXT: store ptr [[TMP25]], ptr [[TMP29]], align 4 -// CHECK3-NEXT: [[TMP30:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 -// CHECK3-NEXT: store ptr [[TMP26]], ptr [[TMP30]], align 4 -// CHECK3-NEXT: [[TMP31:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 -// CHECK3-NEXT: store ptr @.offload_sizes.3, ptr [[TMP31]], align 4 -// CHECK3-NEXT: [[TMP32:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 -// CHECK3-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP32]], align 4 -// CHECK3-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 -// CHECK3-NEXT: store ptr null, ptr [[TMP33]], align 4 -// CHECK3-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 -// CHECK3-NEXT: store ptr null, ptr [[TMP34]], align 4 -// CHECK3-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 -// CHECK3-NEXT: store i64 0, ptr [[TMP35]], align 8 -// CHECK3-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 -// CHECK3-NEXT: store i64 0, ptr [[TMP36]], align 8 -// CHECK3-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 -// CHECK3-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP37]], align 4 -// CHECK3-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 -// CHECK3-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP38]], align 4 -// CHECK3-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 -// CHECK3-NEXT: store i32 0, ptr [[TMP39]], align 4 -// CHECK3-NEXT: [[TMP40:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_main_l44.region_id, ptr [[KERNEL_ARGS]]) -// CHECK3-NEXT: [[TMP41:%.*]] = icmp ne i32 [[TMP40]], 0 -// CHECK3-NEXT: br i1 [[TMP41]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] +// CHECK3-NEXT: [[TMP25:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 1 +// CHECK3-NEXT: store ptr [[B]], ptr [[TMP25]], align 4 +// CHECK3-NEXT: [[TMP26:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 1 +// CHECK3-NEXT: store ptr [[ARRAYIDX4]], ptr [[TMP26]], align 4 +// CHECK3-NEXT: [[TMP27:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i32 0, i32 1 +// CHECK3-NEXT: store ptr null, ptr [[TMP27]], align 4 +// CHECK3-NEXT: [[TMP28:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 2 +// CHECK3-NEXT: store ptr [[TMP19]], ptr [[TMP28]], align 4 +// CHECK3-NEXT: [[TMP29:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 2 +// CHECK3-NEXT: store ptr [[TMP19]], ptr [[TMP29]], align 4 +// CHECK3-NEXT: [[TMP30:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_MAPPERS7]], i32 0, i32 2 +// CHECK3-NEXT: store ptr null, ptr [[TMP30]], align 4 +// CHECK3-NEXT: [[TMP31:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_BASEPTRS5]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP32:%.*]] = getelementptr inbounds [3 x ptr], ptr [[DOTOFFLOAD_PTRS6]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP33:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 0 +// CHECK3-NEXT: store i32 3, ptr [[TMP33]], align 4 +// CHECK3-NEXT: [[TMP34:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 1 +// CHECK3-NEXT: store i32 3, ptr [[TMP34]], align 4 +// CHECK3-NEXT: [[TMP35:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 2 +// CHECK3-NEXT: store ptr [[TMP31]], ptr [[TMP35]], align 4 +// CHECK3-NEXT: [[TMP36:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 3 +// CHECK3-NEXT: store ptr [[TMP32]], ptr [[TMP36]], align 4 +// CHECK3-NEXT: [[TMP37:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 4 +// CHECK3-NEXT: store ptr @.offload_sizes.3, ptr [[TMP37]], align 4 +// CHECK3-NEXT: [[TMP38:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 5 +// CHECK3-NEXT: store ptr @.offload_maptypes.4, ptr [[TMP38]], align 4 +// CHECK3-NEXT: [[TMP39:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 6 +// CHECK3-NEXT: store ptr null, ptr [[TMP39]], align 4 +// CHECK3-NEXT: [[TMP40:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 7 +// CHECK3-NEXT: store ptr null, ptr [[TMP40]], align 4 +// CHECK3-NEXT: [[TMP41:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 8 +// CHECK3-NEXT: store i64 0, ptr [[TMP41]], align 8 +// CHECK3-NEXT: [[TMP42:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 9 +// CHECK3-NEXT: store i64 0, ptr [[TMP42]], align 8 +// CHECK3-NEXT: [[TMP43:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 10 +// CHECK3-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], ptr [[TMP43]], align 4 +// CHECK3-NEXT: [[TMP44:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 11 +// CHECK3-NEXT: store [3 x i32] zeroinitializer, ptr [[TMP44]], align 4 +// CHECK3-NEXT: [[TMP45:%.*]] = getelementptr inbounds nuw [[STRUCT___TGT_KERNEL_ARGUMENTS]], ptr [[KERNEL_ARGS]], i32 0, i32 12 +// CHECK3-NEXT: store i32 0, ptr [[TMP45]], align 4 +// CHECK3-NEXT: [[TMP46:%.*]] = call i32 @__tgt_target_kernel(ptr @[[GLOB1]], i64 -1, i32 -1, i32 0, ptr @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_main_l44.region_id, ptr [[KERNEL_ARGS]]) +// CHECK3-NEXT: [[TMP47:%.*]] = icmp ne i32 [[TMP46]], 0 +// CHECK3-NEXT: br i1 [[TMP47]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]] // CHECK3: omp_offload.failed: -// CHECK3-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_main_l44(ptr [[TMP15]], ptr [[TMP16]]) #[[ATTR1:[0-9]+]] +// CHECK3-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_main_l44(ptr [[TMP18]], ptr [[TMP19]]) #[[ATTR1:[0-9]+]] // CHECK3-NEXT: br label [[OMP_OFFLOAD_CONT]] // CHECK3: omp_offload.cont: -// CHECK3-NEXT: [[TMP42:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 -// CHECK3-NEXT: [[TMP43:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 -// CHECK3-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP42]], ptr [[TMP43]], ptr @.offload_sizes.1, ptr @.offload_maptypes.2, ptr null, ptr null) -// CHECK3-NEXT: [[TMP44:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 -// CHECK3-NEXT: [[TMP45:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 -// CHECK3-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP44]], ptr [[TMP45]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) +// CHECK3-NEXT: [[TMP48:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_BASEPTRS1]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP49:%.*]] = getelementptr inbounds [1 x ptr], ptr [[DOTOFFLOAD_PTRS2]], i32 0, i32 0 +// CHECK3-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 1, ptr [[TMP48]], ptr [[TMP49]], ptr @.offload_sizes.1, ptr @.offload_maptypes.2, ptr null, ptr null) +// CHECK3-NEXT: [[TMP50:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0 +// CHECK3-NEXT: [[TMP51:%.*]] = getelementptr inbounds [2 x ptr], ptr [[DOTOFFLOAD_PTRS]], i32 0, i32 0 +// CHECK3-NEXT: call void @__tgt_target_data_end_mapper(ptr @[[GLOB1]], i64 -1, i32 2, ptr [[TMP50]], ptr [[TMP51]], ptr @.offload_sizes, ptr @.offload_maptypes, ptr null, ptr null) // CHECK3-NEXT: ret i32 0 // // @@ -460,42 +511,42 @@ int main() { // CHECK3-NEXT: [[TMP6:%.*]] = getelementptr inbounds nuw [[STRUCT_KMP_TASK_T]], ptr [[TMP4]], i32 0, i32 0 // CHECK3-NEXT: [[TMP7:%.*]] = load ptr, ptr [[TMP6]], align 4 // CHECK3-NEXT: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT_KMP_TASK_T_WITH_PRIVATES]], ptr [[TMP3]], i32 0, i32 1 -// CHECK3-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META5:![0-9]+]]) -// CHECK3-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META8:![0-9]+]]) -// CHECK3-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META10:![0-9]+]]) -// CHECK3-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META12:![0-9]+]]) -// CHECK3-NEXT: store i32 [[TMP2]], ptr [[DOTGLOBAL_TID__ADDR_I]], align 4, !noalias [[META14:![0-9]+]] -// CHECK3-NEXT: store ptr [[TMP5]], ptr [[DOTPART_ID__ADDR_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: store ptr [[TMP8]], ptr [[DOTPRIVATES__ADDR_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: store ptr @.omp_task_privates_map., ptr [[DOTCOPY_FN__ADDR_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: store ptr [[TMP3]], ptr [[DOTTASK_T__ADDR_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: store ptr [[TMP7]], ptr [[__CONTEXT_ADDR_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: [[TMP9:%.*]] = load ptr, ptr [[__CONTEXT_ADDR_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: [[TMP10:%.*]] = load ptr, ptr [[DOTCOPY_FN__ADDR_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: [[TMP11:%.*]] = load ptr, ptr [[DOTPRIVATES__ADDR_I]], align 4, !noalias [[META14]] +// CHECK3-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META6:![0-9]+]]) +// CHECK3-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META9:![0-9]+]]) +// CHECK3-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META11:![0-9]+]]) +// CHECK3-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META13:![0-9]+]]) +// CHECK3-NEXT: store i32 [[TMP2]], ptr [[DOTGLOBAL_TID__ADDR_I]], align 4, !noalias [[META15:![0-9]+]] +// CHECK3-NEXT: store ptr [[TMP5]], ptr [[DOTPART_ID__ADDR_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: store ptr [[TMP8]], ptr [[DOTPRIVATES__ADDR_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: store ptr @.omp_task_privates_map., ptr [[DOTCOPY_FN__ADDR_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: store ptr [[TMP3]], ptr [[DOTTASK_T__ADDR_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: store ptr [[TMP7]], ptr [[__CONTEXT_ADDR_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: [[TMP9:%.*]] = load ptr, ptr [[__CONTEXT_ADDR_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: [[TMP10:%.*]] = load ptr, ptr [[DOTCOPY_FN__ADDR_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: [[TMP11:%.*]] = load ptr, ptr [[DOTPRIVATES__ADDR_I]], align 4, !noalias [[META15]] // CHECK3-NEXT: call void [[TMP10]](ptr [[TMP11]], ptr [[DOTFIRSTPRIV_PTR_ADDR_I]]) #[[ATTR1]] -// CHECK3-NEXT: [[TMP12:%.*]] = load ptr, ptr [[DOTFIRSTPRIV_PTR_ADDR_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: store i32 0, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK3-NEXT: [[TMP12:%.*]] = load ptr, ptr [[DOTFIRSTPRIV_PTR_ADDR_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: store i32 0, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK3-NEXT: br label [[FOR_COND_I:%.*]] // CHECK3: for.cond.i: -// CHECK3-NEXT: [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK3-NEXT: [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK3-NEXT: [[CMP_I:%.*]] = icmp slt i32 [[TMP13]], 1024 // CHECK3-NEXT: br i1 [[CMP_I]], label [[FOR_BODY_I:%.*]], label [[DOTOMP_OUTLINED__EXIT:%.*]] // CHECK3: for.body.i: // CHECK3-NEXT: [[TMP14:%.*]] = load ptr, ptr [[TMP12]], align 4 -// CHECK3-NEXT: [[TMP15:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK3-NEXT: [[TMP15:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK3-NEXT: [[ARRAYIDX_I:%.*]] = getelementptr inbounds i32, ptr [[TMP14]], i32 [[TMP15]] // CHECK3-NEXT: [[TMP16:%.*]] = load i32, ptr [[ARRAYIDX_I]], align 4 // CHECK3-NEXT: [[MUL_I:%.*]] = mul nsw i32 2, [[TMP16]] -// CHECK3-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP9]], align 4 +// CHECK3-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP9]], align 4, !nonnull [[META16:![0-9]+]], !align [[META17:![0-9]+]] // CHECK3-NEXT: [[TMP18:%.*]] = load ptr, ptr [[TMP17]], align 4 -// CHECK3-NEXT: [[TMP19:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK3-NEXT: [[TMP19:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK3-NEXT: [[ARRAYIDX1_I:%.*]] = getelementptr inbounds i32, ptr [[TMP18]], i32 [[TMP19]] // CHECK3-NEXT: store i32 [[MUL_I]], ptr [[ARRAYIDX1_I]], align 4 -// CHECK3-NEXT: [[TMP20:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK3-NEXT: [[TMP20:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK3-NEXT: [[INC_I:%.*]] = add nsw i32 [[TMP20]], 1 -// CHECK3-NEXT: store i32 [[INC_I]], ptr [[I_I]], align 4, !noalias [[META14]] -// CHECK3-NEXT: br label [[FOR_COND_I]], !llvm.loop [[LOOP15:![0-9]+]] +// CHECK3-NEXT: store i32 [[INC_I]], ptr [[I_I]], align 4, !noalias [[META15]] +// CHECK3-NEXT: br label [[FOR_COND_I]], !llvm.loop [[LOOP18:![0-9]+]] // CHECK3: .omp_outlined..exit: // CHECK3-NEXT: ret i32 0 // @@ -650,44 +701,44 @@ int main() { // CHECK9-NEXT: [[TMP6:%.*]] = getelementptr inbounds nuw [[STRUCT_KMP_TASK_T]], ptr [[TMP4]], i32 0, i32 0 // CHECK9-NEXT: [[TMP7:%.*]] = load ptr, ptr [[TMP6]], align 8 // CHECK9-NEXT: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT_KMP_TASK_T_WITH_PRIVATES]], ptr [[TMP3]], i32 0, i32 1 -// CHECK9-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META5:![0-9]+]]) -// CHECK9-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META8:![0-9]+]]) -// CHECK9-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META10:![0-9]+]]) -// CHECK9-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META12:![0-9]+]]) -// CHECK9-NEXT: store i32 [[TMP2]], ptr [[DOTGLOBAL_TID__ADDR_I]], align 4, !noalias [[META14:![0-9]+]] -// CHECK9-NEXT: store ptr [[TMP5]], ptr [[DOTPART_ID__ADDR_I]], align 8, !noalias [[META14]] -// CHECK9-NEXT: store ptr [[TMP8]], ptr [[DOTPRIVATES__ADDR_I]], align 8, !noalias [[META14]] -// CHECK9-NEXT: store ptr @.omp_task_privates_map., ptr [[DOTCOPY_FN__ADDR_I]], align 8, !noalias [[META14]] -// CHECK9-NEXT: store ptr [[TMP3]], ptr [[DOTTASK_T__ADDR_I]], align 8, !noalias [[META14]] -// CHECK9-NEXT: store ptr [[TMP7]], ptr [[__CONTEXT_ADDR_I]], align 8, !noalias [[META14]] -// CHECK9-NEXT: [[TMP9:%.*]] = load ptr, ptr [[__CONTEXT_ADDR_I]], align 8, !noalias [[META14]] -// CHECK9-NEXT: [[TMP10:%.*]] = load ptr, ptr [[DOTCOPY_FN__ADDR_I]], align 8, !noalias [[META14]] -// CHECK9-NEXT: [[TMP11:%.*]] = load ptr, ptr [[DOTPRIVATES__ADDR_I]], align 8, !noalias [[META14]] +// CHECK9-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META6:![0-9]+]]) +// CHECK9-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META9:![0-9]+]]) +// CHECK9-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META11:![0-9]+]]) +// CHECK9-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META13:![0-9]+]]) +// CHECK9-NEXT: store i32 [[TMP2]], ptr [[DOTGLOBAL_TID__ADDR_I]], align 4, !noalias [[META15:![0-9]+]] +// CHECK9-NEXT: store ptr [[TMP5]], ptr [[DOTPART_ID__ADDR_I]], align 8, !noalias [[META15]] +// CHECK9-NEXT: store ptr [[TMP8]], ptr [[DOTPRIVATES__ADDR_I]], align 8, !noalias [[META15]] +// CHECK9-NEXT: store ptr @.omp_task_privates_map., ptr [[DOTCOPY_FN__ADDR_I]], align 8, !noalias [[META15]] +// CHECK9-NEXT: store ptr [[TMP3]], ptr [[DOTTASK_T__ADDR_I]], align 8, !noalias [[META15]] +// CHECK9-NEXT: store ptr [[TMP7]], ptr [[__CONTEXT_ADDR_I]], align 8, !noalias [[META15]] +// CHECK9-NEXT: [[TMP9:%.*]] = load ptr, ptr [[__CONTEXT_ADDR_I]], align 8, !noalias [[META15]] +// CHECK9-NEXT: [[TMP10:%.*]] = load ptr, ptr [[DOTCOPY_FN__ADDR_I]], align 8, !noalias [[META15]] +// CHECK9-NEXT: [[TMP11:%.*]] = load ptr, ptr [[DOTPRIVATES__ADDR_I]], align 8, !noalias [[META15]] // CHECK9-NEXT: call void [[TMP10]](ptr [[TMP11]], ptr [[DOTFIRSTPRIV_PTR_ADDR_I]]) #[[ATTR3:[0-9]+]] -// CHECK9-NEXT: [[TMP12:%.*]] = load ptr, ptr [[DOTFIRSTPRIV_PTR_ADDR_I]], align 8, !noalias [[META14]] -// CHECK9-NEXT: store i32 0, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK9-NEXT: [[TMP12:%.*]] = load ptr, ptr [[DOTFIRSTPRIV_PTR_ADDR_I]], align 8, !noalias [[META15]] +// CHECK9-NEXT: store i32 0, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK9-NEXT: br label [[FOR_COND_I:%.*]] // CHECK9: for.cond.i: -// CHECK9-NEXT: [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK9-NEXT: [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK9-NEXT: [[CMP_I:%.*]] = icmp slt i32 [[TMP13]], 1024 // CHECK9-NEXT: br i1 [[CMP_I]], label [[FOR_BODY_I:%.*]], label [[DOTOMP_OUTLINED__EXIT:%.*]] // CHECK9: for.body.i: // CHECK9-NEXT: [[TMP14:%.*]] = load ptr, ptr [[TMP12]], align 8 -// CHECK9-NEXT: [[TMP15:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK9-NEXT: [[TMP15:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK9-NEXT: [[IDXPROM_I:%.*]] = sext i32 [[TMP15]] to i64 // CHECK9-NEXT: [[ARRAYIDX_I:%.*]] = getelementptr inbounds i32, ptr [[TMP14]], i64 [[IDXPROM_I]] // CHECK9-NEXT: [[TMP16:%.*]] = load i32, ptr [[ARRAYIDX_I]], align 4 // CHECK9-NEXT: [[MUL_I:%.*]] = mul nsw i32 2, [[TMP16]] -// CHECK9-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP9]], align 8 +// CHECK9-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP9]], align 8, !nonnull [[META16:![0-9]+]], !align [[META17:![0-9]+]] // CHECK9-NEXT: [[TMP18:%.*]] = load ptr, ptr [[TMP17]], align 8 -// CHECK9-NEXT: [[TMP19:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK9-NEXT: [[TMP19:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK9-NEXT: [[IDXPROM1_I:%.*]] = sext i32 [[TMP19]] to i64 // CHECK9-NEXT: [[ARRAYIDX2_I:%.*]] = getelementptr inbounds i32, ptr [[TMP18]], i64 [[IDXPROM1_I]] // CHECK9-NEXT: store i32 [[MUL_I]], ptr [[ARRAYIDX2_I]], align 4 -// CHECK9-NEXT: [[TMP20:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META14]] +// CHECK9-NEXT: [[TMP20:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] // CHECK9-NEXT: [[INC_I:%.*]] = add nsw i32 [[TMP20]], 1 -// CHECK9-NEXT: store i32 [[INC_I]], ptr [[I_I]], align 4, !noalias [[META14]] -// CHECK9-NEXT: br label [[FOR_COND_I]], !llvm.loop [[LOOP15:![0-9]+]] +// CHECK9-NEXT: store i32 [[INC_I]], ptr [[I_I]], align 4, !noalias [[META15]] +// CHECK9-NEXT: br label [[FOR_COND_I]], !llvm.loop [[LOOP18:![0-9]+]] // CHECK9: .omp_outlined..exit: // CHECK9-NEXT: ret i32 0 // @@ -772,42 +823,42 @@ int main() { // CHECK11-NEXT: [[TMP6:%.*]] = getelementptr inbounds nuw [[STRUCT_KMP_TASK_T]], ptr [[TMP4]], i32 0, i32 0 // CHECK11-NEXT: [[TMP7:%.*]] = load ptr, ptr [[TMP6]], align 4 // CHECK11-NEXT: [[TMP8:%.*]] = getelementptr inbounds nuw [[STRUCT_KMP_TASK_T_WITH_PRIVATES]], ptr [[TMP3]], i32 0, i32 1 -// CHECK11-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META6:![0-9]+]]) -// CHECK11-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META9:![0-9]+]]) -// CHECK11-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META11:![0-9]+]]) -// CHECK11-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META13:![0-9]+]]) -// CHECK11-NEXT: store i32 [[TMP2]], ptr [[DOTGLOBAL_TID__ADDR_I]], align 4, !noalias [[META15:![0-9]+]] -// CHECK11-NEXT: store ptr [[TMP5]], ptr [[DOTPART_ID__ADDR_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: store ptr [[TMP8]], ptr [[DOTPRIVATES__ADDR_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: store ptr @.omp_task_privates_map., ptr [[DOTCOPY_FN__ADDR_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: store ptr [[TMP3]], ptr [[DOTTASK_T__ADDR_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: store ptr [[TMP7]], ptr [[__CONTEXT_ADDR_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: [[TMP9:%.*]] = load ptr, ptr [[__CONTEXT_ADDR_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: [[TMP10:%.*]] = load ptr, ptr [[DOTCOPY_FN__ADDR_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: [[TMP11:%.*]] = load ptr, ptr [[DOTPRIVATES__ADDR_I]], align 4, !noalias [[META15]] +// CHECK11-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META7:![0-9]+]]) +// CHECK11-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META10:![0-9]+]]) +// CHECK11-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META12:![0-9]+]]) +// CHECK11-NEXT: call void @llvm.experimental.noalias.scope.decl(metadata [[META14:![0-9]+]]) +// CHECK11-NEXT: store i32 [[TMP2]], ptr [[DOTGLOBAL_TID__ADDR_I]], align 4, !noalias [[META16:![0-9]+]] +// CHECK11-NEXT: store ptr [[TMP5]], ptr [[DOTPART_ID__ADDR_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: store ptr [[TMP8]], ptr [[DOTPRIVATES__ADDR_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: store ptr @.omp_task_privates_map., ptr [[DOTCOPY_FN__ADDR_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: store ptr [[TMP3]], ptr [[DOTTASK_T__ADDR_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: store ptr [[TMP7]], ptr [[__CONTEXT_ADDR_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: [[TMP9:%.*]] = load ptr, ptr [[__CONTEXT_ADDR_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: [[TMP10:%.*]] = load ptr, ptr [[DOTCOPY_FN__ADDR_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: [[TMP11:%.*]] = load ptr, ptr [[DOTPRIVATES__ADDR_I]], align 4, !noalias [[META16]] // CHECK11-NEXT: call void [[TMP10]](ptr [[TMP11]], ptr [[DOTFIRSTPRIV_PTR_ADDR_I]]) #[[ATTR3:[0-9]+]] -// CHECK11-NEXT: [[TMP12:%.*]] = load ptr, ptr [[DOTFIRSTPRIV_PTR_ADDR_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: store i32 0, ptr [[I_I]], align 4, !noalias [[META15]] +// CHECK11-NEXT: [[TMP12:%.*]] = load ptr, ptr [[DOTFIRSTPRIV_PTR_ADDR_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: store i32 0, ptr [[I_I]], align 4, !noalias [[META16]] // CHECK11-NEXT: br label [[FOR_COND_I:%.*]] // CHECK11: for.cond.i: -// CHECK11-NEXT: [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] +// CHECK11-NEXT: [[TMP13:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META16]] // CHECK11-NEXT: [[CMP_I:%.*]] = icmp slt i32 [[TMP13]], 1024 // CHECK11-NEXT: br i1 [[CMP_I]], label [[FOR_BODY_I:%.*]], label [[DOTOMP_OUTLINED__EXIT:%.*]] // CHECK11: for.body.i: // CHECK11-NEXT: [[TMP14:%.*]] = load ptr, ptr [[TMP12]], align 4 -// CHECK11-NEXT: [[TMP15:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] +// CHECK11-NEXT: [[TMP15:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META16]] // CHECK11-NEXT: [[ARRAYIDX_I:%.*]] = getelementptr inbounds i32, ptr [[TMP14]], i32 [[TMP15]] // CHECK11-NEXT: [[TMP16:%.*]] = load i32, ptr [[ARRAYIDX_I]], align 4 // CHECK11-NEXT: [[MUL_I:%.*]] = mul nsw i32 2, [[TMP16]] -// CHECK11-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP9]], align 4 +// CHECK11-NEXT: [[TMP17:%.*]] = load ptr, ptr [[TMP9]], align 4, !nonnull [[META17:![0-9]+]], !align [[META18:![0-9]+]] // CHECK11-NEXT: [[TMP18:%.*]] = load ptr, ptr [[TMP17]], align 4 -// CHECK11-NEXT: [[TMP19:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] +// CHECK11-NEXT: [[TMP19:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META16]] // CHECK11-NEXT: [[ARRAYIDX1_I:%.*]] = getelementptr inbounds i32, ptr [[TMP18]], i32 [[TMP19]] // CHECK11-NEXT: store i32 [[MUL_I]], ptr [[ARRAYIDX1_I]], align 4 -// CHECK11-NEXT: [[TMP20:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META15]] +// CHECK11-NEXT: [[TMP20:%.*]] = load i32, ptr [[I_I]], align 4, !noalias [[META16]] // CHECK11-NEXT: [[INC_I:%.*]] = add nsw i32 [[TMP20]], 1 -// CHECK11-NEXT: store i32 [[INC_I]], ptr [[I_I]], align 4, !noalias [[META15]] -// CHECK11-NEXT: br label [[FOR_COND_I]], !llvm.loop [[LOOP16:![0-9]+]] +// CHECK11-NEXT: store i32 [[INC_I]], ptr [[I_I]], align 4, !noalias [[META16]] +// CHECK11-NEXT: br label [[FOR_COND_I]], !llvm.loop [[LOOP19:![0-9]+]] // CHECK11: .omp_outlined..exit: // CHECK11-NEXT: ret i32 0 // diff --git a/clang/test/OpenMP/target_update_codegen.cpp b/clang/test/OpenMP/target_update_codegen.cpp index c8211f475c7fc..8d160eceb7d7d 100644 --- a/clang/test/OpenMP/target_update_codegen.cpp +++ b/clang/test/OpenMP/target_update_codegen.cpp @@ -43,8 +43,8 @@ double gc[100]; // CK1: [[MTYPE03:@.+]] = {{.+}}constant [1 x i64] [i64 2] -// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] +// CK1: [[SIZE04:@.+]] = {{.+}}constant [1 x i64] [i64 24] +// CK1: [[MTYPE04:@.+]] = {{.+}}constant [1 x i64] [i64 1] // CK1-LABEL: _Z3fooi void foo(int arg) { @@ -123,26 +123,20 @@ void foo(int arg) { {++arg;} // Region 04 - // CK1-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%[^,]+]], ptr [[MTYPE04]]{{.+}}, ptr null) + + // &gb.b[0], &gb.b[0], 3 * sizeof(gb.b[0]), TO + + // CK1-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE04]], ptr [[MTYPE04]]{{.+}}, ptr null) // CK1-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK1-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK1-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]] // CK1-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK1-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK1-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 - // CK1-DAG: store ptr @gb, ptr [[BP0]] - // CK1-DAG: store ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), ptr [[P0]] - // CK1-DAG: [[DIV:%.+]] = sdiv exact i64 sub (i64 ptrtoint (ptr getelementptr (ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), i32 1) to i64), i64 ptrtoint (ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) to i64)), ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) - // CK1-DAG: store i64 [[DIV]], ptr [[PS0]], - - - // CK1-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK1-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK1-DAG: store ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), ptr [[BP1]] - // CK1-DAG: store ptr [[VAL1:%[^,]+]], ptr [[P1]] - // CK1-DAG: [[VAL1]] = getelementptr inbounds {{.+}}ptr [[SEC11:%.+]], i{{.+}} 0 - // CK1-DAG: [[SEC11]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1), + // CK1-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK1-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK1-DAG: [[VAR0]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1) + // CK1-DAG: [[SEC0]] = getelementptr inbounds nuw double, ptr [[SEC00:%.+]], i{{.*}} 0 + // CK1-DAG: [[SEC00]] = load ptr, ptr getelementptr inbounds nuw ([[ST]], ptr @gb, i32 0, i32 1) // CK1: %{{.+}} = add nsw i32 %{{[^,]+}}, 1 // CK1-NOT: __tgt_target_data_end @@ -190,8 +184,8 @@ struct ST { } }; -// CK2: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK2: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710674] +// CK2: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 24] +// CK2: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 2] // CK2-LABEL: _Z3bari int bar(int arg){ @@ -200,31 +194,26 @@ int bar(int arg){ } // Region 00 + +// &b[0], &b[1], 3 * sizeof(b[0]), FROM + // CK2: br i1 %{{[^,]+}}, label %[[IFTHEN:[^,]+]], label %[[IFELSE:[^,]+]] // CK2: [[IFTHEN]] -// CK2-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GEPS:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) +// CK2-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 [[DEV:%[^,]+]], i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK2-DAG: [[DEV]] = sext i32 [[DEVi32:%[^,]+]] to i64 // CK2-DAG: [[DEVi32]] = load i32, ptr %{{[^,]+}}, // CK2-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK2-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] -// CK2-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]] // CK2-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK2-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 -// CK2-DAG: [[PS0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i{{.+}} 0, i{{.+}} 0 // CK2-DAG: store ptr [[VAR0:%[^,]+]], ptr [[BP0]] // CK2-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] -// CK2-DAG: store i64 {{%.+}}, ptr [[PS0]], -// CK2-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 - - -// CK2-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 -// CK2-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 -// CK2-DAG: store ptr [[CBPVAL1:%[^,]+]], ptr [[BP1]] -// CK2-DAG: store ptr [[SEC1:%[^,]+]], ptr [[P1]] -// CK2-DAG: [[SEC1]] = getelementptr inbounds {{.*}}ptr [[SEC11:%[^,]+]], i{{.+}} 1 -// CK2-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], -// CK2-DAG: [[SEC111]] = getelementptr inbounds {{.*}}ptr [[VAR0]], i32 0, i32 1 +// CK2-DAG: [[VAR0]] = load ptr, ptr [[VAR00:%[^,]+]], +// CK2-DAG: [[VAR00]] = getelementptr inbounds {{.*}}ptr [[THIS:%.+]], i32 0, i32 1 +// CK2-DAG: [[SEC0]] = getelementptr inbounds {{.*}}ptr [[SEC00:%[^,]+]], i{{.+}} 1 +// CK2-DAG: [[SEC00]] = load ptr, ptr [[SEC000:%[^,]+]], +// CK2-DAG: [[SEC000]] = getelementptr inbounds {{.*}}ptr [[THIS]], i32 0, i32 1 // CK2: br label %[[IFEND:[^,]+]] @@ -456,31 +445,35 @@ void lvalue(int *B, int l, int e) { // SIMD-ONLY0-NOT: {{__kmpc|__tgt}} #ifdef CK8 -// CK8: [[SIZE00:@.+]] = {{.+}}constant [2 x i[[sz:64|32]]] [i{{64|32}} {{8|4}}, i{{64|32}} 4] -// CK8: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 1, i64 17] + +// &(B+l)[1][0], &(B+l)[1][2], sizeof((B+l)[1][2]), TO + +// CK8: [[SIZE00:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4] +// CK8: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 1] // CK8-LABEL: lvalue void lvalue(int **B, int l, int e) { - // CK8-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK8-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK8-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK8-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK8-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK8-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK8-DAG: store ptr [[ARRAY_IDX_1:%.+]], ptr [[BP0]] + // CK8-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 + // CK8-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 + // CK8-DAG: store ptr [[ARRAY_IDX_1_VAL:%.+]], ptr [[BP0]] // CK8-DAG: store ptr [[ARRAY_IDX_4:%.+]], ptr [[P0]] - // CK8-DAG: store ptr [[ARRAY_IDX_1]], ptr [[NINE:%.+]] + // CK8-DAG: [[ARRAY_IDX_1_VAL]] = load ptr, ptr [[ARRAY_IDX_1:%[^,]+]] // CK8-DAG: [[ARRAY_IDX_1]] = getelementptr inbounds ptr, ptr [[ADD_PTR:%.+]], i{{.+}} 1 // CK8-64-DAG: [[ADD_PTR]] = getelementptr inbounds ptr, ptr [[B_VAL:%.+]], i{{.+}} [[IDX_EXT:%.+]] // CK8-64-DAG: [[IDX_EXT]] = sext i32 [[L_VAL:%.+]] to i64 // CK8-DAG: [[ARRAY_IDX_4]] = getelementptr inbounds i32, ptr [[FIVE:%.+]], i{{.+}} 2 + // CK8-DAG: [[FIVE]] = load ptr, ptr [[ARRAY_IDX_3:%.+]], // CK8-64-DAG: [[ARRAY_IDX_3:%.+]] = getelementptr inbounds ptr, ptr [[ADD_PTR_2:%.+]], i{{.+}} 1 - // CK8-64-DAG: [[ADD_PTR_2]] = getelementptr inbounds ptr, ptr %3, i{{.+}} [[IDX_EXT_1:%.+]] + // CK8-64-DAG: [[ADD_PTR_2]] = getelementptr inbounds ptr, ptr [[B_VAL:%.+]], i{{.+}} [[IDX_EXT_1:%.+]] // CK8-64-DAG: [[IDX_EXT_1]] = sext i32 [[L_VAL:%.+]] to i{{.+}} // CK8-32-DAG: [[ADD_PTR]] = getelementptr inbounds ptr, ptr [[B_VAL:%.+]], i{{.+}} [[L_VAL:%.+]] // CK8-32-DAG: [[ARRAY_IDX_4:%.+]] = getelementptr inbounds ptr, ptr [[ADD_PTR_2:%.+]], i{{.+}} 1 - // CK8-32-DAG: [[ADD_PTR_2]] = getelementptr inbounds ptr, ptr %3, i{{.+}} [[L_VAL:%.+]] + // CK8-32-DAG: [[ADD_PTR_2]] = getelementptr inbounds ptr, ptr [[B_VAL:%.+]], i{{.+}} [[L_VAL:%.+]] #pragma omp target update to((B+l)[1][2]) (B+l)[1][2] += e; #pragma omp target update from((B+l)[1][2]) @@ -509,26 +502,28 @@ struct S { double *p; }; -// CK9: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 8] -// CK9: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] +// &(s->p[0]), &(s->p[0]), sizeof(s->p[0]), TO + +// CK9: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 8] +// CK9: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 1] // CK9-LABEL: lvalue void lvalue(struct S *s, int l, int e) { - // CK9-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GSIZE:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK9-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK9-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK9-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK9-DAG: [[GSIZE]] = getelementptr inbounds {{.+}}[[SIZE:%[^,]+]] // - // CK9-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK9-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK9-DAG: store ptr [[P:%.+]], ptr [[BP0]] - // CK9-DAG: store ptr [[P_VAL:%.+]], ptr [[P0]] + // CK9-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 + // CK9-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 + // CK9-DAG: store ptr [[P_VAL:%.+]], ptr [[BP0]] + // CK9-DAG: store ptr [[P_VAL_1:%.+]], ptr [[P0]] + // CK9-DAG: [[P_VAL]] = load ptr, ptr [[P:%.+]], // CK9-DAG: [[P]] = getelementptr inbounds nuw [[STRUCT_S:%.+]], ptr [[S_VAL:%.+]], i32 0, i32 0 // CK9-DAG: [[S_VAL]] = load ptr, ptr [[S_ADDR:%.+]] - // CK9-DAG: [[P_VAL]] = load ptr, ptr [[P_1:%.+]], + // CK9-DAG: [[P_VAL_1]] = load ptr, ptr [[P_1:%.+]], // CK9-DAG: [[P_1]] = getelementptr inbounds nuw [[STRUCT_S]], ptr [[S_VAL_2:%.+]], i32 0, i32 0 - // CK9-DAG: [[S_VAL_2]] = load ptr, ptr [[S_ADDR:%.+]] + // CK9-DAG: [[S_VAL_2]] = load ptr, ptr [[S_ADDR]] #pragma omp target update to(*(s->p)) *(s->p) += e; #pragma omp target update from(*(s->p)) @@ -556,27 +551,31 @@ struct S { double *p; }; -// CK10: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 8] -// CK10: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] +// &((s->p + l)[0]), &((s->p + l)[0]), sizeof((s->p + l)[0]), TO + +// CK10: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 8] +// CK10: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 1] // CK10-LABEL: lvalue void lvalue(struct S *s, int l, int e) { - // CK10-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GSIZE:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK10-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK10-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK10-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK10-DAG: [[GSIZE]] = getelementptr inbounds {{.+}}[[SIZE:%[^,]+]] // - // CK10-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK10-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK10-DAG: store ptr [[P_VAL:%.+]], ptr [[BP0]] + // CK10-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 + // CK10-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 + // CK10-DAG: store ptr [[S_P:%.+]], ptr [[BP0]] // CK10-DAG: store ptr [[ADD_PTR:%.+]], ptr [[P0]] - // CK10-64-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[S_P:%.+]], i{{.+}} [[IDX_EXT:%.+]] - // CK10-32-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[S_P:%.+]], i{{.+}} [[L_VAL:%.+]] + // CK10-DAG: [[S_P]] = load ptr, ptr [[P_VAL:%.+]] + // CK10-DAG: getelementptr inbounds {{.+}}, ptr [[SS:%.+]], i32 0, i32 0 + // CK10-DAG: [[SS]] = load ptr, ptr [[S_ADDR:%.+]] + // CK10-64-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[S_P_1:%.+]], i{{.+}} [[IDX_EXT:%.+]] + // CK10-32-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[S_P_1:%.+]], i{{.+}} [[L_VAL:%.+]] // CK10-64-DAG: [[IDX_EXT]] = sext i32 [[L_VAL:%.+]] to i64 - // CK10-DAG: [[S_P]] = load ptr, ptr [[P_VAL_1:%.+]] + // CK10-DAG: [[S_P_1]] = load ptr, ptr [[P_VAL_1:%.+]] // CK10-DAG: getelementptr inbounds {{.+}}, ptr [[SS_1:%.+]], i32 0, i32 0 - // CK10-DAG: [[SS_1]] = load ptr, ptr [[S_ADDR:%.+]] + // CK10-DAG: [[SS_1]] = load ptr, ptr [[S_ADDR]] #pragma omp target update to(*(s->p+l)) *(s->p+l) += e; #pragma omp target update from(*(s->p+l)) @@ -603,21 +602,24 @@ void lvalue(struct S *s, int l, int e) { struct S { double *p; }; -// CK11: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 8] -// CK11: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] + +// &((s->p + l)[0]), &((s->p + l)[3]), sizeof((s->p + l)[3]), TO + +// CK11: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 8] +// CK11: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 1] // CK11-LABEL: lvalue void lvalue(struct S *s, int l, int e) { - // CK11-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GSIZE:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK11-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK11-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK11-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK11-DAG: [[GSIZE]] = getelementptr inbounds {{.+}}[[SIZE:%[^,]+]] // - // CK11-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK11-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK11-DAG: store ptr [[P:%.+]], ptr [[BP0]] + // CK11-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 + // CK11-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 + // CK11-DAG: store ptr [[S_P:%.+]], ptr [[BP0]] // CK11-DAG: store ptr [[ARRAY_IDX:%.+]], ptr [[P0]] + // CK11-DAG: [[S_P]] = load ptr, ptr [[P:%.+]], // CK11-DAG: [[P]] = getelementptr inbounds nuw [[STRUCT_S:%.+]], ptr [[SS_1:%.+]], i32 0, i32 0 // CK11-DAG: [[ARRAY_IDX]] = getelementptr inbounds double, ptr [[ADD_PTR:%.+]], i{{.+}} 3 // CK11-64-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[S_P:%.+]], i{{.+}} [[IDX_EXT:%.+]] @@ -652,35 +654,33 @@ struct S { double *p; struct S *sp; }; -// CK12: [[SIZE00:@.+]] = {{.+}}constant [3 x i64] [i64 0, i64 {{4|8}}, i64 8] -// CK12: [[MTYPE00:@.+]] = {{.+}}constant [3 x i64] [i64 0, i64 281474976710672, i64 17] + +// &((s->sp->p)[0]), &((s->sp->p)[0]), sizeof((s->sp->p)[0]), TO + +// CK12: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 8] +// CK12: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 1] // CK12-LABEL: lvalue void lvalue(struct S *s, int l, int e) { - // CK12-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 3, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GSIZE:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK12-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK12-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK12-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK12-DAG: [[GSIZE]] = getelementptr inbounds {{.+}}[[SIZE:%[^,]+]] // - // CK12-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 - // CK12-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK12-DAG: store ptr [[P_VAL:%.+]], ptr [[BP2]] - // CK12-DAG: store ptr [[SIX:%.+]], ptr [[P2]] - // CK12-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK12-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK12-DAG: store ptr [[SP:%.+]], ptr [[BP1]] - // CK12-DAG: store ptr [[P_VAL:%.+]], ptr [[P1]] // CK12-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK12-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK12-DAG: [[SIZE0:%.+]] = getelementptr inbounds {{.+}}[[SIZE]], i{{.+}} 0, i{{.+}} 0 - // CK12-DAG: store ptr [[ZERO:%.+]], ptr [[BP0]] - // CK12-DAG: store ptr [[SP]], ptr [[P0]] - // CK12-DAG: store ptr [[S:%.+]], ptr [[S_VAL:%.+]] - // CK12-DAG: store i{{.+}} {{.+}}, ptr [[SIZE0]] - // CK12-DAG: [[SP]] = getelementptr inbounds nuw [[STRUCT_S:%.+]], ptr [[ONE:%.+]], i32 0, i32 1 - // CK12-DAG: [[ONE]] = load ptr, ptr [[S:%.+]], - // CK12-DAG: [[ZERO]] = load ptr, ptr [[S]], + // CK12-DAG: store ptr [[PVAL:%.+]], ptr [[BP0]] + // CK12-DAG: store ptr [[PVAL1:%.+]], ptr [[P0]] + // CK12-DAG: [[PVAL]] = load ptr, ptr [[P:%[^,]+]] + // CK12-DAG: [[P]] = getelementptr inbounds nuw %struct.S, ptr [[SPVAL:%.+]], i32 0, i32 0 + // CK12-DAG: [[SPVAL]] = load ptr, ptr [[SP:%[^,]+]] + // CK12-DAG: [[SP]] = getelementptr inbounds nuw %struct.S, ptr [[SADDRVAL:%.+]], i32 0, i32 1 + // CK12-DAG: [[SADDRVAL]] = load ptr, ptr %s.addr + // CK12-DAG: [[PVAL1]] = load ptr, ptr [[P1:%[^,]+]] + // CK12-DAG: [[P1]] = getelementptr inbounds nuw %struct.S, ptr [[SPVAL1:%.+]], i32 0, i32 0 + // CK12-DAG: [[SPVAL1]] = load ptr, ptr [[SP1:%[^,]+]] + // CK12-DAG: [[SP1]] = getelementptr inbounds nuw %struct.S, ptr [[SADDRVAL1:%.+]], i32 0, i32 1 + // CK12-DAG: [[SADDRVAL1]] = load ptr, ptr %s.addr #pragma omp target update to(*(s->sp->p)) *(s->sp->p) = e; #pragma omp target update from(*(s->sp->p)) @@ -704,28 +704,36 @@ void lvalue(struct S *s, int l, int e) { // SIMD-ONLY0-NOT: {{__kmpc|__tgt}} #ifdef CK13 -// CK13: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 {{4|8}}, i64 4] -// CK13: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 1, i64 17] +// &((*(BB+a))[0]), &((*(BB+a))[b]), sizeof((*(BB+a))[0]), TO + +// CK13: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 4] +// CK13: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 1] // CK13-LABEL: lvalue void lvalue(int **BB, int a, int b) { - // CK13-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK13-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK13-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK13-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK13-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK13-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK13-DAG: store ptr [[B_VAL1:%.+]], ptr [[BP0]] - // CK13-DAG: store ptr [[ADD_PTR_2:%.+]], ptr [[P0]] - // CK13-64-DAG: [[ADD_PTR_2]] = getelementptr inbounds i32, ptr [[RESULT:%.+]], i64 [[IDX_EXT_1:%.+]] - // CK13-32-DAG: [[ADD_PTR_2]] = getelementptr inbounds i32, ptr [[RESULT:%.+]], i32 [[B_ADDR:%.+]] - // CK13-64-DAG: [[IDX_EXT_1]] = sext i32 [[B_ADDR:%.+]] - // CK13-DAG: [[RESULT]] = load ptr, ptr [[ADD_PTR:%.+]], - // CK13-64-DAG: [[ADD_PTR]] = getelementptr inbounds ptr, ptr [[B_VAL:%.+]], i64 [[IDX_EXT:%.+]] - // CK13-32-DAG: [[ADD_PTR]] = getelementptr inbounds ptr, ptr [[B_VAL:%.+]], i32 [[A_ADDR:%.+]] - // CK13-64-DAG: [[IDX_EXT]] = sext i32 [[TWO:%.+]] to i64 - // CK13-DAG: [[B_VAL]] = load ptr, ptr [[BB_ADDR:%.+]] + // CK13-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 + // CK13-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 + // CK13-DAG: store ptr [[ADD_PTR_VAL:%.+]], ptr [[BP0]] + // CK13-DAG: store ptr [[ADD_PTR1:%.+]], ptr [[P0]] + // CK13-DAG: [[ADD_PTR_VAL]] = load ptr, ptr [[ADD_PTR:%[^,]+]] + // CK13-DAG: [[ADD_PTR]] = getelementptr inbounds ptr, ptr [[BB:%.+]], i{{.*}} [[A_VAL:%[^,]+]] + // CK13-DAG: [[BB]] = load ptr, ptr %BB.addr + // CK13-64-DAG: [[A_VAL:%.+]] = sext i32 [[A_VAL:%.+]] to i64 + // CK13-DAG: [[A_VAL]] = load i32, ptr %a.addr + + // CK13-DAG: [[ADD_PTR1]] = getelementptr inbounds i32, ptr [[ADD_PTR_VAL1:%.+]], i{{.*}} [[B_VAL:%[^,]+]] + // CK13-64-DAG: [[B_VAL]] = sext i32 [[B_VAL:.+]] to i64 + // CK13-DAG: [[B_VAL]] = load i32, ptr %b.addr + // CK13-DAG: [[ADD_PTR_VAL1]] = load ptr, ptr [[ADD_PTR2:%[^,]+]] + // CK13-DAG: [[ADD_PTR2]] = getelementptr inbounds ptr, ptr [[BB1:%.+]], i{{.*}} [[A_VAL1:%[^,]+]] + // CK13-DAG: [[BB1]] = load ptr, ptr %BB.addr + // CK13-64-DAG: [[A_VAL1:%.+]] = sext i32 [[A_VAL1:%.+]] to i64 + // CK13-DAG: [[A_VAL1]] = load i32, ptr %a.addr #pragma omp target update to(*(*(BB+a)+b)) *(*(BB+a)+b) = 1; #pragma omp target update from(*(*(BB+a)+b)) @@ -749,8 +757,10 @@ void lvalue(int **BB, int a, int b) { // SIMD-ONLY0-NOT: {{__kmpc|__tgt}} #ifdef CK14 -// CK14: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 8] -// CK14: [[MTYPE00:@.+]] = private {{.*}}constant [2 x i64] [i64 0, i64 281474976710673] +// &(this->d[0]), &(this->d[1]), sizeof(this->d[1]), TO + +// CK14: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 8] +// CK14: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i64] [i64 1] struct SSA { double *p; @@ -767,24 +777,19 @@ struct SSB { // CK14-LABEL: define {{.+}}foo void foo() { - // CK14-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GSIZE:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK14-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK14-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK14-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK14-DAG: [[GSIZE]] = getelementptr inbounds {{.+}}[[SIZE:%[^,]+]] - - // CK14-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK14-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK14-DAG: store ptr [[D_VAL:%.+]], ptr [[BP1]] - // CK14-DAG: store ptr [[ADD_PTR:%.+]], ptr [[P1]] - // CK14-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[ZERO:%.+]], i{{.+}} 1 - // CK14-DAG: [[ZERO]] = load ptr, ptr [[D_VAL_2:%.+]] - // CK14-DAG: [[D_VAL]] = getelementptr inbounds nuw [[SSB:%.+]], ptr [[THIS:%.+]], i32 0, i32 0 + // CK14-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK14-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK14-DAG: [[SIZE0:%.+]] = getelementptr inbounds {{.+}}[[SIZE]], i{{.+}} 0, i{{.+}} 0 - // CK14-DAG: store ptr [[THIS]], ptr [[BP0]], - // CK14-DAG: store ptr [[D_VAL]], ptr [[P0]] - // CK14-DAG: store i{{.+}} [[COMPUTE_LEN:%.+]], ptr [[SIZE0]] + // CK14-DAG: store ptr [[D_VAL:%.+]], ptr [[BP0]] + // CK14-DAG: store ptr [[ADD_PTR:%.+]], ptr [[P0]] + // CK14-DAG: [[D_VAL]] = load ptr, ptr [[D:%[^,]+]] + // CK14-DAG: [[D]] = getelementptr inbounds nuw [[SSB:%struct.SSB]], ptr [[THIS:%.+]], i32 0, i32 0 + // CK14-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[D_VAL1:%.+]], i{{.+}} 1 + // CK14-DAG: [[D_VAL1]] = load ptr, ptr [[D1:%[^,]+]] + // CK14-DAG: [[D1]] = getelementptr inbounds nuw [[SSB]], ptr [[THIS]], i32 0, i32 0 #pragma omp target update to(*(this->d+1)) *(this->d+1) = 1; @@ -817,8 +822,10 @@ void lvalue_member(SSA *sap) { // SIMD-ONLY0-NOT: {{__kmpc|__tgt}} #ifdef CK15 -// CK15: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 {{8|4}}] -// CK15: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] +// &(sap->p[0]), &(sap->p[3]), sizeof(sap->p[1]), TO + +// CK15: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 8] +// CK15: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 1] struct SSA { double *p; @@ -829,29 +836,21 @@ struct SSA { //CK-15-LABEL: lvalue_member void lvalue_member(SSA *sap) { - // CK15-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[GSIZE:%.+]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK15-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK15-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK15-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK15-DAG: [[GSIZE]] = getelementptr inbounds {{.+}}[[SIZE:%[^,]+]] - - // CK15-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK15-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK15-DAG: store ptr [[P_VAL:%.+]], ptr [[BP1]] - // CK15-DAG: store ptr [[ADD_PTR:%.+]], ptr [[P1]] - // CK15-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[THREE:%.+]], i{{.+}} 3 - // CK15-DAG: [[THREE]] = load ptr, ptr [[P_VAL_1:%.+]] - // CK15-DAG: [[P_VAL]] = getelementptr inbounds nuw [[SSA:%.+]], ptr [[THIS:%.+]], i32 0, i32 0 + // CK15-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK15-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK15-DAG: [[SIZE0:%.+]] = getelementptr inbounds {{.+}}[[SIZE]], i{{.+}} 0, i{{.+}} 0 - // CK15-DAG: store ptr [[ZERO:%.+]], ptr [[BP0]], - // CK15-DAG: store ptr [[P_VAL]], ptr [[P0]], - // CK15-DAG: store i{{.+}} [[COMPUTE_SIZE:%.+]], ptr [[SIZE0]] - // CK15-DAG: [[COMPUTE_SIZE]] = sdiv exact i64 [[NINE:%.+]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) - // CK15-DAG: [[NINE]] = sub i{{.+}} [[SEVEN:%.+]], [[EIGHT:%.+]] - // CK15-DAG: [[SEVEN]] = ptrtoint ptr [[SIX:%.+]] to i64 - // CK15-DAG: [[EIGHT]] = ptrtoint ptr [[FIVE:%.+]] to i64 - // CK15-DAG: [[ZERO]] = load ptr, ptr %{{.+}}, + // CK15-DAG: store ptr [[P_VAL:%.+]], ptr [[BP0]] + // CK15-DAG: store ptr [[ADD_PTR:%.+]], ptr [[P0]] + // CK15-DAG: [[P_VAL]] = load ptr, ptr [[P:%[^,]+]] + // CK15-DAG: [[P]] = getelementptr inbounds nuw %struct.SSA, ptr [[SAP_VAL:%.+]], i32 0, i32 0 + // CK15-DAG: [[SAP_VAL]] = load ptr, ptr %sap.addr + // CK15-DAG: [[ADD_PTR]] = getelementptr inbounds double, ptr [[P_VAL1:%.+]], i{{.*}} 3 + // CK15-DAG: [[P_VAL1]] = load ptr, ptr [[P1:%[^,]+]] + // CK15-DAG: [[P1]] = getelementptr inbounds nuw %struct.SSA, ptr [[SAP_VAL1:%.+]], i32 0, i32 0 + // CK15-DAG: [[SAP_VAL1]] = load ptr, ptr %sap.addr #pragma omp target update to(*(3+sap->p)) *(3+sap->p) = 1; #pragma omp target update from(*(3+sap->p)) @@ -918,8 +917,10 @@ void lvalue_find_base(float *f, int *i) { // SIMD-ONLY0-NOT: {{__kmpc|__tgt}} #ifdef CK17 -// CK17: [[SIZE00:@.+]] = {{.+}}constant [2 x i64] [i64 {{8|4}}, i64 4] -// CK17: [[MTYPE00:@.+]] = {{.+}}constant [2 x i64] [i64 1, i64 17] +// &((*(1+sa->i+f))[0]), &((*(1+sa->i+f))[sa->sa->i]), sizeof((sa->sa->i + *(1+sa->i+f))[0]), TO + +// CK17: [[SIZE00:@.+]] = {{.+}}constant [1 x i64] [i64 4] +// CK17: [[MTYPE00:@.+]] = {{.+}}constant [1 x i64] [i64 1] struct SSA { int i; @@ -929,27 +930,36 @@ struct SSA { //CK17-LABEL: lvalue_find_base void lvalue_find_base(float **f, SSA *sa) { - // CK17-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) + // CK17-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[GEPBP:%.+]], ptr [[GEPP:%.+]], ptr [[SIZE00]], ptr [[MTYPE00]]{{.+}}, ptr null) // CK17-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK17-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] - // CK17-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 - // CK17-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK17-DAG: store ptr [[F_VAL:%.+]], ptr [[BP0]], - // CK17-DAG: store ptr [[ADD_PTR_4:%.+]], ptr [[P0]], - // CK17-64-DAG: [[ADD_PTR_4]] = getelementptr inbounds float, ptr [[SEVEN:%.+]], i64 [[IDX_EXT_3:%.+]] - // CK17-64-DAG: [[IDX_EXT_3]] = sext i32 [[I_VAL:%.+]] to i64 - // CK17-32-DAG: [[ADD_PTR_4]] = getelementptr inbounds float, ptr [[SEVEN:%.+]], i32 [[I_VAL:%.+]] - // CK17-DAG: [[I_VAL]] = load i32, ptr [[I:%.+]], - // CK17-DAG: [[SEVEN]] = load ptr, ptr [[ADD_PTR:%.+]], - // CK17-64-DAG: [[ADD_PTR]] = getelementptr inbounds ptr, ptr [[F:%.+]], i64 [[IDX_EXT:%.+]] - // CK17-32-DAG: [[ADD_PTR]] = getelementptr inbounds ptr, ptr [[F:%.+]], i32 [[ADD:%.+]] - // CK17-64-DAG: [[IDX_EXT]] = sext i32 [[ADD:%.+]] to i64 - // CK17-DAG: [[ADD]] = add nsw i32 1, [[FIVE:%.+]] - // CK17-DAG: [[FIVE]] = load i32, ptr [[I_2:%.+]], - // CK17-DAG: [[I_2]] = getelementptr inbounds nuw [[SSA:%.+]], ptr [[FOUR:%.+]], i32 0, i32 0 - // CK17-DAG: [[FOUR]] = load ptr, ptr [[SSA_ADDR:%.+]], - // CK17-DAG: [[F]] = load ptr, ptr [[F_ADDR:%.+]], + // CK17-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 + // CK17-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 + // CK17-DAG: store ptr [[ADD_PTR_VAL:%.+]], ptr [[BP0]], + // CK17-DAG: store ptr [[ADD_PTR_I:%.+]], ptr [[P0]], + // CK17-DAG: [[ADD_PTR_VAL]] = load ptr, ptr [[ADD_PTR:%[^,]+]] + // CK17-DAG: [[ADD_PTR]] = getelementptr inbounds ptr, ptr [[F:%.+]], i{{.*}} [[I_PLUS_ONE:[^,]*]] + // CK17-DAG: [[F]] = load ptr, ptr %f.addr + // CK17-64-DAG: [[I_PLUS_ONE]] = sext i32 [[I_PLUS_ONE:%.+]] to i64 + // CK17-DAG: [[I_PLUS_ONE]] = add nsw i32 1, [[IVAL:%.+]] + // CK17-DAG: [[IVAL]] = load i32, ptr [[I:%[^,]+]] + // CK17-DAG: [[I]] = getelementptr inbounds nuw %struct.SSA, ptr [[SA:%.+]], i32 0, i32 0 + + // CK17-DAG: [[ADD_PTR_I]] = getelementptr inbounds float, ptr [[ADD_PTR_VAL1:%.+]], i{{.*}} [[I_VAL1:%.+]] + // CK17-64-DAG: [[I_VAL1]] = sext i32 [[I_VAL1:%.+]] to i64 + // CK17-DAG: [[I_VAL1]] = load i32, ptr [[I1:%[^,]+]] + // CK17-DAG: [[I1]] = getelementptr inbounds nuw %struct.SSA, ptr [[SA_VAL1:%.+]], i32 0, i32 0 + // CK17-DAG: [[SA_VAL1]] = load ptr, ptr [[SA1:%[^,]+]] + // CK17-DAG: [[SA1]] = getelementptr inbounds nuw %struct.SSA, ptr [[SA_VAL2:%.+]], i32 0, i32 1 + // CK17-DAG: [[SA_VAL2]] = load ptr, ptr %sa.addr + // CK17-DAG: [[ADD_PTR_VAL1]] = load ptr, ptr [[ADD_PTR1:%[^,]+]] + // CK17-DAG: [[ADD_PTR1]] = getelementptr inbounds ptr, ptr [[F1:%.+]], i{{.*}} [[I_PLUS_ONE1:[^,]*]] + // CK17-DAG: [[F1]] = load ptr, ptr %f.addr + // CK17-64-DAG: [[I_PLUS_ONE1]] = sext i32 [[I_PLUS_ONE1:%.+]] to i64 + // CK17-DAG: [[I_PLUS_ONE1]] = add nsw i32 1, [[IVAL1:%.+]] + // CK17-DAG: [[IVAL1]] = load i32, ptr [[I2:%[^,]+]] + // CK17-DAG: [[I2]] = getelementptr inbounds nuw %struct.SSA, ptr [[SA:%.+]], i32 0, i32 0 #pragma omp target update to(*(sa->sa->i+*(1+sa->i+f))) *(sa->sa->i+*(1+sa->i+f)) = 1; diff --git a/clang/test/OpenMP/target_update_depend_codegen.cpp b/clang/test/OpenMP/target_update_depend_codegen.cpp index 6282863a18d74..29b61c7ec4efd 100644 --- a/clang/test/OpenMP/target_update_depend_codegen.cpp +++ b/clang/test/OpenMP/target_update_depend_codegen.cpp @@ -37,8 +37,8 @@ double gc[100]; // CK1: [[MTYPE03:@.+]] = {{.+}}constant [1 x i64] [i64 2] -// CK1: [[SIZE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 24] -// CK1: [[MTYPE04:@.+]] = {{.+}}constant [2 x i64] [i64 0, i64 281474976710673] +// CK1: [[SIZE04:@.+]] = {{.+}}constant [1 x i64] [i64 24] +// CK1: [[MTYPE04:@.+]] = {{.+}}constant [1 x i64] [i64 1] // CK1-LABEL: _Z3fooi void foo(int arg) { @@ -238,21 +238,19 @@ void foo(int arg) { {++arg;} // Region 04 - // CK1: [[DIV:%.+]] = sdiv exact i64 sub (i64 ptrtoint (ptr getelementptr (ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), i32 1) to i64), i64 ptrtoint (ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) to i64)), ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) - // CK1: [[BP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP:%.+]], i32 0, i32 0 - // CK1: store ptr @gb, ptr [[BP0]], - // CK1: [[P0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P:%.+]], i32 0, i32 0 - // CK1: store ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), ptr [[P0]], - // CK1: [[PS0:%.+]] = getelementptr inbounds [2 x i64], ptr [[PS:%.+]], i32 0, i32 0 - // CK1: store i64 [[DIV]], ptr [[PS0]], - // CK1: [[BP1:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP]], i32 0, i32 1 - // CK1: store ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1), ptr [[BP1]], - // CK1: [[P1:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P]], i32 0, i32 1 - // CK1: store ptr %{{.+}}, ptr [[P1]], - // CK1: [[GEPBP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[BP]], i32 0, i32 0 - // CK1: [[GEPP0:%.+]] = getelementptr inbounds [2 x ptr], ptr [[P]], i32 0, i32 0 - // CK1: [[GEPS0:%.+]] = getelementptr inbounds [2 x i64], ptr [[PS]], i32 0, i32 0 - // CK1: [[RES:%.+]] = call ptr @__kmpc_omp_task_alloc(ptr {{.+}}, i32 {{.+}}, i32 1, i[[sz]] {{88|52}}, i[[sz]] 1, ptr [[TASK_ENTRY4:@.+]]) + // + // &gb.b[0], &gb.b[0], 3 * sizeof(gb.b[0]), TO + // + // CK1: [[B_LOAD:%.+]] = load ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) + // CK1: [[B_LOAD1:%.+]] = load ptr, ptr getelementptr inbounds nuw (%struct.ST, ptr @gb, i32 0, i32 1) + // CK1: [[B0:%.+]] = getelementptr inbounds nuw double, ptr [[B_LOAD1]], i[[sz]] 0 + // CK1: [[BP0:%.+]] = getelementptr inbounds [1 x ptr], ptr [[BP:%.+]], i32 0, i32 0 + // CK1: store ptr [[B_LOAD]], ptr [[BP0]], + // CK1: [[P0:%.+]] = getelementptr inbounds [1 x ptr], ptr [[P:%.+]], i32 0, i32 0 + // CK1: store ptr [[B0]], ptr [[P0]], + // CK1: [[GEPBP0:%.+]] = getelementptr inbounds [1 x ptr], ptr [[BP]], i32 0, i32 0 + // CK1: [[GEPP0:%.+]] = getelementptr inbounds [1 x ptr], ptr [[P]], i32 0, i32 0 + // CK1: [[RES:%.+]] = call ptr @__kmpc_omp_task_alloc(ptr {{.+}}, i32 {{.+}}, i32 1, i[[sz]] {{64|36}}, i[[sz]] 1, ptr [[TASK_ENTRY4:@.+]]) // CK1: [[TASK_T:%.+]] = getelementptr inbounds nuw %struct.kmp_task_t_with_privates{{.+}}, ptr [[RES]], i32 0, i32 0 // CK1: [[PRIVS:%.+]] = getelementptr inbounds nuw %struct.kmp_task_t_with_privates{{.+}}, ptr [[RES]], i32 0, i32 1 // CK1-64: [[PRIVS_BASEPTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 0 @@ -260,13 +258,13 @@ void foo(int arg) { // CK1-64: [[PRIVS_PTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 1 // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_PTRS]], ptr align {{8|4}} [[GEPP0]], i[[sz]] {{16|8}}, i1 false) // CK1-64: [[PRIVS_SIZES:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 2 - // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[GEPS0]], i[[sz]] {{16|8}}, i1 false) + // CK1-64: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[SIZE04]], i[[sz]] {{16|8}}, i1 false) // CK1-32: [[PRIVS_SIZES:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 0 - // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[GEPS0]], i[[sz]] {{16|8}}, i1 false) + // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_SIZES]], ptr align {{8|4}} [[SIZE04]], i[[sz]] {{16|8}}, i1 false) // CK1-32: [[PRIVS_BASEPTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 1 - // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_BASEPTRS]], ptr align {{8|4}} [[GEPBP0]], i[[sz]] {{16|8}}, i1 false) + // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_BASEPTRS]], ptr align {{8|4}} [[GEPBP0]], i[[sz]] {{8|4}}, i1 false) // CK1-32: [[PRIVS_PTRS:%.+]] = getelementptr inbounds nuw %struct..kmp_privates.t{{.+}}, ptr [[PRIVS]], i32 0, i32 2 - // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_PTRS]], ptr align {{8|4}} [[GEPP0]], i[[sz]] {{16|8}}, i1 false) + // CK1-32: call void @llvm.memcpy.p0.p0.i[[sz]](ptr align {{8|4}} [[PRIVS_PTRS]], ptr align {{8|4}} [[GEPP0]], i[[sz]] {{8|4}}, i1 false) // CK1: %{{.+}} = sub nuw // CK1: [[BC_ADR:%.+]] = ptrtoint ptr %{{.+}} to i[[sz]] // CK1: [[DEP:%.+]] = getelementptr %struct.kmp_depend_info, ptr [[MAIN_DEP:%.+]], i[[sz]] 0 @@ -346,7 +344,7 @@ void foo(int arg) { // CK1: } // CK1: define internal{{.*}} i32 [[TASK_ENTRY4]](i32{{.*}}, ptr noalias noundef %1) -// CK1-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 2, ptr [[BP:%.+]], ptr [[P:%.+]], ptr [[S:%.+]], ptr [[MTYPE04]]{{.+}}, ptr null) +// CK1-DAG: call void @__tgt_target_data_update_mapper(ptr @{{.+}}, i64 -1, i32 1, ptr [[BP:%.+]], ptr [[P:%.+]], ptr [[S:%.+]], ptr [[MTYPE04]]{{.+}}, ptr null) // CK1-DAG: [[BP]] = load ptr, ptr [[BP_PRIV:%[^,]+]], // CK1-DAG: [[P]] = load ptr, ptr [[P_PRIV:%[^,]+]], // CK1-DAG: [[S]] = load ptr, ptr [[S_PRIV:%[^,]+]], diff --git a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp index 5980ee35a5cd2..9e8464f2bbbc4 100644 --- a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp +++ b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp @@ -10361,6 +10361,12 @@ void OpenMPIRBuilder::setCorrectMemberOfFlag( omp::OpenMPOffloadMappingFlags::OMP_MAP_MEMBER_OF)) return; + // Entries with ATTACH are not members-of anything. They are handled + // separately by the runtime after other maps have been handled. + if (static_cast>( + Flags & omp::OpenMPOffloadMappingFlags::OMP_MAP_ATTACH)) + return; + // Reset the placeholder value to prepare the flag for the assignment of the // proper MEMBER_OF value. Flags &= ~omp::OpenMPOffloadMappingFlags::OMP_MAP_MEMBER_OF; diff --git a/offload/test/mapping/chained_containing_structs_1.cc b/offload/test/mapping/chained_containing_structs_1.cc index 4dbb17140de12..c9a09bb657be6 100644 --- a/offload/test/mapping/chained_containing_structs_1.cc +++ b/offload/test/mapping/chained_containing_structs_1.cc @@ -1,5 +1,4 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * #include #include diff --git a/offload/test/mapping/chained_containing_structs_2.cc b/offload/test/mapping/chained_containing_structs_2.cc index 29c4c8b7fedfd..272b0ebaa7c92 100644 --- a/offload/test/mapping/chained_containing_structs_2.cc +++ b/offload/test/mapping/chained_containing_structs_2.cc @@ -1,5 +1,4 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * #include #include diff --git a/offload/test/mapping/chained_containing_structs_3.cc b/offload/test/mapping/chained_containing_structs_3.cc index 23555bf69110d..763c9760918ef 100644 --- a/offload/test/mapping/chained_containing_structs_3.cc +++ b/offload/test/mapping/chained_containing_structs_3.cc @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include #include diff --git a/offload/test/mapping/map_ptr_and_star_global.c b/offload/test/mapping/map_ptr_and_star_global.c index 869fb8ca9bc2d..105dd4985410d 100644 --- a/offload/test/mapping/map_ptr_and_star_global.c +++ b/offload/test/mapping/map_ptr_and_star_global.c @@ -48,8 +48,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[0], x0_hostaddr == &p[0]); - // EXPECTED: 111 1 1 0 - // CHECK: 111 0 1 0 + // CHECK: 111 1 1 0 p++; } @@ -58,8 +57,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[-1], x0_hostaddr == &p[-1]); - // EXPECTED: 222 1 1 0 - // CHECK: {{[0-9]+}} 0 0 0 + // CHECK: 222 1 1 0 p++; } @@ -68,8 +66,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[-2], x0_hostaddr == &p[-2]); - // EXPECTED: 333 1 1 0 - // CHECK: 111 1 0 0 + // CHECK: 333 1 1 0 } // The following map(from:p) should not bring back p, because p is an diff --git a/offload/test/mapping/map_ptr_and_star_local.c b/offload/test/mapping/map_ptr_and_star_local.c index 97fa7cd53715f..f8962d1beffc4 100644 --- a/offload/test/mapping/map_ptr_and_star_local.c +++ b/offload/test/mapping/map_ptr_and_star_local.c @@ -51,8 +51,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[0], x0_hostaddr == &p[0]); - // EXPECTED: 111 1 1 0 - // CHECK: 111 0 1 0 + // CHECK: 111 1 1 0 p++; } @@ -61,8 +60,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[-1], x0_hostaddr == &p[-1]); - // EXPECTED: 222 1 1 0 - // CHECK: {{[0-9]+}} 0 0 0 + // CHECK: 222 1 1 0 p++; } @@ -71,8 +69,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[-2], x0_hostaddr == &p[-2]); - // EXPECTED: 333 1 1 0 - // CHECK: 111 1 0 0 + // CHECK: 333 1 1 0 } // The following map(from:p) should not bring back p, because p is an @@ -80,7 +77,7 @@ void f1() { // location, &x[0], on host. #pragma omp target exit data map(always, from : p) printf("%d %d\n", p[0], p == &x[0]); - // CHECK: 111 1 + // CHECK: 111 1 #pragma omp target exit data map(delete : p[0 : 5], p) } diff --git a/offload/test/mapping/map_ptr_and_subscript_global.c b/offload/test/mapping/map_ptr_and_subscript_global.c index 839db068aa906..98166625d428e 100644 --- a/offload/test/mapping/map_ptr_and_subscript_global.c +++ b/offload/test/mapping/map_ptr_and_subscript_global.c @@ -48,8 +48,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[0], x0_hostaddr == &p[0]); - // EXPECTED: 111 1 1 0 - // CHECK: 111 0 1 0 + // CHECK: 111 1 1 0 p++; } @@ -58,8 +57,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[-1], x0_hostaddr == &p[-1]); - // EXPECTED: 222 1 1 0 - // CHECK: 111 0 0 0 + // CHECK: 222 1 1 0 p++; } @@ -68,8 +66,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[-2], x0_hostaddr == &p[-2]); - // EXPECTED: 333 1 1 0 - // CHECK: 111 1 0 0 + // CHECK: 333 1 1 0 } // The following map(from:p) should not bring back p, because p is an diff --git a/offload/test/mapping/map_ptr_and_subscript_local.c b/offload/test/mapping/map_ptr_and_subscript_local.c index 68ac9dc0917fc..c1da07dc56de6 100644 --- a/offload/test/mapping/map_ptr_and_subscript_local.c +++ b/offload/test/mapping/map_ptr_and_subscript_local.c @@ -48,8 +48,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[0], x0_hostaddr == &p[0]); - // EXPECTED: 111 1 1 0 - // CHECK: 111 0 1 0 + // CHECK: 111 1 1 0 p++; } @@ -58,8 +57,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[-1], x0_hostaddr == &p[-1]); - // EXPECTED: 222 1 1 0 - // CHECK: 111 0 0 0 + // CHECK: 222 1 1 0 p++; } @@ -68,8 +66,7 @@ void f1() { { printf("%d %d %d %d\n", p[0], p_mappedptr == &p, x0_mappedptr == &p[-2], x0_hostaddr == &p[-2]); - // EXPECTED: 333 1 1 0 - // CHECK: 111 1 0 0 + // CHECK: 333 1 1 0 } // The following map(from:p) should not bring back p, because p is an diff --git a/offload/test/mapping/map_structptr_and_member_global.c b/offload/test/mapping/map_structptr_and_member_global.c index f855e87d7218a..7336b7c85ca1d 100644 --- a/offload/test/mapping/map_structptr_and_member_global.c +++ b/offload/test/mapping/map_structptr_and_member_global.c @@ -56,8 +56,7 @@ void f1() { { printf("%d %d %d %d\n", ps->x, ps_mappedptr == &ps, s0_mappedptr == &ps->x, s0_hostaddr == &ps->x); - // EXPECTED: 111 1 1 0 - // CHECK: 111 0 1 0 + // CHECK: 111 1 1 0 ps++; } @@ -66,8 +65,7 @@ void f1() { { printf("%d %d %d %d\n", ps->x, ps_mappedptr == &ps, s0_mappedptr == &ps[-1].x, s0_hostaddr == &ps[-1].x); - // EXPECTED: 222 1 1 0 - // CHECK: 111 0 0 0 + // CHECK: 222 1 1 0 ps++; } @@ -77,7 +75,7 @@ void f1() { printf("%d %d %d %d\n", ps->x, ps_mappedptr == &ps, s0_mappedptr == &ps[-2].x, s0_hostaddr == &ps[-2].x); // EXPECTED: 333 1 1 0 - // CHECK: 111 1 0 0 + // CHECK: 333 1 1 0 } // The following map(from:ps) should not bring back ps, because ps is an @@ -85,7 +83,7 @@ void f1() { // location, &s[0], on host. #pragma omp target exit data map(always, from : ps) printf("%d %d\n", ps->x, ps == &s[0]); - // CHECK: 111 1 + // CHECK: 111 1 #pragma omp target exit data map(delete : ps, s) } diff --git a/offload/test/mapping/map_structptr_and_member_local.c b/offload/test/mapping/map_structptr_and_member_local.c index bd9e2a89eb6f1..5936a7c73d48f 100644 --- a/offload/test/mapping/map_structptr_and_member_local.c +++ b/offload/test/mapping/map_structptr_and_member_local.c @@ -55,8 +55,7 @@ void f1() { { printf("%d %d %d %d\n", ps->x, ps_mappedptr == &ps, s0_mappedptr == &ps->x, s0_hostaddr == &ps->x); - // EXPECTED: 111 1 1 0 - // CHECK: 111 0 1 0 + // CHECK: 111 1 1 0 ps++; } @@ -65,8 +64,7 @@ void f1() { { printf("%d %d %d %d\n", ps->x, ps_mappedptr == &ps, s0_mappedptr == &ps[-1].x, s0_hostaddr == &ps[-1].x); - // EXPECTED: 222 1 1 0 - // CHECK: 111 0 0 0 + // CHECK: 222 1 1 0 ps++; } @@ -75,8 +73,7 @@ void f1() { { printf("%d %d %d %d\n", ps->x, ps_mappedptr == &ps, s0_mappedptr == &ps[-2].x, s0_hostaddr == &ps[-2].x); - // EXPECTED: 333 1 1 0 - // CHECK: 111 1 0 0 + // CHECK: 333 1 1 0 } // The following map(from:ps) should not bring back ps, because ps is an @@ -84,7 +81,7 @@ void f1() { // location, &s[0], on host. #pragma omp target exit data map(always, from : ps) printf("%d %d\n", ps->x, ps == &s[0]); - // CHECK: 111 1 + // CHECK: 111 1 #pragma omp target exit data map(delete : ps, s) } diff --git a/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_existing.cpp b/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_existing.cpp index 3b1a8192bf2cf..8465318024e7b 100644 --- a/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_existing.cpp +++ b/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_not_existing.cpp b/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_not_existing.cpp index b9ebde431e7bf..833cc2bf262d4 100644 --- a/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_not_existing.cpp +++ b/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_not_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_ref_not_existing.cpp b/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_ref_not_existing.cpp index 0090cdb095366..1f89ab1575d01 100644 --- a/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_ref_not_existing.cpp +++ b/offload/test/mapping/use_device_addr/target_data_use_device_addr_arrsec_ref_not_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_existing.cpp b/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_existing.cpp index 883297f7e90cd..c62a451d5ab4d 100644 --- a/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_existing.cpp +++ b/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_not_existing.cpp b/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_not_existing.cpp index 79c6f69edba8e..b802857c013ae 100644 --- a/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_not_existing.cpp +++ b/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_not_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_ref_existing.cpp b/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_ref_existing.cpp index f018c65f36ec5..f485240c7022e 100644 --- a/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_ref_existing.cpp +++ b/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_ref_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_ref_not_existing.cpp b/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_ref_not_existing.cpp index 9360db4195041..ded8a03d57997 100644 --- a/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_ref_not_existing.cpp +++ b/offload/test/mapping/use_device_addr/target_data_use_device_addr_var_ref_not_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_existing.cpp b/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_existing.cpp index a7745de53298e..1684008d6c689 100644 --- a/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_existing.cpp +++ b/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_not_existing.cpp b/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_not_existing.cpp index fe3cdb56e4baa..db91577f6b172 100644 --- a/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_not_existing.cpp +++ b/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_not_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_ref_existing.cpp b/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_ref_existing.cpp index 66e65de4195a4..f38aeca6e929e 100644 --- a/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_ref_existing.cpp +++ b/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_ref_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include diff --git a/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_ref_not_existing.cpp b/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_ref_not_existing.cpp index 419ab3eb33d4d..84bad7ee3ea82 100644 --- a/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_ref_not_existing.cpp +++ b/offload/test/mapping/use_device_ptr/target_data_use_device_ptr_ref_not_existing.cpp @@ -1,7 +1,5 @@ // RUN: %libomptarget-compilexx-run-and-check-generic -// XFAIL: * - #include #include