/llvm-project/clang/test/OpenMP/tile_codegen_for_dependent.cpp

https://github.com/KhronosGroup/libclcxx · C++ · 193 lines · 10 code · 7 blank · 176 comment · 1 complexity · 9bb37ec3a67b8e72f96b3a4c01d21bc0 MD5 · raw file 

    

  1. // Check code generation
    2. 

  2. // RUN: %clang_cc1 -verify -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 -emit-llvm %s -o - | FileCheck %s --check-prefix=IR
    3. 

  3. 

  4. // Check same results after serialization round-trip
    5. 

  5. // RUN: %clang_cc1 -verify -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 -emit-pch -o %t %s
    6. 

  6. // RUN: %clang_cc1 -verify -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 -include-pch %t -emit-llvm %s -o - | FileCheck %s --check-prefix=IR
    7. 

  7. // expected-no-diagnostics
    8. 

  8. 

  9. // The loop trip count used by #pragma omp for depends on code generated
    10. 

  10. // by #pragma omp file. Check that theses PreInits are emitted before
    11. 

  11. // the code generated by #pragma omp for.
    12. 

  12. 

  13. #ifndef HEADER
    14. 

  14. #define HEADER
    15. 

  15. 

  16. // placeholder for loop body code.
    17. 

  17. extern "C" void body(...) {}
    18. 

  18. 

  19. 

  20. // IR-LABEL: @func(
    21. 

  21. // IR-NEXT:  [[ENTRY:.*]]:
    22. 

  22. // IR-NEXT:    %[[START_ADDR:.+]] = alloca i32, align 4
    23. 

  23. // IR-NEXT:    %[[END_ADDR:.+]] = alloca i32, align 4
    24. 

  24. // IR-NEXT:    %[[STEP_ADDR:.+]] = alloca i32, align 4
    25. 

  25. // IR-NEXT:    %[[DOTOMP_IV:.+]] = alloca i32, align 4
    26. 

  26. // IR-NEXT:    %[[TMP:.+]] = alloca i32, align 4
    27. 

  27. // IR-NEXT:    %[[I:.+]] = alloca i32, align 4
    28. 

  28. // IR-NEXT:    %[[DOTCAPTURE_EXPR_:.+]] = alloca i32, align 4
    29. 

  29. // IR-NEXT:    %[[DOTCAPTURE_EXPR_1:.+]] = alloca i32, align 4
    30. 

  30. // IR-NEXT:    %[[DOTCAPTURE_EXPR_2:.+]] = alloca i32, align 4
    31. 

  31. // IR-NEXT:    %[[DOTCAPTURE_EXPR_3:.+]] = alloca i32, align 4
    32. 

  32. // IR-NEXT:    %[[DOTCAPTURE_EXPR_6:.+]] = alloca i32, align 4
    33. 

  33. // IR-NEXT:    %[[DOTCAPTURE_EXPR_8:.+]] = alloca i32, align 4
    34. 

  34. // IR-NEXT:    %[[DOTFLOOR_0_IV_I:.+]] = alloca i32, align 4
    35. 

  35. // IR-NEXT:    %[[DOTOMP_LB:.+]] = alloca i32, align 4
    36. 

  36. // IR-NEXT:    %[[DOTOMP_UB:.+]] = alloca i32, align 4
    37. 

  37. // IR-NEXT:    %[[DOTOMP_STRIDE:.+]] = alloca i32, align 4
    38. 

  38. // IR-NEXT:    %[[DOTOMP_IS_LAST:.+]] = alloca i32, align 4
    39. 

  39. // IR-NEXT:    %[[DOTFLOOR_0_IV_I12:.+]] = alloca i32, align 4
    40. 

  40. // IR-NEXT:    %[[DOTTILE_0_IV_I:.+]] = alloca i32, align 4
    41. 

  41. // IR-NEXT:    %[[TMP0:.+]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @2)
    42. 

  42. // IR-NEXT:    store i32 %[[START:.+]], i32* %[[START_ADDR]], align 4
    43. 

  43. // IR-NEXT:    store i32 %[[END:.+]], i32* %[[END_ADDR]], align 4
    44. 

  44. // IR-NEXT:    store i32 %[[STEP:.+]], i32* %[[STEP_ADDR]], align 4
    45. 

  45. // IR-NEXT:    %[[TMP1:.+]] = load i32, i32* %[[START_ADDR]], align 4
    46. 

  46. // IR-NEXT:    store i32 %[[TMP1]], i32* %[[I]], align 4
    47. 

  47. // IR-NEXT:    %[[TMP2:.+]] = load i32, i32* %[[START_ADDR]], align 4
    48. 

  48. // IR-NEXT:    store i32 %[[TMP2]], i32* %[[DOTCAPTURE_EXPR_]], align 4
    49. 

  49. // IR-NEXT:    %[[TMP3:.+]] = load i32, i32* %[[END_ADDR]], align 4
    50. 

  50. // IR-NEXT:    store i32 %[[TMP3]], i32* %[[DOTCAPTURE_EXPR_1]], align 4
    51. 

  51. // IR-NEXT:    %[[TMP4:.+]] = load i32, i32* %[[STEP_ADDR]], align 4
    52. 

  52. // IR-NEXT:    store i32 %[[TMP4]], i32* %[[DOTCAPTURE_EXPR_2]], align 4
    53. 

  53. // IR-NEXT:    %[[TMP5:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_1]], align 4
    54. 

  54. // IR-NEXT:    %[[TMP6:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_]], align 4
    55. 

  55. // IR-NEXT:    %[[SUB:.+]] = sub i32 %[[TMP5]], %[[TMP6]]
    56. 

  56. // IR-NEXT:    %[[SUB4:.+]] = sub i32 %[[SUB]], 1
    57. 

  57. // IR-NEXT:    %[[TMP7:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_2]], align 4
    58. 

  58. // IR-NEXT:    %[[ADD:.+]] = add i32 %[[SUB4]], %[[TMP7]]
    59. 

  59. // IR-NEXT:    %[[TMP8:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_2]], align 4
    60. 

  60. // IR-NEXT:    %[[DIV:.+]] = udiv i32 %[[ADD]], %[[TMP8]]
    61. 

  61. // IR-NEXT:    %[[SUB5:.+]] = sub i32 %[[DIV]], 1
    62. 

  62. // IR-NEXT:    store i32 %[[SUB5]], i32* %[[DOTCAPTURE_EXPR_3]], align 4
    63. 

  63. // IR-NEXT:    %[[TMP9:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_3]], align 4
    64. 

  64. // IR-NEXT:    %[[ADD7:.+]] = add i32 %[[TMP9]], 1
    65. 

  65. // IR-NEXT:    store i32 %[[ADD7]], i32* %[[DOTCAPTURE_EXPR_6]], align 4
    66. 

  66. // IR-NEXT:    %[[TMP10:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_6]], align 4
    67. 

  67. // IR-NEXT:    %[[SUB9:.+]] = sub i32 %[[TMP10]], -3
    68. 

  68. // IR-NEXT:    %[[DIV10:.+]] = udiv i32 %[[SUB9]], 4
    69. 

  69. // IR-NEXT:    %[[SUB11:.+]] = sub i32 %[[DIV10]], 1
    70. 

  70. // IR-NEXT:    store i32 %[[SUB11]], i32* %[[DOTCAPTURE_EXPR_8]], align 4
    71. 

  71. // IR-NEXT:    store i32 0, i32* %[[DOTFLOOR_0_IV_I]], align 4
    72. 

  72. // IR-NEXT:    %[[TMP11:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_6]], align 4
    73. 

  73. // IR-NEXT:    %[[CMP:.+]] = icmp ult i32 0, %[[TMP11]]
    74. 

  74. // IR-NEXT:    br i1 %[[CMP]], label %[[OMP_PRECOND_THEN:.+]], label %[[OMP_PRECOND_END:.+]]
    75. 

  75. // IR-EMPTY:
    76. 

  76. // IR-NEXT:  [[OMP_PRECOND_THEN]]:
    77. 

  77. // IR-NEXT:    store i32 0, i32* %[[DOTOMP_LB]], align 4
    78. 

  78. // IR-NEXT:    %[[TMP12:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_8]], align 4
    79. 

  79. // IR-NEXT:    store i32 %[[TMP12]], i32* %[[DOTOMP_UB]], align 4
    80. 

  80. // IR-NEXT:    store i32 1, i32* %[[DOTOMP_STRIDE]], align 4
    81. 

  81. // IR-NEXT:    store i32 0, i32* %[[DOTOMP_IS_LAST]], align 4
    82. 

  82. // IR-NEXT:    call void @__kmpc_for_static_init_4u(%struct.ident_t* @1, i32 %[[TMP0]], i32 34, i32* %[[DOTOMP_IS_LAST]], i32* %[[DOTOMP_LB]], i32* %[[DOTOMP_UB]], i32* %[[DOTOMP_STRIDE]], i32 1, i32 1)
    83. 

  83. // IR-NEXT:    %[[TMP13:.+]] = load i32, i32* %[[DOTOMP_UB]], align 4
    84. 

  84. // IR-NEXT:    %[[TMP14:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_8]], align 4
    85. 

  85. // IR-NEXT:    %[[CMP13:.+]] = icmp ugt i32 %[[TMP13]], %[[TMP14]]
    86. 

  86. // IR-NEXT:    br i1 %[[CMP13]], label %[[COND_TRUE:.+]], label %[[COND_FALSE:.+]]
    87. 

  87. // IR-EMPTY:
    88. 

  88. // IR-NEXT:  [[COND_TRUE]]:
    89. 

  89. // IR-NEXT:    %[[TMP15:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_8]], align 4
    90. 

  90. // IR-NEXT:    br label %[[COND_END:.+]]
    91. 

  91. // IR-EMPTY:
    92. 

  92. // IR-NEXT:  [[COND_FALSE]]:
    93. 

  93. // IR-NEXT:    %[[TMP16:.+]] = load i32, i32* %[[DOTOMP_UB]], align 4
    94. 

  94. // IR-NEXT:    br label %[[COND_END]]
    95. 

  95. // IR-EMPTY:
    96. 

  96. // IR-NEXT:  [[COND_END]]:
    97. 

  97. // IR-NEXT:    %[[COND:.+]] = phi i32 [ %[[TMP15]], %[[COND_TRUE]] ], [ %[[TMP16]], %[[COND_FALSE]] ]
    98. 

  98. // IR-NEXT:    store i32 %[[COND]], i32* %[[DOTOMP_UB]], align 4
    99. 

  99. // IR-NEXT:    %[[TMP17:.+]] = load i32, i32* %[[DOTOMP_LB]], align 4
    100. 

  100. // IR-NEXT:    store i32 %[[TMP17]], i32* %[[DOTOMP_IV]], align 4
    101. 

  101. // IR-NEXT:    br label %[[OMP_INNER_FOR_COND:.+]]
    102. 

  102. // IR-EMPTY:
    103. 

  103. // IR-NEXT:  [[OMP_INNER_FOR_COND]]:
    104. 

  104. // IR-NEXT:    %[[TMP18:.+]] = load i32, i32* %[[DOTOMP_IV]], align 4
    105. 

  105. // IR-NEXT:    %[[TMP19:.+]] = load i32, i32* %[[DOTOMP_UB]], align 4
    106. 

  106. // IR-NEXT:    %[[ADD14:.+]] = add i32 %[[TMP19]], 1
    107. 

  107. // IR-NEXT:    %[[CMP15:.+]] = icmp ult i32 %[[TMP18]], %[[ADD14]]
    108. 

  108. // IR-NEXT:    br i1 %[[CMP15]], label %[[OMP_INNER_FOR_BODY:.+]], label %[[OMP_INNER_FOR_END:.+]]
    109. 

  109. // IR-EMPTY:
    110. 

  110. // IR-NEXT:  [[OMP_INNER_FOR_BODY]]:
    111. 

  111. // IR-NEXT:    %[[TMP20:.+]] = load i32, i32* %[[DOTOMP_IV]], align 4
    112. 

  112. // IR-NEXT:    %[[MUL:.+]] = mul i32 %[[TMP20]], 4
    113. 

  113. // IR-NEXT:    %[[ADD16:.+]] = add i32 0, %[[MUL]]
    114. 

  114. // IR-NEXT:    store i32 %[[ADD16]], i32* %[[DOTFLOOR_0_IV_I12]], align 4
    115. 

  115. // IR-NEXT:    %[[TMP21:.+]] = load i32, i32* %[[DOTFLOOR_0_IV_I12]], align 4
    116. 

  116. // IR-NEXT:    store i32 %[[TMP21]], i32* %[[DOTTILE_0_IV_I]], align 4
    117. 

  117. // IR-NEXT:    br label %[[FOR_COND:.+]]
    118. 

  118. // IR-EMPTY:
    119. 

  119. // IR-NEXT:  [[FOR_COND]]:
    120. 

  120. // IR-NEXT:    %[[TMP22:.+]] = load i32, i32* %[[DOTTILE_0_IV_I]], align 4
    121. 

  121. // IR-NEXT:    %[[TMP23:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_3]], align 4
    122. 

  122. // IR-NEXT:    %[[ADD17:.+]] = add i32 %[[TMP23]], 1
    123. 

  123. // IR-NEXT:    %[[TMP24:.+]] = load i32, i32* %[[DOTFLOOR_0_IV_I12]], align 4
    124. 

  124. // IR-NEXT:    %[[ADD18:.+]] = add nsw i32 %[[TMP24]], 4
    125. 

  125. // IR-NEXT:    %[[CMP19:.+]] = icmp ult i32 %[[ADD17]], %[[ADD18]]
    126. 

  126. // IR-NEXT:    br i1 %[[CMP19]], label %[[COND_TRUE20:.+]], label %[[COND_FALSE22:.+]]
    127. 

  127. // IR-EMPTY:
    128. 

  128. // IR-NEXT:  [[COND_TRUE20]]:
    129. 

  129. // IR-NEXT:    %[[TMP25:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_3]], align 4
    130. 

  130. // IR-NEXT:    %[[ADD21:.+]] = add i32 %[[TMP25]], 1
    131. 

  131. // IR-NEXT:    br label %[[COND_END24:.+]]
    132. 

  132. // IR-EMPTY:
    133. 

  133. // IR-NEXT:  [[COND_FALSE22]]:
    134. 

  134. // IR-NEXT:    %[[TMP26:.+]] = load i32, i32* %[[DOTFLOOR_0_IV_I12]], align 4
    135. 

  135. // IR-NEXT:    %[[ADD23:.+]] = add nsw i32 %[[TMP26]], 4
    136. 

  136. // IR-NEXT:    br label %[[COND_END24]]
    137. 

  137. // IR-EMPTY:
    138. 

  138. // IR-NEXT:  [[COND_END24]]:
    139. 

  139. // IR-NEXT:    %[[COND25:.+]] = phi i32 [ %[[ADD21]], %[[COND_TRUE20]] ], [ %[[ADD23]], %[[COND_FALSE22]] ]
    140. 

  140. // IR-NEXT:    %[[CMP26:.+]] = icmp ult i32 %[[TMP22]], %[[COND25]]
    141. 

  141. // IR-NEXT:    br i1 %[[CMP26]], label %[[FOR_BODY:.+]], label %[[FOR_END:.+]]
    142. 

  142. // IR-EMPTY:
    143. 

  143. // IR-NEXT:  [[FOR_BODY]]:
    144. 

  144. // IR-NEXT:    %[[TMP27:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_]], align 4
    145. 

  145. // IR-NEXT:    %[[TMP28:.+]] = load i32, i32* %[[DOTTILE_0_IV_I]], align 4
    146. 

  146. // IR-NEXT:    %[[TMP29:.+]] = load i32, i32* %[[DOTCAPTURE_EXPR_2]], align 4
    147. 

  147. // IR-NEXT:    %[[MUL27:.+]] = mul i32 %[[TMP28]], %[[TMP29]]
    148. 

  148. // IR-NEXT:    %[[ADD28:.+]] = add i32 %[[TMP27]], %[[MUL27]]
    149. 

  149. // IR-NEXT:    store i32 %[[ADD28]], i32* %[[I]], align 4
    150. 

  150. // IR-NEXT:    %[[TMP30:.+]] = load i32, i32* %[[START_ADDR]], align 4
    151. 

  151. // IR-NEXT:    %[[TMP31:.+]] = load i32, i32* %[[END_ADDR]], align 4
    152. 

  152. // IR-NEXT:    %[[TMP32:.+]] = load i32, i32* %[[STEP_ADDR]], align 4
    153. 

  153. // IR-NEXT:    %[[TMP33:.+]] = load i32, i32* %[[I]], align 4
    154. 

  154. // IR-NEXT:    call void (...) @body(i32 %[[TMP30]], i32 %[[TMP31]], i32 %[[TMP32]], i32 %[[TMP33]])
    155. 

  155. // IR-NEXT:    br label %[[FOR_INC:.+]]
    156. 

  156. // IR-EMPTY:
    157. 

  157. // IR-NEXT:  [[FOR_INC]]:
    158. 

  158. // IR-NEXT:    %[[TMP34:.+]] = load i32, i32* %[[DOTTILE_0_IV_I]], align 4
    159. 

  159. // IR-NEXT:    %[[INC:.+]] = add nsw i32 %[[TMP34]], 1
    160. 

  160. // IR-NEXT:    store i32 %[[INC]], i32* %[[DOTTILE_0_IV_I]], align 4
    161. 

  161. // IR-NEXT:    br label %[[FOR_COND]], !llvm.loop ![[LOOP2:[0-9]+]]
    162. 

  162. // IR-EMPTY:
    163. 

  163. // IR-NEXT:  [[FOR_END]]:
    164. 

  164. // IR-NEXT:    br label %[[OMP_BODY_CONTINUE:.+]]
    165. 

  165. // IR-EMPTY:
    166. 

  166. // IR-NEXT:  [[OMP_BODY_CONTINUE]]:
    167. 

  167. // IR-NEXT:    br label %[[OMP_INNER_FOR_INC:.+]]
    168. 

  168. // IR-EMPTY:
    169. 

  169. // IR-NEXT:  [[OMP_INNER_FOR_INC]]:
    170. 

  170. // IR-NEXT:    %[[TMP35:.+]] = load i32, i32* %[[DOTOMP_IV]], align 4
    171. 

  171. // IR-NEXT:    %[[ADD29:.+]] = add i32 %[[TMP35]], 1
    172. 

  172. // IR-NEXT:    store i32 %[[ADD29]], i32* %[[DOTOMP_IV]], align 4
    173. 

  173. // IR-NEXT:    br label %[[OMP_INNER_FOR_COND]]
    174. 

  174. // IR-EMPTY:
    175. 

  175. // IR-NEXT:  [[OMP_INNER_FOR_END]]:
    176. 

  176. // IR-NEXT:    br label %[[OMP_LOOP_EXIT:.+]]
    177. 

  177. // IR-EMPTY:
    178. 

  178. // IR-NEXT:  [[OMP_LOOP_EXIT]]:
    179. 

  179. // IR-NEXT:    call void @__kmpc_for_static_fini(%struct.ident_t* @1, i32 %[[TMP0]])
    180. 

  180. // IR-NEXT:    br label %[[OMP_PRECOND_END]]
    181. 

  181. // IR-EMPTY:
    182. 

  182. // IR-NEXT:  [[OMP_PRECOND_END]]:
    183. 

  183. // IR-NEXT:    call void @__kmpc_barrier(%struct.ident_t* @3, i32 %[[TMP0]])
    184. 

  184. // IR-NEXT:    ret void
    185. 

  185. // IR-NEXT:  }
    186. 

  186. extern "C" void func(int start, int end, int step) {
    187. 

  187. #pragma omp for
    188. 

  188. #pragma omp tile sizes(4)
    189. 

  189.   for (int i = start; i < end; i += step)
    190. 

  190.     body(start, end, step, i);
    191. 

  191. }
    192. 

  192. 

  193. #endif /* HEADER */
    194.