; RUN: llc --march=mips64 -mcpu=mips64r2 < %s | FileCheck %s

; Generated from the C program:
; 
; #include <stdio.h>
; #include <string.h>
; 
; struct SmallStruct_1b {
;  char x1;
; };
; 
; struct SmallStruct_2b {
;  char x1;
;  char x2;
; };
; 
; struct SmallStruct_3b {
;  char x1;
;  char x2;
;  char x3;
; };
; 
; struct SmallStruct_4b {
;  char x1;
;  char x2;
;  char x3;
;  char x4;
; };
; 
; struct SmallStruct_5b {
;  char x1;
;  char x2;
;  char x3;
;  char x4;
;  char x5;
; };
; 
; struct SmallStruct_6b {
;  char x1;
;  char x2;
;  char x3;
;  char x4;
;  char x5;
;  char x6;
; };
; 
; struct SmallStruct_7b {
;  char x1;
;  char x2;
;  char x3;
;  char x4;
;  char x5;
;  char x6;
;  char x7;
; };
; 
; struct SmallStruct_8b {
;  char x1;
;  char x2;
;  char x3;
;  char x4;
;  char x5;
;  char x6;
;  char x7;
;  char x8;
; };
; 
; struct SmallStruct_9b {
;  char x1;
;  char x2;
;  char x3;
;  char x4;
;  char x5;
;  char x6;
;  char x7;
;  char x8;
;  char x9;
; };
; 
; void varArgF_SmallStruct(char* c, ...);
; 
; void smallStruct_1b(struct SmallStruct_1b* ss) {
;  varArgF_SmallStruct("", *ss);
; }
; 
; void smallStruct_2b(struct SmallStruct_2b* ss) {
;  varArgF_SmallStruct("", *ss);
; }
; 
; void smallStruct_3b(struct SmallStruct_3b* ss)
; {
;  varArgF_SmallStruct("", *ss);
; }
; 
; void smallStruct_4b(struct SmallStruct_4b* ss)
; {
;  varArgF_SmallStruct("", *ss);
; }
; 
; void smallStruct_5b(struct SmallStruct_5b* ss) 
; {
;  varArgF_SmallStruct("", *ss);
; }
; 
; void smallStruct_6b(struct SmallStruct_6b* ss) 
; {
;  varArgF_SmallStruct("", *ss);
; }
; 
; void smallStruct_7b(struct SmallStruct_7b* ss) 
; {
;  varArgF_SmallStruct("", *ss);
; }
; 
; void smallStruct_8b(struct SmallStruct_8b* ss) 
; {
;  varArgF_SmallStruct("", *ss);
; }
; 
; void smallStruct_9b(struct SmallStruct_9b* ss) 
; {
;  varArgF_SmallStruct("", *ss);
; }

%struct.SmallStruct_1b = type { i8 }
%struct.SmallStruct_2b = type { i8, i8 }
%struct.SmallStruct_3b = type { i8, i8, i8 }
%struct.SmallStruct_4b = type { i8, i8, i8, i8 }
%struct.SmallStruct_5b = type { i8, i8, i8, i8, i8 }
%struct.SmallStruct_6b = type { i8, i8, i8, i8, i8, i8 }
%struct.SmallStruct_7b = type { i8, i8, i8, i8, i8, i8, i8 }
%struct.SmallStruct_8b = type { i8, i8, i8, i8, i8, i8, i8, i8 }
%struct.SmallStruct_9b = type { i8, i8, i8, i8, i8, i8, i8, i8, i8 }

@.str = private unnamed_addr constant [3 x i8] c"01\00", align 1

declare void @varArgF_SmallStruct(i8* %c, ...) 

define void @smallStruct_1b(%struct.SmallStruct_1b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_1b*, align 8
  store %struct.SmallStruct_1b* %ss, %struct.SmallStruct_1b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_1b*, %struct.SmallStruct_1b** %ss.addr, align 8
  %1 = bitcast %struct.SmallStruct_1b* %0 to { i8 }*
  %2 = getelementptr { i8 }, { i8 }* %1, i32 0, i32 0
  %3 = load i8, i8* %2, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8 inreg %3)
  ret void
 ; CHECK-LABEL: smallStruct_1b: 
 ; CHECK: dsll $[[R1:[0-9]+]], $[[R2:[0-9]+]], 56
}

define void @smallStruct_2b(%struct.SmallStruct_2b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_2b*, align 8
  store %struct.SmallStruct_2b* %ss, %struct.SmallStruct_2b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_2b*, %struct.SmallStruct_2b** %ss.addr, align 8
  %1 = bitcast %struct.SmallStruct_2b* %0 to { i16 }*
  %2 = getelementptr { i16 }, { i16 }* %1, i32 0, i32 0
  %3 = load i16, i16* %2, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i16 inreg %3)
  ret void
 ; CHECK-LABEL: smallStruct_2b:
 ; CHECK: dsll $[[R1:[0-9]+]], $[[R2:[0-9]+]], 48
}

define void @smallStruct_3b(%struct.SmallStruct_3b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_3b*, align 8
  %.coerce = alloca { i24 }
  store %struct.SmallStruct_3b* %ss, %struct.SmallStruct_3b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_3b*, %struct.SmallStruct_3b** %ss.addr, align 8
  %1 = bitcast { i24 }* %.coerce to i8*
  %2 = bitcast %struct.SmallStruct_3b* %0 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %2, i64 3, i1 false)
  %3 = getelementptr { i24 }, { i24 }* %.coerce, i32 0, i32 0
  %4 = load i24, i24* %3, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i24 inreg %4)
  ret void
 ; CHECK-LABEL: smallStruct_3b:
 ; CHECK: dsll $[[R1:[0-9]+]], $[[R2:[0-9]+]], 40
}

declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1) #1

define void @smallStruct_4b(%struct.SmallStruct_4b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_4b*, align 8
  store %struct.SmallStruct_4b* %ss, %struct.SmallStruct_4b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_4b*, %struct.SmallStruct_4b** %ss.addr, align 8
  %1 = bitcast %struct.SmallStruct_4b* %0 to { i32 }*
  %2 = getelementptr { i32 }, { i32 }* %1, i32 0, i32 0
  %3 = load i32, i32* %2, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i32 inreg %3)
  ret void
 ; CHECK-LABEL: smallStruct_4b:
 ; CHECK: dsll $[[R1:[0-9]+]], $[[R2:[0-9]+]], 32
}

define void @smallStruct_5b(%struct.SmallStruct_5b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_5b*, align 8
  %.coerce = alloca { i40 }
  store %struct.SmallStruct_5b* %ss, %struct.SmallStruct_5b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_5b*, %struct.SmallStruct_5b** %ss.addr, align 8
  %1 = bitcast { i40 }* %.coerce to i8*
  %2 = bitcast %struct.SmallStruct_5b* %0 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %2, i64 5, i1 false)
  %3 = getelementptr { i40 }, { i40 }* %.coerce, i32 0, i32 0
  %4 = load i40, i40* %3, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i40 inreg %4)
  ret void
 ; CHECK-LABEL: smallStruct_5b:
 ; CHECK: dsll $[[R1:[0-9]+]], $[[R2:[0-9]+]], 24
}

define void @smallStruct_6b(%struct.SmallStruct_6b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_6b*, align 8
  %.coerce = alloca { i48 }
  store %struct.SmallStruct_6b* %ss, %struct.SmallStruct_6b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_6b*, %struct.SmallStruct_6b** %ss.addr, align 8
  %1 = bitcast { i48 }* %.coerce to i8*
  %2 = bitcast %struct.SmallStruct_6b* %0 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %2, i64 6, i1 false)
  %3 = getelementptr { i48 }, { i48 }* %.coerce, i32 0, i32 0
  %4 = load i48, i48* %3, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i48 inreg %4)
  ret void
 ; CHECK-LABEL: smallStruct_6b:
 ; CHECK: dsll $[[R1:[0-9]+]], $[[R2:[0-9]+]], 16
}

define void @smallStruct_7b(%struct.SmallStruct_7b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_7b*, align 8
  %.coerce = alloca { i56 }
  store %struct.SmallStruct_7b* %ss, %struct.SmallStruct_7b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_7b*, %struct.SmallStruct_7b** %ss.addr, align 8
  %1 = bitcast { i56 }* %.coerce to i8*
  %2 = bitcast %struct.SmallStruct_7b* %0 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %2, i64 7, i1 false)
  %3 = getelementptr { i56 }, { i56 }* %.coerce, i32 0, i32 0
  %4 = load i56, i56* %3, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i56 inreg %4)
  ret void
 ; CHECK-LABEL: smallStruct_7b:
 ; CHECK: dsll $[[R1:[0-9]+]], $[[R2:[0-9]+]], 8
}

define void @smallStruct_8b(%struct.SmallStruct_8b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_8b*, align 8
  store %struct.SmallStruct_8b* %ss, %struct.SmallStruct_8b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_8b*, %struct.SmallStruct_8b** %ss.addr, align 8
  %1 = bitcast %struct.SmallStruct_8b* %0 to { i64 }*
  %2 = getelementptr { i64 }, { i64 }* %1, i32 0, i32 0
  %3 = load i64, i64* %2, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 inreg %3)
  ret void
 ; CHECK-LABEL: smallStruct_8b:
 ; Check that the structure is not shifted before the pointer to str is loaded.
 ; CHECK-NOT: dsll
 ; CHECK: lui
}

define void @smallStruct_9b(%struct.SmallStruct_9b* %ss) #0 {
entry:
  %ss.addr = alloca %struct.SmallStruct_9b*, align 8
  %.coerce = alloca { i64, i8 }
  store %struct.SmallStruct_9b* %ss, %struct.SmallStruct_9b** %ss.addr, align 8
  %0 = load %struct.SmallStruct_9b*, %struct.SmallStruct_9b** %ss.addr, align 8
  %1 = bitcast { i64, i8 }* %.coerce to i8*
  %2 = bitcast %struct.SmallStruct_9b* %0 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %2, i64 9, i1 false)
  %3 = getelementptr { i64, i8 }, { i64, i8 }* %.coerce, i32 0, i32 0
  %4 = load i64, i64* %3, align 1
  %5 = getelementptr { i64, i8 }, { i64, i8 }* %.coerce, i32 0, i32 1
  %6 = load i8, i8* %5, align 1
  call void (i8*, ...) @varArgF_SmallStruct(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 inreg %4, i8 inreg %6)
  ret void
 ; CHECK-LABEL: smallStruct_9b:
 ; CHECK: dsll $[[R1:[0-9]+]], $[[R2:[0-9]+]], 56
}