Domů Procházet Nápověda
Registrovat se Přihlásit se
FangSoftSoft
/
clang
2
0
Rozštěpit 0
Soubory Úkoly 0 Pull Requesty 0 Wiki
Strom: 653a638f94
Větve Značky
clang
/
test
/
OpenMP
/
master_taskloop_simd_reduction_codegen.cpp

master_taskloop_simd_reduction_codegen.cpp 13 KB
Historie Surový

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215 
  1. // RUN: %clang_cc1 -fopenmp -x c++ %s -verify -debug-info-kind=limited -emit-llvm -o - -triple powerpc64le-unknown-linux-gnu -std=c++98 | FileCheck %s
    2. 

  2. 

  3. // RUN: %clang_cc1 -fopenmp-simd -x c++ %s -verify -debug-info-kind=limited -emit-llvm -o - -triple powerpc64le-unknown-linux-gnu -std=c++98 | FileCheck --check-prefix SIMD-ONLY0 %s
    4. 

  4. // SIMD-ONLY0-NOT: {{__kmpc|__tgt}}
    5. 

  5. // expected-no-diagnostics
    6. 

  6. 

  7. struct S {
    8. 

  8.   float a;
    9. 

  9.   S() : a(0.0f) {}
    10. 

  10.   ~S() {}
    11. 

  11. };
    12. 

  12. 

  13. #pragma omp declare reduction(+:S:omp_out.a += omp_in.a) initializer(omp_priv = omp_orig)
    14. 

  14. 

  15. float g;
    16. 

  16. 

  17. int a;
    18. 

  18. #pragma omp threadprivate(a)
    19. 

  19. int main (int argc, char *argv[])
    20. 

  20. {
    21. 

  21. int   i, n;
    22. 

  22. float a[100], b[100], sum, e[argc + 100];
    23. 

  23. S c[100];
    24. 

  24. float &d = g;
    25. 

  25. 

  26. /* Some initializations */
    27. 

  27. n = 100;
    28. 

  28. for (i=0; i < n; i++)
    29. 

  29.   a[i] = b[i] = i * 1.0;
    30. 

  30. sum = 0.0;
    31. 

  31. 

  32. #pragma omp master taskloop simd reduction(+:sum, c[:n], d, e)
    33. 

  33.   for (i=0; i < n; i++) {
    34. 

  34.     sum = sum + (a[i] * b[i]);
    35. 

  35.     c[i].a = i*i;
    36. 

  36.     d += i*i;
    37. 

  37.     e[i] = i;
    38. 

  38.   }
    39. 

  39. 

  40. }
    41. 

  41. 

  42. // CHECK-LABEL: @main(
    43. 

  43. // CHECK:    [[RETVAL:%.*]] = alloca i32,
    44. 

  44. // CHECK:    [[ARGC_ADDR:%.*]] = alloca i32,
    45. 

  45. // CHECK:    [[ARGV_ADDR:%.*]] = alloca i8**,
    46. 

  46. // CHECK:    [[I:%.*]] = alloca i32,
    47. 

  47. // CHECK:    [[N:%.*]] = alloca i32,
    48. 

  48. // CHECK:    [[A:%.*]] = alloca [100 x float],
    49. 

  49. // CHECK:    [[B:%.*]] = alloca [100 x float],
    50. 

  50. // CHECK:    [[SUM:%.*]] = alloca float,
    51. 

  51. // CHECK:    [[SAVED_STACK:%.*]] = alloca i8*,
    52. 

  52. // CHECK:    [[C:%.*]] = alloca [100 x %struct.S],
    53. 

  53. // CHECK:    [[D:%.*]] = alloca float*,
    54. 

  54. // CHECK:    [[AGG_CAPTURED:%.*]] = alloca [[STRUCT_ANON:%.*]],
    55. 

  55. // CHECK:    [[DOTRD_INPUT_:%.*]] = alloca [4 x %struct.kmp_task_red_input_t],
    56. 

  56. // CHECK:    alloca i32,
    57. 

  57. // CHECK:    [[DOTCAPTURE_EXPR_:%.*]] = alloca i32,
    58. 

  58. // CHECK:    [[DOTCAPTURE_EXPR_9:%.*]] = alloca i32,
    59. 

  59. // CHECK:    [[TMP0:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t*
    60. 

  60. // CHECK:    store i32 0, i32* [[RETVAL]],
    61. 

  61. // CHECK:    store i32 [[ARGC:%.*]], i32* [[ARGC_ADDR]],
    62. 

  62. // CHECK:    store i8** [[ARGV:%.*]], i8*** [[ARGV_ADDR]],
    63. 

  63. // CHECK:    [[TMP1:%.*]] = load i32, i32* [[ARGC_ADDR]],
    64. 

  64. // CHECK:    [[ADD:%.*]] = add nsw i32 [[TMP1]], 100
    65. 

  65. // CHECK:    [[TMP2:%.*]] = zext i32 [[ADD]] to i64
    66. 

  66. // CHECK:    [[VLA:%.+]] = alloca float, i64 %
    67. 

  67. 

  68. // CHECK:    call void @__kmpc_taskgroup(%struct.ident_t*
    69. 

  69. // CHECK-DAG:    [[TMP21:%.*]] = bitcast float* [[SUM]] to i8*
    70. 

  70. // CHECK-DAG:    store i8* [[TMP21]], i8** [[TMP20:%[^,]+]],
    71. 

  71. // CHECK-DAG:    [[TMP20]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T:%.+]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_:%.+]], i32 0, i32 0
    72. 

  72. // CHECK-DAG:    [[TMP22:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_]], i32 0, i32 1
    73. 

  73. // CHECK-DAG:    store i64 4, i64* [[TMP22]],
    74. 

  74. // CHECK-DAG:    [[TMP23:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_]], i32 0, i32 2
    75. 

  75. // CHECK-DAG:    store i8* bitcast (void (i8*)* @[[RED_INIT1:.+]] to i8*), i8** [[TMP23]],
    76. 

  76. // CHECK-DAG:    [[TMP24:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_]], i32 0, i32 3
    77. 

  77. // CHECK-DAG:    store i8* null, i8** [[TMP24]],
    78. 

  78. // CHECK-DAG:    [[TMP25:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_]], i32 0, i32 4
    79. 

  79. // CHECK-DAG:    store i8* bitcast (void (i8*, i8*)* @[[RED_COMB1:.+]] to i8*), i8** [[TMP25]],
    80. 

  80. // CHECK-DAG:    [[TMP26:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_]], i32 0, i32 5
    81. 

  81. // CHECK-DAG:    [[TMP27:%.*]] = bitcast i32* [[TMP26]] to i8*
    82. 

  82. // CHECK-DAG:    call void @llvm.memset.p0i8.i64(i8* align 8 [[TMP27]], i8 0, i64 4, i1 false)
    83. 

  83. // CHECK-DAG:    [[ARRAYIDX5:%.*]] = getelementptr inbounds [100 x %struct.S], [100 x %struct.S]* [[C]], i64 0, i64 0
    84. 

  84. // CHECK-DAG:    [[LB_ADD_LEN:%.*]] = add nsw i64 -1, %
    85. 

  85. // CHECK-DAG:    [[ARRAYIDX6:%.*]] = getelementptr inbounds [100 x %struct.S], [100 x %struct.S]* [[C]], i64 0, i64 [[LB_ADD_LEN]]
    86. 

  86. // CHECK-DAG:    [[TMP31:%.*]] = bitcast %struct.S* [[ARRAYIDX5]] to i8*
    87. 

  87. // CHECK-DAG:    store i8* [[TMP31]], i8** [[TMP28:%[^,]+]],
    88. 

  88. // CHECK-DAG:    [[TMP28]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_4:%.+]], i32 0, i32 0
    89. 

  89. // CHECK-DAG:    [[TMP32:%.*]] = ptrtoint %struct.S* [[ARRAYIDX6]] to i64
    90. 

  90. // CHECK-DAG:    [[TMP33:%.*]] = ptrtoint %struct.S* [[ARRAYIDX5]] to i64
    91. 

  91. // CHECK-DAG:    [[TMP34:%.*]] = sub i64 [[TMP32]], [[TMP33]]
    92. 

  92. // CHECK-DAG:    [[TMP35:%.*]] = sdiv exact i64 [[TMP34]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
    93. 

  93. // CHECK-DAG:    [[TMP36:%.*]] = add nuw i64 [[TMP35]], 1
    94. 

  94. // CHECK-DAG:    [[TMP37:%.*]] = mul nuw i64 [[TMP36]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
    95. 

  95. // CHECK-DAG:    store i64 [[TMP37]], i64* [[TMP38:%[^,]+]],
    96. 

  96. // CHECK-DAG:    [[TMP38]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_4]], i32 0, i32 1
    97. 

  97. // CHECK-DAG:    [[TMP39:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_4]], i32 0, i32 2
    98. 

  98. // CHECK-DAG:    store i8* bitcast (void (i8*)* @[[RED_INIT2:.+]] to i8*), i8** [[TMP39]],
    99. 

  99. // CHECK-DAG:    [[TMP40:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_4]], i32 0, i32 3
    100. 

  100. // CHECK-DAG:    store i8* bitcast (void (i8*)* @[[RED_FINI2:.+]] to i8*), i8** [[TMP40]],
    101. 

  101. // CHECK-DAG:    [[TMP41:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_4]], i32 0, i32 4
    102. 

  102. // CHECK-DAG:    store i8* bitcast (void (i8*, i8*)* @[[RED_COMB2:.+]] to i8*), i8** [[TMP41]],
    103. 

  103. // CHECK-DAG:    [[TMP42:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_4]], i32 0, i32 5
    104. 

  104. // CHECK-DAG:    store i32 1, i32* [[TMP42]],
    105. 

  105. // CHECK-DAG:    [[TMP44:%.*]] = load float*, float** [[D]],
    106. 

  106. // CHECK-DAG:    [[TMP45:%.*]] = bitcast float* [[TMP44]] to i8*
    107. 

  107. // CHECK-DAG:    store i8* [[TMP45]], i8** [[TMP43:%[^,]+]],
    108. 

  108. // CHECK-DAG:    [[TMP43]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_7:%.+]], i32 0, i32 0
    109. 

  109. // CHECK-DAG:    [[TMP46:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_7]], i32 0, i32 1
    110. 

  110. // CHECK-DAG:    store i64 4, i64* [[TMP46]],
    111. 

  111. // CHECK-DAG:    [[TMP47:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_7]], i32 0, i32 2
    112. 

  112. // CHECK-DAG:    store i8* bitcast (void (i8*)* @[[RED_INIT3:.+]] to i8*), i8** [[TMP47]],
    113. 

  113. // CHECK-DAG:    [[TMP48:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_7]], i32 0, i32 3
    114. 

  114. // CHECK-DAG:    store i8* null, i8** [[TMP48]],
    115. 

  115. // CHECK-DAG:    [[TMP49:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_7]], i32 0, i32 4
    116. 

  116. // CHECK-DAG:    store i8* bitcast (void (i8*, i8*)* @[[RED_COMB3:.+]] to i8*), i8** [[TMP49]],
    117. 

  117. // CHECK-DAG:    [[TMP50:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_7]], i32 0, i32 5
    118. 

  118. // CHECK-DAG:    [[TMP51:%.*]] = bitcast i32* [[TMP50]] to i8*
    119. 

  119. // CHECK-DAG:    call void @llvm.memset.p0i8.i64(i8* align 8 [[TMP51]], i8 0, i64 4, i1 false)
    120. 

  120. // CHECK-DAG:    [[TMP53:%.*]] = bitcast float* [[VLA]] to i8*
    121. 

  121. // CHECK-DAG:    store i8* [[TMP53]], i8** [[TMP52:%[^,]+]],
    122. 

  122. // CHECK-DAG:    [[TMP52]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_8:%.+]], i32 0, i32 0
    123. 

  123. // CHECK-DAG:    [[TMP54:%.*]] = mul nuw i64 [[TMP2]], 4
    124. 

  124. // CHECK-DAG:    [[TMP55:%.*]] = udiv exact i64 [[TMP54]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
    125. 

  125. // CHECK-DAG:    store i64 [[TMP54]], i64* [[TMP56:%[^,]+]],
    126. 

  126. // CHECK-DAG:    [[TMP56]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_8]], i32 0, i32 1
    127. 

  127. // CHECK-DAG:    [[TMP57:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_8]], i32 0, i32 2
    128. 

  128. // CHECK-DAG:    store i8* bitcast (void (i8*)* @[[RED_INIT4:.+]] to i8*), i8** [[TMP57]],
    129. 

  129. // CHECK-DAG:    [[TMP58:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_8]], i32 0, i32 3
    130. 

  130. // CHECK-DAG:    store i8* null, i8** [[TMP58]],
    131. 

  131. // CHECK-DAG:    [[TMP59:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_8]], i32 0, i32 4
    132. 

  132. // CHECK-DAG:    store i8* bitcast (void (i8*, i8*)* @[[RED_COMB4:.+]] to i8*), i8** [[TMP59]],
    133. 

  133. // CHECK-DAG:    [[TMP60:%.*]] = getelementptr inbounds [[STRUCT_KMP_TASK_RED_INPUT_T]], %struct.kmp_task_red_input_t* [[DOTRD_INPUT_GEP_8]], i32 0, i32 5
    134. 

  134. // CHECK-DAG:    store i32 1, i32* [[TMP60]],
    135. 

  135. // CHECK-DAG:    [[DOTRD_INPUT_GEP_]] = getelementptr inbounds [4 x %struct.kmp_task_red_input_t], [4 x %struct.kmp_task_red_input_t]* [[DOTRD_INPUT_]], i64 0, i64
    136. 

  136. // CHECK-DAG:    [[DOTRD_INPUT_GEP_4]] = getelementptr inbounds [4 x %struct.kmp_task_red_input_t], [4 x %struct.kmp_task_red_input_t]* [[DOTRD_INPUT_]], i64 0, i64
    137. 

  137. // CHECK-DAG:    [[DOTRD_INPUT_GEP_7]] = getelementptr inbounds [4 x %struct.kmp_task_red_input_t], [4 x %struct.kmp_task_red_input_t]* [[DOTRD_INPUT_]], i64 0, i64
    138. 

  138. // CHECK-DAG:    [[DOTRD_INPUT_GEP_8]] = getelementptr inbounds [4 x %struct.kmp_task_red_input_t], [4 x %struct.kmp_task_red_input_t]* [[DOTRD_INPUT_]], i64 0, i64
    139. 

  139. // CHECK:    [[TMP61:%.*]] = bitcast [4 x %struct.kmp_task_red_input_t]* [[DOTRD_INPUT_]] to i8*
    140. 

  140. // CHECK:    [[TMP62:%.*]] = call i8* @__kmpc_task_reduction_init(i32 [[TMP0]], i32 4, i8* [[TMP61]])
    141. 

  141. // CHECK:    [[TMP63:%.*]] = load i32, i32* [[N]],
    142. 

  142. // CHECK:    store i32 [[TMP63]], i32* [[DOTCAPTURE_EXPR_]],
    143. 

  143. // CHECK:    [[TMP64:%.*]] = load i32, i32* [[DOTCAPTURE_EXPR_]],
    144. 

  144. // CHECK:    [[SUB:%.*]] = sub nsw i32 [[TMP64]], 0
    145. 

  145. // CHECK:    [[SUB10:%.*]] = sub nsw i32 [[SUB]], 1
    146. 

  146. // CHECK:    [[ADD11:%.*]] = add nsw i32 [[SUB10]], 1
    147. 

  147. // CHECK:    [[DIV:%.*]] = sdiv i32 [[ADD11]], 1
    148. 

  148. // CHECK:    [[SUB12:%.*]] = sub nsw i32 [[DIV]], 1
    149. 

  149. // CHECK:    store i32 [[SUB12]], i32* [[DOTCAPTURE_EXPR_9]],
    150. 

  150. // CHECK:    [[TMP65:%.*]] = call i8* @__kmpc_omp_task_alloc(%struct.ident_t* %{{.+}}, i32 [[TMP0]], i32 1, i64 888, i64 72, i32 (i32, i8*)* bitcast (i32 (i32, %struct.kmp_task_t_with_privates*)* @{{.+}} to i32 (i32, i8*)*))
    151. 

  151. // CHECK:    call void @__kmpc_taskloop(%struct.ident_t* %{{.+}}, i32 [[TMP0]], i8* [[TMP65]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
    152. 

  152. // CHECK:    call void @__kmpc_end_taskgroup(%struct.ident_t*
    153. 

  153. 

  154. // CHECK:    ret i32
    155. 

  155. 

  156. // CHECK: define internal void @[[RED_INIT1]](i8* %0)
    157. 

  157. // CHECK: store float 0.000000e+00, float* %
    158. 

  158. // CHECK: ret void
    159. 

  159. 

  160. // CHECK: define internal void @[[RED_COMB1]](i8* %0, i8* %1)
    161. 

  161. // CHECK: fadd float %
    162. 

  162. // CHECK: store float %{{.+}}, float* %
    163. 

  163. // CHECK: ret void
    164. 

  164. 

  165. // CHECK: define internal void @[[RED_INIT2]](i8* %0)
    166. 

  166. // CHECK: call i8* @__kmpc_threadprivate_cached(
    167. 

  167. // CHECK: call i8* @__kmpc_threadprivate_cached(
    168. 

  168. // CHECK: call void [[OMP_INIT1:@.+]](
    169. 

  169. // CHECK: ret void
    170. 

  170. 

  171. // CHECK: define internal void [[OMP_COMB1:@.+]](%struct.S* noalias %0, %struct.S* noalias %1)
    172. 

  172. // CHECK: fadd float %
    173. 

  173. 

  174. // CHECK: define internal void [[OMP_INIT1]](%struct.S* noalias %0, %struct.S* noalias %1)
    175. 

  175. // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(
    176. 

  176. 

  177. // CHECK: define internal void @[[RED_FINI2]](i8* %0)
    178. 

  178. // CHECK: call i8* @__kmpc_threadprivate_cached(
    179. 

  179. // CHECK: call void @
    180. 

  180. // CHECK: ret void
    181. 

  181. 

  182. // CHECK: define internal void @[[RED_COMB2]](i8* %0, i8* %1)
    183. 

  183. // CHECK: call i8* @__kmpc_threadprivate_cached(
    184. 

  184. // CHECK: call void [[OMP_COMB1]](
    185. 

  185. // CHECK: ret void
    186. 

  186. 

  187. // CHECK: define internal void @[[RED_INIT3]](i8* %0)
    188. 

  188. // CHECK: store float 0.000000e+00, float* %
    189. 

  189. // CHECK: ret void
    190. 

  190. 

  191. // CHECK: define internal void @[[RED_COMB3]](i8* %0, i8* %1)
    192. 

  192. // CHECK: fadd float %
    193. 

  193. // CHECK: store float %{{.+}}, float* %
    194. 

  194. // CHECK: ret void
    195. 

  195. 

  196. // CHECK: define internal void @[[RED_INIT4]](i8* %0)
    197. 

  197. // CHECK: call i8* @__kmpc_threadprivate_cached(
    198. 

  198. // CHECK: store float 0.000000e+00, float* %
    199. 

  199. // CHECK: ret void
    200. 

  200. 

  201. // CHECK: define internal void @[[RED_COMB4]](i8* %0, i8* %1)
    202. 

  202. // CHECK: call i8* @__kmpc_threadprivate_cached(
    203. 

  203. // CHECK: fadd float %
    204. 

  204. // CHECK: store float %{{.+}}, float* %
    205. 

  205. // CHECK: ret void
    206. 

  206. 

  207. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_INIT1]]"
    208. 

  208. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_COMB1]]"
    209. 

  209. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_INIT2]]"
    210. 

  210. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_FINI2]]"
    211. 

  211. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_COMB2]]"
    212. 

  212. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_INIT3]]"
    213. 

  213. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_COMB3]]"
    214. 

  214. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_INIT4]]"
    215. 

  215. // CHECK-DAG: !DISubprogram(linkageName: "[[RED_COMB4]]"
    216.