// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG

// CIR-DAG: cir.global "private"{{.*}}constant cir_private @[[FUNC2_ARR:.*]] = #cir.const_array<[#cir.int<5> : !s32i, #cir.int<0> : !s32i]> : !cir.array<!s32i x 2>
// CIR-DAG: cir.global "private"{{.*}}constant cir_private @[[FUNC3_ARR:.*]] = #cir.const_array<[#cir.int<5> : !s32i, #cir.int<6> : !s32i]> : !cir.array<!s32i x 2>
// CIR-DAG: cir.global "private"{{.*}}constant cir_private @[[FUNC4_ARR:.*]] = #cir.const_array<[#cir.const_array<[#cir.int<5> : !s32i]> : !cir.array<!s32i x 1>, #cir.const_array<[#cir.int<6> : !s32i]> : !cir.array<!s32i x 1>]> : !cir.array<!cir.array<!s32i x 1> x 2>
// CIR-DAG: cir.global "private"{{.*}}constant cir_private @[[FUNC5_ARR:.*]] = #cir.const_array<[#cir.const_array<[#cir.int<5> : !s32i]> : !cir.array<!s32i x 1>, #cir.zero : !cir.array<!s32i x 1>]> : !cir.array<!cir.array<!s32i x 1> x 2>
// CIR-DAG: cir.global "private"{{.*}}constant cir_private @[[FUNC7_ARR:.*]] = #cir.zero : !cir.array<!cir.ptr<!s32i> x 1>
// CIR-DAG: cir.global "private"{{.*}}constant cir_private @[[COMPLEX_ARR:.*]] = #cir.const_array<[#cir.const_complex<#cir.fp<1.100000e+00> : !cir.float, #cir.fp<2.200000e+00> : !cir.float> : !cir.complex<!cir.float>, #cir.const_complex<#cir.fp<3.300000e+00> : !cir.float, #cir.fp<4.400000e+00> : !cir.float> : !cir.complex<!cir.float>]> : !cir.array<!cir.complex<!cir.float> x 2>

int a[10];
// CIR: cir.global external @a = #cir.zero : !cir.array<!s32i x 10>

// LLVM: @a = global [10 x i32] zeroinitializer

// OGCG: @a = global [10 x i32] zeroinitializer

int aa[10][5];
// CIR: cir.global external @aa = #cir.zero : !cir.array<!cir.array<!s32i x 5> x 10>

// LLVM: @aa = global [10 x [5 x i32]] zeroinitializer

// OGCG: @aa = global [10 x [5 x i32]] zeroinitializer

int c[10] = {};
// CIR: cir.global external @c = #cir.zero : !cir.array<!s32i x 10>

// LLVM: @c = global [10 x i32] zeroinitializer

// OGCG: @c = global [10 x i32] zeroinitializer

int d[3] = {1, 2, 3};
// CIR: cir.global external @d = #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i]> : !cir.array<!s32i x 3>

// LLVM: @d = global [3 x i32] [i32 1, i32 2, i32 3]

// OGCG: @d = global [3 x i32] [i32 1, i32 2, i32 3]

int dd[3][2] = {{1, 2}, {3, 4}, {5, 6}};
// CIR: cir.global external @dd = #cir.const_array<[#cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i]> : !cir.array<!s32i x 2>, #cir.const_array<[#cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.array<!s32i x 2>, #cir.const_array<[#cir.int<5> : !s32i, #cir.int<6> : !s32i]> : !cir.array<!s32i x 2>]> : !cir.array<!cir.array<!s32i x 2> x 3>

// LLVM: @dd = global [3 x [2 x i32]] [
// LLVM: [2 x i32] [i32 1, i32 2], [2 x i32]
// LLVM: [i32 3, i32 4], [2 x i32] [i32 5, i32 6]]

// OGCG: @dd = global [3 x [2 x i32]] [
// OGCG: [2 x i32] [i32 1, i32 2], [2 x i32]
// OGCG: [i32 3, i32 4], [2 x i32] [i32 5, i32 6]]

int e[10] = {1, 2};
// CIR: cir.global external @e = #cir.const_record<{#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.zero : !cir.array<!s32i x 8>}> : !rec_anon_struct

// LLVM: @e = global <{ i32, i32, [8 x i32] }> <{ i32 1, i32 2, [8 x i32] zeroinitializer }>

// OGCG: @e = global <{ i32, i32, [8 x i32] }> <{ i32 1, i32 2, [8 x i32] zeroinitializer }>

int f[5] = {1, 2};
// CIR: cir.global external @f = #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<0> : !s32i, #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.array<!s32i x 5>

// LLVM: @f = global [5 x i32] [i32 1, i32 2, i32 0, i32 0, i32 0]

// OGCG: @f = global [5 x i32] [i32 1, i32 2, i32 0, i32 0, i32 0]

