-
+This instruction takes a valist value and the type of the argument. It
+returns another valist.
'va_arg' Instruction
+
'vanext' Instruction
Syntax:
- <result> = va_arg <va_list>* <arglist>, <retty>
+ <resultarglist> = vanext <va_list> <arglist>, <argty>
Overview:
-The 'va_arg' instruction is used to access arguments passed through the
-"variable argument" area of a function call. It corresponds directly to the
+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 pointer to a valist value to read a new
-argument from. The return type of the instruction is defined by the second
-argument, a type.Semantics:
-The 'va_arg' instruction works just like the va_arg macro
-available in C. In a target-dependent way, it reads the argument indicated by
-the value the arglist points to, updates the arglist, then returns a value of
-the specified type. This instruction should be used in conjunction with the
-variable argument handling Intrinsic Functions.
+The 'vanext' instruction advances the specified valist 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.
-va_arg is an LLVM instruction instead of an intrinsic function because the return type depends on an -argument.
+vanext is an LLVM instruction instead of an intrinsic function because it takes an type as an +argument.
+
+
+
+
+
+
'vaarg' Instruction
+
+
Syntax:
+
+ <resultval> = vaarg <va_list> <arglist>, <argty>
+
+
+Overview:
+
+The 'vaarg' 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 valist value and the type of the argument. It
+returns a value of the specified argument type.
+
+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.
+ +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 intrinsic function because it takes an type as an +argument.
+ ++ + + + +
|
@@ -1781,37 +1825,35 @@ function.
|
+href="#i_vanext">vanext instruction and these three intrinsic +functions. These functions are related to the similarly named macros defined in +the <stdarg.h> header file.
-All of these functions operate on arguments that use a target-specific type -"va_list". The LLVM assembly language reference manual does not define -what this type is, so all transformations should be prepared to handle +All of these functions operate on arguments that use a target-specific value +type "va_list". The LLVM assembly language reference manual does not +define what this type is, so all transformations should be prepared to handle intrinsics with any type used.
-This example shows how the va_arg instruction +This example shows how the vanext instruction and the variable argument handling intrinsic functions are used.
int %test(int %X, ...) {
- ; Allocate two va_list items. On this target, va_list is of type sbyte*
- %ap = alloca sbyte*
- %aq = alloca sbyte*
-
; Initialize variable argument processing
- call void (sbyte**)* %llvm.va_start(sbyte** %ap)
+ %ap = call sbyte*()* %llvm.va_start()
; Read a single integer argument
- %tmp = va_arg sbyte** %ap, int
+ %tmp = vaarg sbyte* %ap, int
- ; Demonstrate usage of llvm.va_copy and llvm_va_end
- %apv = load sbyte** %ap
- call void %llvm.va_copy(sbyte** %aq, sbyte* %apv)
- call void %llvm.va_end(sbyte** %aq)
+ ; Advance to the next argument
+ %ap2 = vanext sbyte* %ap, int
+
+ ; Demonstrate usage of llvm.va_copy and llvm.va_end
+ %aq = call sbyte* (sbyte*)* %llvm.va_copy(sbyte* %ap2)
+ call void %llvm.va_end(sbyte* %aq)
; Stop processing of arguments.
- call void %llvm.va_end(sbyte** %ap)
+ call void %llvm.va_end(sbyte* %ap2)
ret int %tmp
}
@@ -1821,28 +1863,25 @@ int %test(int %X, ...) {
- call void (va_list*)* %llvm.va_start(<va_list>* <arglist>) + call va_list ()* %llvm.va_start()
- -
+The 'llvm.va_start' intrinsic returns a new <arglist> +for subsequent use by the variable argument intrinsics.
+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.
@@ -1850,25 +1889,25 @@ last argument of the function, the compiler can figure that out.
- call void (va_list*)* %llvm.va_end(<va_list>* <arglist>) + call void (va_list)* %llvm.va_end(va_list <arglist>)
+The 'llvm.va_end' intrinsic destroys <arglist> which has +been initialized previously with llvm.va_begin or llvm.va_copy.
+The argument is a va_list to destroy.
@@ -1879,8 +1918,7 @@ to llvm.va_end.
- call void (va_list*, va_list)* %va_copy(<va_list>* <destarglist>, - <va_list> <srcarglist>) + call va_list (va_list)* %llvm.va_copy(va_list <destarglist>)
- +The argument is the va_list to copy.
@@ -1913,7 +1949,7 @@ arbitrarily complex and require memory allocation, for example.
Chris Lattner -Last modified: Thu Oct 9 23:58:41 CDT 2003 +Last modified: Fri Oct 17 18:28:10 CDT 2003