// RUN: %clang_cc1 -triple avr -target-cpu atmega328 -emit-llvm %s -o - \
// RUN:     | FileCheck %s --check-prefix AVR
// RUN: %clang_cc1 -triple avr -target-cpu attiny40 -emit-llvm %s -o - \
// RUN:     | FileCheck %s --check-prefix TINY

// NOTE: All arguments are passed via the stack for functions with variable arguments.
// AVR:      define {{.*}} i8 @foo0(i8 {{.*}}, i8 {{.*}}, ...)
// TINY:     define {{.*}} i8 @foo0(i8 {{.*}}, i8 {{.*}}, ...)
// AVR-NOT:  define {{.*}} i8 @foo0(i8 {{.*}} signext {{.*}}, i8 {{.*}} signext {{.*}}, ...)
// TINY-NOT: define {{.*}} i8 @foo0(i8 {{.*}} signext {{.*}}, i8 {{.*}} signext {{.*}}, ...)
char foo0(char a, char b, ...) {
  return a + b;
}

// NOTE: All arguments are passed via registers on both avr and avrtiny.
// AVR:  define {{.*}} i8 @foo1(i32 {{.*}}, i8 {{.*}} signext {{.*}})
// TINY: define {{.*}} i8 @foo1(i32 {{.*}}, i8 {{.*}} signext {{.*}})
char foo1(long a, char b) {
  return a + b;
}

// NOTE: The argument `char c` is passed via registers on avr, while via the stack on avrtiny.
//       The argument `char b` costs 2 registers, so there is no vacant register left for
//       `char c` on avrtiny.
// AVR:      define {{.*}} i8 @foo2(i32 {{.*}}, i8 {{.*}} signext {{.*}}, i8 {{.*}} signext {{.*}})
// TINY:     define {{.*}} i8 @foo2(i32 {{.*}}, i8 {{.*}} signext {{.*}}, i8 {{.*}})
// TINY-NOT: define {{.*}} i8 @foo2(i32 {{.*}}, i8 {{.*}} signext {{.*}}, i8 {{.*}} signext {{.*}})
char foo2(long a, char b, char c) {
  return a + b + c;
}

// NOTE: On avr, the argument `a` costs 16 registers and `b` costs 2 registers, so
//       `c` has to be passed via the stack.
// AVR:      define {{.*}} i8 @foo3({{.*}}, i8 {{.*}} signext {{.*}}, i8 {{.*}})
// AVR-NOT:  define {{.*}} i8 @foo3({{.*}}, i8 {{.*}} signext {{.*}}, i8 {{.*}} signext {{.*}})
// TINY:     define {{.*}} i8 @foo3({{.*}}, i8 {{.*}}, i8 {{.*}})
// TINY-NOT: define {{.*}} i8 @foo3({{.*}}, i8 {{.*}} signext {{.*}}, i8 {{.*}} signext {{.*}})
struct s15 {
  char arr[15];
};
char foo3(struct s15 a, char b, char c) {
  return a.arr[b] + a.arr[c];
}

// NOTE: On avr, `a` only costs 16 registers, though there are 2 vacant registers,
//       both `b` and `c` have to be passed via the stack.
// AVR:      define {{.*}} i8 @foo4({{.*}}, i32 {{.*}}, i8 {{.*}})
// AVR-NOT:  define {{.*}} i8 @foo4({{.*}}, i32 {{.*}}, i8 {{.*}} signext {{.*}})
// TINY:     define {{.*}} i8 @foo4({{.*}}, i32 {{.*}}, i8 {{.*}})
// TINY-NOT: define {{.*}} i8 @foo4({{.*}}, i32 {{.*}}, i8 {{.*}} signext {{.*}})
char foo4(struct s15 a, long b, char c) {
  return a.arr[c];
}

// NOTE: On avrtiny, `a` only costs 4 registers, though there are 2 vacant
//       registers, both `b` and `c` are passed via the stack.
// AVR:      define {{.*}} i8 @foo5(i32 {{.*}}, i32 {{.*}}, i8 {{.*}} signext {{.*}})
// TINY:     define {{.*}} i8 @foo5(i32 {{.*}}, i32 {{.*}}, i8 {{.*}})
// TINY-NOT: define {{.*}} i8 @foo5(i32 {{.*}}, i32 {{.*}}, i8 {{.*}} signext {{.*}})
char foo5(long a, long b, char c) {
  return c + 1;
}

// NOTE: All arguments are passed via the stack, though all registers are vacant.
// AVR:      define {{.*}} i8 @foo6({{.*}}, i8 {{.*}})
// AVR-NOT:  define {{.*}} i8 @foo6({{.*}}, i8 {{.*}} signext {{.*}})
// TINY:     define {{.*}} i8 @foo6({{.*}}, i8 {{.*}})
// TINY-NOT: define {{.*}} i8 @foo6({{.*}}, i8 {{.*}} signext {{.*}})
struct s32 {
  char arr[32];
};
char foo6(struct s32 a, char b) {
  return a.arr[b];
}

// NOTE: All arguments are passed via registers on avr. While all arguments are passed
//       via the stack on avrtiny, though all registers are vacant.
// AVR:      define {{.*}} i8 @foo7({{.*}}, i8 {{.*}} signext {{.*}})
// TINY:     define {{.*}} i8 @foo7({{.*}}, i8 {{.*}})
// TINY-NOT: define {{.*}} i8 @foo7({{.*}}, i8 {{.*}} signext {{.*}})
char foo7(struct s15 a, char b) {
  return a.arr[b];
}

// NOTE: On avr, though `a` only cost 16 registers, `b` has to be passed via the
//       stack, since there is an implicit pointer argument costs 2 registers.
// AVR:      define {{.*}} @foo8({{.*}}, {{.*}}, i8 {{.*}})
// AVR-NOT:  define {{.*}} @foo8({{.*}}, {{.*}}, i8 {{.*}} signext {{.*}})
// TINY:     define {{.*}} @foo8({{.*}}, {{.*}}, i8 {{.*}})
// TINY-NOT: define {{.*}} @foo8({{.*}}, {{.*}}, i8 {{.*}} signext {{.*}})
struct s15 foo8(struct s15 a, char b) {
  a.arr[0] = b;
  return a;
}

// NOTE: On avrtiny, `b` has to be passed via the stack, since there is an
//       implicit pointer argument costs 2 registers.
// AVR:      define {{.*}} @foo9({{.*}}, i32 {{.*}}, i8 {{.*}} signext {{.*}})
// TINY:     define {{.*}} @foo9({{.*}}, i32 {{.*}}, i8 {{.*}})
// TINY-NOT: define {{.*}} @foo9({{.*}}, i32 {{.*}}, i8 {{.*}} signext {{.*}})
struct s15 foo9(long a, char b) {
  struct s15 x;
  x.arr[0] = b;
  return x;
}

// NOTE: All arguments are passed via registers, though there is an implicit
//       pointer argument costs 2 registers.
// AVR:  define {{.*}} @fooa({{.*}}, i8 {{.*}} signext {{.*}}, i8 {{.*}} signext {{.*}})
// TINY: define {{.*}} @fooa({{.*}}, i8 {{.*}} signext {{.*}}, i8 {{.*}} signext {{.*}})
struct s15 fooa(char a, char b) {
  struct s15 x;
  x.arr[0] = a;
  x.arr[1] = b;
  return x;
}