|
- pointer to value of type pty
+ pointer to value of type pty
|
Type.pointer(pty, addrspc)
@@ -1064,8 +1106,559 @@ cellspacing="0" cellpadding="4">
PointerType
VectorType
+ The class-level documentation follows:
+
+ llvm.core.Type
+
+ Static Constructors
+-
+int(n)
+
+-
+
+ Create an integer type of bit width n.
+
+
+-
+float()
+
+-
+
+ Create a 32-bit floating point type.
+
+
+-
+double()
+
+-
+
+ Create a 64-bit floating point type.
+
+
+-
+x86_fp80()
+
+-
+
+ Create a 80-bit 80x87-style floating point type.
+
+
+-
+fp128()
+
+-
+
+ Create a 128-bit floating point type (112-bit mantissa).
+
+
+-
+ppc_fp128()
+
+-
+
+ Create a 128-bit float (two 64-bits).
+
+
+-
+function(ret, params, vararg=False)
+
+-
+
+ Create a function type, having the return type ret (must be a
+ Type), accepting the parameters params, where params is an
+ iterable, that yields Type objects representing the type of
+ each function argument in order. If vararg is True, function is
+ variadic.
+
+
+-
+struct(eltys)
+
+-
+
+ Create an unpacked structure. eltys is an iterable, that yields
+ Type objects representing the type of each element in order.
+
+
+-
+packed_struct(eltys)
+
+-
+
+ Like struct(eltys), but creates a packed struct.
+
+
+-
+array(elty, count)
+
+-
+
+ Creates an array type, holding count elements, each of type elty
+ (which should be a Type).
+
+
+-
+pointer(pty, addrspc=0)
+
+-
+
+ Create a pointer to type pty (which should be a `Type). (TODO
+ addrspc).
+
+
+-
+void()
+
+-
+
+ Creates a void type. Used for function return types.
+
+
+-
+label()
+
+-
+
+ Creates a label type.
+
+
+-
+opaque()
+
+-
+
+ Opaque type, used for creating self-referencing types.
+
+
+
+ Properties
+-
+kind [read-only]
+
+-
+
+ A value (enum) representing the “type” of the object. It will be
+ one of the following constants defined in llvm.core:
+
+
+
+ TYPE_VOID = 0
+TYPE_FLOAT = 1
+TYPE_DOUBLE = 2
+TYPE_X86_FP80 = 3
+TYPE_FP128 = 4
+TYPE_PPC_FP128 = 5
+TYPE_LABEL = 6
+TYPE_INTEGER = 7
+TYPE_FUNCTION = 8
+TYPE_STRUCT = 9
+TYPE_ARRAY = 10
+TYPE_POINTER = 11
+TYPE_OPAQUE = 12
+TYPE_VECTOR = 13
+ Example:
+
+
+ assert Type.int().kind == TYPE_INTEGER
+assert Type.void().kind == TYPE_VOID
+
+
+ Methods
+-
+refine
+
+-
+
+ Used for constructing self-referencing types. See the documentation
+ of TypeHandle objects.
+
+
+
+ Special Methods
+-
+__str__
+
+-
+
+ Type objects can be stringified into it's LLVM assembly language
+ representation.
+
+
+-
+__eq__
+
+-
+
+ Type objects can be compared for equality. Internally, this
+ converts both arguments into their LLVM assembly representations and
+ compares the resultant strings.
+
+
+
+
+ llvm.core.IntegerType
+
+ Base Class
+-
+
+llvm.core.Type
+
+
+
+ Properties
+-
+width [read-only]
+
+-
+
+ The width of the integer type, in number of bits.
+
+
+
+
+ llvm.core.FunctionType
+
+ Base Class
+-
+
+llvm.core.Type
+
+
+
+ Properties
+-
+return_type [read-only]
+
+-
+
+ A Type object, representing the return type of the function.
+
+
+-
+vararg [read-only]
+
+-
+
+ True if the function is variadic.
+
+
+-
+args [read-only]
+
+-
+
+ Returns an iterable object that yields Type objects that
+ represent, in order, the types of the arguments accepted by the
+ function. Used like this:
+
+
+
+ func_type = Type.function( Type.int(), [ Type.int(), Type.int() ] )
+for arg in func_type.args:
+ assert arg.kind == TYPE_INTEGER
+ assert arg == Type.int()
+assert func_type.arg_count == len(func_type.args)
+
+-
+arg_count [read-only]
+
+-
+
+ The number of arguments. Same as len(obj.args), but faster.
+
+
+
+
+ llvm.core.StructType
+
+ Base Class
+-
+
+llvm.core.Type
+
+
+
+ Properties
+-
+packed [read-only]
+
+-
+
+ True if the structure is packed (no padding between elements).
+
+
+-
+elements [read-only]
+
+-
+
+ Returns an iterable object that yields Type objects that
+ represent, in order, the types of the elements of the structure.
+ Used like this:
+
+
+
+ struct_type = Type.struct( [ Type.int(), Type.int() ] )
+for elem in struct_type.elements:
+ assert elem.kind == TYPE_INTEGER
+ assert elem == Type.int()
+assert struct_type.element_count == len(struct_type.elements)
+
+-
+element_count [read-only]
+
+-
+
+ The number of elements. Same as len(obj.elements), but faster.
+
+
+
+
+ llvm.core.ArrayType
+
+ Base Class
+-
+
+llvm.core.Type
+
+
+
+ Properties
+-
+element [read-only]
+
+-
+
+ A Type object representing the type of the element of the array.
+
+
+-
+count [read-only]
+
+-
+
+ The number of elements in the array.
+
+
+
+
+ llvm.core.PointerType
+
+ Base Class
+-
+
+llvm.core.Type
+
+
+
+ Properties
+-
+address_space [read-only]
+
+-
+
+ The address space of the pointer.
+
+
+-
+pointee [read-only]
+
+-
+
+ TODO missing
+
+
+
+
+ llvm.core.VectorType
+
+ Base Class
+-
+
+llvm.core.Type
+
+
+
+ Properties
+-
+element [read-only]
+
+-
+
+ A Type object representing the type of the element of the vector.
+
+
+-
+count [read-only]
+
+-
+
+ The number of elements in the vector.
+
+
+
+ Here is an example that demonstrates the creation of types:
+
+
+ #!/usr/bin/env python
+
+# integers
+int_ty = Type.int()
+bool_ty = Type.int(1)
+int_64bit = Type.int(64)
+
+# floats
+sprec_real = Type.float()
+dprec_real = Type.double()
+
+# arrays and vectors
+intar_ty = Type.array( int_ty, 10 ) # "typedef int intar_ty[10];"
+twodim = Type.array( intar_ty , 10 ) # "typedef int twodim[10][10];"
+vec = Type.array( int_ty, 10 )
+
+# structures
+s1_ty = Type.struct( [ int_ty, sprec_real ] )
+ # "struct s1_ty { int v1; float v2; };"
+
+# pointers
+intptr_ty = Type.pointer(int_ty) # "typedef int *intptr_ty;"
+
+# functions
+f1 = Type.function( int_ty, [ int_ty ] )
+ # functions that take 1 int_ty and return 1 int_ty
+
+f2 = Type.function( Type.void(), [ int_ty ] )
+ # functions that take 1 int_ty and return nothing
+
+fnargs = [ Type.pointer( Type.int(8) ) ]
+printf = Type.function( Type.int(), fnargs, True )
+ # variadic function
+Values (llvm.core)
-TODO
+llvm.core.Value is the base class of all values computed by a program
+that may be used as operands to other values. A value has a type
+associated with it (an object of llvm.core.Type).
+The class hierarchy is:
+
+
+ Value
+ Constant
+ GlobalValue
+ GlobalVariable
+ Function
+ Argument
+ Instruction
+ CallOrInvokeInstruction
+ PHINode
+ SwitchInstruction
+ BasicBlock
+ The Value class is abstract, it's not meant to be instantiated.
+Constant-s represent constants that appear within code or as
+initializers of globals. They are constructed using static methods of
+Constant. The Constant class is covered in a separate section below.
+The Function object represents an instance of a function type. Such
+objects contain Argument objects, which represent the actual,
+local-variable-like arguments of the function (not to be confused with
+the arguments returned by a function type object — these represent
+the type of the arguments). The various Instruction-s are created by
+the Builder class. These are also covered separately.
+Value objects have a type (read-only), and a name (read-write).
+
+ llvm.core.Value
+
+ Properties
+-
+name
+
+-
+
+ The name of the value.
+
+
+-
+type [read-only]
+
+-
+
+ An llvm.core.Type object representing the type of the value.
+
+
+
+ Special Methods
+-
+__str__
+
+-
+
+ Value objects can be stringified into it's LLVM assembly language
+ representation.
+
+
+-
+__eq__
+
+-
+
+ Value objects can be compared for equality. Internally, this
+ converts both arguments into their LLVM assembly representations and
+ compares the resultant strings.
+
+
+
+ Constants (llvm.core)
+Constant-s represents constants that appear within the code. The
+values of such objects are known at creation time. Constants can be
+created from Python constants. A constant expression is also a constant.
+Given a Constant object, an operation (like addition, subtraction etc)
+can be specified, to yield a new Constant object. Let's see some
+examples:
+
+
+ #!/usr/bin/env python
+
+ti = Type.int() # a 32-bit int type
+
+k1 = Constant.int(ti, 42) # "int k1 = 42;"
+k2 = k1.add( Constant.int( ti, 10 ) ) # "int k2 = k1 + 10;"
+
+tr = Type.float()
+
+r1 = Constant.real(tr, "3.141592") # create from a string
+r2 = Constant.real(tr, 1.61803399) # create from a Python float
+
+r3 = Constant.undef() # an `undefined' value
+ Instructions (llvm.core)
TODO
Basic Block (llvm.core)
@@ -1109,7 +1702,7 @@ reached at mdevan.foobar@gmail.com.
|
+