int g[16] = {1, 2, 3, 4, 5, 6, 7, 8};
// CIR:      cir.global external @g = #cir.const_record<{
// CIR-SAME:   #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME:                     #cir.int<3> : !s32i, #cir.int<4> : !s32i,
// CIR-SAME:                     #cir.int<5> : !s32i, #cir.int<6> : !s32i,
// CIR-SAME:                     #cir.int<7> : !s32i, #cir.int<8> : !s32i]>
// CIR-SAME:                     : !cir.array<!s32i x 8>,
// CIR-SAME:   #cir.zero : !cir.array<!s32i x 8>}> : !rec_anon_struct1

// LLVM:       @g = global <{ [8 x i32], [8 x i32] }> 
// LLVM-SAME:          <{ [8 x i32]
// LLVM-SAME:              [i32 1, i32 2, i32 3, i32 4,
// LLVM-SAME:               i32 5, i32 6, i32 7, i32 8],
// LLVM-SAME:             [8 x i32] zeroinitializer }>

// OGCG:       @g = global <{ [8 x i32], [8 x i32] }> 
// OGCG-SAME:          <{ [8 x i32]
// OGCG-SAME:              [i32 1, i32 2, i32 3, i32 4,
// OGCG-SAME:               i32 5, i32 6, i32 7, i32 8],
// OGCG-SAME:             [8 x i32] zeroinitializer }>

// If we have explicit trailing zeros, those should still be combined into
// a zero initializer array.
int h[16] = {1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0};

// CIR:      cir.global external @h = #cir.const_record<{
// CIR-SAME:   #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME:                     #cir.int<3> : !s32i, #cir.int<4> : !s32i,
// CIR-SAME:                     #cir.int<5> : !s32i, #cir.int<6> : !s32i,
// CIR-SAME:                     #cir.int<7> : !s32i, #cir.int<8> : !s32i]>
// CIR-SAME:                     : !cir.array<!s32i x 8>,
// CIR-SAME:   #cir.zero : !cir.array<!s32i x 8>}> : !rec_anon_struct1

// LLVM:       @h = global <{ [8 x i32], [8 x i32] }>
// LLVM-SAME:          <{ [8 x i32]
// LLVM-SAME:              [i32 1, i32 2, i32 3, i32 4,
// LLVM-SAME:               i32 5, i32 6, i32 7, i32 8],
// LLVM-SAME:             [8 x i32] zeroinitializer }>

// OGCG:       @h = global <{ [8 x i32], [8 x i32] }>
// OGCG-SAME:          <{ [8 x i32]
// OGCG-SAME:              [i32 1, i32 2, i32 3, i32 4,
// OGCG-SAME:               i32 5, i32 6, i32 7, i32 8],
// OGCG-SAME:             [8 x i32] zeroinitializer }>

char huge[0x1FFFFFFFFFFFFFFFULL];
// CIR: cir.global external @huge = #cir.zero : !cir.array<!s8i x 2305843009213693951>
// LLVM: @huge = global [2305843009213693951 x i8] zeroinitializer
// OGCG: @huge = global [2305843009213693951 x i8] zeroinitializer

extern int b[10];
// CIR: cir.global "private" external @b : !cir.array<!s32i x 10>
// LLVM: @b = external global [10 x i32]
// OGCG: @b = external global [10 x i32]

extern int bb[10][5];
// CIR: cir.global "private" external @bb : !cir.array<!cir.array<!s32i x 5> x 10>
// LLVM: @bb = external global [10 x [5 x i32]]
// OGCG: @bb = external global [10 x [5 x i32]]

// This function is only here to make sure the external globals are emitted.
void reference_externs() {
  b;
  bb;
}

// OGCG: @[[FUN2_ARR:.*]] = private unnamed_addr constant [2 x i32] [i32 5, i32 0], align 4
// OGCG: @[[FUN3_ARR:.*]] = private unnamed_addr constant [2 x i32] [i32 5, i32 6], align 4
// OGCG: @[[FUN4_ARR:.*]] = private unnamed_addr constant [2 x [1 x i32]] [
// OGCG: [1 x i32] [i32 5], [1 x i32] [i32 6]], align 4
// OGCG: @[[FUN5_ARR:.*]] = private unnamed_addr constant [2 x [1 x i32]] [
// OGCG: [1 x i32] [i32 5], [1 x i32] zeroinitializer], align 4

void func() {
  int arr[10];
  int e = arr[0];
  int e2 = arr[1];
}

// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["arr"]
// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
// CIR: %[[INIT_2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e2", init]
// CIR: %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[ELE_PTR:.*]] = cir.get_element %[[ARR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[ELE_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR" cir.store %[[TMP]], %[[INIT]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[IDX:.*]] = cir.const #cir.int<1> : !s64i
// CIR: %[[ELE_PTR:.*]] = cir.get_element %[[ARR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[ELE_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR" cir.store %[[TMP]], %[[INIT_2]] : !s32i, !cir.ptr<!s32i>

