reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

    1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68

// RUN: %clang_cc1 %s -verify -fsyntax-only -triple i686-pc-linux

int a __attribute__((naked)); // expected-warning {{'naked' attribute only applies to functions}}

__attribute__((naked)) int t0(void) {
  __asm__ volatile("mov r0, #0");
}

void t1() __attribute__((naked));

void t2() __attribute__((naked(2))); // expected-error {{'naked' attribute takes no arguments}}

__attribute__((naked)) int t3() { // expected-note{{attribute is here}}
  return 42; // expected-error{{non-ASM statement in naked function is not supported}}
}

__attribute__((naked)) int t4() {
  asm("movl $42, %eax");
  asm("retl");
}

__attribute__((naked)) int t5(int x) {
  asm("movl x, %eax");
  asm("retl");
}

__attribute__((naked)) void t6() {
  ;
}

__attribute__((naked)) void t7() {
  asm("movl $42, %eax");
  ;
}

extern int x, y;

__attribute__((naked)) void t8(int z) { // expected-note{{attribute is here}}
  __asm__ ("movl $42, %1"
           : "=r"(x),
             "=r"(z) // expected-error{{parameter references not allowed in naked functions}}
           );
}

__attribute__((naked)) void t9(int z) { // expected-note{{attribute is here}}
  __asm__ ("movl %eax, %1"
           : : "r"(x),
               "r"(z) // expected-error{{parameter references not allowed in naked functions}}
           );
}

__attribute__((naked)) void t10() {  // expected-note{{attribute is here}}
  int a; // expected-error{{non-ASM statement in naked function is not supported}}
}

__attribute__((naked)) void t11() {  // expected-note{{attribute is here}}
  register int a asm("eax") = x; // expected-error{{non-ASM statement in naked function is not supported}}
}

__attribute__((naked)) void t12() {  // expected-note{{attribute is here}}
  register int a asm("eax"), b asm("ebx") = x; // expected-error{{non-ASM statement in naked function is not supported}}
}

__attribute__((naked)) void t13() {
  register int a asm("eax");
  register int b asm("ebx"), c asm("ecx");
}