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 ↗

(On Diff #100768)

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

llvm/trunk/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 subtypes : lltype -> lltype array = "llvm_subtypes"
 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"

llvm/trunk/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} *)
 
+(** [subtypes ty] returns [ty]'s subtypes *)
+val subtypes : lltype -> lltype array
+
 (** [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

llvm/trunk/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 -> lltype array */
+CAMLprim value llvm_subtypes(LLVMTypeRef Ty) {
+    CAMLparam0();
+    CAMLlocal1(Arr);
+
+    unsigned Size = LLVMGetNumContainedTypes(Ty);
+
+    Arr = caml_alloc(Size, 0);
+
+    LLVMGetSubtypes(Ty, (LLVMTypeRef *) Arr);
+
+    CAMLreturn(Arr);
+}
+
 /* 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);

llvm/trunk/include/llvm-c/Core.h

  *
  * This works on array, vector, and pointer types.
  *
  * @see llvm::SequentialType::getElementType()
  */
 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
 
 /**
+ * Returns type's subtypes
+ *
+ * @see llvm::Type::subtypes()
+ */
+void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr);
+
+/**
+ *  Return the number of types in the derived type.
+ *
+ * @see llvm::Type::getNumContainedTypes()
+ */
+unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp);
+
+/**
  * 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);

llvm/trunk/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) .....--*/
 
+void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr) {
+    int i = 0;
+    for (auto *T : unwrap(Tp)->subtypes()) {
+        Arr[i] = wrap(T);
+        i++;
+    }
+}
+
 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));
 }
 
 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) {
   return wrap(VectorType::get(unwrap(ElementType), ElementCount));
 }
 
 LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) {
   auto *Ty = unwrap<Type>(WrappedTy);
   if (auto *PTy = dyn_cast<PointerType>(Ty))
     return wrap(PTy->getElementType());
   return wrap(cast<SequentialType>(Ty)->getElementType());
 }
 
+unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp) {
+    return unwrap(Tp)->getNumContainedTypes();
+}
+
 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
   return unwrap<ArrayType>(ArrayTy)->getNumElements();
 }
 
 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) {
   return unwrap<PointerType>(PointerTy)->getAddressSpace();
 }
 

llvm/trunk/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
+  insist (i32_type = (Array.get (subtypes pointer_i32) 0));
+
+  let ar = struct_type context [| i32_type; i8_type |] in
+  insist (i32_type = (Array.get (subtypes ar)) 0);
+  insist (i8_type = (Array.get (subtypes ar)) 1)
+
 
 (*===-- 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;