// LLVM: define{{.*}} void @_Z4funcv(){{.*}}
// LLVM-NEXT: %[[ARR:.*]] = alloca [10 x i32], i64 1, align 16
// LLVM-NEXT: %[[INIT:.*]] = alloca i32, i64 1, align 4
// LLVM-NEXT: %[[INIT_2:.*]] = alloca i32, i64 1, align 4
// LLVM-NEXT: %[[ELE_PTR:.*]] = getelementptr [10 x i32], ptr %[[ARR]], i32 0, i64 0
// LLVM-NEXT: %[[TMP_1:.*]] = load i32, ptr %[[ELE_PTR]], align 16
// LLVM-NEXT: store i32 %[[TMP_1]], ptr %[[INIT]], align 4
// LLVM-NEXT: %[[ELE_PTR:.*]] = getelementptr [10 x i32], ptr %[[ARR]], i32 0, i64 1
// LLVM-NEXT: %[[TMP_2:.*]] = load i32, ptr %[[ELE_PTR]], align 4
// LLVM-NEXT: store i32 %[[TMP_2]], ptr %[[INIT_2]], align 4

// OGCG: %[[ARR:.*]] = alloca [10 x i32], align 16
// OGCG: %[[INIT:.*]] = alloca i32, align 4
// OGCG: %[[INIT_2:.*]] = alloca i32, align 4
// OGCG: %[[ELE_PTR:.*]] = getelementptr inbounds [10 x i32], ptr %[[ARR]], i64 0, i64 0
// OGCG: %[[TMP_1:.*]] = load i32, ptr %[[ELE_PTR]], align 16
// OGCG: store i32 %[[TMP_1]], ptr %[[INIT]], align 4
// OGCG: %[[ELE_PTR:.*]] = getelementptr inbounds [10 x i32], ptr %[[ARR]], i64 0, i64 1
// OGCG: %[[TMP_2:.*]] = load i32, ptr %[[ELE_PTR]], align 4
// OGCG: store i32 %[[TMP_2]], ptr %[[INIT_2]], align 4

void func2() {
  int arr[2] = {5};
}

// CIR: %[[ARR2:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr", init]
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC2_ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR2]] : !cir.ptr<!cir.array<!s32i x 2>>

// LLVM: define{{.*}} void @_Z5func2v(){{.*}}
// LLVM:   %[[ARR:.*]] = alloca [2 x i32], i64 1, align 4
// LLVM:   call void @llvm.memcpy.p0.p0.i64(ptr %[[ARR]], ptr @[[FUNC2_ARR:.*]], i64 8, i1 false)

// OGCG: %[[ARR:.*]] = alloca [2 x i32], align 4
// OGCG: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[ARR]], ptr align 4 @[[FUN2_ARR]], i64 8, i1 false)

void func3() {
  int arr[2] = {5, 6};

  int idx = 1;
  int e = arr[idx];
}

// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr", init]
// CIR: %[[IDX:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["idx", init]
// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC3_ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[IDX_V:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[IDX_V]], %[[IDX]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP_IDX:.*]] = cir.load{{.*}} %[[IDX]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[TMP_IDX_64:.*]] = cir.cast integral %[[TMP_IDX]] : !s32i -> !s64i
// CIR: %[[ELE_PTR:.*]] = cir.get_element %[[ARR]][%[[TMP_IDX_64]] : !s64i] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: %[[ELE_TMP:.*]] = cir.load{{.*}} %[[ELE_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store{{.*}} %[[ELE_TMP]], %[[INIT]] : !s32i, !cir.ptr<!s32i>

// LLVM: define{{.*}} void @_Z5func3v(){{.*}}
// LLVM:  %[[ARR:.*]] = alloca [2 x i32], i64 1, align 4
// LLVM:  %[[IDX:.*]] = alloca i32, i64 1, align 4
// LLVM:  %[[INIT:.*]] = alloca i32, i64 1, align 4
// LLVM:  call void @llvm.memcpy.p0.p0.i64(ptr %[[ARR]], ptr @[[FUNC3_ARR:.*]], i64 8, i1 false)
// LLVM:  store i32 1, ptr %[[IDX]], align 4
// LLVM:  %[[TMP1:.*]] = load i32, ptr %[[IDX]], align 4
// LLVM:  %[[IDX_I64:.*]] = sext i32 %[[TMP1]] to i64
// LLVM:  %[[ELE:.*]] = getelementptr [2 x i32], ptr %[[ARR]], i32 0, i64 %[[IDX_I64]]
// LLVM:  %[[TMP2:.*]] = load i32, ptr %[[ELE]], align 4
// LLVM:  store i32 %[[TMP2]], ptr %[[INIT]], align 4

