From 8bf607a22103bfae21bd31710694dd8860a52783 Mon Sep 17 00:00:00 2001 From: Andrew Lenharth Date: Sat, 18 Jun 2005 18:28:17 +0000 Subject: [PATCH] OK, after checking the backwards compatibility code on X86 and the new code path on alpha, now has come the time for new vararg support. So, with out further ado, I revert behavior back a couple of years! Well, ok, I lied. A few more notes. First, the Simple ISels cannot be expected to work any longer, but they should still compile Second, there are likely some bugs to track down once the nightly testers start with this. Third, the initial patch doesn't include sparcv9, but I'll do that today. Forth, subsequent patches won't bother being long winded. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@22251 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/LangRef.html | 141 ++++++++++++++++------------------------------ 1 file changed, 49 insertions(+), 92 deletions(-) diff --git a/docs/LangRef.html b/docs/LangRef.html index d5abdce7af0..f5406f5f928 100644 --- a/docs/LangRef.html +++ b/docs/LangRef.html @@ -101,7 +101,6 @@
  • 'cast .. to' Instruction
  • 'select' Instruction
  • 'call' Instruction
    • -
  • 'vanext' Instruction
  • 'vaarg' Instruction
    • @@ -2209,58 +2208,6 @@ the invoke instruction.

    - -
    - 'vanext' Instruction -
    - -
    - -
    Syntax:
    - -
    -  <resultarglist> = vanext <va_list> <arglist>, <argty>
-
    - -
    Overview:
    - -

    The 'vanext' instruction is used to access arguments passed -through the "variable argument" area of a function call. It is used to -implement the va_arg macro in C.

    - -
    Arguments:
    - -

    This instruction takes a va_list value and the type of the -argument. It returns another va_list. The actual type of -va_list may be defined differently for different targets. Most targets -use a va_list type of sbyte* or some other pointer type.

    - -
    Semantics:
    - -

    The 'vanext' instruction advances the specified va_list -past an argument of the specified type. In conjunction with the vaarg instruction, it is used to implement -the va_arg macro available in C. For more information, see -the variable argument handling Intrinsic -Functions.

    - -

    It is legal for this instruction to be called in a function which -does not take a variable number of arguments, for example, the vfprintf -function.

    - -

    vanext is an LLVM instruction instead of an intrinsic function because it takes a type as an -argument. The type refers to the current argument in the va_list; it -tells the compiler how far on the stack it needs to advance to find the next -argument.

    - -
    Example:
    - -

    See the variable argument processing -section.

    - -
    -
    'vaarg' Instruction @@ -2271,34 +2218,35 @@ section.

    Syntax:
    -  <resultval> = vaarg <va_list> <arglist>, <argty>
