Skip to content
  1. Feb 12, 2009
    • Bill Wendling's avatar
      Move debug loc info along when the spiller creates new instructions. · f6d609a2
      Bill Wendling authored 
      llvm-svn: 64342
      f6d609a2
    • Fariborz Jahanian's avatar
      Last @encode'ing fix for objc2's nonfragile abi. · 77b6b5d6
      Fariborz Jahanian authored 
      All relevant dejagnu enocding tests pass in this mode.

llvm-svn: 64341
      77b6b5d6
    • Evan Cheng's avatar
      Apparently some MachineBasicBlock's don't have corresponding llvm basic blocks. · 6f6abfd9
      Evan Cheng authored 
      llvm-svn: 64340
      6f6abfd9
    • Evan Cheng's avatar
      Remove a bogus assertion. It's possible a live-in available value is used by a... · eb5ec4a0
      Evan Cheng authored 
      Remove a bogus assertion. It's possible a live-in available value is used by a previous instruction.

llvm-svn: 64339
      eb5ec4a0
    • Ted Kremenek's avatar
      PTH: Have meta data be at the beginning of the PTH file, not the end. · 4c1d41f2
      Ted Kremenek authored 
      llvm-svn: 64338
      4c1d41f2
    • Mike Stump's avatar
      Fix comment. · c89c8e32
      Mike Stump authored 
      llvm-svn: 64337
      c89c8e32
    • Douglas Gregor's avatar
      Initial implementation of function overloading in C. · 4e5cbdcb
      Douglas Gregor authored 
      This commit adds a new attribute, "overloadable", that enables C++
function overloading in C. The attribute can only be added to function
declarations, e.g.,

  int *f(int) __attribute__((overloadable));

If the "overloadable" attribute exists on a function with a given
name, *all* functions with that name (and in that scope) must have the
"overloadable" attribute. Sets of overloaded functions with the
"overloadable" attribute then follow the normal C++ rules for
overloaded functions, e.g., overloads must have different
parameter-type-lists from each other.

When calling an overloaded function in C, we follow the same
overloading rules as C++, with three extensions to the set of standard
conversions:

  - A value of a given struct or union type T can be converted to the
    type T. This is just the identity conversion. (In C++, this would
    go through a copy constructor).
  - A value of pointer type T* can be converted to a value of type U*
    if T and U are compatible types. This conversion has Conversion
    rank (it's considered a pointer conversion in C).
  - A value of type T can be converted to a value of type U if T and U
    are compatible (and are not both pointer types). This conversion
    has Conversion rank (it's considered to be a new kind of
    conversion unique to C, a "compatible" conversion).

Known defects (and, therefore, next steps):
  1) The standard-conversion handling does not understand conversions
  involving _Complex or vector extensions, so it is likely to get
  these wrong. We need to add these conversions.
  2) All overloadable functions with the same name will have the same
  linkage name, which means we'll get a collision in the linker (if
  not sooner). We'll need to mangle the names of these functions.

llvm-svn: 64336
      4e5cbdcb
  3. Feb 11, 2009