// OGCG:  %[[ARR:.*]] = alloca [2 x i32], align 4
// OGCG:  %[[IDX:.*]] = alloca i32, align 4
// OGCG:  %[[INIT:.*]] = alloca i32, align 4
// OGCG:  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[ARR]], ptr align 4 @[[FUN3_ARR]], i64 8, i1 false)
// OGCG:  store i32 1, ptr %[[IDX]], align 4
// OGCG:  %[[TMP:.*]] = load i32, ptr %[[IDX]], align 4
// OGCG:  %[[IDX_I64:.*]] = sext i32 %[[TMP]] to i64
// OGCG:  %[[ELE:.*]] = getelementptr inbounds [2 x i32], ptr %[[ARR]], i64 0, i64 %[[IDX_I64]]
// OGCG:  %[[TMP_2:.*]] = load i32, ptr %[[ELE]], align 4
// OGCG:  store i32 %[[TMP_2:.*]], ptr %[[INIT]], align 4

void func4() {
  int arr[2][1] = {{5}, {6}};
  int e = arr[1][0];
}

// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.array<!s32i x 1> x 2>, !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>, ["arr", init]
// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC4_ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[IDX_1:.*]] = cir.const #cir.int<1> : !s64i
// CIR: %[[ARR_1:.*]] = cir.get_element %[[ARR]][%[[IDX_1]] : !s64i] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>> -> !cir.ptr<!cir.array<!s32i x 1>>
// CIR: %[[ELE_0:.*]] = cir.get_element %[[ARR_1]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 1>> -> !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[ELE_0]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store{{.*}} %[[TMP]], %[[INIT]] : !s32i, !cir.ptr<!s32i>

// LLVM: define{{.*}} void @_Z5func4v(){{.*}}
// LLVM:  %[[ARR:.*]] = alloca [2 x [1 x i32]], i64 1, align 4
// LLVM:  %[[INIT:.*]] = alloca i32, i64 1, align 4
// LLVM:  call void @llvm.memcpy.p0.p0.i64(ptr %[[ARR]], ptr @[[FUNC4_ARR:.*]], i64 8, i1 false)
// LLVM:  %[[ARR_1:.*]] = getelementptr [2 x [1 x i32]], ptr %[[ARR]], i32 0, i64 1
// LLVM:  %[[ELE_PTR:.*]] = getelementptr [1 x i32], ptr %[[ARR_1]], i32 0, i64 0
// LLVM:  %[[TMP:.*]] = load i32, ptr %[[ELE_PTR]], align 4
// LLVM:  store i32 %[[TMP]], ptr %[[INIT]], align 4

// OGCG: %[[ARR:.*]] = alloca [2 x [1 x i32]], align 4
// OGCG: %[[INIT:.*]] = alloca i32, align 4
// OGCG: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[ARR]], ptr align 4 @[[FUN4_ARR]], i64 8, i1 false)
// OGCG: %[[ARR_1:.*]] = getelementptr inbounds [2 x [1 x i32]], ptr %[[ARR]], i64 0, i64 1
// OGCG: %[[ARR_1_0:.*]] = getelementptr inbounds [1 x i32], ptr %[[ARR_1]], i64 0, i64 0
// OGCG: %[[TMP:.*]] = load i32, ptr %[[ARR_1_0]], align 4
// OGCG: store i32 %[[TMP]], ptr %[[INIT]], align 4

void func5() {
  int arr[2][1] = {{5}};
}

// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.array<!s32i x 1> x 2>, !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>, ["arr", init]
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC5_ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>

// LLVM: define{{.*}} void @_Z5func5v(){{.*}}
// LLVM:   %[[ARR:.*]] = alloca [2 x [1 x i32]], i64 1, align 4
// LLVM:   call void @llvm.memcpy.p0.p0.i64(ptr %[[ARR]], ptr @[[FUNC5_ARR:.*]], i64 8, i1 false)

// OGCG: %[[ARR:.*]] = alloca [2 x [1 x i32]], align 4
// OGCG: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[ARR]], ptr align 4 @[[FUN5_ARR]], i64 8, i1 false)

void func6() {
  int x = 4;
  int arr[2] = { x, 5 };
}

// CIR: %[[VAR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr", init]
// CIR: %[[V:.*]] = cir.const #cir.int<4> : !s32i
// CIR: cir.store{{.*}} %[[V]], %[[VAR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[ARR_PTR:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[VAR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store{{.*}} %[[TMP]], %[[ARR_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<1> : !s64i
// CIR: %[[ELE_PTR:.*]] = cir.ptr_stride %[[ARR_PTR]], %[[OFFSET]] : (!cir.ptr<!s32i>, !s64i) -> !cir.ptr<!s32i>
// CIR: %[[V1:.*]] = cir.const #cir.int<5> : !s32i
// CIR: cir.store{{.*}} %[[V1]], %[[ELE_PTR]] : !s32i, !cir.ptr<!s32i>

