text: // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
  // RUN: %clang_cc1 -no-opaque-pointers -triple armv8-none-linux-eabi   -fno-aapcs-bitfield-width -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s -check-prefix=LE
  // RUN: %clang_cc1 -no-opaque-pointers -triple armebv8-none-linux-eabi -fno-aapcs-bitfield-width -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s -check-prefix=BE
  
  // RUN: %clang_cc1 -no-opaque-pointers -triple armv8-none-linux-eabi   -faapcs-bitfield-load -fno-aapcs-bitfield-width -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s -check-prefixes=LENUMLOADS
  // RUN: %clang_cc1 -no-opaque-pointers -triple armebv8-none-linux-eabi -faapcs-bitfield-load -fno-aapcs-bitfield-width -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s -check-prefixes=BENUMLOADS
  
  // RUN: %clang_cc1 -no-opaque-pointers -triple armv8-none-linux-eabi   -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s -check-prefix=LEWIDTH
  // RUN: %clang_cc1 -no-opaque-pointers -triple armebv8-none-linux-eabi -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s -check-prefix=BEWIDTH
  
  // RUN: %clang_cc1 -no-opaque-pointers -triple armv8-none-linux-eabi   -faapcs-bitfield-load -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s -check-prefixes=LEWIDTHNUM
  // RUN: %clang_cc1 -no-opaque-pointers -triple armebv8-none-linux-eabi -faapcs-bitfield-load -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s -check-prefixes=BEWIDTHNUM
  
  struct st0 {
    short c : 7;
  };
  
  // LE-LABEL: @st0_check_load(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LE-NEXT:    ret i32 [[CONV]]
  //
  // BE-LABEL: @st0_check_load(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BE-NEXT:    ret i32 [[CONV]]
  //
  // LENUMLOADS-LABEL: @st0_check_load(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // BENUMLOADS-LABEL: @st0_check_load(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTH-LABEL: @st0_check_load(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTH-LABEL: @st0_check_load(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTHNUM-LABEL: @st0_check_load(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTHNUM-LABEL: @st0_check_load(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  int st0_check_load(struct st0 *m) {
    return m->c;
  }
  
  // LE-LABEL: @st0_check_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LE-NEXT:    store i8 [[BF_SET]], i8* [[TMP0]], align 2
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st0_check_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BE-NEXT:    store i8 [[BF_SET]], i8* [[TMP0]], align 2
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st0_check_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LENUMLOADS-NEXT:    store i8 [[BF_SET]], i8* [[TMP0]], align 2
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st0_check_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BENUMLOADS-NEXT:    store i8 [[BF_SET]], i8* [[TMP0]], align 2
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st0_check_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LEWIDTH-NEXT:    store i8 [[BF_SET]], i8* [[TMP0]], align 2
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st0_check_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BEWIDTH-NEXT:    store i8 [[BF_SET]], i8* [[TMP0]], align 2
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st0_check_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LEWIDTHNUM-NEXT:    store i8 [[BF_SET]], i8* [[TMP0]], align 2
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st0_check_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st0* [[M:%.*]] to i8*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[TMP0]], align 2
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BEWIDTHNUM-NEXT:    store i8 [[BF_SET]], i8* [[TMP0]], align 2
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st0_check_store(struct st0 *m) {
    m->c = 1;
  }
  
  struct st1 {
    int a : 10;
    short c : 6;
  };
  
  // LE-LABEL: @st1_check_load(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 10
  // LE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LE-NEXT:    ret i32 [[CONV]]
  //
  // BE-LABEL: @st1_check_load(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 10
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 10
  // BE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BE-NEXT:    ret i32 [[CONV]]
  //
  // LENUMLOADS-LABEL: @st1_check_load(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 10
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // BENUMLOADS-LABEL: @st1_check_load(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 10
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 10
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTH-LABEL: @st1_check_load(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 10
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTH-LABEL: @st1_check_load(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 10
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 10
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTHNUM-LABEL: @st1_check_load(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 10
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTHNUM-LABEL: @st1_check_load(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 10
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 10
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  int st1_check_load(struct st1 *m) {
    return m->c;
  }
  
  // LE-LABEL: @st1_check_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 1023
  // LE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1024
  // LE-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st1_check_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -64
  // BE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // BE-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st1_check_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 1023
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1024
  // LENUMLOADS-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st1_check_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -64
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // BENUMLOADS-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st1_check_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 1023
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1024
  // LEWIDTH-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st1_check_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -64
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // BEWIDTH-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st1_check_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 1023
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1024
  // LEWIDTHNUM-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st1_check_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st1* [[M:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -64
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // BEWIDTHNUM-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st1_check_store(struct st1 *m) {
    m->c = 1;
  }
  
  struct st2 {
    int a : 10;
    short c : 7;
  };
  
  // LE-LABEL: @st2_check_load(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LE-NEXT:    ret i32 [[CONV]]
  //
  // BE-LABEL: @st2_check_load(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BE-NEXT:    ret i32 [[CONV]]
  //
  // LENUMLOADS-LABEL: @st2_check_load(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // BENUMLOADS-LABEL: @st2_check_load(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTH-LABEL: @st2_check_load(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTH-LABEL: @st2_check_load(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTHNUM-LABEL: @st2_check_load(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTHNUM-LABEL: @st2_check_load(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  int st2_check_load(struct st2 *m) {
    return m->c;
  }
  
  // LE-LABEL: @st2_check_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LE-NEXT:    store i8 [[BF_SET]], i8* [[C]], align 2
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st2_check_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BE-NEXT:    store i8 [[BF_SET]], i8* [[C]], align 2
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st2_check_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LENUMLOADS-NEXT:    store i8 [[BF_SET]], i8* [[C]], align 2
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st2_check_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BENUMLOADS-NEXT:    store i8 [[BF_SET]], i8* [[C]], align 2
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st2_check_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LEWIDTH-NEXT:    store i8 [[BF_SET]], i8* [[C]], align 2
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st2_check_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BEWIDTH-NEXT:    store i8 [[BF_SET]], i8* [[C]], align 2
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st2_check_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LEWIDTHNUM-NEXT:    store i8 [[BF_SET]], i8* [[C]], align 2
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st2_check_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST2:%.*]], %struct.st2* [[M:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i8, i8* [[C]], align 2
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BEWIDTHNUM-NEXT:    store i8 [[BF_SET]], i8* [[C]], align 2
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st2_check_store(struct st2 *m) {
    m->c = 1;
  }
  // Volatile access is allowed to use 16 bits
  struct st3 {
    volatile short c : 7;
  };
  
  // LE-LABEL: @st3_check_load(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 2
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LE-NEXT:    ret i32 [[CONV]]
  //
  // BE-LABEL: @st3_check_load(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 2
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BE-NEXT:    ret i32 [[CONV]]
  //
  // LENUMLOADS-LABEL: @st3_check_load(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 2
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 1
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // BENUMLOADS-LABEL: @st3_check_load(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 2
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i16
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_CAST]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTH-LABEL: @st3_check_load(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i16*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 2
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 9
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 9
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTH-LABEL: @st3_check_load(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i16*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 2
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 9
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTHNUM-LABEL: @st3_check_load(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 2
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 9
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 9
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTHNUM-LABEL: @st3_check_load(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 2
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 9
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  int st3_check_load(struct st3 *m) {
    return m->c;
  }
  
  // LE-LABEL: @st3_check_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 2
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LE-NEXT:    store volatile i8 [[BF_SET]], i8* [[TMP0]], align 2
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st3_check_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 2
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BE-NEXT:    store volatile i8 [[BF_SET]], i8* [[TMP0]], align 2
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st3_check_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 2
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -128
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LENUMLOADS-NEXT:    store volatile i8 [[BF_SET]], i8* [[TMP0]], align 2
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st3_check_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 2
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // BENUMLOADS-NEXT:    store volatile i8 [[BF_SET]], i8* [[TMP0]], align 2
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st3_check_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i16*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 2
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -128
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LEWIDTH-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 2
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st3_check_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i16*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 2
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 511
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 512
  // BEWIDTH-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 2
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st3_check_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 2
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -128
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LEWIDTHNUM-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 2
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st3_check_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st3* [[M:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 2
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 511
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 512
  // BEWIDTHNUM-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 2
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st3_check_store(struct st3 *m) {
    m->c = 1;
  }
  // Volatile access to st4.c should use a char ld/st
  struct st4 {
    int b : 9;
    volatile char c : 5;
  };
  
  // LE-LABEL: @st4_check_load(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 2
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 11
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i16 [[BF_ASHR]] to i8
  // LE-NEXT:    [[CONV:%.*]] = sext i8 [[BF_CAST]] to i32
  // LE-NEXT:    ret i32 [[CONV]]
  //
  // BE-LABEL: @st4_check_load(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 9
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 11
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i16 [[BF_ASHR]] to i8
  // BE-NEXT:    [[CONV:%.*]] = sext i8 [[BF_CAST]] to i32
  // BE-NEXT:    ret i32 [[CONV]]
  //
  // LENUMLOADS-LABEL: @st4_check_load(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 2
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 11
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i16 [[BF_ASHR]] to i8
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i8 [[BF_CAST]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // BENUMLOADS-LABEL: @st4_check_load(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 9
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 11
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i16 [[BF_ASHR]] to i8
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i8 [[BF_CAST]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTH-LABEL: @st4_check_load(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i8*
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 2
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTH-LABEL: @st4_check_load(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i8*
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTHNUM-LABEL: @st4_check_load(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i8*
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 2
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTHNUM-LABEL: @st4_check_load(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i8*
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  int st4_check_load(struct st4 *m) {
    return m->c;
  }
  
  // LE-LABEL: @st4_check_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -15873
  // LE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 512
  // LE-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st4_check_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -125
  // BE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 4
  // BE-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st4_check_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -15873
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 512
  // LENUMLOADS-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st4_check_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -125
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 4
  // BENUMLOADS-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st4_check_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i8*
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -63
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // LEWIDTH-NEXT:    store volatile i8 [[BF_SET]], i8* [[TMP1]], align 1
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st4_check_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i8*
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -125
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 4
  // BEWIDTH-NEXT:    store volatile i8 [[BF_SET]], i8* [[TMP1]], align 1
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st4_check_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i8*
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -63
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 2
  // LEWIDTHNUM-NEXT:    store volatile i8 [[BF_SET]], i8* [[TMP1]], align 1
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st4_check_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i8*
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -125
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 4
  // BEWIDTHNUM-NEXT:    store volatile i8 [[BF_SET]], i8* [[TMP1]], align 1
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st4_check_store(struct st4 *m) {
    m->c = 1;
  }
  
  // LE-LABEL: @st4_check_nonv_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -512
  // LE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LE-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st4_check_nonv_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 127
  // BE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 128
  // BE-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st4_check_nonv_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -512
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LENUMLOADS-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st4_check_nonv_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 127
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 128
  // BENUMLOADS-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st4_check_nonv_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -512
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LEWIDTH-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st4_check_nonv_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 127
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 128
  // BEWIDTH-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st4_check_nonv_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -512
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LEWIDTHNUM-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st4_check_nonv_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st4* [[M:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 127
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 128
  // BEWIDTHNUM-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st4_check_nonv_store(struct st4 *m) {
    m->b = 1;
  }
  
  struct st5 {
    int a : 12;
    volatile char c : 5;
  };
  
  // LE-LABEL: @st5_check_load(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 3
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LE-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LE-NEXT:    ret i32 [[CONV]]
  //
  // BE-LABEL: @st5_check_load(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 3
  // BE-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BE-NEXT:    ret i32 [[CONV]]
  //
  // LENUMLOADS-LABEL: @st5_check_load(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 3
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // BENUMLOADS-LABEL: @st5_check_load(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 3
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTH-LABEL: @st5_check_load(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 3
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTH-LABEL: @st5_check_load(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 3
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    ret i32 [[CONV]]
  //
  // LEWIDTHNUM-LABEL: @st5_check_load(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 3
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  // BEWIDTHNUM-LABEL: @st5_check_load(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 3
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret i32 [[CONV]]
  //
  int st5_check_load(struct st5 *m) {
    return m->c;
  }
  
  // LE-LABEL: @st5_check_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -32
  // LE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LE-NEXT:    store volatile i8 [[BF_SET]], i8* [[C]], align 2
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st5_check_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 7
  // BE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 8
  // BE-NEXT:    store volatile i8 [[BF_SET]], i8* [[C]], align 2
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st5_check_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -32
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LENUMLOADS-NEXT:    store volatile i8 [[BF_SET]], i8* [[C]], align 2
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st5_check_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 7
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 8
  // BENUMLOADS-NEXT:    store volatile i8 [[BF_SET]], i8* [[C]], align 2
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st5_check_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -32
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LEWIDTH-NEXT:    store volatile i8 [[BF_SET]], i8* [[C]], align 2
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st5_check_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 7
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 8
  // BEWIDTH-NEXT:    store volatile i8 [[BF_SET]], i8* [[C]], align 2
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st5_check_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -32
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 1
  // LEWIDTHNUM-NEXT:    store volatile i8 [[BF_SET]], i8* [[C]], align 2
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st5_check_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST5:%.*]], %struct.st5* [[M:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[C]], align 2
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 7
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 8
  // BEWIDTHNUM-NEXT:    store volatile i8 [[BF_SET]], i8* [[C]], align 2
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st5_check_store(struct st5 *m) {
    m->c = 1;
  }
  
  struct st6 {
    int a : 12;
    char b;
    int c : 5;
  };
  
  // LE-LABEL: @st6_check_load(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 4
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 4
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // LE-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[B]], align 2
  // LE-NEXT:    [[CONV:%.*]] = sext i8 [[TMP1]] to i32
  // LE-NEXT:    [[ADD:%.*]] = add nsw i32 [[BF_CAST]], [[CONV]]
  // LE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[C]], align 1
  // LE-NEXT:    [[BF_SHL2:%.*]] = shl i8 [[BF_LOAD1]], 3
  // LE-NEXT:    [[BF_ASHR3:%.*]] = ashr i8 [[BF_SHL2]], 3
  // LE-NEXT:    [[BF_CAST4:%.*]] = sext i8 [[BF_ASHR3]] to i32
  // LE-NEXT:    [[ADD5:%.*]] = add nsw i32 [[ADD]], [[BF_CAST4]]
  // LE-NEXT:    ret i32 [[ADD5]]
  //
  // BE-LABEL: @st6_check_load(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 4
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // BE-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[B]], align 2
  // BE-NEXT:    [[CONV:%.*]] = sext i8 [[TMP1]] to i32
  // BE-NEXT:    [[ADD:%.*]] = add nsw i32 [[BF_CAST]], [[CONV]]
  // BE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[C]], align 1
  // BE-NEXT:    [[BF_ASHR2:%.*]] = ashr i8 [[BF_LOAD1]], 3
  // BE-NEXT:    [[BF_CAST3:%.*]] = sext i8 [[BF_ASHR2]] to i32
  // BE-NEXT:    [[ADD4:%.*]] = add nsw i32 [[ADD]], [[BF_CAST3]]
  // BE-NEXT:    ret i32 [[ADD4]]
  //
  // LENUMLOADS-LABEL: @st6_check_load(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 4
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 4
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[B]], align 2
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i8 [[TMP1]] to i32
  // LENUMLOADS-NEXT:    [[ADD:%.*]] = add nsw i32 [[BF_CAST]], [[CONV]]
  // LENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[C]], align 1
  // LENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i8 [[BF_LOAD1]], 3
  // LENUMLOADS-NEXT:    [[BF_ASHR3:%.*]] = ashr i8 [[BF_SHL2]], 3
  // LENUMLOADS-NEXT:    [[BF_CAST4:%.*]] = sext i8 [[BF_ASHR3]] to i32
  // LENUMLOADS-NEXT:    [[ADD5:%.*]] = add nsw i32 [[ADD]], [[BF_CAST4]]
  // LENUMLOADS-NEXT:    ret i32 [[ADD5]]
  //
  // BENUMLOADS-LABEL: @st6_check_load(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 4
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[B]], align 2
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i8 [[TMP1]] to i32
  // BENUMLOADS-NEXT:    [[ADD:%.*]] = add nsw i32 [[BF_CAST]], [[CONV]]
  // BENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[C]], align 1
  // BENUMLOADS-NEXT:    [[BF_ASHR2:%.*]] = ashr i8 [[BF_LOAD1]], 3
  // BENUMLOADS-NEXT:    [[BF_CAST3:%.*]] = sext i8 [[BF_ASHR2]] to i32
  // BENUMLOADS-NEXT:    [[ADD4:%.*]] = add nsw i32 [[ADD]], [[BF_CAST3]]
  // BENUMLOADS-NEXT:    ret i32 [[ADD4]]
  //
  // LEWIDTH-LABEL: @st6_check_load(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 4
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 4
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[B]], align 2
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i8 [[TMP1]] to i32
  // LEWIDTH-NEXT:    [[ADD:%.*]] = add nsw i32 [[BF_CAST]], [[CONV]]
  // LEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[C]], align 1
  // LEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i8 [[BF_LOAD1]], 3
  // LEWIDTH-NEXT:    [[BF_ASHR3:%.*]] = ashr i8 [[BF_SHL2]], 3
  // LEWIDTH-NEXT:    [[BF_CAST4:%.*]] = sext i8 [[BF_ASHR3]] to i32
  // LEWIDTH-NEXT:    [[ADD5:%.*]] = add nsw i32 [[ADD]], [[BF_CAST4]]
  // LEWIDTH-NEXT:    ret i32 [[ADD5]]
  //
  // BEWIDTH-LABEL: @st6_check_load(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 4
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[B]], align 2
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i8 [[TMP1]] to i32
  // BEWIDTH-NEXT:    [[ADD:%.*]] = add nsw i32 [[BF_CAST]], [[CONV]]
  // BEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[C]], align 1
  // BEWIDTH-NEXT:    [[BF_ASHR2:%.*]] = ashr i8 [[BF_LOAD1]], 3
  // BEWIDTH-NEXT:    [[BF_CAST3:%.*]] = sext i8 [[BF_ASHR2]] to i32
  // BEWIDTH-NEXT:    [[ADD4:%.*]] = add nsw i32 [[ADD]], [[BF_CAST3]]
  // BEWIDTH-NEXT:    ret i32 [[ADD4]]
  //
  // LEWIDTHNUM-LABEL: @st6_check_load(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 4
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 4
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[B]], align 2
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i8 [[TMP1]] to i32
  // LEWIDTHNUM-NEXT:    [[ADD:%.*]] = add nsw i32 [[BF_CAST]], [[CONV]]
  // LEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[C]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i8 [[BF_LOAD1]], 3
  // LEWIDTHNUM-NEXT:    [[BF_ASHR3:%.*]] = ashr i8 [[BF_SHL2]], 3
  // LEWIDTHNUM-NEXT:    [[BF_CAST4:%.*]] = sext i8 [[BF_ASHR3]] to i32
  // LEWIDTHNUM-NEXT:    [[ADD5:%.*]] = add nsw i32 [[ADD]], [[BF_CAST4]]
  // LEWIDTHNUM-NEXT:    ret i32 [[ADD5]]
  //
  // BEWIDTHNUM-LABEL: @st6_check_load(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 4
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[B]], align 2
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i8 [[TMP1]] to i32
  // BEWIDTHNUM-NEXT:    [[ADD:%.*]] = add nsw i32 [[BF_CAST]], [[CONV]]
  // BEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[C]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_ASHR2:%.*]] = ashr i8 [[BF_LOAD1]], 3
  // BEWIDTHNUM-NEXT:    [[BF_CAST3:%.*]] = sext i8 [[BF_ASHR2]] to i32
  // BEWIDTHNUM-NEXT:    [[ADD4:%.*]] = add nsw i32 [[ADD]], [[BF_CAST3]]
  // BEWIDTHNUM-NEXT:    ret i32 [[ADD4]]
  //
  int st6_check_load(volatile struct st6 *m) {
    int x = m->a;
    x += m->b;
    x += m->c;
    return x;
  }
  
  // LE-LABEL: @st6_check_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -4096
  // LE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LE-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // LE-NEXT:    store i8 2, i8* [[B]], align 2
  // LE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load i8, i8* [[C]], align 1
  // LE-NEXT:    [[BF_CLEAR2:%.*]] = and i8 [[BF_LOAD1]], -32
  // LE-NEXT:    [[BF_SET3:%.*]] = or i8 [[BF_CLEAR2]], 3
  // LE-NEXT:    store i8 [[BF_SET3]], i8* [[C]], align 1
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st6_check_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 15
  // BE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 16
  // BE-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // BE-NEXT:    store i8 2, i8* [[B]], align 2
  // BE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load i8, i8* [[C]], align 1
  // BE-NEXT:    [[BF_CLEAR2:%.*]] = and i8 [[BF_LOAD1]], 7
  // BE-NEXT:    [[BF_SET3:%.*]] = or i8 [[BF_CLEAR2]], 24
  // BE-NEXT:    store i8 [[BF_SET3]], i8* [[C]], align 1
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st6_check_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -4096
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LENUMLOADS-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // LENUMLOADS-NEXT:    store i8 2, i8* [[B]], align 2
  // LENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i8, i8* [[C]], align 1
  // LENUMLOADS-NEXT:    [[BF_CLEAR2:%.*]] = and i8 [[BF_LOAD1]], -32
  // LENUMLOADS-NEXT:    [[BF_SET3:%.*]] = or i8 [[BF_CLEAR2]], 3
  // LENUMLOADS-NEXT:    store i8 [[BF_SET3]], i8* [[C]], align 1
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st6_check_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 15
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 16
  // BENUMLOADS-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // BENUMLOADS-NEXT:    store i8 2, i8* [[B]], align 2
  // BENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i8, i8* [[C]], align 1
  // BENUMLOADS-NEXT:    [[BF_CLEAR2:%.*]] = and i8 [[BF_LOAD1]], 7
  // BENUMLOADS-NEXT:    [[BF_SET3:%.*]] = or i8 [[BF_CLEAR2]], 24
  // BENUMLOADS-NEXT:    store i8 [[BF_SET3]], i8* [[C]], align 1
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st6_check_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -4096
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LEWIDTH-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // LEWIDTH-NEXT:    store i8 2, i8* [[B]], align 2
  // LEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i8, i8* [[C]], align 1
  // LEWIDTH-NEXT:    [[BF_CLEAR2:%.*]] = and i8 [[BF_LOAD1]], -32
  // LEWIDTH-NEXT:    [[BF_SET3:%.*]] = or i8 [[BF_CLEAR2]], 3
  // LEWIDTH-NEXT:    store i8 [[BF_SET3]], i8* [[C]], align 1
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st6_check_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 15
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 16
  // BEWIDTH-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // BEWIDTH-NEXT:    store i8 2, i8* [[B]], align 2
  // BEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i8, i8* [[C]], align 1
  // BEWIDTH-NEXT:    [[BF_CLEAR2:%.*]] = and i8 [[BF_LOAD1]], 7
  // BEWIDTH-NEXT:    [[BF_SET3:%.*]] = or i8 [[BF_CLEAR2]], 24
  // BEWIDTH-NEXT:    store i8 [[BF_SET3]], i8* [[C]], align 1
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st6_check_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -4096
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 1
  // LEWIDTHNUM-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    store i8 2, i8* [[B]], align 2
  // LEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i8, i8* [[C]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR2:%.*]] = and i8 [[BF_LOAD1]], -32
  // LEWIDTHNUM-NEXT:    [[BF_SET3:%.*]] = or i8 [[BF_CLEAR2]], 3
  // LEWIDTHNUM-NEXT:    store i8 [[BF_SET3]], i8* [[C]], align 1
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st6_check_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st6* [[M:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i16, i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], 15
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 16
  // BEWIDTHNUM-NEXT:    store i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST6:%.*]], %struct.st6* [[M]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    store i8 2, i8* [[B]], align 2
  // BEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST6]], %struct.st6* [[M]], i32 0, i32 2
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i8, i8* [[C]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR2:%.*]] = and i8 [[BF_LOAD1]], 7
  // BEWIDTHNUM-NEXT:    [[BF_SET3:%.*]] = or i8 [[BF_CLEAR2]], 24
  // BEWIDTHNUM-NEXT:    store i8 [[BF_SET3]], i8* [[C]], align 1
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st6_check_store(struct st6 *m) {
    m->a = 1;
    m->b = 2;
    m->c = 3;
  }
  
  // Nested structs and bitfields.
  struct st7a {
    char a;
    int b : 5;
  };
  
  struct st7b {
    char x;
    volatile struct st7a y;
  };
  
  // LE-LABEL: @st7_check_load(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // LE-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 4
  // LE-NEXT:    [[CONV:%.*]] = sext i8 [[TMP0]] to i32
  // LE-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LE-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // LE-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[A]], align 4
  // LE-NEXT:    [[CONV1:%.*]] = sext i8 [[TMP1]] to i32
  // LE-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV1]]
  // LE-NEXT:    [[Y2:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y2]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 3
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LE-NEXT:    [[ADD3:%.*]] = add nsw i32 [[ADD]], [[BF_CAST]]
  // LE-NEXT:    ret i32 [[ADD3]]
  //
  // BE-LABEL: @st7_check_load(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // BE-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 4
  // BE-NEXT:    [[CONV:%.*]] = sext i8 [[TMP0]] to i32
  // BE-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BE-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // BE-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[A]], align 4
  // BE-NEXT:    [[CONV1:%.*]] = sext i8 [[TMP1]] to i32
  // BE-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV1]]
  // BE-NEXT:    [[Y2:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y2]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 3
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BE-NEXT:    [[ADD3:%.*]] = add nsw i32 [[ADD]], [[BF_CAST]]
  // BE-NEXT:    ret i32 [[ADD3]]
  //
  // LENUMLOADS-LABEL: @st7_check_load(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 4
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i8 [[TMP0]] to i32
  // LENUMLOADS-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LENUMLOADS-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[A]], align 4
  // LENUMLOADS-NEXT:    [[CONV1:%.*]] = sext i8 [[TMP1]] to i32
  // LENUMLOADS-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV1]]
  // LENUMLOADS-NEXT:    [[Y2:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y2]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 3
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[ADD3:%.*]] = add nsw i32 [[ADD]], [[BF_CAST]]
  // LENUMLOADS-NEXT:    ret i32 [[ADD3]]
  //
  // BENUMLOADS-LABEL: @st7_check_load(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 4
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i8 [[TMP0]] to i32
  // BENUMLOADS-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BENUMLOADS-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[A]], align 4
  // BENUMLOADS-NEXT:    [[CONV1:%.*]] = sext i8 [[TMP1]] to i32
  // BENUMLOADS-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV1]]
  // BENUMLOADS-NEXT:    [[Y2:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y2]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 3
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[ADD3:%.*]] = add nsw i32 [[ADD]], [[BF_CAST]]
  // BENUMLOADS-NEXT:    ret i32 [[ADD3]]
  //
  // LEWIDTH-LABEL: @st7_check_load(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 4
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i8 [[TMP0]] to i32
  // LEWIDTH-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LEWIDTH-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[A]], align 4
  // LEWIDTH-NEXT:    [[CONV1:%.*]] = sext i8 [[TMP1]] to i32
  // LEWIDTH-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV1]]
  // LEWIDTH-NEXT:    [[Y2:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y2]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 3
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[ADD3:%.*]] = add nsw i32 [[ADD]], [[BF_CAST]]
  // LEWIDTH-NEXT:    ret i32 [[ADD3]]
  //
  // BEWIDTH-LABEL: @st7_check_load(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 4
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i8 [[TMP0]] to i32
  // BEWIDTH-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BEWIDTH-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[A]], align 4
  // BEWIDTH-NEXT:    [[CONV1:%.*]] = sext i8 [[TMP1]] to i32
  // BEWIDTH-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV1]]
  // BEWIDTH-NEXT:    [[Y2:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y2]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 3
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[ADD3:%.*]] = add nsw i32 [[ADD]], [[BF_CAST]]
  // BEWIDTH-NEXT:    ret i32 [[ADD3]]
  //
  // LEWIDTHNUM-LABEL: @st7_check_load(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 4
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i8 [[TMP0]] to i32
  // LEWIDTHNUM-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LEWIDTHNUM-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[A]], align 4
  // LEWIDTHNUM-NEXT:    [[CONV1:%.*]] = sext i8 [[TMP1]] to i32
  // LEWIDTHNUM-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV1]]
  // LEWIDTHNUM-NEXT:    [[Y2:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y2]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i8 [[BF_LOAD]], 3
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_SHL]], 3
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[ADD3:%.*]] = add nsw i32 [[ADD]], [[BF_CAST]]
  // LEWIDTHNUM-NEXT:    ret i32 [[ADD3]]
  //
  // BEWIDTHNUM-LABEL: @st7_check_load(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 4
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i8 [[TMP0]] to i32
  // BEWIDTHNUM-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BEWIDTHNUM-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = load volatile i8, i8* [[A]], align 4
  // BEWIDTHNUM-NEXT:    [[CONV1:%.*]] = sext i8 [[TMP1]] to i32
  // BEWIDTHNUM-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV1]]
  // BEWIDTHNUM-NEXT:    [[Y2:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y2]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i8 [[BF_LOAD]], 3
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[ADD3:%.*]] = add nsw i32 [[ADD]], [[BF_CAST]]
  // BEWIDTHNUM-NEXT:    ret i32 [[ADD3]]
  //
  int st7_check_load(struct st7b *m) {
    int r = m->x;
    r += m->y.a;
    r += m->y.b;
    return r;
  }
  
  // LE-LABEL: @st7_check_store(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // LE-NEXT:    store i8 1, i8* [[X]], align 4
  // LE-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LE-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // LE-NEXT:    store volatile i8 2, i8* [[A]], align 4
  // LE-NEXT:    [[Y1:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y1]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -32
  // LE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 3
  // LE-NEXT:    store volatile i8 [[BF_SET]], i8* [[B]], align 1
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @st7_check_store(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // BE-NEXT:    store i8 1, i8* [[X]], align 4
  // BE-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BE-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // BE-NEXT:    store volatile i8 2, i8* [[A]], align 4
  // BE-NEXT:    [[Y1:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y1]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 7
  // BE-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 24
  // BE-NEXT:    store volatile i8 [[BF_SET]], i8* [[B]], align 1
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @st7_check_store(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // LENUMLOADS-NEXT:    store i8 1, i8* [[X]], align 4
  // LENUMLOADS-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LENUMLOADS-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // LENUMLOADS-NEXT:    store volatile i8 2, i8* [[A]], align 4
  // LENUMLOADS-NEXT:    [[Y1:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y1]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -32
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 3
  // LENUMLOADS-NEXT:    store volatile i8 [[BF_SET]], i8* [[B]], align 1
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @st7_check_store(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // BENUMLOADS-NEXT:    store i8 1, i8* [[X]], align 4
  // BENUMLOADS-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BENUMLOADS-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // BENUMLOADS-NEXT:    store volatile i8 2, i8* [[A]], align 4
  // BENUMLOADS-NEXT:    [[Y1:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y1]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 7
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 24
  // BENUMLOADS-NEXT:    store volatile i8 [[BF_SET]], i8* [[B]], align 1
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @st7_check_store(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // LEWIDTH-NEXT:    store i8 1, i8* [[X]], align 4
  // LEWIDTH-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LEWIDTH-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // LEWIDTH-NEXT:    store volatile i8 2, i8* [[A]], align 4
  // LEWIDTH-NEXT:    [[Y1:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y1]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -32
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 3
  // LEWIDTH-NEXT:    store volatile i8 [[BF_SET]], i8* [[B]], align 1
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @st7_check_store(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // BEWIDTH-NEXT:    store i8 1, i8* [[X]], align 4
  // BEWIDTH-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BEWIDTH-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // BEWIDTH-NEXT:    store volatile i8 2, i8* [[A]], align 4
  // BEWIDTH-NEXT:    [[Y1:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y1]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 7
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 24
  // BEWIDTH-NEXT:    store volatile i8 [[BF_SET]], i8* [[B]], align 1
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @st7_check_store(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // LEWIDTHNUM-NEXT:    store i8 1, i8* [[X]], align 4
  // LEWIDTHNUM-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LEWIDTHNUM-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // LEWIDTHNUM-NEXT:    store volatile i8 2, i8* [[A]], align 4
  // LEWIDTHNUM-NEXT:    [[Y1:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // LEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y1]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], -32
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 3
  // LEWIDTHNUM-NEXT:    store volatile i8 [[BF_SET]], i8* [[B]], align 1
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @st7_check_store(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_ST7B:%.*]], %struct.st7b* [[M:%.*]], i32 0, i32 0
  // BEWIDTHNUM-NEXT:    store i8 1, i8* [[X]], align 4
  // BEWIDTHNUM-NEXT:    [[Y:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BEWIDTHNUM-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_ST7A:%.*]], %struct.st7a* [[Y]], i32 0, i32 0
  // BEWIDTHNUM-NEXT:    store volatile i8 2, i8* [[A]], align 4
  // BEWIDTHNUM-NEXT:    [[Y1:%.*]] = getelementptr inbounds [[STRUCT_ST7B]], %struct.st7b* [[M]], i32 0, i32 2
  // BEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ST7A]], %struct.st7a* [[Y1]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i8 [[BF_LOAD]], 7
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i8 [[BF_CLEAR]], 24
  // BEWIDTHNUM-NEXT:    store volatile i8 [[BF_SET]], i8* [[B]], align 1
  // BEWIDTHNUM-NEXT:    ret void
  //
  void st7_check_store(struct st7b *m) {
    m->x = 1;
    m->y.a = 2;
    m->y.b = 3;
  }
  
  // Check overflowing assignments to bitfields.
  struct st8 {
    unsigned f : 16;
  };
  
  // LE-LABEL: @st8_check_assignment(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st8* [[M:%.*]] to i16*
  // LE-NEXT:    store i16 -1, i16* [[TMP0]], align 4
  // LE-NEXT:    ret i32 65535
  //
  // BE-LABEL: @st8_check_assignment(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st8* [[M:%.*]] to i16*
  // BE-NEXT:    store i16 -1, i16* [[TMP0]], align 4
  // BE-NEXT:    ret i32 65535
  //
  // LENUMLOADS-LABEL: @st8_check_assignment(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st8* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    store i16 -1, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    ret i32 65535
  //
  // BENUMLOADS-LABEL: @st8_check_assignment(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st8* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    store i16 -1, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    ret i32 65535
  //
  // LEWIDTH-LABEL: @st8_check_assignment(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st8* [[M:%.*]] to i16*
  // LEWIDTH-NEXT:    store i16 -1, i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    ret i32 65535
  //
  // BEWIDTH-LABEL: @st8_check_assignment(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st8* [[M:%.*]] to i16*
  // BEWIDTH-NEXT:    store i16 -1, i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    ret i32 65535
  //
  // LEWIDTHNUM-LABEL: @st8_check_assignment(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st8* [[M:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    store i16 -1, i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    ret i32 65535
  //
  // BEWIDTHNUM-LABEL: @st8_check_assignment(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st8* [[M:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    store i16 -1, i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    ret i32 65535
  //
  int st8_check_assignment(struct st8 *m) {
    return m->f = 0xffff;
  }
  
  struct st9{
    int f : 8;
  };
  
  // LE-LABEL: @read_st9(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LE-NEXT:    ret i32 [[BF_CAST]]
  //
  // BE-LABEL: @read_st9(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BE-NEXT:    ret i32 [[BF_CAST]]
  //
  // LENUMLOADS-LABEL: @read_st9(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[BF_CAST]]
  //
  // BENUMLOADS-LABEL: @read_st9(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[BF_CAST]]
  //
  // LEWIDTH-LABEL: @read_st9(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 24
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTH-NEXT:    ret i32 [[BF_ASHR]]
  //
  // BEWIDTH-LABEL: @read_st9(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 24
  // BEWIDTH-NEXT:    ret i32 [[BF_ASHR]]
  //
  // LEWIDTHNUM-LABEL: @read_st9(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 24
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTHNUM-NEXT:    ret i32 [[BF_ASHR]]
  //
  // BEWIDTHNUM-LABEL: @read_st9(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 24
  // BEWIDTHNUM-NEXT:    ret i32 [[BF_ASHR]]
  //
  int read_st9(volatile struct st9 *m) {
    return m->f;
  }
  
  // LE-LABEL: @store_st9(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // LE-NEXT:    store volatile i8 1, i8* [[TMP0]], align 4
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @store_st9(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // BE-NEXT:    store volatile i8 1, i8* [[TMP0]], align 4
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @store_st9(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    store volatile i8 1, i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @store_st9(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    store volatile i8 1, i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @store_st9(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -256
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 1
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @store_st9(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], 16777215
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 16777216
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @store_st9(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -256
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 1
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @store_st9(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], 16777215
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 16777216
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    ret void
  //
  void store_st9(volatile struct st9 *m) {
    m->f = 1;
  }
  
  // LE-LABEL: @increment_st9(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // LE-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_st9(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // BE-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_st9(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_st9(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_st9(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 24
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -256
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_st9(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 24
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 16777215
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_st9(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 24
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -256
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_st9(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st9* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 24
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 16777215
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_st9(volatile struct st9 *m) {
    ++m->f;
  }
  
  struct st10{
    int e : 1;
    int f : 8;
  };
  
  // LE-LABEL: @read_st10(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 7
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LE-NEXT:    ret i32 [[BF_CAST]]
  //
  // BE-LABEL: @read_st10(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 1
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BE-NEXT:    ret i32 [[BF_CAST]]
  //
  // LENUMLOADS-LABEL: @read_st10(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 7
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[BF_CAST]]
  //
  // BENUMLOADS-LABEL: @read_st10(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[BF_CAST]]
  //
  // LEWIDTH-LABEL: @read_st10(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 23
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTH-NEXT:    ret i32 [[BF_ASHR]]
  //
  // BEWIDTH-LABEL: @read_st10(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // BEWIDTH-NEXT:    ret i32 [[BF_ASHR]]
  //
  // LEWIDTHNUM-LABEL: @read_st10(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 23
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTHNUM-NEXT:    ret i32 [[BF_ASHR]]
  //
  // BEWIDTHNUM-LABEL: @read_st10(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // BEWIDTHNUM-NEXT:    ret i32 [[BF_ASHR]]
  //
  int read_st10(volatile struct st10 *m) {
    return m->f;
  }
  
  // LE-LABEL: @store_st10(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -511
  // LE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 2
  // LE-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @store_st10(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -32641
  // BE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 128
  // BE-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @store_st10(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -511
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 2
  // LENUMLOADS-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @store_st10(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -32641
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], 128
  // BENUMLOADS-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @store_st10(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -511
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 2
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @store_st10(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -2139095041
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 8388608
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @store_st10(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -511
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 2
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @store_st10(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -2139095041
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 8388608
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    ret void
  //
  void store_st10(volatile struct st10 *m) {
    m->f = 1;
  }
  
  // LE-LABEL: @increment_st10(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 7
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i16
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i16 [[TMP1]], 255
  // LE-NEXT:    [[BF_SHL2:%.*]] = shl i16 [[BF_VALUE]], 1
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD1]], -511
  // LE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_SHL2]]
  // LE-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i16 [[BF_VALUE]], 8
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i16 [[BF_RESULT_SHL]], 8
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_st10(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 1
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i16
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i16 [[TMP1]], 255
  // BE-NEXT:    [[BF_SHL2:%.*]] = shl i16 [[BF_VALUE]], 7
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD1]], -32641
  // BE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_SHL2]]
  // BE-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i16 [[BF_VALUE]], 8
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i16 [[BF_RESULT_SHL]], 8
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_st10(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 7
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i16
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i16 [[TMP1]], 255
  // LENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i16 [[BF_VALUE]], 1
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD1]], -511
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_SHL2]]
  // LENUMLOADS-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i16 [[BF_VALUE]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i16 [[BF_RESULT_SHL]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_st10(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i16
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i16 [[TMP1]], 255
  // BENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i16 [[BF_VALUE]], 7
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD1]], -32641
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_SHL2]]
  // BENUMLOADS-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i16 [[BF_VALUE]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i16 [[BF_RESULT_SHL]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_st10(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 23
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // LEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 1
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -511
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_st10(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // BEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 23
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -2139095041
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_st10(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 23
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // LEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 1
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -511
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_st10(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st10* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // BEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 23
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -2139095041
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_st10(volatile struct st10 *m) {
    ++m->f;
  }
  
  struct st11{
    char e;
    int f : 16;
  };
  
  // LE-LABEL: @read_st11(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // LE-NEXT:    ret i32 [[BF_CAST]]
  //
  // BE-LABEL: @read_st11(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // BE-NEXT:    ret i32 [[BF_CAST]]
  //
  // LENUMLOADS-LABEL: @read_st11(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // LENUMLOADS-NEXT:    ret i32 [[BF_CAST]]
  //
  // BENUMLOADS-LABEL: @read_st11(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // BENUMLOADS-NEXT:    ret i32 [[BF_CAST]]
  //
  // LEWIDTH-LABEL: @read_st11(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // LEWIDTH-NEXT:    ret i32 [[BF_CAST]]
  //
  // BEWIDTH-LABEL: @read_st11(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // BEWIDTH-NEXT:    ret i32 [[BF_CAST]]
  //
  // LEWIDTHNUM-LABEL: @read_st11(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // LEWIDTHNUM-NEXT:    ret i32 [[BF_CAST]]
  //
  // BEWIDTHNUM-LABEL: @read_st11(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // BEWIDTHNUM-NEXT:    ret i32 [[BF_CAST]]
  //
  int read_st11(volatile struct st11 *m) {
    return m->f;
  }
  
  // LE-LABEL: @store_st11(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LE-NEXT:    store volatile i16 1, i16* [[F]], align 1
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @store_st11(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BE-NEXT:    store volatile i16 1, i16* [[F]], align 1
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @store_st11(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LENUMLOADS-NEXT:    store volatile i16 1, i16* [[F]], align 1
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @store_st11(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BENUMLOADS-NEXT:    store volatile i16 1, i16* [[F]], align 1
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @store_st11(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    store volatile i16 1, i16* [[F]], align 1
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @store_st11(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    store volatile i16 1, i16* [[F]], align 1
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @store_st11(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LEWIDTHNUM-NEXT:    store volatile i16 1, i16* [[F]], align 1
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @store_st11(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BEWIDTHNUM-NEXT:    store volatile i16 1, i16* [[F]], align 1
  // BEWIDTHNUM-NEXT:    ret void
  //
  void store_st11(volatile struct st11 *m) {
    m->f = 1;
  }
  
  // LE-LABEL: @increment_st11(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i16
  // LE-NEXT:    store volatile i16 [[TMP0]], i16* [[F]], align 1
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[TMP0]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_st11(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i16
  // BE-NEXT:    store volatile i16 [[TMP0]], i16* [[F]], align 1
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[TMP0]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_st11(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i16
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[F]], align 1
  // LENUMLOADS-NEXT:    store volatile i16 [[TMP0]], i16* [[F]], align 1
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[TMP0]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_st11(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i16
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[F]], align 1
  // BENUMLOADS-NEXT:    store volatile i16 [[TMP0]], i16* [[F]], align 1
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[TMP0]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_st11(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i16
  // LEWIDTH-NEXT:    store volatile i16 [[TMP0]], i16* [[F]], align 1
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[TMP0]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_st11(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i16
  // BEWIDTH-NEXT:    store volatile i16 [[TMP0]], i16* [[F]], align 1
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[TMP0]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_st11(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i16
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[F]], align 1
  // LEWIDTHNUM-NEXT:    store volatile i16 [[TMP0]], i16* [[F]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[TMP0]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_st11(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[F:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[F]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i16 [[BF_LOAD]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i16
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[F]], align 1
  // BEWIDTHNUM-NEXT:    store volatile i16 [[TMP0]], i16* [[F]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i16 [[TMP0]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_st11(volatile struct st11 *m) {
    ++m->f;
  }
  
  // LE-LABEL: @increment_e_st11(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[E:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 0
  // LE-NEXT:    [[TMP0:%.*]] = load volatile i8, i8* [[E]], align 4
  // LE-NEXT:    [[INC:%.*]] = add i8 [[TMP0]], 1
  // LE-NEXT:    store volatile i8 [[INC]], i8* [[E]], align 4
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_e_st11(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[E:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 0
  // BE-NEXT:    [[TMP0:%.*]] = load volatile i8, i8* [[E]], align 4
  // BE-NEXT:    [[INC:%.*]] = add i8 [[TMP0]], 1
  // BE-NEXT:    store volatile i8 [[INC]], i8* [[E]], align 4
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_e_st11(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[E:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 0
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = load volatile i8, i8* [[E]], align 4
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add i8 [[TMP0]], 1
  // LENUMLOADS-NEXT:    store volatile i8 [[INC]], i8* [[E]], align 4
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_e_st11(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[E:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 0
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = load volatile i8, i8* [[E]], align 4
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add i8 [[TMP0]], 1
  // BENUMLOADS-NEXT:    store volatile i8 [[INC]], i8* [[E]], align 4
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_e_st11(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[E:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 0
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = load volatile i8, i8* [[E]], align 4
  // LEWIDTH-NEXT:    [[INC:%.*]] = add i8 [[TMP0]], 1
  // LEWIDTH-NEXT:    store volatile i8 [[INC]], i8* [[E]], align 4
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_e_st11(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[E:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 0
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = load volatile i8, i8* [[E]], align 4
  // BEWIDTH-NEXT:    [[INC:%.*]] = add i8 [[TMP0]], 1
  // BEWIDTH-NEXT:    store volatile i8 [[INC]], i8* [[E]], align 4
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_e_st11(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[E:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 0
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = load volatile i8, i8* [[E]], align 4
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add i8 [[TMP0]], 1
  // LEWIDTHNUM-NEXT:    store volatile i8 [[INC]], i8* [[E]], align 4
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_e_st11(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[E:%.*]] = getelementptr inbounds [[STRUCT_ST11:%.*]], %struct.st11* [[M:%.*]], i32 0, i32 0
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = load volatile i8, i8* [[E]], align 4
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add i8 [[TMP0]], 1
  // BEWIDTHNUM-NEXT:    store volatile i8 [[INC]], i8* [[E]], align 4
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_e_st11(volatile struct st11 *m) {
    ++m->e;
  }
  
  struct st12{
    int e : 8;
    int f : 16;
  };
  
  // LE-LABEL: @read_st12(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LE-NEXT:    ret i32 [[BF_ASHR]]
  //
  // BE-LABEL: @read_st12(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // BE-NEXT:    ret i32 [[BF_ASHR]]
  //
  // LENUMLOADS-LABEL: @read_st12(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LENUMLOADS-NEXT:    ret i32 [[BF_ASHR]]
  //
  // BENUMLOADS-LABEL: @read_st12(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // BENUMLOADS-NEXT:    ret i32 [[BF_ASHR]]
  //
  // LEWIDTH-LABEL: @read_st12(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LEWIDTH-NEXT:    ret i32 [[BF_ASHR]]
  //
  // BEWIDTH-LABEL: @read_st12(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // BEWIDTH-NEXT:    ret i32 [[BF_ASHR]]
  //
  // LEWIDTHNUM-LABEL: @read_st12(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LEWIDTHNUM-NEXT:    ret i32 [[BF_ASHR]]
  //
  // BEWIDTHNUM-LABEL: @read_st12(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // BEWIDTHNUM-NEXT:    ret i32 [[BF_ASHR]]
  //
  int read_st12(volatile struct st12 *m) {
    return m->f;
  }
  
  // LE-LABEL: @store_st12(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -16776961
  // LE-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 256
  // LE-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @store_st12(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -16776961
  // BE-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 256
  // BE-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @store_st12(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -16776961
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 256
  // LENUMLOADS-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @store_st12(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -16776961
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 256
  // BENUMLOADS-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @store_st12(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -16776961
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 256
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @store_st12(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -16776961
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 256
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @store_st12(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -16776961
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 256
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @store_st12(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD]], -16776961
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], 256
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    ret void
  //
  void store_st12(volatile struct st12 *m) {
    m->f = 1;
  }
  
  // LE-LABEL: @increment_st12(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // LE-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 8
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16776961
  // LE-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // LE-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_st12(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // BE-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 8
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16776961
  // BE-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // BE-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_st12(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // LENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 8
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16776961
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // LENUMLOADS-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_st12(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // BENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 8
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16776961
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // BENUMLOADS-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_st12(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // LEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 8
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16776961
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_st12(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // BEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 8
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16776961
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_st12(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // LEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 8
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16776961
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_st12(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // BEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i32 [[BF_VALUE]], 8
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16776961
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL2]]
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_st12(volatile struct st12 *m) {
    ++m->f;
  }
  
  // LE-LABEL: @increment_e_st12(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 24
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -256
  // LE-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LE-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_e_st12(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 24
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 16777215
  // BE-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BE-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_e_st12(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 24
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -256
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LENUMLOADS-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_e_st12(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 24
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 16777215
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BENUMLOADS-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_e_st12(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 24
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -256
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_e_st12(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 24
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 16777215
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_e_st12(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 24
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 24
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -256
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_e_st12(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st12* [[M:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 24
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 255
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 16777215
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 24
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 24
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_e_st12(volatile struct st12 *m) {
    ++m->e;
  }
  
  struct st13 {
    char a : 8;
    int b : 32;
  } __attribute__((packed));
  
  // LE-LABEL: @increment_b_st13(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st13* [[S:%.*]] to i40*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 8
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 255
  // LE-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // LE-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_b_st13(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st13* [[S:%.*]] to i40*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 8
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 8
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -4294967296
  // BE-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // BE-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_b_st13(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st13* [[S:%.*]] to i40*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 8
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 255
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // LENUMLOADS-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_b_st13(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st13* [[S:%.*]] to i40*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 8
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 8
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -4294967296
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // BENUMLOADS-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_b_st13(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st13* [[S:%.*]] to i40*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 8
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 255
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // LEWIDTH-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_b_st13(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st13* [[S:%.*]] to i40*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 8
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 8
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -4294967296
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // BEWIDTH-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_b_st13(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st13* [[S:%.*]] to i40*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 8
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 255
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // LEWIDTHNUM-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_b_st13(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st13* [[S:%.*]] to i40*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 8
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 8
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -4294967296
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // BEWIDTHNUM-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_b_st13(volatile struct st13 *s) {
    s->b++;
  }
  
  struct st14 {
    char a : 8;
  } __attribute__((packed));
  
  // LE-LABEL: @increment_a_st14(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st14* [[S:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LE-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // LE-NEXT:    store volatile i8 [[INC]], i8* [[TMP0]], align 1
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_a_st14(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st14* [[S:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BE-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // BE-NEXT:    store volatile i8 [[INC]], i8* [[TMP0]], align 1
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_a_st14(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st14* [[S:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    store volatile i8 [[INC]], i8* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_a_st14(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st14* [[S:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    store volatile i8 [[INC]], i8* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_a_st14(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st14* [[S:%.*]] to i8*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // LEWIDTH-NEXT:    store volatile i8 [[INC]], i8* [[TMP0]], align 1
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_a_st14(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st14* [[S:%.*]] to i8*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    store volatile i8 [[INC]], i8* [[TMP0]], align 1
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_a_st14(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st14* [[S:%.*]] to i8*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    store volatile i8 [[INC]], i8* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_a_st14(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st14* [[S:%.*]] to i8*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    store volatile i8 [[INC]], i8* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_a_st14(volatile struct st14 *s) {
    s->a++;
  }
  
  struct st15 {
    short a : 8;
  } __attribute__((packed));
  
  // LE-LABEL: @increment_a_st15(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st15* [[S:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i16
  // LE-NEXT:    [[INC:%.*]] = add i16 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = trunc i16 [[INC]] to i8
  // LE-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 1
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i16
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_a_st15(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st15* [[S:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i16
  // BE-NEXT:    [[INC:%.*]] = add i16 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = trunc i16 [[INC]] to i8
  // BE-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 1
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i16
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_a_st15(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st15* [[S:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i16
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add i16 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = trunc i16 [[INC]] to i8
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i16
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_a_st15(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st15* [[S:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i16
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add i16 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = trunc i16 [[INC]] to i8
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i16
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_a_st15(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st15* [[S:%.*]] to i8*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i16
  // LEWIDTH-NEXT:    [[INC:%.*]] = add i16 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = trunc i16 [[INC]] to i8
  // LEWIDTH-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i16
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_a_st15(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st15* [[S:%.*]] to i8*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i16
  // BEWIDTH-NEXT:    [[INC:%.*]] = add i16 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = trunc i16 [[INC]] to i8
  // BEWIDTH-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i16
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_a_st15(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st15* [[S:%.*]] to i8*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i16
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add i16 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = trunc i16 [[INC]] to i8
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i16
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_a_st15(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st15* [[S:%.*]] to i8*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i16
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add i16 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = trunc i16 [[INC]] to i8
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i16
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_a_st15(volatile struct st15 *s) {
    s->a++;
  }
  
  struct st16 {
    int a : 32;
    int b : 16;
    int c : 32;
    int d : 16;
  };
  
  // LE-LABEL: @increment_a_st16(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LE-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_a_st16(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BE-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_a_st16(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LENUMLOADS-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_a_st16(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BENUMLOADS-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_a_st16(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTH-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_a_st16(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTH-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_a_st16(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTHNUM-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_a_st16(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTHNUM-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_a_st16(struct st16 *s) {
    s->a++;
  }
  
  // LE-LABEL: @increment_b_st16(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LE-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LE-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_b_st16(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BE-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BE-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_b_st16(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LENUMLOADS-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_b_st16(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BENUMLOADS-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_b_st16(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LEWIDTH-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_b_st16(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BEWIDTH-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_b_st16(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LEWIDTHNUM-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_b_st16(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BEWIDTHNUM-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_b_st16(struct st16 *s) {
    s->b++;
  }
  
  // LE-LABEL: @increment_c_st16(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LE-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LE-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_c_st16(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BE-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BE-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_c_st16(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LENUMLOADS-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_c_st16(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BENUMLOADS-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_c_st16(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTH-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_c_st16(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTH-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_c_st16(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTHNUM-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_c_st16(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTHNUM-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_c_st16(struct st16 *s) {
    s->c++;
  }
  
  // LE-LABEL: @increment_d_st16(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LE-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LE-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LE-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_d_st16(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BE-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BE-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BE-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_d_st16(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LENUMLOADS-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_d_st16(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BENUMLOADS-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_d_st16(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LEWIDTH-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_d_st16(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BEWIDTH-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BEWIDTH-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_d_st16(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LEWIDTHNUM-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_d_st16(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load i64, i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BEWIDTHNUM-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BEWIDTHNUM-NEXT:    store i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_d_st16(struct st16 *s) {
    s->d++;
  }
  
  // LE-LABEL: @increment_v_a_st16(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LE-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_v_a_st16(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BE-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_v_a_st16(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LENUMLOADS-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_v_a_st16(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BENUMLOADS-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_v_a_st16(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_LOAD]], 1
  // LEWIDTH-NEXT:    store volatile i32 [[INC]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_v_a_st16(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    store volatile i32 [[INC]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_v_a_st16(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_LOAD]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    store volatile i32 [[INC]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_v_a_st16(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    store volatile i32 [[INC]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_v_a_st16(volatile struct st16 *s) {
    s->a++;
  }
  
  // LE-LABEL: @increment_v_b_st16(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LE-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LE-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_v_b_st16(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BE-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BE-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_v_b_st16(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LENUMLOADS-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_v_b_st16(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i64*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BENUMLOADS-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_v_b_st16(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 16
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -65536
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP1]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_v_b_st16(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 16
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 65535
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP1]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_v_b_st16(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 16
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -65536
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_v_b_st16(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 16
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 65535
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_v_b_st16(volatile struct st16 *s) {
    s->b++;
  }
  
  // LE-LABEL: @increment_v_c_st16(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LE-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LE-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_v_c_st16(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BE-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BE-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_v_c_st16(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294967296
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_VALUE]]
  // LENUMLOADS-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_v_c_st16(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[C:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i48* [[C]] to i64*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL]]
  // BENUMLOADS-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_v_c_st16(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 2
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_LOAD]], 1
  // LEWIDTH-NEXT:    store volatile i32 [[INC]], i32* [[TMP1]], align 4
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_v_c_st16(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 2
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    store volatile i32 [[INC]], i32* [[TMP1]], align 4
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_v_c_st16(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 2
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_LOAD]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    store volatile i32 [[INC]], i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_v_c_st16(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 2
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    store volatile i32 [[INC]], i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_v_c_st16(volatile struct st16 *s) {
    s->c++;
  }
  
  // LE-LABEL: @increment_v_d_st16(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LE-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LE-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LE-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_v_d_st16(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BE-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BE-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BE-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BE-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_v_d_st16(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 16
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // LENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -281470681743361
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // LENUMLOADS-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_v_d_st16(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[D:%.*]] = getelementptr inbounds [[STRUCT_ST16:%.*]], %struct.st16* [[S:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i48* [[D]] to i64*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i64 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i64 [[BF_SHL]], 48
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i64 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i64
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i64, i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i64 [[TMP1]], 65535
  // BENUMLOADS-NEXT:    [[BF_SHL2:%.*]] = shl i64 [[BF_VALUE]], 16
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i64 [[BF_LOAD1]], -4294901761
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i64 [[BF_CLEAR]], [[BF_SHL2]]
  // BENUMLOADS-NEXT:    store volatile i64 [[BF_SET]], i64* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i64 [[BF_VALUE]], 48
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i64 [[BF_RESULT_SHL]], 48
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i64 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_v_d_st16(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 3
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 16
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -65536
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP1]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_v_d_st16(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 3
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 16
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 65535
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP1]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_v_d_st16(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 3
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 16
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 16
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -65536
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP1]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_v_d_st16(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st16* [[S:%.*]] to i32*
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], i32 3
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 16
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 65535
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 65535
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP1]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 16
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 16
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_v_d_st16(volatile struct st16 *s) {
    s->d++;
  }
  // st17 has alignment = 1, the AAPCS defines nothing for the
  // accessing of b, but accessing c should use char
  struct st17 {
  int b : 32;
  char c : 8;
  } __attribute__((packed));
  
  // LE-LABEL: @increment_v_b_st17(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 8
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 8
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -4294967296
  // LE-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // LE-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_v_b_st17(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 8
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 255
  // BE-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // BE-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_v_b_st17(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 8
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 8
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -4294967296
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // LENUMLOADS-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_v_b_st17(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 8
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 255
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // BENUMLOADS-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_v_b_st17(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 8
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 8
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -4294967296
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTH-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_v_b_st17(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 8
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 255
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTH-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_v_b_st17(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 8
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 8
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -4294967296
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTHNUM-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_v_b_st17(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 8
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = zext i32 [[INC]] to i40
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 4294967295
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 255
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTHNUM-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 8
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 8
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_v_b_st17(volatile struct st17 *s) {
    s->b++;
  }
  
  // LE-LABEL: @increment_v_c_st17(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 32
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i8
  // LE-NEXT:    [[INC:%.*]] = add i8 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = zext i8 [[INC]] to i40
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 255
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 4294967295
  // LE-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // LE-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 32
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 32
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i8
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_v_c_st17(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 32
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 32
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i8
  // BE-NEXT:    [[INC:%.*]] = add i8 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = zext i8 [[INC]] to i40
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 255
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -256
  // BE-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // BE-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 32
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 32
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i8
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_v_c_st17(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_LOAD]], 32
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i8
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add i8 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i8 [[INC]] to i40
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 255
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], 4294967295
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_SHL]]
  // LENUMLOADS-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 32
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i8
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_v_c_st17(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i40*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i40 [[BF_LOAD]], 32
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i40 [[BF_SHL]], 32
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i40 [[BF_ASHR]] to i8
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add i8 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = zext i8 [[INC]] to i40
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i40, i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i40 [[TMP1]], 255
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i40 [[BF_LOAD1]], -256
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i40 [[BF_CLEAR]], [[BF_VALUE]]
  // BENUMLOADS-NEXT:    store volatile i40 [[BF_SET]], i40* [[TMP0]], align 1
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i40 [[BF_VALUE]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i40 [[BF_RESULT_SHL]], 32
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i40 [[BF_RESULT_ASHR]] to i8
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_v_c_st17(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i8*
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 4
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // LEWIDTH-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // LEWIDTH-NEXT:    store volatile i8 [[INC]], i8* [[TMP1]], align 1
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_v_c_st17(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i8*
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 4
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // BEWIDTH-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // BEWIDTH-NEXT:    store volatile i8 [[INC]], i8* [[TMP1]], align 1
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_v_c_st17(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i8*
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 4
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // LEWIDTHNUM-NEXT:    store volatile i8 [[INC]], i8* [[TMP1]], align 1
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_v_c_st17(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.st17* [[S:%.*]] to i8*
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i32 4
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add i8 [[BF_LOAD]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP1]], align 1
  // BEWIDTHNUM-NEXT:    store volatile i8 [[INC]], i8* [[TMP1]], align 1
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_v_c_st17(volatile struct st17 *s) {
    s->c++;
  }
  
  // A zero bitfield should block, as the C11 specification
  // requires a and b to be different memory positions
  struct zero_bitfield {
    int a : 8;
    char : 0;
    int b : 8;
  };
  
  // LE-LABEL: @increment_a_zero_bitfield(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield* [[S:%.*]] to i8*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // LE-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_a_zero_bitfield(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield* [[S:%.*]] to i8*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // BE-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_a_zero_bitfield(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield* [[S:%.*]] to i8*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_a_zero_bitfield(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield* [[S:%.*]] to i8*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_a_zero_bitfield(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield* [[S:%.*]] to i8*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // LEWIDTH-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_a_zero_bitfield(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield* [[S:%.*]] to i8*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // BEWIDTH-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_a_zero_bitfield(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield* [[S:%.*]] to i8*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_a_zero_bitfield(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield* [[S:%.*]] to i8*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = trunc i32 [[INC]] to i8
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    store volatile i8 [[TMP1]], i8* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP1]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_a_zero_bitfield(volatile struct zero_bitfield *s) {
    s->a++;
  }
  
  // LE-LABEL: @increment_b_zero_bitfield(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD:%.*]], %struct.zero_bitfield* [[S:%.*]], i32 0, i32 1
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LE-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i8
  // LE-NEXT:    store volatile i8 [[TMP0]], i8* [[B]], align 1
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP0]] to i32
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_b_zero_bitfield(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD:%.*]], %struct.zero_bitfield* [[S:%.*]], i32 0, i32 1
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BE-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BE-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i8
  // BE-NEXT:    store volatile i8 [[TMP0]], i8* [[B]], align 1
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP0]] to i32
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_b_zero_bitfield(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD:%.*]], %struct.zero_bitfield* [[S:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i8
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[B]], align 1
  // LENUMLOADS-NEXT:    store volatile i8 [[TMP0]], i8* [[B]], align 1
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP0]] to i32
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_b_zero_bitfield(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD:%.*]], %struct.zero_bitfield* [[S:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i8
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[B]], align 1
  // BENUMLOADS-NEXT:    store volatile i8 [[TMP0]], i8* [[B]], align 1
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP0]] to i32
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_b_zero_bitfield(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD:%.*]], %struct.zero_bitfield* [[S:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i8
  // LEWIDTH-NEXT:    store volatile i8 [[TMP0]], i8* [[B]], align 1
  // LEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP0]] to i32
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_b_zero_bitfield(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD:%.*]], %struct.zero_bitfield* [[S:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BEWIDTH-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i8
  // BEWIDTH-NEXT:    store volatile i8 [[TMP0]], i8* [[B]], align 1
  // BEWIDTH-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP0]] to i32
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_b_zero_bitfield(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD:%.*]], %struct.zero_bitfield* [[S:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i8
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[B]], align 1
  // LEWIDTHNUM-NEXT:    store volatile i8 [[TMP0]], i8* [[B]], align 1
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP0]] to i32
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_b_zero_bitfield(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD:%.*]], %struct.zero_bitfield* [[S:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i8, i8* [[B]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_CAST]], 1
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = trunc i32 [[INC]] to i8
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[B]], align 1
  // BEWIDTHNUM-NEXT:    store volatile i8 [[TMP0]], i8* [[B]], align 1
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_CAST:%.*]] = sext i8 [[TMP0]] to i32
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_b_zero_bitfield(volatile struct zero_bitfield *s) {
    s->b++;
  }
  
  // The zero bitfield here does not affect
  struct zero_bitfield_ok {
    short a : 8;
    char a1 : 8;
    long : 0;
    int b : 24;
  };
  
  // LE-LABEL: @increment_a_zero_bitfield_ok(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield_ok* [[S:%.*]] to i16*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 8
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // LE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LE-NEXT:    [[TMP1:%.*]] = bitcast %struct.zero_bitfield_ok* [[S]] to i16*
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[TMP1]], align 4
  // LE-NEXT:    [[BF_ASHR2:%.*]] = ashr i16 [[BF_LOAD1]], 8
  // LE-NEXT:    [[BF_CAST:%.*]] = trunc i16 [[BF_ASHR2]] to i8
  // LE-NEXT:    [[CONV3:%.*]] = sext i8 [[BF_CAST]] to i32
  // LE-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV3]], [[CONV]]
  // LE-NEXT:    [[CONV4:%.*]] = trunc i32 [[ADD]] to i8
  // LE-NEXT:    [[TMP2:%.*]] = zext i8 [[CONV4]] to i16
  // LE-NEXT:    [[BF_LOAD5:%.*]] = load volatile i16, i16* [[TMP1]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i16 [[TMP2]], 255
  // LE-NEXT:    [[BF_SHL6:%.*]] = shl i16 [[BF_VALUE]], 8
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD5]], 255
  // LE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_SHL6]]
  // LE-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP1]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i16 [[BF_VALUE]], 8
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i16 [[BF_RESULT_SHL]], 8
  // LE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i16 [[BF_RESULT_ASHR]] to i8
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_a_zero_bitfield_ok(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield_ok* [[S:%.*]] to i16*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 8
  // BE-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BE-NEXT:    [[TMP1:%.*]] = bitcast %struct.zero_bitfield_ok* [[S]] to i16*
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[TMP1]], align 4
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD1]], 8
  // BE-NEXT:    [[BF_ASHR2:%.*]] = ashr i16 [[BF_SHL]], 8
  // BE-NEXT:    [[BF_CAST:%.*]] = trunc i16 [[BF_ASHR2]] to i8
  // BE-NEXT:    [[CONV3:%.*]] = sext i8 [[BF_CAST]] to i32
  // BE-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV3]], [[CONV]]
  // BE-NEXT:    [[CONV4:%.*]] = trunc i32 [[ADD]] to i8
  // BE-NEXT:    [[TMP2:%.*]] = zext i8 [[CONV4]] to i16
  // BE-NEXT:    [[BF_LOAD5:%.*]] = load volatile i16, i16* [[TMP1]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i16 [[TMP2]], 255
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD5]], -256
  // BE-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_VALUE]]
  // BE-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP1]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i16 [[BF_VALUE]], 8
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i16 [[BF_RESULT_SHL]], 8
  // BE-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i16 [[BF_RESULT_ASHR]] to i8
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_a_zero_bitfield_ok(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield_ok* [[S:%.*]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 8
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // LENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LENUMLOADS-NEXT:    [[TMP1:%.*]] = bitcast %struct.zero_bitfield_ok* [[S]] to i16*
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[TMP1]], align 4
  // LENUMLOADS-NEXT:    [[BF_ASHR2:%.*]] = ashr i16 [[BF_LOAD1]], 8
  // LENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i16 [[BF_ASHR2]] to i8
  // LENUMLOADS-NEXT:    [[CONV3:%.*]] = sext i8 [[BF_CAST]] to i32
  // LENUMLOADS-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV3]], [[CONV]]
  // LENUMLOADS-NEXT:    [[CONV4:%.*]] = trunc i32 [[ADD]] to i8
  // LENUMLOADS-NEXT:    [[TMP2:%.*]] = zext i8 [[CONV4]] to i16
  // LENUMLOADS-NEXT:    [[BF_LOAD5:%.*]] = load volatile i16, i16* [[TMP1]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i16 [[TMP2]], 255
  // LENUMLOADS-NEXT:    [[BF_SHL6:%.*]] = shl i16 [[BF_VALUE]], 8
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD5]], 255
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_SHL6]]
  // LENUMLOADS-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP1]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i16 [[BF_VALUE]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i16 [[BF_RESULT_SHL]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i16 [[BF_RESULT_ASHR]] to i8
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_a_zero_bitfield_ok(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield_ok* [[S:%.*]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 8
  // BENUMLOADS-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BENUMLOADS-NEXT:    [[TMP1:%.*]] = bitcast %struct.zero_bitfield_ok* [[S]] to i16*
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i16, i16* [[TMP1]], align 4
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD1]], 8
  // BENUMLOADS-NEXT:    [[BF_ASHR2:%.*]] = ashr i16 [[BF_SHL]], 8
  // BENUMLOADS-NEXT:    [[BF_CAST:%.*]] = trunc i16 [[BF_ASHR2]] to i8
  // BENUMLOADS-NEXT:    [[CONV3:%.*]] = sext i8 [[BF_CAST]] to i32
  // BENUMLOADS-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV3]], [[CONV]]
  // BENUMLOADS-NEXT:    [[CONV4:%.*]] = trunc i32 [[ADD]] to i8
  // BENUMLOADS-NEXT:    [[TMP2:%.*]] = zext i8 [[CONV4]] to i16
  // BENUMLOADS-NEXT:    [[BF_LOAD5:%.*]] = load volatile i16, i16* [[TMP1]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i16 [[TMP2]], 255
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD5]], -256
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_VALUE]]
  // BENUMLOADS-NEXT:    store volatile i16 [[BF_SET]], i16* [[TMP1]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i16 [[BF_VALUE]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i16 [[BF_RESULT_SHL]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_CAST:%.*]] = trunc i16 [[BF_RESULT_ASHR]] to i8
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_a_zero_bitfield_ok(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield_ok* [[S:%.*]] to i16*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 8
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // LEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LEWIDTH-NEXT:    [[TMP1:%.*]] = bitcast %struct.zero_bitfield_ok* [[S]] to i8*
  // LEWIDTH-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i8, i8* [[TMP1]], i32 1
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP2]], align 1
  // LEWIDTH-NEXT:    [[CONV2:%.*]] = sext i8 [[BF_LOAD1]] to i32
  // LEWIDTH-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV2]], [[CONV]]
  // LEWIDTH-NEXT:    [[CONV3:%.*]] = trunc i32 [[ADD]] to i8
  // LEWIDTH-NEXT:    store volatile i8 [[CONV3]], i8* [[TMP2]], align 1
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_a_zero_bitfield_ok(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield_ok* [[S:%.*]] to i16*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 8
  // BEWIDTH-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BEWIDTH-NEXT:    [[TMP1:%.*]] = bitcast %struct.zero_bitfield_ok* [[S]] to i8*
  // BEWIDTH-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i8, i8* [[TMP1]], i32 1
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP2]], align 1
  // BEWIDTH-NEXT:    [[CONV2:%.*]] = sext i8 [[BF_LOAD1]] to i32
  // BEWIDTH-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV2]], [[CONV]]
  // BEWIDTH-NEXT:    [[CONV3:%.*]] = trunc i32 [[ADD]] to i8
  // BEWIDTH-NEXT:    store volatile i8 [[CONV3]], i8* [[TMP2]], align 1
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_a_zero_bitfield_ok(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield_ok* [[S:%.*]] to i16*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 8
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8
  // LEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // LEWIDTHNUM-NEXT:    [[TMP1:%.*]] = bitcast %struct.zero_bitfield_ok* [[S]] to i8*
  // LEWIDTHNUM-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i8, i8* [[TMP1]], i32 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP2]], align 1
  // LEWIDTHNUM-NEXT:    [[CONV2:%.*]] = sext i8 [[BF_LOAD1]] to i32
  // LEWIDTHNUM-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV2]], [[CONV]]
  // LEWIDTHNUM-NEXT:    [[CONV3:%.*]] = trunc i32 [[ADD]] to i8
  // LEWIDTHNUM-NEXT:    [[BF_LOAD4:%.*]] = load volatile i8, i8* [[TMP2]], align 1
  // LEWIDTHNUM-NEXT:    store volatile i8 [[CONV3]], i8* [[TMP2]], align 1
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_a_zero_bitfield_ok(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast %struct.zero_bitfield_ok* [[S:%.*]] to i16*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i16, i16* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i16 [[BF_LOAD]], 8
  // BEWIDTHNUM-NEXT:    [[CONV:%.*]] = sext i16 [[BF_ASHR]] to i32
  // BEWIDTHNUM-NEXT:    [[TMP1:%.*]] = bitcast %struct.zero_bitfield_ok* [[S]] to i8*
  // BEWIDTHNUM-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i8, i8* [[TMP1]], i32 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i8, i8* [[TMP2]], align 1
  // BEWIDTHNUM-NEXT:    [[CONV2:%.*]] = sext i8 [[BF_LOAD1]] to i32
  // BEWIDTHNUM-NEXT:    [[ADD:%.*]] = add nsw i32 [[CONV2]], [[CONV]]
  // BEWIDTHNUM-NEXT:    [[CONV3:%.*]] = trunc i32 [[ADD]] to i8
  // BEWIDTHNUM-NEXT:    [[BF_LOAD4:%.*]] = load volatile i8, i8* [[TMP2]], align 1
  // BEWIDTHNUM-NEXT:    store volatile i8 [[CONV3]], i8* [[TMP2]], align 1
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_a_zero_bitfield_ok(volatile struct zero_bitfield_ok *s) {
    s->a1 += s->a;
  }
  
  // LE-LABEL: @increment_b_zero_bitfield_ok(
  // LE-NEXT:  entry:
  // LE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD_OK:%.*]], %struct.zero_bitfield_ok* [[S:%.*]], i32 0, i32 1
  // LE-NEXT:    [[TMP0:%.*]] = bitcast i24* [[B]] to i32*
  // LE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LE-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 8
  // LE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 16777215
  // LE-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16777216
  // LE-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LE-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // LE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 8
  // LE-NEXT:    ret void
  //
  // BE-LABEL: @increment_b_zero_bitfield_ok(
  // BE-NEXT:  entry:
  // BE-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD_OK:%.*]], %struct.zero_bitfield_ok* [[S:%.*]], i32 0, i32 1
  // BE-NEXT:    [[TMP0:%.*]] = bitcast i24* [[B]] to i32*
  // BE-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 8
  // BE-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BE-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 16777215
  // BE-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // BE-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 255
  // BE-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BE-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BE-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // BE-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 8
  // BE-NEXT:    ret void
  //
  // LENUMLOADS-LABEL: @increment_b_zero_bitfield_ok(
  // LENUMLOADS-NEXT:  entry:
  // LENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD_OK:%.*]], %struct.zero_bitfield_ok* [[S:%.*]], i32 0, i32 1
  // LENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i24* [[B]] to i32*
  // LENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 8
  // LENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 16777215
  // LENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16777216
  // LENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LENUMLOADS-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // LENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 8
  // LENUMLOADS-NEXT:    ret void
  //
  // BENUMLOADS-LABEL: @increment_b_zero_bitfield_ok(
  // BENUMLOADS-NEXT:  entry:
  // BENUMLOADS-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD_OK:%.*]], %struct.zero_bitfield_ok* [[S:%.*]], i32 0, i32 1
  // BENUMLOADS-NEXT:    [[TMP0:%.*]] = bitcast i24* [[B]] to i32*
  // BENUMLOADS-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 8
  // BENUMLOADS-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BENUMLOADS-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 16777215
  // BENUMLOADS-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // BENUMLOADS-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 255
  // BENUMLOADS-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BENUMLOADS-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BENUMLOADS-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // BENUMLOADS-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 8
  // BENUMLOADS-NEXT:    ret void
  //
  // LEWIDTH-LABEL: @increment_b_zero_bitfield_ok(
  // LEWIDTH-NEXT:  entry:
  // LEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD_OK:%.*]], %struct.zero_bitfield_ok* [[S:%.*]], i32 0, i32 1
  // LEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast i24* [[B]] to i32*
  // LEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 8
  // LEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 16777215
  // LEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16777216
  // LEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // LEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 8
  // LEWIDTH-NEXT:    ret void
  //
  // BEWIDTH-LABEL: @increment_b_zero_bitfield_ok(
  // BEWIDTH-NEXT:  entry:
  // BEWIDTH-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD_OK:%.*]], %struct.zero_bitfield_ok* [[S:%.*]], i32 0, i32 1
  // BEWIDTH-NEXT:    [[TMP0:%.*]] = bitcast i24* [[B]] to i32*
  // BEWIDTH-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 8
  // BEWIDTH-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTH-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 16777215
  // BEWIDTH-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // BEWIDTH-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 255
  // BEWIDTH-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTH-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTH-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // BEWIDTH-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 8
  // BEWIDTH-NEXT:    ret void
  //
  // LEWIDTHNUM-LABEL: @increment_b_zero_bitfield_ok(
  // LEWIDTHNUM-NEXT:  entry:
  // LEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD_OK:%.*]], %struct.zero_bitfield_ok* [[S:%.*]], i32 0, i32 1
  // LEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast i24* [[B]] to i32*
  // LEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_LOAD]], 8
  // LEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_SHL]], 8
  // LEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // LEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 16777215
  // LEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], -16777216
  // LEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_VALUE]]
  // LEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // LEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 8
  // LEWIDTHNUM-NEXT:    ret void
  //
  // BEWIDTHNUM-LABEL: @increment_b_zero_bitfield_ok(
  // BEWIDTHNUM-NEXT:  entry:
  // BEWIDTHNUM-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_ZERO_BITFIELD_OK:%.*]], %struct.zero_bitfield_ok* [[S:%.*]], i32 0, i32 1
  // BEWIDTHNUM-NEXT:    [[TMP0:%.*]] = bitcast i24* [[B]] to i32*
  // BEWIDTHNUM-NEXT:    [[BF_LOAD:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_ASHR:%.*]] = ashr i32 [[BF_LOAD]], 8
  // BEWIDTHNUM-NEXT:    [[INC:%.*]] = add nsw i32 [[BF_ASHR]], 1
  // BEWIDTHNUM-NEXT:    [[BF_LOAD1:%.*]] = load volatile i32, i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_VALUE:%.*]] = and i32 [[INC]], 16777215
  // BEWIDTHNUM-NEXT:    [[BF_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // BEWIDTHNUM-NEXT:    [[BF_CLEAR:%.*]] = and i32 [[BF_LOAD1]], 255
  // BEWIDTHNUM-NEXT:    [[BF_SET:%.*]] = or i32 [[BF_CLEAR]], [[BF_SHL]]
  // BEWIDTHNUM-NEXT:    store volatile i32 [[BF_SET]], i32* [[TMP0]], align 4
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_SHL:%.*]] = shl i32 [[BF_VALUE]], 8
  // BEWIDTHNUM-NEXT:    [[BF_RESULT_ASHR:%.*]] = ashr i32 [[BF_RESULT_SHL]], 8
  // BEWIDTHNUM-NEXT:    ret void
  //
  void increment_b_zero_bitfield_ok(volatile struct zero_bitfield_ok *s) {
    s->b++;
  }
  