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
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96

// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
// CHECK: _Z1fPA10_1X
// CHECK: _Z1fPFvE

int __attribute__((overloadable)) f(int x) { return x; }
float __attribute__((overloadable)) f(float x) { return x; }
double __attribute__((overloadable)) f(double x) { return x; }
double _Complex __attribute__((overloadable)) f(double _Complex x) { return x; }
typedef short v4hi __attribute__ ((__vector_size__ (8)));
v4hi __attribute__((overloadable)) f(v4hi x) { return x; }

struct X { };
void  __attribute__((overloadable)) f(struct X (*ptr)[10]) { }

void __attribute__((overloadable)) f(int x, int y, ...) { }

void __attribute__((overloadable)) f(void (*x)()) {}

int main() {
  int iv = 17;
  float fv = 3.0f;
  double dv = 4.0;
  double _Complex cdv;
  v4hi vv;

  iv = f(iv);
  fv = f(fv);
  dv = f(dv);
  cdv = f(cdv);
  vv = f(vv);
}

// Ensuring that we pick the correct function for taking the address of an
// overload when conversions are involved.

void addrof_many(int *a) __attribute__((overloadable, enable_if(0, "")));
void addrof_many(void *a) __attribute__((overloadable));
void addrof_many(char *a) __attribute__((overloadable));

void addrof_single(int *a) __attribute__((overloadable, enable_if(0, "")));
void addrof_single(char *a) __attribute__((overloadable, enable_if(0, "")));
void addrof_single(char *a) __attribute__((overloadable));

// CHECK-LABEL: define {{(dso_local )?}}void @foo
void foo() {
  // CHECK: store void (i8*)* @_Z11addrof_manyPc
  void (*p1)(char *) = &addrof_many;
  // CHECK: store void (i8*)* @_Z11addrof_manyPv
  void (*p2)(void *) = &addrof_many;
  // CHECK: void (i8*)* @_Z11addrof_manyPc
  void *vp1 = (void (*)(char *)) & addrof_many;
  // CHECK: void (i8*)* @_Z11addrof_manyPv
  void *vp2 = (void (*)(void *)) & addrof_many;

  // CHECK: store void (i8*)* @_Z13addrof_singlePc
  void (*p3)(char *) = &addrof_single;
  // CHECK: @_Z13addrof_singlePc
  void (*p4)(int *) = &addrof_single;
  // CHECK: @_Z13addrof_singlePc
  void *vp3 = &addrof_single;
}


void ovl_bar(char *) __attribute__((overloadable));
void ovl_bar(int) __attribute__((overloadable));

// CHECK-LABEL: define {{(dso_local )?}}void @bar
void bar() {
  char charbuf[1];
  unsigned char ucharbuf[1];

  // CHECK: call void @_Z7ovl_barPc
  ovl_bar(charbuf);
  // CHECK: call void @_Z7ovl_barPc
  ovl_bar(ucharbuf);
}

void ovl_baz(int *, int) __attribute__((overloadable));
void ovl_baz(unsigned int *, unsigned int) __attribute__((overloadable));
void ovl_baz2(int, int *) __attribute__((overloadable));
void ovl_baz2(unsigned int, unsigned int *) __attribute__((overloadable));
// CHECK-LABEL: define {{(dso_local )?}}void @baz
void baz() {
  unsigned int j;
  // Initial rules for incompatible pointer conversions made this overload
  // ambiguous.
  // CHECK: call void @_Z7ovl_bazPjj
  ovl_baz(&j, 0);
  // CHECK: call void @_Z7ovl_bazPjj
  ovl_baz(&j, 0u);

  // CHECK: call void @_Z8ovl_baz2jPj
  ovl_baz2(0, &j);
  // CHECK: call void @_Z8ovl_baz2jPj
  ovl_baz2(0u, &j);
}