// LLVM: define{{.*}} void @_Z5func6v(){{.*}}
// LLVM:  %[[VAR:.*]] = alloca i32, i64 1, align 4
// LLVM:  %[[ARR:.*]] = alloca [2 x i32], i64 1, align 4
// LLVM:  store i32 4, ptr %[[VAR]], align 4
// LLVM:  %[[ELE_0:.*]] = getelementptr i32, ptr %[[ARR]], i32 0
// LLVM:  %[[TMP:.*]] = load i32, ptr %[[VAR]], align 4
// LLVM:  store i32 %[[TMP]], ptr %[[ELE_0]], align 4
// LLVM:  %[[ELE_1:.*]] = getelementptr i32, ptr %[[ELE_0]], i64 1
// LLVM:  store i32 5, ptr %[[ELE_1]], align 4

// OGCG:  %[[VAR:.*]] = alloca i32, align 4
// OGCG:  %[[ARR:.*]] = alloca [2 x i32], align 4
// OGCG:  store i32 4, ptr %[[VAR]], align 4
// OGCG:  %[[ELE_0:.*]] = load i32, ptr %[[VAR]], align 4
// OGCG:  store i32 %[[ELE_0]], ptr %[[ARR]], align 4
// OGCG:  %[[ELE_1:.*]] = getelementptr inbounds i32, ptr %[[ARR]], i64 1
// OGCG:  store i32 5, ptr %[[ELE_1:.*]], align 4

void func7() {
  int* arr[1] = {};
}

// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.ptr<!s32i> x 1>, !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>, ["arr", init]
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC7_ARR]] : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>

// LLVM: define{{.*}} void @_Z5func7v(){{.*}}
// LLVM:   %[[ARR:.*]] = alloca [1 x ptr], i64 1, align 8
// LLVM:   call void @llvm.memcpy.p0.p0.i64(ptr %[[ARR]], ptr @[[FUNC7_ARR:.*]], i64 8, i1 false)

// OGCG: %[[ARR:.*]] = alloca [1 x ptr], align 8
// OGCG: call void @llvm.memset.p0.i64(ptr align 8 %[[ARR]], i8 0, i64 8, i1 false)

void func8(int arr[10]) {
  int e = arr[0];
  int e2 = arr[1];
}

// CIR: cir.func{{.*}} @_Z5func8Pi(%[[ARG:.*]]: !cir.ptr<!s32i>
// CIR:  %[[ARR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arr", init]
// CIR:  %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
// CIR:  %[[INIT_2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e2", init]
// CIR:  cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR:  %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
// CIR:  %[[TMP_1:.*]] = cir.load{{.*}} %[[ARR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR:  %[[ELE_0:.*]] = cir.ptr_stride %[[TMP_1]], %[[IDX]] : (!cir.ptr<!s32i>, !s64i) -> !cir.ptr<!s32i>
// CIR:  %[[TMP_2:.*]] = cir.load{{.*}} %[[ELE_0]] : !cir.ptr<!s32i>, !s32i
// CIR:  cir.store{{.*}} %[[TMP_2]], %[[INIT]] : !s32i, !cir.ptr<!s32i>
// CIR:  %[[IDX_1:.*]] = cir.const #cir.int<1> : !s64i
// CIR:  %[[TMP_3:.*]] = cir.load{{.*}} %[[ARR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR:  %[[ELE_1:.*]] = cir.ptr_stride %[[TMP_3]], %[[IDX_1]] : (!cir.ptr<!s32i>, !s64i) -> !cir.ptr<!s32i>
// CIR:  %[[TMP_4:.*]] = cir.load{{.*}} %[[ELE_1]] : !cir.ptr<!s32i>, !s32i
// CIR:  cir.store{{.*}} %[[TMP_4]], %[[INIT_2]] : !s32i, !cir.ptr<!s32i>

// LLVM: define{{.*}} void @_Z5func8Pi(ptr {{.*}} %[[ARG:.*]]){{.*}}
// LLVM:  %[[ARR:.*]] = alloca ptr, i64 1, align 8
// LLVM:  %[[INIT:.*]] = alloca i32, i64 1, align 4
// LLVM:  %[[INIT_2:.*]] = alloca i32, i64 1, align 4
// LLVM:  store ptr %[[ARG]], ptr %[[ARR]], align 8
// LLVM:  %[[TMP_1:.*]] = load ptr, ptr %[[ARR]], align 8
// LLVM:  %[[ELE_0:.*]] = getelementptr i32, ptr %[[TMP_1]], i64 0
// LLVM:  %[[TMP_2:.*]] = load i32, ptr %[[ELE_0]], align 4
// LLVM:  store i32 %[[TMP_2]], ptr %[[INIT]], align 4
// LLVM:  %[[TMP_3:.*]] = load ptr, ptr %[[ARR]], align 8
// LLVM:  %[[ELE_1:.*]] = getelementptr i32, ptr %[[TMP_3]], i64 1
// LLVM:  %[[TMP_4:.*]] = load i32, ptr %[[ELE_1]], align 4
// LLVM:  store i32 %[[TMP_4]], ptr %[[INIT_2]], align 4

