subtypes for C and OCaml API

[TyanNN]

Summary

This patch provides LLVMGetSubtypes & LLVMGetNumContainedTypes + subtypes (for ocaml) functions, which are bindings to llvm::Type::subtypes & llvm::Type::getNumContainedTypes

[deadalnix]

What's the difference betwenn this and LLVMStructGetTypeAtIndex ?

[TyanNN]

In D33677#767728, @deadalnix wrote:

What's the difference betwenn this and LLVMStructGetTypeAtIndex ?

Well, it's only for structures (possibly packed), this method extracts type from, for example, pointers

[TyanNN]

I think i'm not allowed to commit by myself, please commit this patch when everything's good

[deadalnix]

There is also facilities to do it for pointers and alike, and I assume you need to check what kind of type you are iterating on, because you have no way to know if the index is valid or not when you don't, so I'm not sure what is the use case here. The C++ code seems to use that to do an iterator interface, but there are no iterators in C.

[TyanNN]

Hmm, should I add getNumContainedTypes too, so one could check if there are any contained types then? (Because i think it's not possible in C API)

[TyanNN]

Added LLVMGetNumContainedTypes and num_contained_types

[whitequark]

On second thought I would prefer the OCaml interface to have a single function returning an array, since this is safer and easier to use.

[deadalnix]

@whitequark can you explain the use case here ?
@TyanNN what you need to do depends on the use case.

[whitequark]

@deadalnix The use case is the same. The current API can assert, the one I suggest can not.

[deadalnix]

There is an assert within getContainedType so I'm not sure how that's different.

[TyanNN]

Array is generally safer, but I (personally) use getContainedType just to get contained type of a pointer (it has only 1). We can do both, like in C++ API

[whitequark]

@TyanNN What's wrong with using element_type then?

[TyanNN]

@whitequark Hm.. makes sense, i guess. But why are there both in C++ api then...?
Anyway, it seems that there are already all functions provided, they just don't cover whole C++ API..?

[whitequark]

I don't think anyone ever had a goal of covering the entire C++ API, the binding is produced demand-side.

[TyanNN]

@whitequark altighty, i'm closing this review then?

[whitequark]

Sure, unless you want to get all contained types as an array.

[TyanNN]

@whitequark actually i do.. Well, off to write it

[TyanNN]

Subtypes list

[whitequark]

bindings/ocaml/llvm/llvm.mli

665

This shouldn't be exposed in the public interface, I think.

[TyanNN]

Don't expose getNumContainedTypes in ocaml api

[TyanNN]

Fix, remove in llvm.ml too

[TyanNN]

Remove num_contained_types from llvm_ocaml.c too

[TyanNN]

@whitequark please commit this patch when you can, because i do not have commit access

[TyanNN]

@whitequark @deadalnix ping

bindings/ocaml/llvm/llvm.ml

 external struct_set_body : lltype -> lltype array -> bool -> unit =
     "llvm_struct_set_body"
 external struct_element_types : lltype -> lltype array
                               = "llvm_struct_element_types"
 external is_packed : lltype -> bool = "llvm_is_packed"
 external is_opaque : lltype -> bool = "llvm_is_opaque"
 
 (*--... Operations on pointer, vector, and array types .....................--*)
+external contained_type : lltype -> int -> lltype = "llvm_contained_type"
 external array_type : lltype -> int -> lltype = "llvm_array_type"
 external pointer_type : lltype -> lltype = "llvm_pointer_type"
 external qualified_pointer_type : lltype -> int -> lltype
                                 = "llvm_qualified_pointer_type"
 external vector_type : lltype -> int -> lltype = "llvm_vector_type"
 
 external element_type : lltype -> lltype = "LLVMGetElementType"
 external array_length : lltype -> int = "llvm_array_length"

bindings/ocaml/llvm/llvm.mli

 
 (** [is_opaque sty] returns [true] if the structure type [sty] is opaque.
     [false] otherwise. See the method [llvm::StructType::isOpaque]. *)
 val is_opaque : lltype -> bool
 
 
 (** {7 Operations on pointer, vector, and array types} *)
 
+(** [contained_type ty n] returns the [n]'th type 'contained' in the derived type *)
+val contained_type : lltype -> int -> lltype
+
 (** [array_type ty n] returns the array type containing [n] elements of type
     [ty]. See the method [llvm::ArrayType::get]. *)
 val array_type : lltype -> int -> lltype
 
 (** [pointer_type ty] returns the pointer type referencing objects of type
     [ty] in the default address space (0).
     See the method [llvm::PointerType::getUnqual]. *)
 val pointer_type : lltype -> lltype
 
 (** [qualified_pointer_type ty as] returns the pointer type referencing objects

bindings/ocaml/llvm/llvm_ocaml.c

 /* lltype -> bool */
 CAMLprim value llvm_is_opaque(LLVMTypeRef StructTy) {
   return Val_bool(LLVMIsOpaqueStruct(StructTy));
 }
 
 /*--... Operations on array, pointer, and vector types .....................--*/
 
 /* lltype -> int -> lltype */
+CAMLprim LLVMTypeRef llvm_contained_type(LLVMTypeRef Ty, value ElementNum) {
+    return LLVMGetContainedType(Ty, Int_val(ElementNum));
+}
+
+/* lltype -> int -> lltype */
 CAMLprim LLVMTypeRef llvm_array_type(LLVMTypeRef ElementTy, value Count) {
   return LLVMArrayType(ElementTy, Int_val(Count));
 }
 
 /* lltype -> lltype */
 CAMLprim LLVMTypeRef llvm_pointer_type(LLVMTypeRef ElementTy) {
   return LLVMPointerType(ElementTy, 0);
 }

include/llvm-c/Core.h

  *
  * This works on array, vector, and pointer types.
  *
  * @see llvm::SequentialType::getElementType()
  */
 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
 
 /**
+ * Returns the types 'contained' in the derived type
+ *
+ * @see llvm::Type::getContainedType()
+ */
+LLVMTypeRef LLVMGetContainedType(LLVMTypeRef Tp, unsigned ElementNum);
+
+/**
  * Create a fixed size array type that refers to a specific type.
  *
  * The created type will exist in the context that its element type
  * exists in.
  *
  * @see llvm::ArrayType::get()
  */
 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);

lib/IR/Core.cpp

 }
 
 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) {
   return wrap(unwrap(M)->getTypeByName(Name));
 }
 
 /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
 
