juliac: log entrypoints and nonstandard typedefs #59108
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -15,6 +15,7 @@ | |
| /test/results_*.json | ||
| /test/results_*.dat | ||
| /test/deps | ||
| /test/trimming/Manifest.toml | ||
|
|
||
| *.expmap | ||
| *.exe | ||
|
|
||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,219 @@ | ||
| const C_friendly_types = Base.IdSet{Any}([ # a few of these are redundant to make it easier to maintain | ||
| Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Float32, Float64, Bool, | ||
| Cvoid, Cint, Cshort, Clong, Cuint, Cushort, Culong, Cssize_t, Csize_t, | ||
| Cchar, Cwchar_t, Cstring, Cwstring, | ||
| RawFD, | ||
| ]) | ||
|
|
||
| function recursively_add_types!(types::Base.IdSet{DataType}, @nospecialize(T::DataType)) | ||
| T in types && return types | ||
| while T.name === Ptr.body.name | ||
| push!(types, T) | ||
timholy marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| T = T.parameters[1] # unwrap Ptr{...} | ||
| T in types && return types | ||
| end | ||
| if T.name.module === Core && T ∉ C_friendly_types | ||
| error("invalid type for juliac: ", T) # exclude internals (they may change) | ||
| end | ||
| push!(types, T) | ||
| for list in (T.parameters, fieldtypes(T)) | ||
| for S in list | ||
| recursively_add_types!(types, S) | ||
| end | ||
| end | ||
| return types | ||
| end | ||
|
|
||
| struct TypeEmitter | ||
| io::IO | ||
| type_ids::IdDict{Any,Int} | ||
| end | ||
|
|
||
| function escape_string_json(s::AbstractString) | ||
|
There was a problem hiding this comment. IIUC there isn't a "meaningful" test of this escaping. There was a problem hiding this comment. It looks like we have a number of copies of this now running around (test_print_str_escape_json, json_repr). Can we potentially combine them, or at least put them all in a single file to include as needed, so that we can make sure they all use the same logic? |
||
| iob = IOBuffer() | ||
| print(iob, '"') | ||
| for c in s | ||
| if c == '"' | ||
| print(iob, "\\\"") | ||
| elseif c == '\\' | ||
| print(iob, "\\\\") | ||
| elseif c == '\b' | ||
| print(iob, "\\b") | ||
| elseif c == '\f' | ||
| print(iob, "\\f") | ||
| elseif c == '\n' | ||
| print(iob, "\\n") | ||
| elseif c == '\r' | ||
| print(iob, "\\r") | ||
| elseif c == '\t' | ||
| print(iob, "\\t") | ||
| elseif '\x00' <= c <= '\x1f' | ||
| print(iob, "\\u", lpad(string(UInt16(c), base=16), 4, '0')) | ||
| else | ||
| @assert isvalid(c) "invalid unicode character" | ||
| print(iob, c) | ||
| end | ||
| end | ||
| print(iob, '"') | ||
| return String(take!(iob)) | ||
| end | ||
|
|
||
| function type_name_json(@nospecialize(dt::DataType)) | ||
| return escape_string_json(repr(dt)) | ||
| end | ||
|
|
||
| function field_name_json(@nospecialize(dt::DataType), field::Int) | ||
| name = String(fieldname(dt, field)) | ||
| return escape_string_json(name) | ||
| end | ||
|
|
||
| function emit_pointer_info!(ctx::TypeEmitter, @nospecialize(dt::DataType); indent::Int = 0) | ||
| pointee_type_id = ctx.type_ids[dt.parameters[1]] | ||
| let indented_println(args...) = println(ctx.io, " " ^ indent, args...) | ||
| indented_println("{") | ||
| indented_println(" \"id\": ", ctx.type_ids[dt], ",") | ||
| indented_println(" \"kind\": \"pointer\",") | ||
| indented_println(" \"name\": ", type_name_json(dt), ",") | ||
| indented_println(" \"pointee_type_id\": ", pointee_type_id) | ||
| print(ctx.io, " " ^ indent, "}") | ||
| end | ||
| end | ||
|
|
||
| function emit_field_info!(ctx::TypeEmitter, @nospecialize(dt::DataType), field::Int; indent::Int = 0) | ||
| desc = Base.DataTypeFieldDesc(dt)[field] | ||
| type_id = ctx.type_ids[fieldtype(dt, field)] | ||
| print(ctx.io, " " ^ indent) | ||
| print(ctx.io, "{") | ||
| print(ctx.io, " \"name\": ", field_name_json(dt, field), ",") | ||
| print(ctx.io, " \"type_id\": ", type_id, ",") | ||
| print(ctx.io, " \"offset\": ", desc.offset) | ||
| print(ctx.io, " }") | ||
timholy marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| end | ||
|
|
||
| function emit_struct_info!(ctx::TypeEmitter, @nospecialize(dt::DataType); indent::Int = 0) | ||
| type_id = ctx.type_ids[dt] | ||
| let indented_println(args...) = println(ctx.io, " " ^ indent, args...) | ||
| indented_println("{") | ||
| indented_println(" \"id\": ", type_id, ",") | ||
| indented_println(" \"kind\": \"struct\",") | ||
timholy marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| indented_println(" \"name\": ", type_name_json(dt), ",") | ||
| indented_println(" \"size\": ", Core.sizeof(dt), ",") | ||
| indented_println(" \"alignment\": ", Base.datatype_alignment(dt), ",") | ||
| indented_println(" \"fields\": [") | ||
| for i = 1:Base.datatype_nfields(dt) | ||
| emit_field_info!(ctx, dt, i; indent = indent + 4) | ||
| println(ctx.io, i == Base.datatype_nfields(dt) ? "" : ",") | ||
| end | ||
| indented_println(" ]") | ||
| print(ctx.io, " " ^ indent, "}") | ||
| end | ||
| end | ||
|
|
||
| function emit_primitive_type!(ctx::TypeEmitter, @nospecialize(dt::DataType); indent::Int = 0) | ||
| type_id = ctx.type_ids[dt] | ||
| let indented_println(args...) = println(ctx.io, " " ^ indent, args...) | ||
| indented_println("{") | ||
| indented_println(" \"id\": ", type_id, ",") | ||
| indented_println(" \"kind\": \"primitive\",") | ||
| indented_println(" \"name\": ", type_name_json(dt), ",") | ||
| indented_println(" \"signed\": ", (dt <: Signed), ",") | ||
| indented_println(" \"bits\": ", 8 * Base.packedsize(dt), ",") # size for reinterpret / in-register | ||
| indented_println(" \"size\": ", Base.aligned_sizeof(dt), ",") # size with padding / in-memory | ||
| indented_println(" \"alignment\": ", Base.datatype_alignment(dt)) | ||
| print(ctx.io, " " ^ indent, "}") | ||
| end | ||
| end | ||
|
|
||
| function emit_type_info!(ctx::TypeEmitter, @nospecialize(dt::DataType); indent::Int = 0) | ||
| if dt.name === Ptr.body.name | ||
| emit_pointer_info!(ctx, dt; indent) | ||
| elseif Base.isprimitivetype(dt) | ||
| emit_primitive_type!(ctx, dt; indent) | ||
| else | ||
| emit_struct_info!(ctx, dt; indent) | ||
| end | ||
| end | ||
|
|
||
| function emit_method_info!(ctx::TypeEmitter, method::Core.Method; indent::Int = 0) | ||
| (rt, sig) = method.ccallable | ||
| (name, symbol) = let | ||
| symbol = length(method.ccallable) > 2 ? Symbol(method.ccallable[3]) : method.name | ||
| iob = IOBuffer() | ||
| print(IOContext(iob, :print_method_signature_only => true), method) | ||
| str = String(take!(iob)) | ||
| if symbol !== method.name && startswith(str, String(method.name)) | ||
| # Make a best-effort attempt to use the exported name | ||
| # | ||
| # Note: the `startswith` check is to make sure we support 'functor's in arg0, | ||
| # which Base.@ccallable supports as long as they are singletons. | ||
| str = replace(str, String(method.name) => String(symbol); count = 1) | ||
| end | ||
| (str, String(symbol)) | ||
| end | ||
|
|
||
| argnames = String.(Base.method_argnames(method)) | ||
| let indented_println(args...) = println(ctx.io, " " ^ indent, args...) | ||
| indented_println("{") | ||
| indented_println(" \"symbol\": ", escape_string_json(symbol), ",") | ||
| indented_println(" \"name\": ", escape_string_json(name), ",") | ||
timholy marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| indented_println(" \"arguments\": [") | ||
| for i in 2:length(sig.parameters) | ||
| print(ctx.io, " " ^ (indent + 4)) | ||
| print(ctx.io, "{") | ||
| print(ctx.io, " \"name\": ", escape_string_json(argnames[i]), ",") | ||
| print(ctx.io, " \"type_id\": ", ctx.type_ids[sig.parameters[i]]) | ||
| println(ctx.io, i == length(sig.parameters) ? " }" : " },") | ||
| end | ||
| indented_println(" ],") | ||
| indented_println(" \"returns\": { \"type_id\": ", ctx.type_ids[rt], " }") | ||
| print(ctx.io, " " ^ indent, "}") | ||
| end | ||
| end | ||
|
|
||
| function emit_abi_info!(ctx::TypeEmitter, exported::Vector{Core.Method}, types::IdSet{DataType}) | ||
| println(ctx.io, "{") | ||
|
|
||
| # assign an ID to each type, so that we can refer to them | ||
| for (i, T) in enumerate(types) | ||
| ctx.type_ids[T] = i | ||
| end | ||
|
|
||
| # print exported functions | ||
| println(ctx.io, " \"functions\": [") | ||
| for (i, method) in enumerate(exported) | ||
| emit_method_info!(ctx, method; indent = 4) | ||
| println(ctx.io, i == length(exported) ? "" : ",") | ||
| end | ||
| println(ctx.io, " ],") | ||
|
|
||
| # print type / structure information | ||
| println(ctx.io, " \"types\": [") | ||
| for (i, T) in enumerate(types) | ||
| emit_type_info!(ctx, T; indent = 4) | ||
| println(ctx.io, i == length(types) ? "" : ",") | ||
| end | ||
| println(ctx.io, " ]") | ||
|
|
||
| println(ctx.io, "}") | ||
| end | ||
|
|
||
| function write_abi_metadata(io::IO) | ||
| types = Base.IdSet{DataType}() | ||
|
|
||
| # discover all exported methods + any types they reference | ||
| exported = Core.Method[] | ||
| Base.visit(Core.methodtable) do method | ||
| if isdefined(method, :ccallable) | ||
| push!(exported, method) | ||
| (rt, sig) = method.ccallable | ||
| for T in sig.parameters[2:end] | ||
| recursively_add_types!(types, T) | ||
| end | ||
| recursively_add_types!(types, rt) | ||
| end | ||
| end | ||
|
|
||
| # print the discovered ABI info | ||
| ctx = TypeEmitter(io, IdDict{Any,Int}()) | ||
| emit_abi_info!(ctx, exported, types) | ||
| end | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,20 @@ | ||
| #include <stdio.h> | ||
| #include "libsimple.h" | ||
|
|
||
| int main() { | ||
| // Example usage of the functions defined in libsimple.h | ||
| CVectorPair_Float32 vecPair; | ||
| vecPair.from.length = 3; | ||
| vecPair.from.data = (float[]){1.0f, 2.0f, 3.0f}; | ||
| vecPair.to.length = 3; | ||
| vecPair.to.data = (float[]){4.0f, 5.0f, 6.0f}; | ||
|
|
||
| float sum = copyto_and_sum(vecPair); | ||
| printf("Sum of copied values: %f\n", sum); | ||
|
|
||
| MyTwoVec list[] = {{1, 2}, {5, 5}, {3, 4}}; | ||
| int32_t count = countsame(list, 3); | ||
| printf("Count of same vectors: %d\n", count); | ||
|
|
||
| return 0; | ||
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,31 @@ | ||
| #ifndef JULIALIB_LIBSIMPLE_H | ||
| #define JULIALIB_LIBSIMPLE_H | ||
| #include <stddef.h> | ||
| #include <stdint.h> | ||
| #include <stdbool.h> | ||
|
|
||
| struct CTree_Float64; | ||
| typedef struct CVector_CTree_Float64 { | ||
| int32_t length; | ||
| struct CTree_Float64* data; | ||
| } CVector_CTree_Float64; | ||
| typedef struct CTree_Float64 { | ||
| CVector_CTree_Float64 children; | ||
| } CTree_Float64; | ||
| typedef struct MyTwoVec { | ||
| int32_t x; | ||
| int32_t y; | ||
| } MyTwoVec; | ||
| typedef struct CVector_Float32 { | ||
| int32_t length; | ||
| float* data; | ||
| } CVector_Float32; | ||
| typedef struct CVectorPair_Float32 { | ||
| CVector_Float32 from; | ||
| CVector_Float32 to; | ||
| } CVectorPair_Float32; | ||
|
|
||
| float copyto_and_sum(CVectorPair_Float32 fromto); | ||
| int64_t tree_size(CTree_Float64 tree); | ||
| int32_t countsame(MyTwoVec* list, int32_t n); | ||
| #endif // JULIALIB_LIBSIMPLE_H |
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Uh oh!
There was an error while loading. Please reload this page.