// OGCG: %[[ARR:.*]] = alloca ptr, align 8
// OGCG: %[[INIT:.*]] = alloca i32, align 4
// OGCG: %[[INIT_2:.*]] = alloca i32, align 4
// OGCG: store ptr {{%.*}}, ptr %[[ARR]], align 8
// OGCG: %[[TMP_1:.*]] = load ptr, ptr %[[ARR]], align 8
// OGCG: %[[ELE_0:.*]] = getelementptr inbounds i32, ptr %[[TMP_1]], i64 0
// OGCG: %[[TMP_2:.*]] = load i32, ptr %[[ELE_0]], align 4
// OGCG: store i32 %[[TMP_2]], ptr %[[INIT]], align 4
// OGCG: %[[TMP_3:.*]] = load ptr, ptr %[[ARR]], align 8
// OGCG: %[[ELE_1:.*]] = getelementptr inbounds i32, ptr %[[TMP_3]], i64 1
// OGCG: %[[TMP_2:.*]] = load i32, ptr %[[ELE_1]], align 4
// OGCG: store i32 %[[TMP_2]], ptr %[[INIT_2]], align 4

void func9(int arr[10][5]) {
  int e = arr[1][2];
}

// CIR: cir.func{{.*}} @_Z5func9PA5_i(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>
// CIR:  %[[ARR:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, ["arr", init]
// CIR:  %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
// CIR:  cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
// CIR:  %[[IDX:.*]] = cir.const #cir.int<2> : !s64i
// CIR:  %[[IDX_1:.*]] = cir.const #cir.int<1> : !s64i
// CIR:  %[[TMP_1:.*]] = cir.load{{.*}} %[[ARR]] : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, !cir.ptr<!cir.array<!s32i x 5>>
// CIR:  %[[ARR_1:.*]] = cir.ptr_stride %[[TMP_1]], %[[IDX_1]] : (!cir.ptr<!cir.array<!s32i x 5>>, !s64i) -> !cir.ptr<!cir.array<!s32i x 5>>
// CIR: %[[ARR_1_2:.*]] = cir.get_element %[[ARR_1]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!s32i>
// CIR:  %[[TMP_2:.*]] = cir.load{{.*}} %[[ARR_1_2]] : !cir.ptr<!s32i>, !s32i
// CIR:  cir.store{{.*}} %[[TMP_2]], %[[INIT]] : !s32i, !cir.ptr<!s32i>

// LLVM: define{{.*}} void @_Z5func9PA5_i(ptr {{.*}} %[[ARG:.*]]){{.*}}
// LLVM:  %[[ARR:.*]] = alloca ptr, i64 1, align 8
// LLVM:  %[[INIT:.*]] = alloca i32, i64 1, align 4
// LLVM:  store ptr %[[ARG]], ptr %[[ARR]], align 8
// LLVM:  %[[TMP_1:.*]] = load ptr, ptr %[[ARR]], align 8
// LLVM:  %[[ARR_1:.*]] = getelementptr [5 x i32], ptr %[[TMP_1]], i64 1
// LLVM:  %[[ARR_1_2:.*]] = getelementptr [5 x i32], ptr %[[ARR_1]], i32 0, i64 2
// LLVM:  %[[TMP_2:.*]] = load i32, ptr %[[ARR_1_2]], align 4
// LLVM:  store i32 %[[TMP_2]], ptr %[[INIT]], align 4

// OGCG: %[[ARR:.*]] = alloca ptr, align 8
// OGCG: %[[INIT:.*]] = alloca i32, align 4
// OGCG: store ptr {{%.*}}, ptr %[[ARR]], align 8
// OGCG: %[[TMP_1:.*]] = load ptr, ptr %[[ARR]], align 8
// OGCG: %[[ARR_1:.*]] = getelementptr inbounds [5 x i32], ptr %[[TMP_1]], i64 1
// OGCG: %[[ARR_1_2:.*]] = getelementptr inbounds [5 x i32], ptr %[[ARR_1]], i64 0, i64 2
// OGCG: %[[TMP_2:.*]] = load i32, ptr %[[ARR_1_2]], align 4
// OGCG: store i32 %[[TMP_2]], ptr %[[INIT]], align 4

void func10(int *a) {
  int e = a[5];
}

// CIR: cir.func{{.*}} @_Z6func10Pi(%[[ARG:.*]]: !cir.ptr<!s32i>
// CIR: %[[ARR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["a", init]
// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
// CIR: cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<5> : !s64i
// CIR: %[[TMP_1:.*]] = cir.load{{.*}} %[[ARR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR: %[[ELE:.*]] = cir.ptr_stride %[[TMP_1]], %[[IDX]] : (!cir.ptr<!s32i>, !s64i) -> !cir.ptr<!s32i>
// CIR: %[[TMP_2:.*]] = cir.load{{.*}} %[[ELE]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store{{.*}} %[[TMP_2]], %[[INIT]] : !s32i, !cir.ptr<!s32i>