+LLVMTypeRef LLVMGetContainedType(LLVMTypeRef Tp, unsigned ElementNum) {
+    return wrap(unwrap(Tp)->getContainedType(ElementNum));
+}
+
 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) {
   return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
 }
 
 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) {
   return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
 }
 

test/Bindings/OCaml/core.ml

let suite name f =
   f ()
 
 
 (*===-- Fixture -----------------------------------------------------------===*)
 
 let filename = Sys.argv.(1)
 let m = create_module context filename
 
+(*===-- Contained types  --------------------------------------------------===*)
+
+let test_contained_types () =
+  let pointer_i32 = pointer_type i32_type in
+  let contained_i32 = contained_type pointer_i32 0 in
+  insist (i32_type = contained_i32);
+
+  let pointer_to_pointer = pointer_type (pointer_type i8_type) in
+  let pp = contained_type pointer_to_pointer 0 in
+  insist ((pointer_type i8_type) = pp );
+  insist (i8_type = (contained_type pp 0))
 
 (*===-- Conversion --------------------------------------------------------===*)
 
 let test_conversion () =
   insist ("i32" = (string_of_lltype i32_type));
   let c = const_int i32_type 42 in
   insist ("i32 42" = (string_of_llvalue c))
 
let test_writer () =
   insist (write_bitcode_file m filename);
 
   dispose_module m
 
 
 (*===-- Driver ------------------------------------------------------------===*)
 
 let _ =
+  suite "contained types"  test_contained_types;
   suite "conversion"       test_conversion;
   suite "target"           test_target;
   suite "constants"        test_constants;
   suite "attributes"       test_attributes;
   suite "global values"    test_global_values;
   suite "global variables" test_global_variables;
   suite "uses"             test_uses;
   suite "users"            test_users;