+  <resultval> = va_arg <va_list*> <arglist>, <argty>
    Overview:
    -

    The 'vaarg' instruction is used to access arguments passed through +

    The 'va_arg' instruction is used to access arguments passed through the "variable argument" area of a function call. It is used to implement the va_arg macro in C.

    Arguments:
    -

    This instruction takes a va_list value and the type of the -argument. It returns a value of the specified argument type. Again, the actual -type of va_list is target specific.

    +

    This instruction takes a va_list* value and the type of +the argument. It returns a value of the specified argument type and +increments the va_list to poin to the next argument. Again, the +actual type of va_list is target specific.

    Semantics:
    -

    The 'vaarg' instruction loads an argument of the specified type from -the specified va_list. In conjunction with the vanext instruction, it is used to implement the -va_arg macro available in C. For more information, see the variable -argument handling Intrinsic Functions.

    +

    The 'va_arg' instruction loads an argument of the specified +type from the specified va_list and causes the +va_list to point to the next argument. For more information, +see the variable argument handling Intrinsic +Functions.

    It is legal for this instruction to be called in a function which does not take a variable number of arguments, for example, the vfprintf function.

    -

    vaarg is an LLVM instruction instead of an va_arg is an LLVM instruction instead of an intrinsic function because it takes a type as an argument.

    @@ -2361,20 +2309,20 @@ used.

     int %test(int %X, ...) {
   ; Initialize variable argument processing
-  %ap = call sbyte* %llvm.va_start()
+  %ap = alloca sbyte*
+  call void %llvm.va_start(sbyte** %ap)
 
   ; Read a single integer argument
-  %tmp = vaarg sbyte* %ap, int
-
-  ; Advance to the next argument
-  %ap2 = vanext sbyte* %ap, int
+  %tmp = va_arg sbyte** %ap, int
 
   ; Demonstrate usage of llvm.va_copy and llvm.va_end
-  %aq = call sbyte* %llvm.va_copy(sbyte* %ap2)
-  call void %llvm.va_end(sbyte* %aq)
+  %aq = alloca sbyte*
+  %apv = load sbyte** %ap
+  call void %llvm.va_copy(sbyte** %aq, sbyte* %apv)
+  call void %llvm.va_end(sbyte** %aq)
 
   ; Stop processing of arguments.
-  call void %llvm.va_end(sbyte* %ap2)
+  call void %llvm.va_end(sbyte** %ap)
   ret int %tmp
 }
    @@ -2388,19 +2336,25 @@ int %test(int %X, ...) {
    Syntax:
    -
      declare <va_list> %llvm.va_start()
    +
      declare void %llvm.va_start(<va_list>* <arglist>)
    Overview:
    -

    The 'llvm.va_start' intrinsic returns a new <arglist> -for subsequent use by the variable argument intrinsics.

    +

    The 'llvm.va_start' intrinsic initializes +*<arglist> for subsequent use by va_arg.

    + +
    Arguments:
    + +

    The argument is a pointer to a va_list element to initialize.

    +
    Semantics:
    -

    The 'llvm.va_start' intrinsic works just like the va_start -macro available in C. In a target-dependent way, it initializes and -returns a va_list element, so that the next vaarg -will produce the first variable argument passed to the function. Unlike -the C va_start macro, this intrinsic does not need to know the -last argument of the function; the compiler can figure that out.

    -

    Note that this intrinsic function is only legal to be called from -within the body of a variable argument function.

    + +

    The 'llvm.va_start' intrinsic works just like the va_start +macro available in C. In a target-dependent way, it initializes the +va_list element the argument points to, so that the next call to +va_arg will produce the first variable argument passed to the function. +Unlike the C va_start macro, this intrinsic does not need to know the +last argument of the function, the compiler can figure that out.

    +
    @@ -2410,7 +2364,7 @@ within the body of a variable argument function.

    Syntax:
    -
      declare void %llvm.va_end(<va_list> <arglist>)
    +
      declare void %llvm.va_end(<va_list*> <arglist>)
    Overview:

    The 'llvm.va_end' intrinsic destroys <arglist> which has been initialized previously with llvm.va_start @@ -2435,24 +2389,27 @@ with calls to llvm.va_end.

    Syntax:
    -  declare <va_list> %llvm.va_copy(<va_list> <destarglist>)
+  declare void %llvm.va_copy(<va_list>* <destarglist>,
+                                          <va_list> <srcarglist>)
    Overview:
    -

    The 'llvm.va_copy' intrinsic copies the current argument position -from the source argument list to the destination argument list.

    +

    The 'llvm.va_copy' intrinsic copies the current argument position from +the source argument list to the destination argument list.

    Arguments:
    -

    The argument is the va_list to copy.

    +

    The first argument is a pointer to a va_list element to initialize. +The second argument is a va_list element to copy from.

    +
    Semantics:
    -

    The 'llvm.va_copy' intrinsic works just like the va_copy -macro available in C. In a target-dependent way, it copies the source -va_list element into the returned list. This intrinsic is necessary -because the llvm.va_start intrinsic may be +

    The 'llvm.va_copy' intrinsic works just like the va_copy macro +available in C. In a target-dependent way, it copies the source +va_list element into the destination list. This intrinsic is necessary +because the llvm.va_begin intrinsic may be arbitrarily complex and require memory allocation, for example.