// LLVM: define{{.*}} void @_Z6func10Pi(ptr {{.*}} %[[ARG:.*]]){{.*}} {
// LLVM:  %[[ARR:.*]] = alloca ptr, i64 1, align 8
// LLVM:  %[[INIT:.*]] = alloca i32, i64 1, align 4
// LLVM:  store ptr %[[ARG]], ptr %[[ARR]], align 8
// LLVM:  %[[TMP_1:.*]] = load ptr, ptr %[[ARR]], align 8
// LLVM:  %[[ELE:.*]] = getelementptr i32, ptr %[[TMP_1]], i64 5
// LLVM:  %[[TMP_2:.*]] = load i32, ptr %[[ELE]], align 4
// LLVM:  store i32 %[[TMP_2]], ptr %[[INIT]], align 4

// OGCG:  %[[ARR:.*]] = alloca ptr, align 8
// OGCG:  %[[INIT:.*]] = alloca i32, align 4
// OGCG:  store ptr {{%.*}}, ptr %[[ARR]], align 8
// OGCG:  %[[TMP_1:.*]] = load ptr, ptr %[[ARR]], align 8
// OGCG:  %[[ELE:.*]] = getelementptr inbounds i32, ptr %[[TMP_1]], i64 5
// OGCG:  %[[TMP_2:.*]] = load i32, ptr %[[ELE]], align 4
// OGCG:  store i32 %[[TMP_2]], ptr %[[INIT]], align 4

void func11() { int _Complex a[4]; }

// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.complex<!s32i> x 4>, !cir.ptr<!cir.array<!cir.complex<!s32i> x 4>>, ["a"]

// LLVM: %[[ARR:.*]] = alloca [4 x { i32, i32 }], i64 1, align 16

// OGCG: %[[ARR:.*]] = alloca [4 x { i32, i32 }], align 16

void func12() {
  struct Point {
    int x;
    int y;
  };

  Point a[4];
}

// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!rec_Point x 4>, !cir.ptr<!cir.array<!rec_Point x 4>>, ["a"]

// LLVM: %[[ARR:.*]] = alloca [4 x %struct.Point], i64 1, align 16

// OGCG: %[[ARR:.*]] = alloca [4 x %struct.Point], align 16

void array_with_complex_elements() {
  _Complex float arr[2] = {{1.1f, 2.2f}, {3.3f, 4.4f}};
}

// CIR: %[[ARR_ADDR:.*]] = cir.alloca !cir.array<!cir.complex<!cir.float> x 2>, !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>, ["arr", init]
// CIR: %[[CONST:.*]] = cir.get_global @[[COMPLEX_ARR]] : !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR_ADDR]] : !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>

// LLVM: %[[ARR_ADDR:.*]] = alloca [2 x { float, float }], i64 1, align 16
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr %[[ARR_ADDR]], ptr @[[COMPLEX_ARR:.*]], i64 16, i1 false)

// OGCG: %[[ARR_ADDR:.*]] = alloca [2 x { float, float }], align 16
// OGCG: call void @llvm.memcpy.p0.p0.i64(ptr align 16 %[[ARR_ADDR]], ptr align 16 @__const._Z27array_with_complex_elementsv.arr, i64 16, i1 false)

void boolean_index_access(int x) {
  int arr[2] = { 1, 2 };
  int n = arr[x > 4];
}

// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
// CIR: %[[ARR_ADDR:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr", init]
// CIR: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
// CIR: %[[CMP:.*]] = cir.cmp gt %[[X]], %[[FOUR]] : !s32i
// CIR: %[[IDX:.*]] = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !u64i
// CIR: %[[ELE:.*]] = cir.get_element %[[ARR_ADDR]][%[[IDX]] : !u64i] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: %[[VAL:.*]] = cir.load{{.*}} %[[ELE]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store{{.*}} %[[VAL]], %[[N_ADDR]] : !s32i, !cir.ptr<!s32i>

// LLVM: %[[X_ADDR:.*]] = alloca i32
// LLVM: %[[ARR_ADDR:.*]] = alloca [2 x i32]
// LLVM: %[[N_ADDR:.*]] = alloca i32
// LLVM: %[[X:.*]] = load i32, ptr %[[X_ADDR]]
// LLVM: %[[CMP:.*]] = icmp sgt i32 %[[X]], 4
// LLVM: %[[IDX:.*]] = zext i1 %[[CMP]] to i64
// LLVM: %[[ELE:.*]] = getelementptr [2 x i32], ptr %[[ARR_ADDR]], i32 0, i64 %[[IDX]]
// LLVM: %[[VAL:.*]] = load i32, ptr %[[ELE]]
// LLVM: store i32 %[[VAL]], ptr %[[N_ADDR]]

// OGCG: %[[X_ADDR:.*]] = alloca i32
// OGCG: %[[ARR_ADDR:.*]] = alloca [2 x i32]
// OGCG: %[[N_ADDR:.*]] = alloca i32
// OGCG: %[[X:.*]] = load i32, ptr %[[X_ADDR]]
// OGCG: %[[CMP:.*]] = icmp sgt i32 %[[X]], 4
// OGCG: %[[IDX:.*]] = zext i1 %[[CMP]] to i64
// OGCG: %[[ELE:.*]] = getelementptr inbounds nuw [2 x i32], ptr %[[ARR_ADDR]], i64 0, i64 %[[IDX]]
// OGCG: %[[VAL:.*]] = load i32, ptr %[[ELE]]
// OGCG: store i32 %[[VAL]], ptr %[[N_ADDR]]

void bitint_index_access(_BitInt(7) i) {
  int arr[10] = {};
  int n = arr[i];
}

// A narrow signed _BitInt index must be sign-extended to pointer width before
// being used as a subscript.

// CIR: cir.func{{.*}} @_Z19bitint_index_accessDB7_
// CIR:   %[[I_ADDR:.*]] = cir.alloca !cir.int<s, 7, bitint>, !cir.ptr<!cir.int<s, 7, bitint>>, ["i", init]
// CIR:   %[[ARR_ADDR:.*]] = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["arr", init]
// CIR:   %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
// CIR:   %[[I:.*]] = cir.load{{.*}} %[[I_ADDR]] : !cir.ptr<!cir.int<s, 7, bitint>>, !cir.int<s, 7, bitint>
// CIR:   %[[IDX:.*]] = cir.cast integral %[[I]] : !cir.int<s, 7, bitint> -> !s64i
// CIR:   %[[ELE:.*]] = cir.get_element %[[ARR_ADDR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
// CIR:   %[[VAL:.*]] = cir.load{{.*}} %[[ELE]] : !cir.ptr<!s32i>, !s32i
// CIR:   cir.store{{.*}} %[[VAL]], %[[N_ADDR]] : !s32i, !cir.ptr<!s32i>

// LLVM: define{{.*}} @_Z19bitint_index_accessDB7_(i7 {{[^)]*}})
// LLVM:   %[[I_ADDR:.*]] = alloca i7
// LLVM:   %[[ARR_ADDR:.*]] = alloca [10 x i32]
// LLVM:   %[[N_ADDR:.*]] = alloca i32
// LLVM:   %[[I:.*]] = load i7, ptr %[[I_ADDR]]
// LLVM:   %[[IDX:.*]] = sext i7 %[[I]] to i64
// LLVM:   %[[ELE:.*]] = getelementptr [10 x i32], ptr %[[ARR_ADDR]], i32 0, i64 %[[IDX]]
// LLVM:   %[[VAL:.*]] = load i32, ptr %[[ELE]]
// LLVM:   store i32 %[[VAL]], ptr %[[N_ADDR]]

// OGCG: define{{.*}} @_Z19bitint_index_accessDB7_(i7 {{[^)]*}})
// OGCG:   %[[I_ADDR:.*]] = alloca i8
// OGCG:   %[[ARR_ADDR:.*]] = alloca [10 x i32]
// OGCG:   %[[N_ADDR:.*]] = alloca i32
// OGCG:   %[[I:.*]] = load i8, ptr %[[I_ADDR]]
// OGCG:   %[[I_CAST:.*]] = trunc i8 %[[I]] to i7
// OGCG:   %[[IDX:.*]] = sext i7 %[[I_CAST]] to i64
// OGCG:   %[[ELE:.*]] = getelementptr inbounds [10 x i32], ptr %[[ARR_ADDR]], i64 0, i64 %[[IDX]]
// OGCG:   %[[VAL:.*]] = load i32, ptr %[[ELE]]
// OGCG:   store i32 %[[VAL]], ptr %[[N_ADDR]]

char access_last_element_of_huge_array() {
  return huge[0x1FFFFFFFFFFFFFFEULL];
}

// CIR: cir.func{{.*}} @_Z33access_last_element_of_huge_arrayv
// CIR:   %[[IDX:.*]] = cir.const #cir.int<2305843009213693950> : !u64i
// CIR:   %[[HUGE:.*]] = cir.get_global @huge : !cir.ptr<!cir.array<!s8i x 2305843009213693951>>
// CIR:   %[[ELE:.*]] = cir.get_element %[[HUGE]][%[[IDX]] : !u64i] : !cir.ptr<!cir.array<!s8i x 2305843009213693951>> -> !cir.ptr<!s8i>
// CIR:   cir.load{{.*}} %[[ELE]] : !cir.ptr<!s8i>, !s8i

// LLVM: define{{.*}} @_Z33access_last_element_of_huge_arrayv()
// LLVM:   load i8, ptr getelementptr inbounds nuw (i8, ptr @huge, i64 2305843009213693950)

// OGCG: define{{.*}} @_Z33access_last_element_of_huge_arrayv()
// OGCG:   load i8, ptr getelementptr inbounds nuw (i8, ptr @huge, i64 2305843009213693950)