3499 lines
140 KiB
Plaintext
3499 lines
140 KiB
Plaintext
2014-11-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
|
||
2014-11-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* dummy-frontend.c: Add includes now needed since r216805 by
|
||
cgraph.h: hash-map.h, is-a.h, plugin-api.h, vec.h, hashtab.h,
|
||
hash-set.h, machmode.h, tm.h, hard-reg-set.h, function.h,
|
||
ipa-ref.h, dumpfile.h.
|
||
* jit-playback.c: Likewise.
|
||
|
||
2014-11-05 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* jit-playback.c (gcc::jit::playback::context::handle_locations):
|
||
Drop the disabled debugging code.
|
||
|
||
2014-11-05 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/topics/expressions.rst (Type-coercion): Casts between
|
||
pointer types are valid.
|
||
* libgccjit.c: Document that gcc_jit_context et al are actually
|
||
subclasses of the gcc::jit::recording classes.
|
||
(RETURN_VAL_IF_FAIL): Add top-level descriptive comment.
|
||
(RETURN_IF_NOT_VALID_BLOCK): Likewise.
|
||
(RETURN_NULL_IF_NOT_VALID_BLOCK): Likewise.
|
||
(jit_error): Likewise.
|
||
(compatible_types): Likewise.
|
||
(gcc_jit_context_acquire): Likewise.
|
||
(gcc_jit_context_release): Likewise.
|
||
(gcc_jit_context_new_child_context): Likewise.
|
||
(gcc_jit_context_new_location): Likewise.
|
||
(gcc_jit_location_as_object): Likewise.
|
||
(gcc_jit_type_as_object): Likewise.
|
||
(gcc_jit_context_get_type): Likewise.
|
||
(gcc_jit_context_get_int_type): Likewise.
|
||
(gcc_jit_type_get_pointer): Likewise.
|
||
(gcc_jit_type_get_const): Likewise.
|
||
(gcc_jit_type_get_volatile): Likewise.
|
||
(gcc_jit_context_new_array_type): Likewise. Also document that
|
||
LOC can be NULL. Fail with an error on negative size.
|
||
(gcc_jit_context_new_field): Add top-level descriptive comment and
|
||
document that LOC can be NULL.
|
||
(gcc_jit_field_as_object): Add top-level descriptive comment.
|
||
(gcc_jit_context_new_struct_type): Likewise. Also document that
|
||
LOC can be NULL.
|
||
(gcc_jit_context_new_opaque_struct): Likewise.
|
||
(gcc_jit_struct_as_type): Add top-level descriptive comment.
|
||
(gcc_jit_struct_set_fields): Likewise. Also document that LOC can
|
||
be NULL.
|
||
(gcc_jit_context_new_union_type): Likewise.
|
||
(gcc_jit_context_new_function_ptr_type): Likewise.
|
||
(gcc_jit_context_new_param): Likewise.
|
||
(gcc_jit_param_as_object): Add top-level descriptive comment.
|
||
(gcc_jit_param_as_lvalue): Likewise.
|
||
(gcc_jit_param_as_rvalue): Likewise.
|
||
(gcc_jit_context_new_function): Likewise. Also document that LOC
|
||
can be NULL.
|
||
(gcc_jit_context_get_builtin_function): Add top-level descriptive
|
||
comment.
|
||
(gcc_jit_function_as_object): Likewise.
|
||
(gcc_jit_function_get_param): Likewise.
|
||
(gcc_jit_function_dump_to_dot): Likewise.
|
||
(gcc_jit_function_new_block): Likewise.
|
||
(gcc_jit_block_as_object): Likewise.
|
||
(gcc_jit_block_get_function): Likewise.
|
||
(gcc_jit_context_new_global): Likewise. Also document that LOC
|
||
can be NULL.
|
||
(gcc_jit_lvalue_as_object): Add top-level descriptive comment.
|
||
(gcc_jit_lvalue_as_rvalue): Likewise.
|
||
(gcc_jit_rvalue_as_object): Likewise.
|
||
(gcc_jit_rvalue_get_type): Likewise.
|
||
(RETURN_NULL_IF_FAIL_NONNULL_NUMERIC_TYPE): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_int): Likewise.
|
||
(gcc_jit_context_zero): Likewise.
|
||
(gcc_jit_context_one): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_double): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_ptr): Likewise.
|
||
(gcc_jit_context_null): Likewise.
|
||
(gcc_jit_context_new_string_literal): Likewise.
|
||
(gcc_jit_context_new_unary_op): Likewise. Also document that LOC
|
||
can be NULL.
|
||
(gcc_jit_context_new_binary_op): Likewise.
|
||
(gcc_jit_context_new_comparison): Likewise.
|
||
(gcc_jit_context_new_call): Likewise.
|
||
(gcc_jit_context_new_call_through_ptr): Likewise.
|
||
(is_valid_cast): Add top-level descriptive comment.
|
||
(gcc_jit_context_new_cast): Likewise. Also document that LOC can
|
||
be NULL.
|
||
(gcc_jit_context_new_array_access): Likewise.
|
||
(gcc_jit_object_get_context): Add top-level descriptive comment.
|
||
(gcc_jit_object_get_debug_string): Likewise.
|
||
(gcc_jit_lvalue_access_field): Likewise. Also document that LOC can
|
||
be NULL.
|
||
(gcc_jit_rvalue_access_field): Likewise.
|
||
(gcc_jit_rvalue_dereference_field): Likewise.
|
||
(gcc_jit_rvalue_dereference): Likewise.
|
||
(gcc_jit_lvalue_get_address): Likewise.
|
||
(gcc_jit_function_new_local): Likewise.
|
||
(gcc_jit_block_add_eval): Likewise.
|
||
(gcc_jit_block_add_assignment): Likewise.
|
||
(gcc_jit_block_add_assignment_op): Likewise.
|
||
(is_bool): Add top-level descriptive comment.
|
||
(gcc_jit_block_end_with_conditional): Likewise. Also document
|
||
that LOC can be NULL.
|
||
(gcc_jit_block_add_comment): Likewise.
|
||
(gcc_jit_block_end_with_jump): Likewise.
|
||
(gcc_jit_block_end_with_return): Likewise.
|
||
(gcc_jit_block_end_with_void_return): Likewise.
|
||
(gcc_jit_context_set_str_option): Add top-level descriptive
|
||
comment.
|
||
(gcc_jit_context_set_int_option): Likewise.
|
||
(gcc_jit_context_set_bool_option): Likewise.
|
||
(gcc_jit_context_compile): Likewise.
|
||
(gcc_jit_context_dump_to_file): Likewise.
|
||
(gcc_jit_context_get_first_error): Likewise.
|
||
(gcc_jit_result_get_code): Likewise.
|
||
(gcc_jit_result_release): Likewise.
|
||
|
||
* libgccjit.h (gcc_jit_context_acquire): Remove FIXME from
|
||
comment.
|
||
(gcc_jit_context_get_int_type): Add comment.
|
||
(gcc_jit_context_new_field): Likewise.
|
||
(gcc_jit_context_new_struct_type): Likewise.
|
||
(gcc_jit_context_new_opaque_struct): Likewise.
|
||
(gcc_jit_struct_as_type): Likewise.
|
||
(gcc_jit_context_new_param): Likewise.
|
||
(gcc_jit_param_as_lvalue): Likewise.
|
||
(gcc_jit_param_as_rvalue): Likewise.
|
||
(enum gcc_jit_function_kind): Likewise.
|
||
(gcc_jit_context_new_function): Likewise.
|
||
(gcc_jit_context_get_builtin_function): Likewise.
|
||
(gcc_jit_function_get_param): Likewise.
|
||
|
||
2014-11-05 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (gcc_jit_context_get_type): Verify that "type"
|
||
is valid immediately, rather than relying on called code.
|
||
(gcc_jit_context_new_function): Likewise for "kind".
|
||
(gcc_jit_context_new_unary_op): Likewise for "op".
|
||
(valid_binary_op_p): New.
|
||
(gcc_jit_context_new_binary_op): Verify that "op" is valid
|
||
immediately, rather than relying on called code.
|
||
(gcc_jit_context_new_comparison): Likewise.
|
||
(gcc_jit_block_add_assignment_op): Likewise.
|
||
|
||
2014-11-05 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c: Include safe-ctype.h from libiberty.
|
||
(IS_ASCII_ALPHA): Delete.
|
||
(IS_ASCII_DIGIT): Delete.
|
||
(IS_ASCII_ALNUM): Delete.
|
||
(gcc_jit_context_new_function): Replace use of IS_ASCII_ALPHA and
|
||
IS_ASCII_ALNUM with ISALPHA and ISALNUM respectively, from
|
||
libiberty.
|
||
|
||
2014-10-30 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* dummy-frontend.c (jit_langhook_init): Remove some dead code.
|
||
|
||
2014-10-27 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* dummy-frontend.c: Drop includes of tree-iterator.h,
|
||
tree-ssa-alias.h, gimple-expr.h, gimple.h, gimple-pretty-print.h.
|
||
* jit-playback.c: Drop includes of debug.h, langhooks.h,
|
||
langhooks-def.h, tree-iterator.h, gimple-expr.h, tree-ssa-alias.h,
|
||
gimple.h, gimple-pretty-print.h, diagnostic-core.h, dumpfile.h.
|
||
|
||
2014-10-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* jit-recording.c: Include tm.h. Don't include function.h.
|
||
|
||
2014-10-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
|
||
2014-10-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/intro/index.rst: Drop install.rst. Add tutorial04.rst.
|
||
* docs/intro/install.rst: Rename to...
|
||
* docs/intro/tutorial01.rst: ...this, renaming old tutorial01.rst to...
|
||
* docs/intro/tutorial02.rst: ...this, renaming old tutorial02.rst to...
|
||
* docs/intro/tutorial03.rst: ...this, renaming old tutorial03.rst to...
|
||
* docs/intro/tutorial04.rst: ...this.
|
||
* docs/examples/install-hello-world.c: Rename to...
|
||
* docs/examples/tut01-hello-world.c: ...this.
|
||
* docs/examples/tut01-square.c: Rename to...
|
||
* docs/examples/tut02-square.c: ...this.
|
||
* docs/examples/tut02-sum-of-squares.c: Rename to...
|
||
* docs/examples/tut03-sum-of-squares.c: ...this.
|
||
* docs/examples/tut03-toyvm: Rename directory to...
|
||
* docs/examples/tut04-toyvm: ...this.
|
||
* docs/examples/tut04-toyvm/toyvm.c (PATH_TO_SCRIPTS): Update
|
||
for directory renaming.
|
||
|
||
2014-10-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/intro/install.rst ("Installation via packages"): Drop
|
||
this section.
|
||
("Installation from source"): Drop this section, moving parts
|
||
of it to https://gcc.gnu.org/wiki/JIT and some others to
|
||
docs/internals/index.rst.
|
||
("Hello world"): This section becomes the only remaining part
|
||
of this file. Eliminate references to pkg-config.
|
||
|
||
* docs/internals/index.rst
|
||
("Using a working copy without installing every time"): Rewrite
|
||
as...
|
||
("Working on the JIT library"): ...new section, aimed at
|
||
contributors (and myself) working from a build directory,
|
||
eliminating references to installation. Add description
|
||
of pertinent configuration options.
|
||
("Running the test suite"): Add setting of LIBRARY_PATH to
|
||
description of how to run a built binary outside of the test
|
||
suite.
|
||
("Environment variables"): New section, describing pertinent
|
||
environment variables.
|
||
|
||
2014-10-20 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* jit-recording.c (gcc::jit::dump::dump): Handle fopen failures
|
||
by emitting an error on the context.
|
||
(gcc::jit::dump::~dump): Likewise for fclose failures.
|
||
(gcc::jit::dump::write): Don't attempt further work if the fopen
|
||
failed. Handle fwrite failures by emitting an error on the
|
||
context.
|
||
|
||
2014-10-20 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* Make-lang.in (jit.install-common): Drop installation of
|
||
libgccjit.pc.
|
||
* config-lang.in (outputs): Drop jit/libgccjit.pc.
|
||
* libgccjit.pc.in: Delete.
|
||
|
||
2014-10-17 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* Make-lang.in (jit): Add $(FULL_DRIVER_NAME) as a dependency, so
|
||
that the symlink is created for testing.
|
||
|
||
* jit-playback.c (gcc::jit::playback::context::compile): Add
|
||
"-fno-use-linker-plugin" when invoking the driver. Update error
|
||
messages to talk about the "gcc driver" rather than the
|
||
"gcc harness". To ease troubleshooting, add error messages giving
|
||
the driver name and PATH to the error-handling code that fires
|
||
when the driver can't be found.
|
||
|
||
2014-10-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
|
||
2014-10-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/internals/index.rst (Overview of code structure): Directly
|
||
include the comment from jit-common.h as rst, rather than as a
|
||
quoted C++ comment.
|
||
* jit-common.h: Convert the summary format to valid reStructured
|
||
text for inclusion by docs/internals/index.rst.
|
||
* notes.txt: Clarify where libgccjit.c, jit-recording.c and
|
||
jit-playback.c fit into the high-level diagram.
|
||
|
||
2014-10-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* Make-lang.in (jit_OBJS): Drop jit/internal-api.o.
|
||
Add jit/jit-recording.o and jit/jit-playback.o.
|
||
|
||
* internal-api.c: Delete, moving content to new files jit-recording.c
|
||
and jit-playback.c.
|
||
* internal-api.h: Delete, moving content to new files
|
||
jit-common.h, jit-playback.h, jit-recording.h.
|
||
* jit-common.h: New file, containing the forward decls of classes
|
||
formerly in internal-api.h.
|
||
* jit-recording.c: New file, containing the gcc::jit::recording
|
||
code formerly in internal-api.c, and gcc::jit::dump.
|
||
* jit-recording.h: New file, containing the gcc::jit::recording
|
||
prototypes formerly in internal-api.h.
|
||
* jit-playback.c: New file, containing the gcc::jit::playback
|
||
code formerly in internal-api.c.
|
||
* jit-playback.h: New file, containing the gcc::jit::playback
|
||
prototypes formerly in internal-api.h.
|
||
|
||
* dummy-frontend.c: Don't include "internal-api.h". Add includes
|
||
of jit-common.h and jit-playback.h.
|
||
* jit-builtins.h: Replace include of internal-api.h with
|
||
jit-common.h.
|
||
* jit-builtins.c: Replace include of internal-api.h with
|
||
jit-common.h. Add include of jit-recording.h.
|
||
* libgccjit.c: Likewise.
|
||
|
||
* docs/internals/index.rst (Overview of code structure): Update
|
||
to reflect the above changes.
|
||
|
||
2014-10-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/internals/index.rst
|
||
(Using a working copy without installing): Rename to...
|
||
(Using a working copy without installing every time): ...this, and
|
||
update to reflect the need to have installed the driver binary
|
||
when running directly from a build directory.
|
||
(Running the test suite): Add PATH setting to the example.
|
||
* docs/intro/install.rst ("Hello world"): Likewise.
|
||
* internal-api.c: Include new autogenerated header
|
||
"gcc-driver-name.h".
|
||
(gcc::jit::playback::context::compile): Rather than looking for a
|
||
"gcc" on the path, look for GCC_DRIVER_NAME from gcc-driver-name.h,
|
||
as created by the configure script, so that we are using one for
|
||
the correct target.
|
||
|
||
2014-10-02 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* Make-lang.in (jit.info): Implement.
|
||
(jit.install-info): Implement.
|
||
(jit.dvi): Implement.
|
||
(jit.pdf): Implement in terms of new target "jit.texinfo.pdf".
|
||
(jit.install-pdf): Likewise for new target
|
||
"jit.texinfo.install-pdf".
|
||
(jit.install-html): Implement in terms of
|
||
"jit.$(doc_build_sys).install-html" to redirect to new targets
|
||
"jit.sphinx.install-html" or "jit.texinfo.install-html".
|
||
(jit.html): Implement in terms of "jit.$(doc_build_sys).html" to
|
||
redirect to new targets "jit.sphinx.html" or "jit.texinfo.html".
|
||
(JIT_TEXI_FILES): New variable.
|
||
(jit.texinfo.html): New target.
|
||
(jit.texinfo.install-html): New target.
|
||
(jit.texinfo.pdf): New target.
|
||
(jit.texinfo.install-pdf): New target.
|
||
(SPHINX_BUILD_DIR): New variable.
|
||
(jit.sphinx.html): New target.
|
||
(jit_htmldir): New variable.
|
||
(jit.sphinx.install-html): New target.
|
||
(jit.sphinx.pdf): New target.
|
||
|
||
2014-09-26 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.h (gcc::jit::recording::context): Convert field
|
||
"m_first_error_str" from a fixed-size buffer to a pointer, and add
|
||
a field "m_owns_first_error_str" to determine if we're responsible
|
||
for freeing it.
|
||
* internal-api.c (gcc::jit::recording::context::context): Update
|
||
initializations in ctor for above change.
|
||
(gcc::jit::recording::context::~context): Free m_first_error_str
|
||
if we own it.
|
||
(gcc::jit::recording::context::add_error_va): When capturing the
|
||
first error message on a context, rather than copying "errmsg" to
|
||
a fixed-size buffer and truncating if oversize, simply store the
|
||
pointer to the error message, and flag whether we need to free it.
|
||
(gcc::jit::recording::context::get_first_error): Update for change
|
||
of "m_first_error_str" from an internal buffer to a pointer.
|
||
|
||
2014-09-25 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::playback::context::compile): Use
|
||
pex_one rather than system when invoking "gcc" to go from a .s
|
||
file to a .so file.
|
||
|
||
2014-09-25 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (make_tempdir_path_template): New.
|
||
(gcc::jit::playback::context::compile): Call
|
||
make_tempdir_path_template to make m_path_template, rather than
|
||
hardcoding "/tmp/" within "/tmp/libgccjit-XXXXXX".
|
||
|
||
2014-09-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/internals/index.rst ("Overview of code structure"): Add
|
||
more descriptive text, including various fragments of
|
||
internal-api.h as appropriate.
|
||
* internal-api.h: Add marker comments for use by "literalinclude"
|
||
directives in docs/internals/index.rst.
|
||
|
||
2014-09-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* dummy-frontend.c (my_walker): Rename to...
|
||
(my_ggc_walker): ...this.
|
||
(my_root_tab): Rename to...
|
||
(jit_root_tab): ...this.
|
||
(jit_langhook_init): Update for renaming of "my_root_tab" to
|
||
"jit_root_tab".
|
||
* internal-api.c: Add descriptive API comments to functions
|
||
throughout.
|
||
(mutex): Rename to...
|
||
(jit_mutex): ...this.
|
||
(gcc::jit::recording::context::compile): Update for renaming of
|
||
"mutex" to "jit_mutex".
|
||
* internal-api.h: Add descriptive API comments to functions
|
||
throughout. Add indentation to forward declarations of classes
|
||
to indicate inheritance.
|
||
* jit-builtins.c: Likewise.
|
||
|
||
2014-09-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::dump::write): Eliminate fixed-size
|
||
buffer "buf" by replacing call to vsnprintf with one to vasprintf
|
||
and a free, emitting an error on the dump's context if a malloc
|
||
failure occurs.
|
||
(gcc::jit::recording::context::add_error_va): Likewise, using
|
||
a precanned message if the malloc inside vasprinf fails. Split
|
||
local "buf" into "malloced_msg" and "errmsg" to ensure that we
|
||
free the message iff we're using one malloc-ed by vasprintf.
|
||
(gcc::jit::recording::string::from_printf): Eliminate fixed-size
|
||
buffer "buf" by replacing call to vsnprintf with one to vasprintf
|
||
and a free, emitting an error on the relevant context if a malloc
|
||
failure occurs.
|
||
|
||
2014-09-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* dummy-frontend.c: Update copyright year. Follow standard for
|
||
initial includes by removing redundant include of "ansidecl.h".
|
||
* internal-api.c: Follow standard for initial includes by removing
|
||
redundant include of "ansidecl.h".
|
||
* jit-builtins.c: Likewise.
|
||
* libgccjit.c: Likewise.
|
||
|
||
2014-09-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* ChangeLog.jit: Add copyright footer.
|
||
* Make-lang.in: Update copyright.
|
||
* config-lang.in: Update copyright.
|
||
* docs/examples/install-hello-world.c: Add copyright header.
|
||
* docs/examples/tut01-square.c: Likewise.
|
||
* docs/examples/tut02-sum-of-squares.c: Likewise.
|
||
* docs/examples/tut03-toyvm/toyvm.c: Likewise.
|
||
* internal-api.c: Likewise.
|
||
* internal-api.h: Likewise.
|
||
* libgccjit++.h: Likewise.
|
||
* libgccjit.c: Likewise.
|
||
* libgccjit.h: Likewise.
|
||
* libgccjit.map: Likewise.
|
||
|
||
2014-09-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst (API): Shift operators are done.
|
||
* docs/topics/expressions.rst (Binary): Add shift operators.
|
||
* internal-api.c (binary_op_strings): Likewise.
|
||
(gcc::jit::playback::context::new_binary_op): Likewise.
|
||
* libgccjit.h (enum gcc_jit_binary_op): Likewise.
|
||
|
||
2014-09-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst: Rename "Initial Release" section to "API", and
|
||
remove completed items: builtins, docs, pkgconfig file, fuzz
|
||
testing. Move ability to name contexts and stmt_list per block
|
||
ideas to a new "Nice to have" section and note that it might be
|
||
better to go straight to gimple.
|
||
Move code coverage to "Test suite" section.
|
||
Add a "Probably not needed" section, moving some items to it.
|
||
Note that we're still missing shift operators.
|
||
Add idea that we could warn about unused objects in a context.
|
||
|
||
2014-09-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/examples/tut03-toyvm/toyvm.c: Include <dejagnu.h>.
|
||
Add missing typedef of compilation_state.
|
||
(toyvm_function_parse): Add "name param.
|
||
(test): New.
|
||
(CHECK_NON_NULL): New, from harness.h
|
||
(CHECK_VALUE): Likewise.
|
||
(test_script): New.
|
||
(PATH_TO_SCRIPTS): New define.
|
||
(test_suite): New.
|
||
(main): If called with no args, run the test suite.
|
||
|
||
2014-09-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/conf.py (__read_file): New helper function, for
|
||
extracting...
|
||
(gcc_BASEVER): New variable, read from "BASE-VER" in gcc src dir.
|
||
(gcc_DEVPHASE): Likewise, from file "DEV-PHASE".
|
||
(gcc_DATESTAMP): Likewise, from file "DATESTAMP".
|
||
(gcc_REVISION): Likewise, from file "REVISION" (if present).
|
||
(version): Rather than hardcoding this variable, extract from file
|
||
BASE-VER, via gcc_BASEVER local.
|
||
(release): Likewise, building it up from the files read above.
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
|
||
2014-09-22 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/intro/tutorial01.rst: Remove stray "FIXME".
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
|
||
2014-09-22 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/index.rst: Add internals/index.rst.
|
||
* docs/internals/index.rst: New.
|
||
* notes.txt: Update to reflect renaming of toplev_main to
|
||
toplev::main.
|
||
|
||
2014-09-22 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
* docs/intro/install.rst: Reduce width of listing.
|
||
* docs/intro/tutorial01.rst: Use <libgccjit.h> rather than
|
||
"libgccjit.h" when including the header.
|
||
* docs/intro/tutorial02.rst: Likewise.
|
||
* docs/intro/tutorial03.rst: Clarify various sections; show
|
||
effect of reducing optimization level down from 3 to 2.
|
||
("Putting it all together"): Move to above...
|
||
("Behind the curtain: optimizing away stack manipulation"):
|
||
...this, and rename this to...
|
||
("Behind the curtain: How does our code get optimized?"): ...and
|
||
add more detail, and discussion of elimination of tail recursion.
|
||
|
||
2014-09-19 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst: Add detection of uninitialized variables, since
|
||
this bit me when developing "toyvm".
|
||
|
||
* docs/examples/tut03-toyvm/Makefile: New.
|
||
* docs/examples/tut03-toyvm/factorial.toy: New.
|
||
* docs/examples/tut03-toyvm/fibonacci.toy: New.
|
||
* docs/examples/tut03-toyvm/toyvm.c: New.
|
||
|
||
* docs/intro/index.rst: Add tutorial03.rst.
|
||
* docs/intro/tutorial01.rst: Fix example of how to dump
|
||
generated machine code.
|
||
* docs/intro/tutorial03.rst: New.
|
||
* docs/intro/factorial.png: New.
|
||
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
* docs/_build/texinfo/factorial.png: New (copied by sphinx from
|
||
docs/intro/factorial.png).
|
||
|
||
2014-09-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* Make-lang.in (jit.install-common): Install libgccjit.pc to
|
||
"$(DESTDIR)/$(libdir)/pkgconfig".
|
||
* config-lang.in (outputs): Define this, adding jit/libgccjit.pc
|
||
so that it makes it into AC_CONFIG_FILES and is thus generated from
|
||
jit/libgccjit.pc.in at configure time.
|
||
* docs/intro/install.rst ("Hello world"): Add discussion about the
|
||
use of pkg-config when building against an install in
|
||
a non-standard location.
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
* libgccjit.pc.in: New.
|
||
|
||
2014-09-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/index.rst: Split index out into two new files...
|
||
* docs/intro/index.rst: New file.
|
||
* docs/topics/index.rst: New file.
|
||
* docs/_build/texinfo/libgccjit.texi: Regenerate.
|
||
|
||
2014-09-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/_build/texinfo/Makefile: New file, generated by Sphinx, by
|
||
running "make texinfo" in docs directory.
|
||
* docs/_build/texinfo/libgccjit.texi: Likewise.
|
||
* docs/_build/texinfo/sum-of-squares.png: Likewise.
|
||
|
||
2014-09-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/conf.py (Options for HTML output): Update html_theme from
|
||
"default" to "pyramid".
|
||
|
||
2014-09-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/intro/install.rst: Markup fixes.
|
||
* docs/intro/tutorial01.rst: Likewise.
|
||
* docs/intro/tutorial02.rst: Likewise.
|
||
* docs/topics/contexts.rst: Likewise.
|
||
* docs/topics/expressions.rst: Likewise.
|
||
* docs/topics/functions.rst: Likewise.
|
||
* docs/topics/locations.rst: Likewise.
|
||
* docs/topics/types.rst: Likewise.
|
||
|
||
2014-09-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/examples/install-hello-world.c (main): Fix missing
|
||
"return".
|
||
* docs/examples/tut01-square.c (main): Likewise.
|
||
* docs/examples/tut02-sum-of-squares.c (main): Likewise.
|
||
|
||
2014-09-17 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* docs/Makefile: New file.
|
||
* docs/conf.py: New file.
|
||
* docs/examples/install-hello-world.c: New file.
|
||
* docs/examples/tut01-square.c: New file.
|
||
* docs/examples/tut02-sum-of-squares.c: New file.
|
||
* docs/index.rst: New file.
|
||
* docs/intro/install.rst: New file.
|
||
* docs/intro/sum-of-squares.png: New file.
|
||
* docs/intro/tutorial01.rst: New file.
|
||
* docs/intro/tutorial02.rst: New file.
|
||
* docs/topics/contexts.rst: New file.
|
||
* docs/topics/expressions.rst: New file.
|
||
* docs/topics/functions.rst: New file.
|
||
* docs/topics/locations.rst: New file.
|
||
* docs/topics/objects.rst: New file.
|
||
* docs/topics/results.rst: New file.
|
||
* docs/topics/types.rst: New file.
|
||
|
||
2014-09-11 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst (Initial Release): Update for addition of myself as
|
||
maintainer.
|
||
|
||
2014-09-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst (Test suite): Multithreaded test is done.
|
||
|
||
2014-09-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* dummy-frontend.c: Fix up for the header file flattening on
|
||
trunk by adding includes of signop.h, tree-core.h, stor-layout.h,
|
||
tree-ssa-alias.h, gimple-expr.h.
|
||
(jit_langhook_write_globals): Update call to
|
||
finalize_compilation_unit to symtab->finalize_compilation_unit to
|
||
track change made on trunk in r214422.
|
||
|
||
* internal-api.c: Fix up for the header file flattening on trunk
|
||
by adding includes of gimple-expr.h, tree-ssa-alias.h,
|
||
stringpool.h, stor-layout.h, print-tree.h, gimplify.h.
|
||
(new_rvalue_from_int): Update call to real_from_integer.
|
||
(gcc::jit::playback::wrapper::operator new): Use
|
||
ggc_internal_cleared_alloc rather than
|
||
ggc_internal_cleared_alloc_stat.
|
||
(gcc::jit::playback::function::postprocess): Update call to
|
||
cgraph_finalize_function tocgraph_node::finalize_function.
|
||
(gcc::jit::playback::block::add_comment): Update call to
|
||
ggc_internal_alloc_stat to ggc_internal_alloc.
|
||
|
||
2014-08-08 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_context_new_union_type): New entrypoint.
|
||
(gcc_jit_lvalue_access_field): Rename first param from "struct_"
|
||
to "struct_or_union".
|
||
(gcc_jit_rvalue_access_field): Likewise.
|
||
|
||
* libgccjit.c (gcc_jit_context_new_union_type): New entrypoint.
|
||
|
||
* libgccjit.map (gcc_jit_context_new_union_type): New entrypoint.
|
||
|
||
* internal-api.h (gcc::jit::recording::compound_type): New class
|
||
(gcc::jit::recording::union): New class.
|
||
(gcc::jit::playback::struct_): Rename this class to...
|
||
(gcc::jit::playback::compound_type): ...this.
|
||
(gcc::jit::recording::context::new_union_type): New method.
|
||
(gcc::jit::recording::context): Rename field "m_structs" to
|
||
"m_compound_types", generalizing from a vec <struct_ *> to a
|
||
vec<compound_type *>.
|
||
(gcc::jit::recording::field): Update field m_container from
|
||
struct * to container_type *.
|
||
(gcc::jit::recording::field::get_container): Generalize from
|
||
struct_ * to container_type *.
|
||
(gcc::jit::recording::field::set_container): Likewise.
|
||
(gcc::jit::recording::compound_type): New subclass of type, to
|
||
be a superclass of existing class struct_ and new class union_.
|
||
(gcc::jit::recording::struct_::get_name): Move to...
|
||
(gcc::jit::recording::compound_type::get_name): ...here.
|
||
(gcc::jit::recording::struct_::get_loc): Move to...
|
||
(gcc::jit::recording::compound_type::get_loc): ...here.
|
||
(gcc::jit::recording::struct_::set_fields): Move to...
|
||
(gcc::jit::recording::compound_type::set_fields): ...here.
|
||
(gcc::jit::recording::struct_::dereference): Move to...
|
||
(gcc::jit::recording::compound_type::dereference): ...here.
|
||
(gcc::jit::recording::struct_::is_int): Move to...
|
||
(gcc::jit::recording::compound_type::is_int): ...here.
|
||
(gcc::jit::recording::struct_::is_float): Move to...
|
||
(gcc::jit::recording::compound_type::is_float): ...here.
|
||
(gcc::jit::recording::struct_::is_bool): Move to...
|
||
(gcc::jit::recording::compound_type::is_bool): ...here.
|
||
(gcc::jit::recording::struct_::is_pointer): Move to...
|
||
(gcc::jit::recording::compound_type::is_pointer): ...here.
|
||
(gcc::jit::recording::struct_::is_array): Move to...
|
||
(gcc::jit::recording::compound_type::is_array): ...here.
|
||
(gcc::jit::recording::struct_::playback_struct): Move to...
|
||
(gcc::jit::recording::compound_type::playback_compound_type):
|
||
...here, renaming and updating return type.
|
||
(gcc::jit::recording::struct_): Inherit from compound_type,
|
||
rather than just type.
|
||
(gcc::jit::recording::fields): Update to work on compound_type *
|
||
rather than struct_ *, renaming "m_struct" to "m_struct_or_union".
|
||
(gcc::jit::recording::union): New subclass of compound_type.
|
||
(gcc::jit::playback::context::new_struct_type): Generalize by
|
||
renaming to...
|
||
(gcc::jit::playback::context::new_compound_type): ...this, and
|
||
and an "is_struct" bool param.
|
||
(gcc::jit::playback::struct_): Generalize by renaming class to...
|
||
(gcc::jit::playback::compound_type): ...this.
|
||
|
||
* internal-api.c (gcc::jit::recording::context::context): Rename
|
||
field "m_structs" to "m_compound_types".
|
||
(gcc::jit::recording::context::new_struct_type): Likewise.
|
||
(gcc::jit::recording::context::new_union_type): New method.
|
||
(gcc::jit::recording::context::dump_to_file): Field "m_structs"
|
||
is renamed "m_compound_types" and changes type from struct_ *
|
||
to compound_type *.
|
||
(gcc::jit::recording::compound_type::compound_type): New ctor,
|
||
built from old body of gcc::jit::recording::struct_::struct_.
|
||
(gcc::jit::recording::struct_::set_fields): Move class to...
|
||
(gcc::jit::recording::compound_type::set_fields): ... here.
|
||
(gcc::jit::recording::struct_::dereference): Move class to...
|
||
(gcc::jit::recording::compound_type::dereference): ...here.
|
||
(gcc::jit::recording::struct_::struct_): Reimplement by calling
|
||
base class ctor.
|
||
(gcc::jit::recording::struct_::replay_into): The playback hook
|
||
is now "new_compound_type" and adds a bool, with true for
|
||
"is_struct" (vs a union).
|
||
(gcc::jit::recording::struct_::make_debug_string): "m_name" is
|
||
now moved to base class and private, so use an accessor.
|
||
(gcc::jit::recording::union_::union_): New function.
|
||
(gcc::jit::recording::union_::replay_into): New function.
|
||
(gcc::jit::recording::union_::make_debug_string): New function.
|
||
(gcc::jit::recording::fields::fields): Update first param from
|
||
struct_ * to compound_type *, and rename field "m_struct" to
|
||
"m_struct_or_union".
|
||
(gcc::jit::recording::fields::replay_into): "m_struct" is now
|
||
"m_struct_or_union" and has a playback_compound_type rather
|
||
than a playback_struct.
|
||
(gcc::jit::recording::fields::write_to_dump): Update for
|
||
renaming of m_struct to m_struct_or_union.
|
||
(gcc::jit::playback::context::new_struct_type): Rename method
|
||
to...
|
||
(gcc::jit::playback::context::new_compound_type): this,
|
||
generalizing so that it can make unions as well as structs; the
|
||
underlying playback type is now called "compound_type".
|
||
(gcc::jit::playback::struct_::set_fields): This method's class has
|
||
changed name, so this is now...
|
||
(gcc::jit::playback::compound_type::set_fields): ...this method.
|
||
|
||
* TODO.rst: Unions are done.
|
||
|
||
2014-08-08 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst: Function ptrs are done.
|
||
* internal-api.c
|
||
(gcc::jit::recording::context::new_function_ptr_type): New method.
|
||
(gcc::jit::recording::context::new_call_through_ptr): New method.
|
||
(gcc::jit::recording::memento_of_get_pointer::make_debug_string):
|
||
Add special-case handling of function pointer types.
|
||
(gcc::jit::recording::function_type::make_debug_string_with_ptr):
|
||
New method.
|
||
(gcc::jit::recording::function_type::make_debug_string):
|
||
Reimplement in terms of...
|
||
(gcc::jit::recording::function_type::make_debug_string_with): New
|
||
method, based on make_debug_string, but allowing for arbitrary
|
||
text between the return type and the parameters.
|
||
(gcc::jit::recording::call_through_ptr::call_through_ptr): New
|
||
method.
|
||
(gcc::jit::recording::call_through_ptr::replay_into): New method.
|
||
(gcc::jit::recording::call_through_ptr::make_debug_string): New
|
||
method.
|
||
(gcc::jit::playback::context::new_call): Reimplement in terms of...
|
||
(gcc::jit::playback::context::build_call): New method, using parts
|
||
of old implementation of new_call, so that we can share this
|
||
with...
|
||
(gcc::jit::playback::context::new_call_through_ptr): New method.
|
||
* internal-api.h
|
||
(gcc::jit::recording::context::new_function_ptr_type): New method.
|
||
(gcc::jit::recording::context::new_call_through_ptr): New method.
|
||
(gcc::jit::recording::type::dyn_cast_function_type): New method.
|
||
(gcc::jit::recording::function_type::dyn_cast_function_type): New
|
||
method.
|
||
(gcc::jit::recording::function_type::make_debug_string_with_ptr):
|
||
New method.
|
||
(gcc::jit::recording::function_type::make_debug_string_with): New
|
||
method.
|
||
(gcc::jit::recording::call_through_ptr): New subclass of rvalue.
|
||
(gcc::jit::playback::context::new_call_through_ptr): New method.
|
||
(gcc::jit::playback::context::build_call): New method.
|
||
* libgccjit.c (gcc_jit_context_new_function_ptr_type): New
|
||
function.
|
||
(gcc_jit_context_new_call_through_ptr): New function.
|
||
* libgccjit.h (gcc_jit_context_new_function_ptr_type): New
|
||
function.
|
||
(gcc_jit_context_new_call_through_ptr): New function.
|
||
* libgccjit.map (gcc_jit_context_new_call_through_ptr): New function.
|
||
(gcc_jit_context_new_function_ptr_type): New function.
|
||
|
||
2014-07-25 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst (error-checking): Remove various items that either
|
||
already were implemented, or are implemented by this commit.
|
||
* internal-api.h (gcc::jit::recording::type::is_numeric): New.
|
||
* libgccjit.c (RETURN_NULL_IF_FAIL_NONNULL_NUMERIC_TYPE): New macro.
|
||
(gcc_jit_context_new_rvalue_from_int): Verify that numeric_type is
|
||
indeed numeric.
|
||
(gcc_jit_context_zero): Likewise.
|
||
(gcc_jit_context_one): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_double): Likewise.
|
||
(gcc_jit_context_new_array_access): Likewise for type of "index".
|
||
|
||
2014-07-14 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::recording::context::new_array_type):
|
||
Reject attempts to create an array of a struct if the fields of
|
||
the struct haven't yet been set.
|
||
* internal-api.h (gcc::jit::recording::type::dyn_cast_struct): New
|
||
virtual function.
|
||
(gcc::jit::recording::struct_::dyn_cast_struct): New, overriding
|
||
for this subclass.
|
||
(gcc::jit::recording::struct_::get_name): New.
|
||
|
||
2014-05-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* Make-lang.in (LIBGCCJIT_LINKER_NAME): New.
|
||
(LIBGCCJIT_VERSION_NUM): New.
|
||
(LIBGCCJIT_MINOR_NUM): New.
|
||
(LIBGCCJIT_RELEASE_NUM): New.
|
||
(LIBGCCJIT_SONAME): New.
|
||
(LIBGCCJIT_FILENAME): New.
|
||
(LIBGCCJIT_LINKER_NAME_SYMLINK): New.
|
||
(LIBGCCJIT_SONAME_SYMLINK): New.
|
||
(jit): Add symlink targets.
|
||
(libgccjit.so): Convert to...
|
||
(LIBGCCJIT_FILENAME): ...and add a soname.
|
||
(jit.install-common): Install the library with a soname, and
|
||
symlinks. Install libgccjit++.h.
|
||
|
||
2014-04-25 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::playback::context::compile): Put
|
||
any output of dlerror through the add_error method, rather
|
||
than merely printing it to stderr, so that the error is also
|
||
recorded on the context.
|
||
|
||
2014-03-19 Tom Tromey <tromey@redhat.com>
|
||
|
||
* internal-api.c (compile): Use auto_timevar.
|
||
|
||
2014-03-19 Tom Tromey <tromey@redhat.com>
|
||
|
||
* internal-api.c (compile): Use toplev, not toplev_options.
|
||
Simplify.
|
||
|
||
2014-03-19 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::recording::context::add_error_va):
|
||
Rename local "progname" to "ctxt_progname" to avoid shadowing
|
||
the related global, for clarity.
|
||
(gcc::jit::playback::context::compile): Likewise.
|
||
|
||
2014-03-19 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::recording::memento_of_get_pointer::
|
||
accepts_writes_from): Accept writes from pointers, but not arrays.
|
||
|
||
* internal-api.h (gcc::jit::recording::type::is_pointer): New.
|
||
(gcc::jit::recording::type::is_array): New.
|
||
(gcc::jit::recording::memento_of_get_type::accepts_writes_from):
|
||
Allow (void *) to accept writes of pointers, but not arrays.
|
||
(gcc::jit::recording::memento_of_get_type::is_pointer): New.
|
||
(gcc::jit::recording::memento_of_get_type::is_array): New.
|
||
(gcc::jit::recording::memento_of_get_pointer::is_pointer): New.
|
||
(gcc::jit::recording::memento_of_get_pointer::is_array): New.
|
||
(gcc::jit::recording::memento_of_get_const::is_pointer): New.
|
||
(gcc::jit::recording::memento_of_get_const::is_array): New.
|
||
(gcc::jit::recording::memento_of_get_volatile::is_pointer): New.
|
||
(gcc::jit::recording::memento_of_get_volatile::is_array): New.
|
||
(gcc::jit::recording::array_type::is_pointer): New.
|
||
(gcc::jit::recording::array_type::is_array): New.
|
||
(gcc::jit::recording::function_type::is_pointer): New.
|
||
(gcc::jit::recording::function_type::is_array): New.
|
||
(gcc::jit::recording::struct_::is_pointer): New.
|
||
(gcc::jit::recording::struct_::is_array): New.
|
||
|
||
* libgccjit.c (gcc_jit_context_new_rvalue_from_ptr): Require the
|
||
pointer_type to be a pointer, not an array.
|
||
(gcc_jit_context_null): Likewise.
|
||
(is_valid_cast): Require pointer casts to be between pointer types,
|
||
not arrays.
|
||
(gcc_jit_context_new_array_access): Update error message from "not
|
||
a pointer" to "not a pointer or array".
|
||
(gcc_jit_rvalue_dereference_field): Require the pointer arg to be
|
||
of pointer type, not an array.
|
||
(gcc_jit_rvalue_dereference): Likewise.
|
||
|
||
2014-03-14 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (is_valid_cast): Permit casts between pointer types.
|
||
|
||
* internal-api.c (convert): Report more information if this ever
|
||
occurs, and make the error occur on the playback context, so that
|
||
it makes the gcc_jit_result be NULL.
|
||
(gcc::jit::playback::context::build_cast): Handle pointers. Report
|
||
more information if an unhandlable cast reaches here.
|
||
|
||
2014-03-13 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (is_valid_cast): New.
|
||
(gcc_jit_context_new_cast): Check for compatible types.
|
||
|
||
* internal-api.c (gcc::jit::recording::memento_of_get_type::
|
||
is_int): New.
|
||
(gcc::jit::recording::memento_of_get_type::is_float): New.
|
||
(gcc::jit::recording::memento_of_get_type::is_bool): New.
|
||
|
||
* internal-api.h (gcc::jit::recording::type::is_int): New.
|
||
(gcc::jit::recording::type::is_float): New.
|
||
(gcc::jit::recording::type::is_bool): New.
|
||
|
||
(gcc::jit::recording::memento_of_get_type::is_int): New.
|
||
(gcc::jit::recording::memento_of_get_type::is_float): New.
|
||
(gcc::jit::recording::memento_of_get_type::is_bool): New.
|
||
|
||
(gcc::jit::recording::memento_of_get_pointer::is_int): New.
|
||
(gcc::jit::recording::memento_of_get_pointer::is_float): New.
|
||
(gcc::jit::recording::memento_of_get_pointer::is_bool): New.
|
||
|
||
(gcc::jit::recording::memento_of_get_const::is_int): New.
|
||
(gcc::jit::recording::memento_of_get_const::is_float): New.
|
||
(gcc::jit::recording::memento_of_get_const::is_bool): New.
|
||
|
||
(gcc::jit::recording::memento_of_get_volatile::is_int): New.
|
||
(gcc::jit::recording::memento_of_get_volatile::is_float): New.
|
||
(gcc::jit::recording::memento_of_get_volatile::is_bool): New.
|
||
|
||
(gcc::jit::recording::array_type::is_int): New.
|
||
(gcc::jit::recording::array_type::is_float): New.
|
||
(gcc::jit::recording::array_type::is_bool): New.
|
||
|
||
(gcc::jit::recording::function_type::is_int): New.
|
||
(gcc::jit::recording::function_type::is_float): New.
|
||
(gcc::jit::recording::function_type::is_bool): New.
|
||
|
||
(gcc::jit::recording::struct_::is_int): New.
|
||
(gcc::jit::recording::struct_::is_float): New.
|
||
(gcc::jit::recording::struct_::is_bool): New.
|
||
|
||
2014-03-13 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::recording::context::set_str_option):
|
||
Provide NULL recording::location to add_error.
|
||
(gcc::jit::recording::context::set_int_option): Likewise.
|
||
(gcc::jit::recording::context::set_bool_option): Likewise.
|
||
(gcc::jit::playback::context::compile): Likewise.
|
||
(gcc::jit::recording::context::add_error): Add recording::location
|
||
param.
|
||
(gcc::jit::recording::context::add_error_va): Likewise; print it
|
||
when present; add "error: " to stderr messages.
|
||
(gcc::jit::recording::location::replay_into): Provide
|
||
recording::location to the playback::location.
|
||
|
||
(gcc::jit::recording::function::validate): Add locations to the
|
||
add_error invocations.
|
||
(gcc::jit::recording::block::validate): Likewise.
|
||
(gcc::jit::playback::context::get_type): Likewise.
|
||
(gcc::jit::playback::context::new_unary_op): Likewise.
|
||
(gcc::jit::playback::context::new_binary_op): Likewise.
|
||
(gcc::jit::playback::context::new_comparison): Likewise.
|
||
|
||
(gcc::jit::recording::block::get_loc): New.
|
||
(gcc::jit::recording::block::get_first_statement): New.
|
||
|
||
(gcc::jit::playback::context::build_cast): Pass in higher-level
|
||
arguments in the hope of eventually providing better error
|
||
messages when a cast isn't possible.
|
||
(gcc::jit::playback::context::new_cast): As above.
|
||
|
||
(gcc::jit::playback::context::add_error): Add playback::location
|
||
parameter, using it to provide the corresponding
|
||
recording::location (if any) when reporting the error to the
|
||
recording::context.
|
||
(gcc::jit::playback::context::add_error_va): Likewise.
|
||
(gcc::jit::playback::context::new_location): Likewise.
|
||
(gcc::jit::playback::source_line::get_location): Likewise.
|
||
(gcc::jit::playback::location::location): Likewise.
|
||
|
||
* internal-api.h (gcc::jit::recording::context::add_error): Add
|
||
recording::location param.
|
||
(gcc::jit::recording::context::add_error_va): Likewise.
|
||
|
||
(gcc::jit::recording::context::errors_occurred): Also consider
|
||
errors that occur on a parent or ancestor context, recursively.
|
||
|
||
(gcc::jit::recording::block::get_loc): New.
|
||
(gcc::jit::recording::block::get_first_statement): New.
|
||
(gcc::jit::recording::statement::get_loc): New.
|
||
|
||
(gcc::jit::playback::context::new_location): Add recording::location
|
||
parameter.
|
||
|
||
(gcc::jit::playback::context::add_error): Add playback::location
|
||
parameter.
|
||
(gcc::jit::playback::context::add_error_va): Likewise.
|
||
|
||
(gcc::jit::playback::context::build_cast): Pass in higher-level
|
||
arguments in the hope of eventually providing better error
|
||
messages when a cast isn't possible.
|
||
|
||
(gcc::jit::playback::source_line::get_location): Add
|
||
recording::location parameter.
|
||
(gcc::jit::playback::location::location): Likewise.
|
||
(gcc::jit::playback::location::get_recording_loc): New.
|
||
(gcc::jit::playback::location::m_recording_loc): New.
|
||
|
||
* jit-builtins.c (gcc::jit::builtins_manager::get_builtin_function):
|
||
Provide NULL recording::location to add_error.
|
||
(gcc::jit::builtins_manager::make_primitive_type): Likewise.
|
||
|
||
* libgccjit.c (RETURN_VAL_IF_FAIL): Add location argument.
|
||
(RETURN_VAL_IF_FAIL_PRINTF1): Likewise.
|
||
(RETURN_VAL_IF_FAIL_PRINTF2): Likewise.
|
||
(RETURN_VAL_IF_FAIL_PRINTF3): Likewise.
|
||
(RETURN_VAL_IF_FAIL_PRINTF4): Likewise.
|
||
(RETURN_VAL_IF_FAIL_PRINTF6): Likewise.
|
||
(RETURN_NULL_IF_FAIL): Likewise.
|
||
(RETURN_NULL_IF_FAIL_PRINTF1): Likewise.
|
||
(RETURN_NULL_IF_FAIL_PRINTF2): Likewise.
|
||
(RETURN_NULL_IF_FAIL_PRINTF3): Likewise.
|
||
(RETURN_NULL_IF_FAIL_PRINTF4): Likewise.
|
||
(RETURN_NULL_IF_FAIL_PRINTF6): Likewise.
|
||
(RETURN_IF_FAIL): Likewise.
|
||
(RETURN_IF_FAIL_PRINTF1): Likewise.
|
||
(RETURN_IF_FAIL_PRINTF2): Likewise.
|
||
(RETURN_IF_FAIL_PRINTF4): Likewise.
|
||
(RETURN_IF_NOT_VALID_BLOCK): Likewise.
|
||
(RETURN_NULL_IF_NOT_VALID_BLOCK): Likewise.
|
||
|
||
(jit_error): Likewise.
|
||
|
||
(gcc_jit_location_as_object): Provided location argument to
|
||
error-handling macros.
|
||
(gcc_jit_type_as_object): Likewise.
|
||
(gcc_jit_context_get_type): Likewise.
|
||
(gcc_jit_context_get_int_type): Likewise.
|
||
(gcc_jit_type_get_pointer): Likewise.
|
||
(gcc_jit_type_get_const): Likewise.
|
||
(gcc_jit_type_get_volatile): Likewise.
|
||
(gcc_jit_context_new_array_type): Likewise.
|
||
(gcc_jit_context_new_field): Likewise.
|
||
(gcc_jit_context_new_struct_type): Likewise.
|
||
(gcc_jit_context_new_opaque_struct): Likewise.
|
||
(gcc_jit_struct_as_type): Likewise.
|
||
(gcc_jit_struct_set_fields): Likewise.
|
||
(gcc_jit_context_new_param): Likewise.
|
||
(gcc_jit_param_as_object): Likewise.
|
||
(gcc_jit_param_as_lvalue): Likewise.
|
||
(gcc_jit_param_as_rvalue): Likewise.
|
||
(gcc_jit_context_new_function): Likewise.
|
||
(gcc_jit_context_get_builtin_function): Likewise.
|
||
(gcc_jit_function_as_object): Likewise.
|
||
(gcc_jit_function_get_param): Likewise.
|
||
(gcc_jit_function_dump_to_dot): Likewise.
|
||
(gcc_jit_function_new_block): Likewise.
|
||
(gcc_jit_block_as_object): Likewise.
|
||
(gcc_jit_block_get_function): Likewise.
|
||
(gcc_jit_context_new_global): Likewise.
|
||
(gcc_jit_lvalue_as_object): Likewise.
|
||
(gcc_jit_lvalue_as_rvalue): Likewise.
|
||
(gcc_jit_rvalue_as_object): Likewise.
|
||
(gcc_jit_rvalue_get_type): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_int): Likewise.
|
||
(gcc_jit_context_zero): Likewise.
|
||
(gcc_jit_context_one): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_double): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_ptr): Likewise.
|
||
(gcc_jit_context_null): Likewise.
|
||
(gcc_jit_context_new_string_literal): Likewise.
|
||
(gcc_jit_context_new_unary_op): Likewise.
|
||
(gcc_jit_context_new_binary_op): Likewise.
|
||
(gcc_jit_context_new_comparison): Likewise.
|
||
(gcc_jit_context_new_call): Likewise.
|
||
(gcc_jit_context_new_cast): Likewise.
|
||
(gcc_jit_context_new_array_access): Likewise.
|
||
(gcc_jit_object_get_context): Likewise.
|
||
(gcc_jit_object_get_debug_string): Likewise.
|
||
(gcc_jit_lvalue_access_field): Likewise.
|
||
(gcc_jit_rvalue_access_field): Likewise.
|
||
(gcc_jit_rvalue_dereference_field): Likewise.
|
||
(gcc_jit_rvalue_dereference_field): Likewise.
|
||
(gcc_jit_rvalue_dereference): Likewise.
|
||
(gcc_jit_lvalue_get_address): Likewise.
|
||
(gcc_jit_function_new_local): Likewise.
|
||
(gcc_jit_block_add_eval): Likewise.
|
||
(gcc_jit_block_add_assignment): Likewise.
|
||
(gcc_jit_block_add_assignment_op): Likewise.
|
||
(gcc_jit_block_end_with_conditional): Likewise.
|
||
(gcc_jit_block_add_comment): Likewise.
|
||
(gcc_jit_block_end_with_jump): Likewise.
|
||
(gcc_jit_block_end_with_return): Likewise.
|
||
(gcc_jit_block_end_with_void_return): Likewise.
|
||
(gcc_jit_context_set_str_option): Likewise.
|
||
(gcc_jit_context_set_int_option): Likewise.
|
||
(gcc_jit_context_set_bool_option): Likewise.
|
||
(gcc_jit_context_compile): Likewise.
|
||
(gcc_jit_context_dump_to_file): Likewise.
|
||
(gcc_jit_context_get_first_error): Likewise.
|
||
(gcc_jit_result_get_code): Likewise.
|
||
(gcc_jit_result_get_code): Likewise.
|
||
(gcc_jit_result_release): Likewise.
|
||
|
||
2014-03-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::context::new_rvalue): Make these
|
||
methods const.
|
||
(gccjit::context::zero): Likewise.
|
||
(gccjit::context::one): Likewise.
|
||
(gccjit::function::get_param): Likewise.
|
||
|
||
2014-03-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::error): New class, for exceptions.
|
||
(gccjit::context::get_inner_context): New accessor, so that we
|
||
can...
|
||
(gccjit::context::m_inner_ctxt): Make private.
|
||
(gccjit::context::context): Throw a gccjit::error if a NULL
|
||
context is passed in.
|
||
(gccjit::context::compile): Throw a gccjit::error if a NULL
|
||
result is returned from the C API, which indicates an error.
|
||
(gccjit::object::object): Throw a gccjit::error if a NULL
|
||
object is passed in, since that indicates that an error has
|
||
occurred.
|
||
(gccjit::location::location): In the default ctor, call the
|
||
base class default ctor rather than passing in a NULL to the
|
||
single-argument ctor, since the latter now indicates an error
|
||
has occurred at the C API level.
|
||
(gccjit::field::field): Likewise.
|
||
(gccjit::type::type): Likewise.
|
||
(gccjit::function::function): Likewise.
|
||
(gccjit::block::block): Likewise.
|
||
(gccjit::rvalue::rvalue): Likewise.
|
||
|
||
2014-03-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (enum gcc_jit_function_kind): Add
|
||
GCC_JIT_FUNCTION_ALWAYS_INLINE.
|
||
* internal-api.c (gcc::jit::recording::function::write_to_dump):
|
||
Handle GCC_JIT_FUNCTION_ALWAYS_INLINE.
|
||
(gcc::jit::playback::context::new_function): Likewise.
|
||
(gcc::jit::playback::context::postprocess): Handle
|
||
GCC_JIT_FUNCTION_INTERNAL and GCC_JIT_FUNCTION_ALWAYS_INLINE by
|
||
clearing DECL_EXTERNAL and TREE_PUBLIC. Doing so fixes the
|
||
"undefined symbol" bug seen with GCC_JIT_FUNCTION_INTERNAL.
|
||
* TODO.rst: Update.
|
||
|
||
2014-03-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::context::new_global): New.
|
||
|
||
2014-03-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::playback::context::handle_locations):
|
||
Add a disabled call to line_table_dump, in case it's handy for
|
||
debugging in the future.
|
||
(gcc::jit::playback::context::set_tree_location): Assert that
|
||
the location is non-NULL.
|
||
(gcc::jit::playback::location::location): Initialize m_src_loc
|
||
to UNKNOWN_LOCATION. This field should always be overwritten by
|
||
handle_locations before use, but given recent issues with bogus
|
||
locations it seems safer to initialize it.
|
||
|
||
2014-03-06 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::recording::context::
|
||
disassociate_from_playback): Recursively visit parent contexts.
|
||
|
||
2014-03-05 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_function_dump_to_dot): New.
|
||
* libgccjit.map (gcc_jit_function_dump_to_dot): New.
|
||
* libgccjit++.h (gccjit::function::dump_to_dot): New.
|
||
* libgccjit.c (gcc_jit_function_dump_to_dot): New.
|
||
* internal-api.h (gcc::jit::recording::function::dump_to_dot): New.
|
||
(gcc::jit::recording::block::block): Add m_index member.
|
||
(gcc::jit::recording::block::dump_to_dot): New.
|
||
(gcc::jit::recording::block::dump_edges_to_dot): New.
|
||
* internal-api.c (gcc::jit::recording::function::new_block): Give
|
||
each block an index.
|
||
(gcc::jit::recording::function::dump_to_dot): New.
|
||
(gcc::jit::recording::block::dump_to_dot): New.
|
||
(gcc::jit::recording::block::dump_edges_to_dot): New.
|
||
|
||
2014-03-04 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::recording::memento_of_get_pointer::
|
||
accepts_writes_from): Avoid segfaulting when the argument is not
|
||
of pointer type.
|
||
* internal-api.h (gcc::jit::recording::accepts_writes_from): Add
|
||
an assertion.
|
||
* libgccjit.c (gcc_jit_context_new_comparison): Strip away const
|
||
and volatile when comparing input types.
|
||
|
||
2014-03-04 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_type_get_volatile): New.
|
||
* libgccjit.map (gcc_jit_type_get_volatile): New.
|
||
* libgccjit.c (gcc_jit_type_get_volatile): New.
|
||
* libgccjit++.h (gccjit::type::get_volatile): New.
|
||
* internal-api.c (gcc::jit::recording::type::get_volatile): New.
|
||
(gcc::jit::recording::memento_of_get_volatile::replay_into): New.
|
||
(gcc::jit::recording::memento_of_get_volatile::make_debug_string): New.
|
||
* internal-api.h (gcc::jit::recording::type::get_volatile): New.
|
||
(gcc::jit::recording::type::accepts_writes_from): Strip off
|
||
qualifiers such as "const" and "volatile" from the source type.
|
||
(gcc::jit::recording::memento_of_get_volatile): New class.
|
||
(gcc::jit::playback::type::get_volatile): New.
|
||
* TODO.rst: Update.
|
||
|
||
2014-03-03 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::function::operator()): Add overload for
|
||
a call with 3 arguments.
|
||
(gccjit::block::add_call): Likewise for 4 arguments.
|
||
(gccjit::rvalue::cast_to): New method.
|
||
(gccjit::rvalue::operator[]): New methods.
|
||
|
||
2014-02-28 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (gcc_jit_context_new_binary_op): Check that the
|
||
operands have the same type.
|
||
(gcc_jit_context_new_comparison): Likewise.
|
||
|
||
2014-02-28 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_context_new_cast): New.
|
||
* libgccjit.map (gcc_jit_context_new_cast): New.
|
||
* libgccjit++.h (gccjit::context::new_cast): New method.
|
||
* libgccjit.c (gcc_jit_context_new_cast): New.
|
||
|
||
* internal-api.h (gcc::jit::recording::context::new_cast): New method.
|
||
(gcc::jit::recording::cast): New subclass of rvalue.
|
||
(gcc::jit::playback::context::new_cast): New method.
|
||
(gcc::jit::playback::context::build_cast): New method.
|
||
|
||
* internal-api.c (convert): New.
|
||
(gcc::jit::recording::context::new_cast): New.
|
||
(gcc::jit::recording::cast::replay_into): New.
|
||
(gcc::jit::recording::cast::make_debug_string): New.
|
||
(gcc::jit::playback::context::build_cast): New.
|
||
(gcc::jit::playback::context::new_cast): New.
|
||
|
||
* TODO.rst: Update.
|
||
|
||
2014-02-28 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_block_get_function): New.
|
||
* libgccjit.map (gcc_jit_block_get_function): New.
|
||
* libgccjit++.h (gccjit::block::get_function): New method.
|
||
* libgccjit.c (gcc_jit_block_get_function): New.
|
||
|
||
2014-02-27 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_label): Delete in favor of...
|
||
(gcc_jit_block): New type.
|
||
(gcc_jit_loop): Delete.
|
||
|
||
(gcc_jit_function_new_forward_label): Delete in favor of...
|
||
(gcc_jit_function_new_block): New.
|
||
|
||
(gcc_jit_label_as_object): Delete in favor of...
|
||
(gcc_jit_block_as_object): New.
|
||
|
||
(gcc_jit_function_add_eval): Delete in favor of...
|
||
(gcc_jit_block_add_eval): New.
|
||
|
||
(gcc_jit_function_add_assignment): Delete in favor of...
|
||
(gcc_jit_block_add_assignment): New.
|
||
|
||
(gcc_jit_function_add_assignment_op): Delete in favor of...
|
||
(gcc_jit_block_add_assignment_op): New.
|
||
|
||
(gcc_jit_function_add_comment): Delete in favor of...
|
||
(gcc_jit_block_add_comment): New.
|
||
|
||
(gcc_jit_label_as_object): Delete in favor of...
|
||
(gcc_jit_block_as_object): New.
|
||
|
||
(gcc_jit_function_add_conditional): Delete in favor of...
|
||
(gcc_jit_block_end_with_conditional): New.
|
||
|
||
(gcc_jit_function_add_jump): Delete in favor of...
|
||
(gcc_jit_block_end_with_jump): New.
|
||
|
||
(gcc_jit_function_add_return): Delete in favor of...
|
||
(gcc_jit_block_end_with_return): New.
|
||
|
||
(gcc_jit_function_add_void_return): Delete in favor of...
|
||
(gcc_jit_block_end_with_void_return): New.
|
||
|
||
(gcc_jit_function_new_loop): Delete.
|
||
(gcc_jit_function_new_loop_over_range): Delete.
|
||
(gcc_jit_loop_as_object): Delete.
|
||
(gcc_jit_loop_end): Delete.
|
||
|
||
* libgccjit.map (gcc_jit_function_add_assignment): Delete in favor of...
|
||
(gcc_jit_block_add_assignment): New.
|
||
|
||
(gcc_jit_function_add_assignment_op): Delete in favor of...
|
||
(gcc_jit_block_add_assignment_op): New.
|
||
|
||
(gcc_jit_function_add_comment): Delete in favor of...
|
||
(gcc_jit_block_add_comment): New.
|
||
|
||
(gcc_jit_function_add_eval): Delete in favor of...
|
||
(gcc_jit_block_add_eval): New.
|
||
|
||
(gcc_jit_label_as_object): Delete in favor of...
|
||
(gcc_jit_block_as_object): New.
|
||
|
||
(gcc_jit_function_add_conditional): Delete in favor of...
|
||
(gcc_jit_block_end_with_conditional): New.
|
||
|
||
(gcc_jit_function_add_jump): Delete in favor of...
|
||
(gcc_jit_block_end_with_jump): New.
|
||
|
||
(gcc_jit_function_add_return): Delete in favor of...
|
||
(gcc_jit_block_end_with_return): New.
|
||
|
||
(gcc_jit_function_add_void_return): Delete in favor of...
|
||
(gcc_jit_block_end_with_void_return): New.
|
||
|
||
(gcc_jit_function_add_label): Delete in favor of...
|
||
(gcc_jit_function_new_block): New.
|
||
(gcc_jit_function_new_forward_label): Delete.
|
||
(gcc_jit_function_place_forward_label): Delete.
|
||
|
||
(gcc_jit_function_new_loop): Delete.
|
||
(gcc_jit_function_new_loop_over_range): Delete.
|
||
(gcc_jit_loop_as_object): Delete.
|
||
(gcc_jit_loop_end): Delete.
|
||
|
||
* libgccjit.c (gcc_jit_label): Delete in favor of...
|
||
(gcc_jit_block): New type.
|
||
(gcc_jit_loop): Delete.
|
||
|
||
(RETURN_IF_NOT_FUNC_DEFINITION): Delete in favor of...
|
||
(RETURN_IF_NOT_VALID_BLOCK): New macro.
|
||
(RETURN_NULL_IF_NOT_FUNC_DEFINITION): Delete in favor of...
|
||
(RETURN_NULL_IF_NOT_VALID_BLOCK): New macro.
|
||
|
||
(gcc_jit_function_new_forward_label): Delete in favor of...
|
||
(gcc_jit_function_new_block): New.
|
||
|
||
(gcc_jit_label_as_object): Delete in favor of...
|
||
(gcc_jit_block_as_object): New.
|
||
|
||
(gcc_jit_rvalue_dereference_field): Ensure that field has been
|
||
placed.
|
||
|
||
(gcc_jit_function_add_label): Delete
|
||
(gcc_jit_function_place_forward_label): Delete.
|
||
|
||
(gcc_jit_function_add_eval): Delete in favor of...
|
||
(gcc_jit_block_add_eval): New.
|
||
|
||
(gcc_jit_function_add_assignment): Delete in favor of...
|
||
(gcc_jit_block_add_assignment): New.
|
||
|
||
(gcc_jit_function_add_assignment_op): Delete in favor of...
|
||
(gcc_jit_block_add_assignment_op): New.
|
||
|
||
(gcc_jit_function_add_conditional): Delete in favor of...
|
||
(gcc_jit_block_end_with_conditional): New.
|
||
|
||
(gcc_jit_function_add_comment): Delete in favor of...
|
||
(gcc_jit_block_add_comment): New.
|
||
|
||
(gcc_jit_function_add_jump): Delete in favor of...
|
||
(gcc_jit_block_end_with_jump): New.
|
||
|
||
(gcc_jit_function_add_return): Delete in favor of...
|
||
(gcc_jit_block_end_with_return): New.
|
||
|
||
(gcc_jit_function_add_void_return): Delete in favor of...
|
||
(gcc_jit_block_end_with_void_return): New.
|
||
|
||
(gcc_jit_function_new_loop): Delete.
|
||
(gcc_jit_function_new_loop_over_range): Delete.
|
||
(gcc_jit_loop_as_object): Delete.
|
||
(gcc_jit_loop_end): Delete.
|
||
|
||
* internal-api.h (gcc::jit::recording::label): Delete class in
|
||
favor of...
|
||
(gcc::jit::recording::block): New class.
|
||
(gcc::jit::recording::loop): Delete class.
|
||
(gcc::jit::recording::loop_end): Delete class.
|
||
|
||
(gcc::jit::playback::label): Delete class in favor of...
|
||
(gcc::jit::playback::block): New class.
|
||
|
||
(gcc::jit::playback::loop): Delete class.
|
||
|
||
(gcc::jit::recording::playback_label): Delete function in favor of...
|
||
(gcc::jit::recording::playback_block): New function.
|
||
|
||
(gcc::jit::recording::context::validate): New.
|
||
|
||
(gcc::jit::recording::function::new_forward_label): Delete method.
|
||
(gcc::jit::recording::function::add_eval): Delete method in favor
|
||
of method of new gcc::jit::recording::block class.
|
||
(gcc::jit::recording::function::add_assignment): Likewise.
|
||
(gcc::jit::recording::function::add_assignment_op): Likewise.
|
||
(gcc::jit::recording::function::add_comment): Likewise.
|
||
(gcc::jit::recording::function::add_conditional): Likewise.
|
||
(gcc::jit::recording::function::place_forward_label): Likewise.
|
||
(gcc::jit::recording::function::add_jump): Likewise.
|
||
(gcc::jit::recording::function::add_return): Likewise.
|
||
|
||
(gcc::jit::recording::function::add_label): Delete method in favor of...
|
||
(gcc::jit::recording::function::new_block): New method.
|
||
|
||
(gcc::jit::recording::function::new_loop): Delete method.
|
||
|
||
(gcc::jit::recording::function::validate): New method.
|
||
(gcc::jit::recording::function::m_activity): Delete field in favor of...
|
||
(gcc::jit::recording::function::m_blocks): New field.
|
||
|
||
(gcc::jit::recording::statement::get_successor_blocks): New method.
|
||
(gcc::jit::recording::statement::write_to_dump): Make public.
|
||
(gcc::jit::recording::statement::statement): Accept a block rather
|
||
than a function.
|
||
(gcc::jit::recording::statement::playback_function): Delete.
|
||
(gcc::jit::recording::statement::get_block): New.
|
||
(gcc::jit::recording::statement::m_func): Delete in favor of...
|
||
(gcc::jit::recording::statement::m_block): ...this.
|
||
|
||
(gcc::jit::recording::eval::eval): Accept a block rather than a
|
||
function.
|
||
(gcc::jit::recording::assignment::assignment): Likewise.
|
||
(gcc::jit::recording::assignment_op::assignment_op): Likewise.
|
||
(gcc::jit::recording::comment::comment): Likewise.
|
||
(gcc::jit::recording::return::return): Likewise.
|
||
(gcc::jit::recording::conditional::conditional): Likewise; accept
|
||
blocks rather than labels.
|
||
(gcc::jit::recording::jump::jump): Likewise.
|
||
(gcc::jit::recording::conditional::get_successor_blocks): New.
|
||
(gcc::jit::recording::jump::get_successor_blocks): New.
|
||
|
||
(gcc::jit::playback::function::new_forward_label): Delete method
|
||
in favor of...
|
||
(gcc::jit::playback::function::new_block): New method.
|
||
(gcc::jit::playback::function::build_stmt_list): New method.
|
||
(gcc::jit::playback::function::m_blocks): New field.
|
||
|
||
* libgccjit++.h (gccjit::label): Delete class in favor of...
|
||
(gccjit::block): New class.
|
||
(gccjit::function::new_forward_label): Delete methods in favor of...
|
||
(gccjit::function::new_block): New methods.
|
||
(gccjit::function::add_comment): Delete methods in favor of methods
|
||
of new class gccjit::block.
|
||
(gccjit::function::add_conditional): Likewise.
|
||
(gccjit::function::add_label): Likewise.
|
||
(gccjit::function::place_forward_label): Likewise.
|
||
(gccjit::function::add_jump): Likewise.
|
||
(gccjit::function::add_return): Likewise.
|
||
(gccjit::function::add_call): Likewise.
|
||
|
||
* internal-api.c (gcc::jit::recording::playback_label): Delete in
|
||
favor of...
|
||
(gcc::jit::recording::playback_block): New.
|
||
(gcc::jit::recording::context::compile): Validate.
|
||
(gcc::jit::recording::context::validate): New.
|
||
(gcc::jit::recording::function::function): Update.
|
||
(gcc::jit::recording::function::new_forward_label): Delete.
|
||
(gcc::jit::recording::function::add_eval): Delete.
|
||
(gcc::jit::recording::function::add_assignment): Delete.
|
||
(gcc::jit::recording::function::add_assignment_op): Delete.
|
||
(gcc::jit::recording::function::new_block): New.
|
||
(gcc::jit::recording::function::add_comment): Delete.
|
||
(gcc::jit::ecording::function::add_conditional): Delete.
|
||
(gcc::jit::recording::function::add_label): Delete.
|
||
(gcc::jit::recording::function::place_forward_label): Delete.
|
||
(gcc::jit::recording::function::add_jump): Delete.
|
||
(gcc::jit::recording::function::add_return): Delete.
|
||
(gcc::jit::recording::function::new_loop): Delete.
|
||
(gcc::jit::recording::function::write_to_dump): Port to block-based
|
||
representation.
|
||
(gcc::jit::recording::function::validate): New.
|
||
(gcc::jit::recording::block::add_eval): New.
|
||
(gcc::jit::recording::block::add_assignment): New.
|
||
(gcc::jit::recording::label::replay_into): Delete.
|
||
(gcc::jit::recording::block::add_assignment_op): New.
|
||
(gcc::jit::recording::block::add_comment): New.
|
||
(gcc::jit::recording::block::end_with_conditional): New.
|
||
(gcc::jit::recording::block::end_with_jump): New.
|
||
(gcc::jit::recording::block::end_with_return): New.
|
||
(gcc::jit::recording::block::write_to_dump): New.
|
||
(gcc::jit::recording::block::validate): New.
|
||
(gcc::jit::recording::block::get_last_statement): New.
|
||
(gcc::jit::recording::block::get_successor_blocks): New.
|
||
(gcc::jit::recording::block::replay_into): New.
|
||
(gcc::jit::recording::label::make_debug_string): Delete.
|
||
(gcc::jit::recording::block::make_debug_string): New.
|
||
(gcc::jit::recording::statement::get_successor_blocks): New.
|
||
(gcc::jit::recording::eval::replay_into): Port to block-based
|
||
representation.
|
||
(gcc::jit::recording::assignment::replay_into): Likewise.
|
||
(gcc::jit::recording::assignment_op::replay_into): Likewise.
|
||
(gcc::jit::recording::comment::replay_into): Likewise.
|
||
(gcc::jit::recording::conditional::replay_into): Likewise.
|
||
(gcc::jit::recording::jump::replay_into): Likewise.
|
||
(gcc::jit::recording::return_::replay_into): Likewise.
|
||
|
||
(gcc::jit::recording::conditional::get_successor_blocks): New.
|
||
(gcc::jit::recording::place_label::place_label): Delete.
|
||
(gcc::jit::recording::place_label::replay_into): Delete.
|
||
(gcc::jit::recording::place_label::make_debug_string): Delete.
|
||
(gcc::jit::recording::place_label::write_to_dump): Delete.
|
||
|
||
(gcc::jit::recording::jump::get_successor_blocks): New.
|
||
(gcc::jit::recording::return_::get_successor_blocks): New.
|
||
|
||
(gcc::jit::recording::loop::replay_into): Delete.
|
||
(gcc::jit::recording::loop::make_debug_string): Delete.
|
||
(gcc::jit::recording::loop::end): Delete.
|
||
(gcc::jit::recording::loop_end::replay_into): Delete.
|
||
(gcc::jit::recording::loop_end::make_debug_string): Delete.
|
||
|
||
(gcc::jit::playback::function::new_forward_label): Delete.
|
||
(gcc::jit::playback::function::new_block): New.
|
||
(gcc::jit::playback::function::build_stmt_list): New.
|
||
(gcc::jit::playback::function::add_eval): Replace with...
|
||
(gcc::jit::playback::block::add_eval): New.
|
||
(gcc::jit::playback::function::add_assignment): Replace with...
|
||
(gcc::jit::playback::block::add_assignment): New.
|
||
(gcc::jit::playback::function::add_comment): Replace with...
|
||
(gcc::jit::playback::block::add_comment): New, reimplementing,
|
||
given that we no longer have labels.
|
||
(gcc::jit::playback::function::add_conditional): Replace with...
|
||
(gcc::jit::playback::block::add_conditional): New, reworking,
|
||
given that on_false can no longer be NULL.
|
||
(gcc::jit::playback::function::add_label): Delete.
|
||
(gcc::jit::playback::function::place_forward_label): Delete.
|
||
(gcc::jit::playback::function::add_jump): Replace with...
|
||
(gcc::jit::playback::block::add_jump): New.
|
||
(gcc::jit::playback::function::add_return): Replace with...
|
||
(gcc::jit::playback::block::add_return): New.
|
||
(gcc::jit::playback::function::new_loop): Delete.
|
||
(gcc::jit::playback::label::label): Replace with...
|
||
(gcc::jit::playback::block::block): ...this.
|
||
|
||
(gcc::jit::playback::loop::loop): Delete.
|
||
(gcc::jit::playback::loop::end): Delete.
|
||
|
||
(gcc::jit::playback::context::replay): Call each function's
|
||
build_stmt_list.
|
||
|
||
* TODO.rst: Update
|
||
|
||
2014-02-25 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_function_add_void_return): New.
|
||
* libgccjit.map (gcc_jit_function_add_void_return): New.
|
||
* libgccjit.c (gcc_jit_function_add_void_return): New.
|
||
* libgccjit++.h (add_return): Add overloaded variant with no
|
||
rvalue, calling gcc_jit_function_add_void_return.
|
||
|
||
* internal-api.c (gcc::jit::recording::function::add_return): Add
|
||
comment that rvalue could be NULL.
|
||
(gcc::jit::playback::function::add_return): Support rvalue being
|
||
NULL.
|
||
|
||
2014-02-25 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.h (gcc::jit::playback::function): Add field
|
||
m_inner_block.
|
||
|
||
* internal-api.c (gcc::jit::playback::function::function):
|
||
Create BLOCK here and link it to the BIND_EXPR.
|
||
(gcc::jit::playback::function::gt_ggc_mx): Walk m_inner_block.
|
||
(gcc::jit::playback::function::postprocess): Set up BLOCK_VARS on
|
||
the block, so that the local variables make it into the debuginfo.
|
||
|
||
2014-02-24 Philip Herron <redbrain@gcc.gnu.org>
|
||
|
||
* Make-lang.in (jit.install-common): Implement.
|
||
|
||
2014-02-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_context_dump_to_file): New.
|
||
* libgccjit.map (gcc_jit_context_dump_to_file): New.
|
||
* libgccjit.c (gcc_jit_context_dump_to_file): New.
|
||
* libgccjit++.h (gccjit::context::dump_to_file): New.
|
||
|
||
* internal-api.h (gcc::jit::dump): New class.
|
||
(gcc::jit::recording::playback_location): Add a replayer argument,
|
||
so that playback locations can be created before playback statements.
|
||
(gcc::jit::recording::location::playback_location): Likewise.
|
||
(gcc::jit::recording::statement::playback_location): Likewise.
|
||
(gcc::jit::recording::context::dump_to_file): New.
|
||
(gcc::jit::recording::context::m_structs): New field, for use by
|
||
dump_to_file.
|
||
(gcc::jit::recording::context::m_functions): Likewise.
|
||
(gcc::jit::recording::memento::write_to_dump): New virtual function.
|
||
(gcc::jit::recording::field::write_to_dump): New.
|
||
(gcc::jit::recording::fields::write_to_dump): New.
|
||
(gcc::jit::recording::function::write_to_dump): New.
|
||
(gcc::jit::recording::function::m_locals): New field for use by
|
||
write_to_dump.
|
||
(gcc::jit::recording::function::m_activity): Likewise.
|
||
(gcc::jit::recording::local::write_to_dump): New.
|
||
(gcc::jit::recording::statement::write_to_dump): New.
|
||
(gcc::jit::recording::place_label::write_to_dump): New.
|
||
|
||
* internal-api.c (gcc::jit::dump::dump): New.
|
||
(gcc::jit::dump::~dump): New.
|
||
(gcc::jit::dump::write): New.
|
||
(gcc::jit::dump::make_location): New.
|
||
(gcc::jit::recording::playback_location): Add a replayer argument,
|
||
so that playback locations can be created before playback statements.
|
||
|
||
(gcc::jit::recording::context::context): Initialize new fields.
|
||
(gcc::jit::recording::function::function): Likewise.
|
||
|
||
(gcc::jit::recording::context::new_struct_type): Add struct to the
|
||
context's m_structs vector.
|
||
(gcc::jit::recording::context::new_function): Add function to the
|
||
context's m_functions vector.
|
||
(gcc::jit::recording::context::dump_to_file): New.
|
||
(gcc::jit::recording::memento::write_to_dump): New.
|
||
(gcc::jit::recording::field::write_to_dump): New.
|
||
(gcc::jit::recording::fields::write_to_dump): New.
|
||
(gcc::jit::recording::function::write_to_dump): New.
|
||
(gcc::jit::recording::local::write_to_dump): New.
|
||
(gcc::jit::recording::statement::write_to_dump): New.
|
||
(gcc::jit::recording::place_label::write_to_dump): New.
|
||
|
||
(gcc::jit::recording::array_type::replay_into): Pass on replayer
|
||
to call to playback_location.
|
||
(gcc::jit::recording::field::replay_into): Likewise.
|
||
(gcc::jit::recording::struct_::replay_into): Likewise.
|
||
(gcc::jit::recording::param::replay_into): Likewise.
|
||
(gcc::jit::recording::function::replay_into): Likewise.
|
||
(gcc::jit::recording::global::replay_into): Likewise.
|
||
(gcc::jit::recording::unary_op::replay_into): Likewise.
|
||
(gcc::jit::recording::binary_op::replay_into): Likewise.
|
||
(gcc::jit::recording::comparison::replay_into): Likewise.
|
||
(gcc::jit::recording::call::replay_into): Likewise.
|
||
(gcc::jit::recording::array_access::replay_into): Likewise.
|
||
(gcc::jit::recording::access_field_of_lvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::access_field_rvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::dereference_field_rvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::dereference_rvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::get_address_of_lvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::local::replay_into): Likewise.
|
||
(gcc::jit::recording::eval::replay_into): Likewise.
|
||
(gcc::jit::recording::assignment::replay_into): Likewise.
|
||
(gcc::jit::recording::assignment_op::replay_into): Likewise.
|
||
(gcc::jit::recording::comment::replay_into): Likewise.
|
||
(gcc::jit::recording::conditional::replay_into): Likewise.
|
||
(gcc::jit::recording::place_label::replay_into): Likewise.
|
||
(gcc::jit::recording::jump::replay_into): Likewise.
|
||
(gcc::jit::recording::return_::replay_into): Likewise.
|
||
(gcc::jit::recording::loop::replay_into): Likewise.
|
||
(gcc::jit::recording::loop_end::replay_into): Likewise.
|
||
|
||
(gcc::jit::recording::function::new_local): Add to the function's
|
||
vector of locals.
|
||
(gcc::jit::recording::function::add_eval): Add to the function's
|
||
m_activity field.
|
||
(gcc::jit::recording::function::add_assignment): Likewise.
|
||
(gcc::jit::recording::function::add_assignment_op): Likewise.
|
||
(gcc::jit::recording::function::add_comment): Likewise.
|
||
(gcc::jit::recording::function::add_conditional): Likewise.
|
||
(gcc::jit::recording::function::place_forward_label): Likewise.
|
||
(gcc::jit::recording::function::add_jump): Likewise.
|
||
(gcc::jit::recording::function::add_return): Likewise.
|
||
(gcc::jit::recording::function::new_loop): Likewise.
|
||
|
||
(gcc::jit::recording::conditional::make_debug_string): Add missing
|
||
semicolon.
|
||
|
||
2014-02-19 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (gcc_jit_context_new_rvalue_from_ptr): Verify that
|
||
pointer_type is indeed a pointer type.
|
||
(gcc_jit_context_null): Likewise.
|
||
(gcc_jit_context_new_array_access): Verify that ptr is indeed a
|
||
pointer.
|
||
|
||
* TODO.rst: Update
|
||
|
||
2014-02-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_struct): New.
|
||
(gcc_jit_context_new_struct_type): Change return type from gcc_jit_type
|
||
to gcc_jit_struct.
|
||
(gcc_jit_context_new_opaque_struct): New.
|
||
(gcc_jit_struct_as_type): New.
|
||
(gcc_jit_struct_set_fields): New.
|
||
(gcc_jit_context_null): New.
|
||
|
||
* libgccjit.map (gcc_jit_context_new_opaque_struct): New.
|
||
(gcc_jit_context_null): New.
|
||
(gcc_jit_struct_as_type): New.
|
||
(gcc_jit_struct_set_fields): New.
|
||
|
||
* libgccjit++.h (gccjit::context::new_struct_type): Return a
|
||
struct_ rather than a type.
|
||
(gccjit::context::new_opaque_struct_type): New.
|
||
(gccjit::struct_): New subclass of type.
|
||
|
||
* libgccjit.c (gcc_jit_struct): New.
|
||
(RETURN_VAL_IF_FAIL_PRINTF1): New.
|
||
(RETURN_VAL_IF_FAIL_PRINTF2): New.
|
||
(RETURN_NULL_IF_FAIL_PRINTF1): New.
|
||
(RETURN_IF_FAIL_PRINTF1): New.
|
||
(RETURN_IF_FAIL_PRINTF2): New.
|
||
(gcc_jit_context_new_struct_type): Return a gcc_jit_struct rather
|
||
than a gcc_jit_type; implement by creating the struct, then
|
||
setting the fields in it.
|
||
(gcc_jit_context_new_opaque_struct): New.
|
||
(gcc_jit_struct_as_type): New.
|
||
(gcc_jit_struct_set_fields): New.
|
||
(gcc_jit_context_null): New.
|
||
(gcc_jit_lvalue_access_field): Use the struct's context when
|
||
reporting on a NULL field; verify that the field has been placed
|
||
in a struct.
|
||
(gcc_jit_rvalue_access_field): Likewise.
|
||
(is_bool): New.
|
||
(gcc_jit_function_add_conditional): Use the function's context
|
||
when reporting errors; verify that boolval's type is indeed
|
||
boolean.
|
||
(gcc_jit_function_new_loop): Likewise.
|
||
|
||
* internal-api.h (gcc::jit::recording::context::new_struct_type):
|
||
Don't accept fields, and return a struct_ rather than a type_, so
|
||
that fields can be set later.
|
||
(gcc::jit::recording::struct_::struct_): Store a (fields *) rather
|
||
than a vec of fields.
|
||
(gcc::jit::recording::struct_::as_type): New.
|
||
(gcc::jit::recording::struct_::get_fields): New.
|
||
(gcc::jit::recording::struct_::set_fields): New.
|
||
(gcc::jit::recording::struct_::playback_struct): New.
|
||
(gcc::jit::recording::fields): New class.
|
||
(gcc::jit::playback::context::new_struct_type): Don't accept
|
||
fields, and return a struct_ rather than a type_, so that fields
|
||
can be set later.
|
||
(gcc::jit::playback::struct_): New subclass of type.
|
||
|
||
* internal-api.c (gcc::jit::recording::context::get_type): With
|
||
nested contexts, create basic types within the ultimate parent
|
||
context, allowing for a fast check for the boolean type using
|
||
pointer equality.
|
||
(gcc::jit::recording::context::new_struct_type): Don't accept
|
||
fields, and return a struct_ rather than a type_, so that fields
|
||
can be set later.
|
||
(gcc::jit::recording::context::get_opaque_FILE_type): Update for
|
||
struct-creation changes.
|
||
(gcc::jit::recording::struct_::struct_): Store a (fields *) rather
|
||
than a vec of fields.
|
||
(gcc::jit::recording::struct_::set_fields): New.
|
||
(gcc::jit::recording::struct_::replay_into): Don't playback the
|
||
fields, as this is now done by a fields instance.
|
||
(gcc::jit::recording::fields::fields): New.
|
||
(gcc::jit::recording::fields::replay_into): New.
|
||
(gcc::jit::recording::fields::make_debug_string): New.
|
||
(gcc::jit:: playback::context::new_struct_type): Don't accept
|
||
fields, and return a struct_ rather than a type_, so that fields
|
||
can be set later.
|
||
(gcc::jit::playback::struct_::set_fields): New.
|
||
|
||
* TODO.rst: Update.
|
||
|
||
2014-02-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (gcc_jit_function_new_local): Use the context of the
|
||
function when reporting errors.
|
||
(gcc_jit_function_place_forward_label): Likewise.
|
||
(gcc_jit_function_add_eval): Likewise.
|
||
(gcc_jit_function_add_assignment_op): Likewise.
|
||
(gcc_jit_function_add_comment): Likewise.
|
||
(gcc_jit_function_add_jump): Likewise.
|
||
|
||
2014-02-14 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::type::zero): New method.
|
||
(gccjit::type::one): New method.
|
||
(gccjit::function::add_call): New family of overloaded methods.
|
||
|
||
2014-02-13 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_context_get_builtin_function): New.
|
||
* libgccjit.map (gcc_jit_context_get_builtin_function): New.
|
||
* libgccjit++.h (gccjit::context::get_builtin_function): New method.
|
||
|
||
* Make-lang.in (jit_OBJS): Add jit/jit-builtins.o
|
||
* jit-builtins.c: New source file, for managing builtin functions
|
||
and their types.
|
||
* jit-builtins.h: Likewise.
|
||
|
||
* libgccjit.c (gcc_jit_context_new_function): Pass BUILT_IN_NONE for
|
||
the new argument of new_function
|
||
(gcc_jit_context_get_builtin_function): New.
|
||
|
||
* internal-api.h: Add idempotency guards.
|
||
(gcc::jit::recording::context::new_function): Add parameter
|
||
for builtin functions.
|
||
(gcc::jit::recording::context::get_builtin_function): New method.
|
||
(gcc::jit::recording::context::m_builtins_manager): New field.
|
||
(gcc::jit::recording::type::as_a_function_type): New virtual function.
|
||
(gcc::jit::recording::function_type): New subclass of type.
|
||
(gcc::jit::recording::function::function): Add parameter for
|
||
builtin functions.
|
||
(gcc::jit::recording::function::m_builtin_id): New field.
|
||
(gcc::jit::recording::function::new_function_type): New method.
|
||
(gcc::jit::playback::function::function): Add parameter for
|
||
builtin functions.
|
||
* internal-api.c (gcc::jit::recording::context::context):
|
||
NULL-initialize new field m_builtins_manager.
|
||
(gcc::jit::recording::context::~context): Clean up the builtins
|
||
manager, if one has been created.
|
||
(gcc::jit::recording::context::new_function): Add parameter
|
||
(gcc::jit::recording::context::get_builtin_function): New method.
|
||
(gcc::jit::recording::function_type::function_type): Implement
|
||
constructor for new subclass.
|
||
(gcc::jit::recording::function_type::dereference): Implement
|
||
method for new subclass.
|
||
(gcc::jit::recording::function_type::replay_into): Likewise.
|
||
(gcc::jit::recording::function_type::make_debug_string): Likewise.
|
||
(gcc::jit::recording::function::function): Add parameter for
|
||
builtin functions.
|
||
(gcc::jit::recording::function::replay_into): Likewise for
|
||
creation of playback object.
|
||
(gcc::jit::recording::function::new_function_type): New method.
|
||
(gcc::jit::playback::function::new_function): Add parameter for
|
||
builtin functions, using it to set up the fndecl accordingly.
|
||
|
||
2014-02-11 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (IS_ASCII_ALPHA): New macro.
|
||
(IS_ASCII_DIGIT): New macro.
|
||
(IS_ASCII_ALNUM): New macro.
|
||
(gcc_jit_context_new_function): Require that function names be valid
|
||
C identifiers for now, to avoid later problems in the assembler.
|
||
|
||
2014-02-11 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (enum gcc_jit_types): Add GCC_JIT_TYPE_BOOL.
|
||
|
||
* internal-api.h (gcc::jit::recording::comparison::comparison): Use
|
||
GCC_JIT_TYPE_BOOL as the types of comparisons, rather than
|
||
GCC_JIT_TYPE_INT.
|
||
|
||
* internal-api.c (gcc::jit::recording::memento_of_get_type::
|
||
dereference): Handle GCC_JIT_TYPE_BOOL (with an error).
|
||
(get_type_strings): Add GCC_JIT_TYPE_BOOL.
|
||
(get_tree_node_for_type): Handle GCC_JIT_TYPE_BOOL.
|
||
|
||
2014-02-11 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::recording::context::add_error_va): If
|
||
GCC_JIT_STR_OPTION_PROGNAME is NULL, use "libgccjit.so", as per
|
||
the comment in libgccjit.h
|
||
(gcc::jit::recording::label::replay_into): When reporting on an
|
||
unplaced label, include the name of the containing function in
|
||
the error message.
|
||
* libgccjit.c: Remove comment about "Functions for use within the
|
||
code factory", as this distinction went away in commit
|
||
96b218c9a1d5f39fb649e02c0e77586b180e8516.
|
||
(RETURN_VAL_IF_FAIL_PRINTF4): New.
|
||
(RETURN_NULL_IF_FAIL_PRINTF4): New.
|
||
(jit_error): Invoke vfprintf with the correct format string in
|
||
the NULL context case.
|
||
(gcc_jit_context_new_call): Check for NULL entries within the
|
||
array of arguments.
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_context_get_int_type): New.
|
||
* libgccjit.map (gcc_jit_context_get_int_type): New.
|
||
* libgccjit.c (gcc_jit_context_get_int_type): New.
|
||
|
||
* internal-api.h (gcc::jit::recording::context::get_int_type): New.
|
||
(gcc::jit::recording::context::get_int_type<T>): New template.
|
||
* internal-api.c (gcc::jit::recording::context::get_int_type): New.
|
||
|
||
* libgccjit++.h: Include <limits> so we can use std::numeric_limits.
|
||
(gccjit::context::get_int_type): New.
|
||
(gccjit::context::get_int_type<T>): New.
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_function_get_param): New.
|
||
* libgccjit.map (gcc_jit_function_get_param): New.
|
||
* libgccjit.c (gcc_jit_function_get_param): New.
|
||
* libgccjit++.h (gccjit::function::get_param): New.
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::object::get_inner_object): Make const.
|
||
(gccjit::location::get_inner_location): Likewise.
|
||
(gccjit::field::get_inner_field): Likewise.
|
||
(gccjit::type::get_inner_type): Likewise.
|
||
(gccjit::function::get_inner_function): Likewise.
|
||
(gccjit::label::get_inner_label): Likewise.
|
||
(gccjit::rvalue::get_inner_rvalue): Likewise.
|
||
(gccjit::lvalue::get_inner_lvalue): Likewise.
|
||
(gccjit::param::get_inner_param): Likewise.
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::object::get_context): New method.
|
||
(gccjit::function): Add overloaded operator () for various
|
||
numbers of arguments as a very terse way of creating function calls.
|
||
(gccjit::rvalue::get_type): New method.
|
||
|
||
(operator-): New overloaded unary op for rvalues.
|
||
(operator~): Likewise.
|
||
(operator!): Likewise.
|
||
|
||
(operator+): New overloaded binary op for rvalues.
|
||
(operator-): Likewise.
|
||
(operator*): Likewise.
|
||
(operator/): Likewise.
|
||
(operator%): Likewise.
|
||
(operator&): Likewise.
|
||
(operator^): Likewise.
|
||
(operator|): Likewise.
|
||
(operator&&): Likewise.
|
||
(operator||): Likewise.
|
||
|
||
(operator==): New overloaded comparison for rvalues.
|
||
(operator!=): Likewise.
|
||
(operator<): Likewise.
|
||
(operator<=): Likewise.
|
||
(operator>): Likewise.
|
||
(operator>=): Likewise.
|
||
|
||
(operator*): New overloaded operator for dereferencing an
|
||
rvalue representing a pointer.
|
||
|
||
* libgccjit.c (gcc_jit_rvalue_get_type): New.
|
||
* libgccjit.h (gcc_jit_rvalue_get_type): New.
|
||
* libgccjit.map (gcc_jit_rvalue_get_type): New.
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::context::new_minus): New method,
|
||
providing a way to do a specific unary op with less typing.
|
||
(gccjit::context::new_bitwise_negate): Likewise.
|
||
(gccjit::context::new_logical_negate): Likewise.
|
||
|
||
(gccjit::context::new_plus): Likewise, for binary op.
|
||
(gccjit::context::new_minus): Likewise.
|
||
(gccjit::context::new_mult): Likewise.
|
||
(gccjit::context::new_divide): Likewise.
|
||
(gccjit::context::new_modulo): Likewise.
|
||
(gccjit::context::new_bitwise_and): Likewise.
|
||
(gccjit::context::new_bitwise_xor): Likewise.
|
||
(gccjit::context::new_bitwise_or): Likewise.
|
||
(gccjit::context::new_logical_and): Likewise.
|
||
(gccjit::context::new_logical_or): Likewise.
|
||
|
||
(gccjit::context::new_eq): Likewise, for comparison.
|
||
(gccjit::context::new_ne): Likewise.
|
||
(gccjit::context::new_lt): Likewise.
|
||
(gccjit::context::new_le): Likewise.
|
||
(gccjit::context::gccjit::context::new_gt): Likewise.
|
||
(gccjit::context::gccjit::context::new_ge): Likewise.
|
||
|
||
(gccjit::context::new_call): Add a series of overloaded methods
|
||
for specific numbers of args (from 0 - 6), to avoid the need for
|
||
client code to manually build a std::vector (or requiring C++11).
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::context::new_struct_type): Pass std::vector
|
||
"fields" argument by reference rather than by value.
|
||
(gccjit::context::new_function): Likewise, for "params" arg.
|
||
(gccjit::context::new_call): Likewise, for "args" arg.
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::context::new_location): Update filename
|
||
arg from a const char * to a const std::string &.
|
||
(gccjit::context::new_field): Likewise for "name" arg.
|
||
(gccjit::context::new_struct_type): Likewise.
|
||
(gccjit::context::new_param): Likewise.
|
||
(gccjit::context::new_function): Likewise.
|
||
(gccjit::function::new_local): Likewise.
|
||
(gccjit::context::new_rvalue): Likewise for "value" arg.
|
||
(gccjit::function::add_comment): Likewise for "text" arg.
|
||
(gccjit::function::new_forward_label): Likewise for "name" arg; add
|
||
variant taking no args for anonymous labels.
|
||
(gccjit::function::add_label): Likewise.
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h (gccjit::object, gccjit::location): Move
|
||
these declarations to before that of gccjit::context so that
|
||
the various methods of context taking a location can have a
|
||
default location value.
|
||
(gccjit::context::new_array_type): Consolidate two methods,
|
||
one accepting a gccjit::location, the other without, by
|
||
providing a default argument (which thus has to be moved to the
|
||
end of the argument list).
|
||
(gccjit::context::new_field): Likewise.
|
||
(gccjit::context::new_struct_type): Likewise.
|
||
(gccjit::context::new_param): Likewise.
|
||
(gccjit::context::new_function): Likewise.
|
||
(gccjit::context::new_unary_op): Likewise.
|
||
(gccjit::context::new_binary_op): Likewise.
|
||
(gccjit::context::new_comparison): Likewise.
|
||
(gccjit::context::new_call): Likewise.
|
||
(gccjit::context::new_array_access): Likewise.
|
||
(gccjit::function::new_local): Likewise.
|
||
(gccjit::function::add_eval): Likewise.
|
||
(gccjit::function::add_assignment): Likewise.
|
||
(gccjit::function::add_assignment_op): Likewise.
|
||
(gccjit::function::add_comment): Likewise.
|
||
(gccjit::function::add_conditional): Likewise.
|
||
(gccjit::function::add_label): Likewise.
|
||
(gccjit::function::place_forward_label): Likewise.
|
||
(gccjit::function::add_jump): Likewise.
|
||
(gccjit::function::add_return): Likewise.
|
||
(gccjit::rvalue::access_field): Likewise.
|
||
(gccjit::rvalue::dereference_field): Likewise.
|
||
(gccjit::rvalue::dereference): Likewise.
|
||
(gccjit::lvalue::access_field): Likewise.
|
||
(gccjit::lvalue::get_address): Likewise.
|
||
|
||
2014-02-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst: Update.
|
||
|
||
2014-02-06 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h: Include <ostream> rather than <iostream>, since
|
||
the former gets us std::ostream, and the latter may introduce
|
||
startup-time overhead for constructing std::cout et al.
|
||
(gccjit::context::new_child_context): New.
|
||
(gccjit::context::release): New.
|
||
(gccjit::context::compile): New.
|
||
(gccjit::context::set_int_option): New.
|
||
(gccjit::context::set_bool_option): New.
|
||
|
||
2014-02-03 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (struct gcc_jit_object): New.
|
||
(gcc_jit_object_get_context): New.
|
||
(gcc_jit_object_get_debug_string): New.
|
||
(gcc_jit_location_as_object): New.
|
||
(gcc_jit_type_as_object): New.
|
||
(gcc_jit_field_as_object): New.
|
||
(gcc_jit_param_as_object): New.
|
||
(gcc_jit_function_as_object): New.
|
||
(gcc_jit_label_as_object): New.
|
||
(gcc_jit_lvalue_as_object): New.
|
||
(gcc_jit_rvalue_as_object): New.
|
||
(gcc_jit_loop_as_object): New.
|
||
|
||
* libgccjit.map (gcc_jit_field_as_object): New.
|
||
(gcc_jit_function_as_object): New.
|
||
(gcc_jit_label_as_object): New.
|
||
(gcc_jit_location_as_object): New.
|
||
(gcc_jit_loop_as_object): New.
|
||
(gcc_jit_lvalue_as_object): New.
|
||
(gcc_jit_object_get_context): New.
|
||
(gcc_jit_object_get_debug_string): New.
|
||
(gcc_jit_param_as_object): New.
|
||
(gcc_jit_rvalue_as_object): New.
|
||
(gcc_jit_type_as_object): New.
|
||
|
||
* libgccjit.c (struct gcc_jit_object): New.
|
||
(gcc_jit_location_as_object): New.
|
||
(gcc_jit_type_as_object): New.
|
||
(gcc_jit_field_as_object): New.
|
||
(gcc_jit_param_as_object): New.
|
||
(gcc_jit_function_as_object): New.
|
||
(gcc_jit_label_as_object): New.
|
||
(gcc_jit_lvalue_as_object): New.
|
||
(gcc_jit_rvalue_as_object): New.
|
||
(gcc_jit_object_get_context): New.
|
||
(gcc_jit_object_get_debug_string): New.
|
||
(gcc_jit_loop_as_object): New.
|
||
* internal-api.h (gcc::jit::recording::memento::get_context): New.
|
||
(gcc::jit::recording::memento::as_object): New.
|
||
|
||
* libgccjit++.h: Require iostream, for std::ostream.
|
||
(class object): New base class.
|
||
(operator << (std::ostream& stream, const object &obj)): New.
|
||
(location): Inherit from the new "object" base class.
|
||
(location::m_inner_loc): Remove, in favor of...
|
||
(location::get_inner_location): ...new method.
|
||
(field): Inherit from the new "object" base class.
|
||
(field::m_inner_field): Remove, in favor of...
|
||
(field::get_inner_field): ...new method.
|
||
(type): Inherit from the new "object" base class.
|
||
(type::m_inner_type): Remove, in favor of...
|
||
(type::get_inner_type): ...new method.
|
||
(function): Inherit from the new "object" base class.
|
||
(function::m_inner_func): Remove, in favor of...
|
||
(function::get_inner_function): ...new method.
|
||
(label): Inherit from the new "object" base class.
|
||
(label::m_inner_label): Remove, in favor of...
|
||
(label::get_inner_label): ...new method.
|
||
(rvalue) Inherit from the new "object" base class.
|
||
(rvalue::m_inner_rvalue): Remove, in favor of...
|
||
(rvalue::get_inner_rvalue): ...new method.
|
||
|
||
(context::new_field): Update for move of inner pointer to the
|
||
"object" base class.
|
||
(context::new_struct_type): Likewise.
|
||
(context::new_param): Likewise.
|
||
(context::new_function): Likewise.
|
||
(context::new_rvalue): Likewise.
|
||
(context::zero): Likewise.
|
||
(context::one): Likewise.
|
||
(context::new_rvalue): Likewise.
|
||
(context::new_rvalue): Likewise.
|
||
(context::new_unary_op): Likewise.
|
||
(context::new_binary_op): Likewise.
|
||
(context::new_comparison): Likewise.
|
||
(context::new_call): Likewise.
|
||
|
||
(object::get_debug_string): New.
|
||
(object::object): New.
|
||
(object::get_inner_object): New.
|
||
(operator << (std::ostream&, const object &)): New.
|
||
|
||
(location::location): Update for move of inner pointer to the
|
||
"object" base class.
|
||
(location::get_inner_location): New.
|
||
|
||
(field::field): Update for move of inner pointer to the
|
||
"object" base class.
|
||
(field::get_inner_field): New.
|
||
|
||
(type::type): Update for move of inner pointer to the
|
||
"object" base class.
|
||
(type::get_pointer): Likewise.
|
||
(type::get_inner_type): New.
|
||
|
||
(function::function): Update for move of inner pointer to the
|
||
"object" base class.
|
||
(function::new_forward_label): Likewise.
|
||
(function::new_local): Likewise.
|
||
(function::add_eval): Likewise.
|
||
(function::add_assignment): Likewise.
|
||
(function::add_assignment_op): Likewise.
|
||
(function::add_comment): Likewise.
|
||
(function::add_conditional): Likewise.
|
||
(function::add_label): Likewise.
|
||
(function::place_forward_label): Likewise.
|
||
(function::add_jump): Likewise.
|
||
(function::add_return): Likewise.
|
||
(function::get_inner_function): New.
|
||
|
||
(label::label): Update for move of inner pointer to the "object"
|
||
base class.
|
||
(label::get_inner_label): New
|
||
|
||
(rvalue::rvalue): Update for move of inner pointer to the "object"
|
||
base class.
|
||
(rvalue::get_inner_rvalue): New.
|
||
(rvalue::access_field): Likewise.
|
||
(rvalue::dereference_field): Likewise.
|
||
(rvalue::dereference): Likewise.
|
||
|
||
(lvalue::get_inner_lvalue): Update for move of inner pointer to
|
||
the "object" base class.
|
||
(lvalue::access_field): Likewise.
|
||
(lvalue::get_address): Likewise.
|
||
|
||
2014-01-31 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit++.h: New file - a C++ wrapper for the libgccjit.h API.
|
||
|
||
* TODO.rst ("Test Suite"): New section, adding note about C++
|
||
tests.
|
||
|
||
2014-01-31 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_context_new_rvalue_from_int): Give the type
|
||
parameter a more descriptive name.
|
||
(gcc_jit_context_zero): Likewise.
|
||
(gcc_jit_context_one): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_double): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_ptr): Likewise.
|
||
|
||
* libgccjit.c (gcc_jit_context_new_rvalue_from_int): Likewise.
|
||
(gcc_jit_context_zero): Likewise.
|
||
(gcc_jit_context_one): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_double): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_ptr): Likewise.
|
||
|
||
* internal-api.h (gcc::jit::recording::context::
|
||
new_rvalue_from_int): Likewise.
|
||
(gcc::jit::recording::context::
|
||
new_rvalue_from_double): Likewise.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_int::
|
||
memento_of_new_rvalue_from_int): Likewise.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_double::
|
||
memento_of_new_rvalue_from_double): Likewise.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_ptr::
|
||
memento_of_new_rvalue_from_ptr): Likewise.
|
||
|
||
2014-01-30 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst: Label-placement is now checked.
|
||
|
||
* internal-api.c (gcc::jit::recording::context::replay_into): Give
|
||
up if any errors occur during the playback.
|
||
(gcc::jit::recording::label::replay_into): Issue an error if the
|
||
label has not yet been placed (at playback time).
|
||
(gcc::jit::recording::place_label::place_label): Move this here
|
||
from internal-api.h. Issue an error if the label has already
|
||
been placed (at recording time).
|
||
|
||
* internal-api.h (gcc::jit::recording::label): Add an
|
||
m_has_been_placed field, and make class place_label a friend so
|
||
it can set it.
|
||
(gcc::jit::recording::label::has_been_placed): New accessor.
|
||
(gcc::jit::recording::place_label::place_label): Move to
|
||
internal-api.c.
|
||
|
||
(gcc::jit::playback::context::errors_occurred): Make public, for
|
||
use by gcc::jit::recording::context::replay_into.
|
||
|
||
2014-01-30 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::recording::type::get_pointer):
|
||
Ensure that repeated calls yield the same type.
|
||
(gcc::jit::recording::memento_of_get_pointer::
|
||
accepts_writes_from): New.
|
||
(gcc::jit::recording::context::new_call): Move
|
||
the existing argument checking to...
|
||
|
||
* libgccjit.c (gcc_jit_context_new_call): ...here, and add
|
||
checking of the types of the arguments against the function.
|
||
(RETURN_VAL_IF_FAIL_PRINTF6): New.
|
||
(RETURN_NULL_IF_FAIL_PRINTF6): New.
|
||
|
||
* internal-api.h (gcc::jit::recording::type): New field
|
||
m_pointer_to_this_type, for use by get_pointer method.
|
||
(gcc::jit::recording::memento_of_get_pointer::
|
||
accepts_writes_from): New.
|
||
(gcc::jit::recording::function::get_param): New.
|
||
|
||
* TODO.rst (argument checking of gcc_jit_context_new_call): Done.
|
||
|
||
2014-01-30 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst: begin a list of error-checking we could do that this
|
||
commit *doesn't* cover.
|
||
|
||
* libgccjit.h (gcc_jit_field): Add note that fields can't be
|
||
shared between structs.
|
||
(GCC_JIT_BINARY_OP_MODULO): Fix typo in comment.
|
||
|
||
* libgccjit.c: (RETURN_VAL_IF_FAIL_PRINTF2): New.
|
||
(RETURN_VAL_IF_FAIL_PRINTF3): New.
|
||
(RETURN_NULL_IF_FAIL_PRINTF2): New.
|
||
(RETURN_NULL_IF_FAIL_PRINTF3): New.
|
||
(RETURN_IF_FAIL_PRINTF4): New.
|
||
|
||
(jit_error): Take a gcc::jit::recording::context rather than
|
||
a gcc_jit_context so that we pass in contexts from the inner
|
||
layer.
|
||
|
||
(compatible_types): New, for use in type-checking.
|
||
|
||
(gcc_jit_context_new_struct_type): Check each field to ensure that
|
||
it isn't already in use by another struct.
|
||
|
||
(gcc_jit_rvalue_dereference_field): Check that ptr is of a pointer
|
||
type and that the field is within the correct struct, using new
|
||
get_debug_string hooks to generate error messages.
|
||
|
||
(gcc_jit_rvalue_dereference): Check that rvalue is of a pointer
|
||
type.
|
||
|
||
(gcc_jit_function_add_assignment): Use the function's context when
|
||
reporting on NULL lvalue or rvalue. Verify that the lvalue and
|
||
rvalue have compatible types.
|
||
|
||
(gcc_jit_function_add_return): Use the function's context when
|
||
reporting on NULL rvalue. Verify that the rvalue is of an
|
||
appropriate type given the function's return type.
|
||
|
||
* internal-api.h (NUM_GCC_JIT_TYPES): New.
|
||
(gcc::jit::recording::context::record): Move from here to
|
||
internal-api.c.
|
||
(gcc::jit::recording::context::get_opaque_FILE_type): New.
|
||
(gcc::jit::recording::context::m_basic_types): New field.
|
||
(gcc::jit::recording::context::m_FILE_type): New field.
|
||
|
||
(gcc::jit::recording::memento::get_debug_string): New method.
|
||
(gcc::jit::recording::memento::memento): Initialize new field
|
||
m_debug_string, and verify context is non-NULL.
|
||
(gcc::jit::recording::memento::make_debug_string): New
|
||
pure-virtual function lazily used by get_debug_string.
|
||
(gcc::jit::recording::memento::m_debug_string): New field, for
|
||
get_debug_string to use as a cache.
|
||
|
||
(gcc::jit::recording::string): Rename field m_copy to m_buffer.
|
||
(gcc::jit::recording::from_printf): New factory function.
|
||
(gcc::jit::recording::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::location::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::type::dereference): New pure-virtual
|
||
function.
|
||
(gcc::jit::recording::type::accepts_writes_from): New virtual
|
||
function.
|
||
(gcc::jit::recording::type::unqualified): New virtual function.
|
||
|
||
(gcc::jit::recording::memento_of_get_type::dereference): New.
|
||
(gcc::jit::recording::memento_of_get_type::
|
||
accepts_writes_from): New.
|
||
(gcc::jit::recording::memento_of_get_type::make_debug_string):
|
||
New.
|
||
|
||
(gcc::jit::recording::memento_of_get_pointer::make_debug_string):
|
||
New.
|
||
(gcc::jit::recording::memento_of_get_pointer::dereference): New.
|
||
New.
|
||
|
||
(gcc::jit::recording::memento_of_get_const::make_debug_string):
|
||
New.
|
||
(gcc::jit::recording::memento_of_get_const::dereference): New.
|
||
New.
|
||
(gcc::jit::recording::memento_of_get_const::accepts_writes_from):
|
||
New.
|
||
(gcc::jit::recording::memento_of_get_const::unqualified): New.
|
||
|
||
(gcc::jit::recording::field): New field m_container, for the
|
||
containing struct (or union, if we implement that).
|
||
(gcc::jit::recording::field::get_type): New.
|
||
(gcc::jit::recording::field::get_container): New.
|
||
(gcc::jit::recording::field:set_container): New.
|
||
(gcc::jit::recording::field::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::struct_::struct_): Move ctor implementation
|
||
from here into internal-api.c.
|
||
(gcc::jit::recording::struct_::dereference): New.
|
||
(gcc::jit::recording::struct_::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::rvalue::m_type): New field.
|
||
(gcc::jit::recording::rvalue::rvalue): Require a non-NULL type for
|
||
new rvalue instances.
|
||
(gcc::jit::recording::rvalue::get_type): New accessor.
|
||
|
||
(gcc::jit::recording::lvalue): Eliminate field m_type in favor of
|
||
that within the rvalue base class.
|
||
|
||
(gcc::jit::recording::param::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::function::get_return_type): New accessor.
|
||
(gcc::jit::recording::function::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::label::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::global): Eliminate field m_type in favor of
|
||
that within the rvalue ultimate base class (via lvalue).
|
||
(gcc::jit::recording::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_int): Eliminate
|
||
field m_type in favor of that within the rvalue base class.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_int::
|
||
make_debug_string): New.
|
||
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_double): Eliminate
|
||
field m_type in favor of that within the rvalue base class.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_double::
|
||
make_debug_string): New.
|
||
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_ptr): Eliminate
|
||
field m_type in favor of that within the rvalue base class.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_ptr::
|
||
make_debug_string): New.
|
||
|
||
(gcc::jit::recording::memento_of_new_string_literal::
|
||
memento_of_new_string_literal): Initialize type.
|
||
(gcc::jit::recording::memento_of_new_string_literal::
|
||
make_debug_string): New.
|
||
|
||
(gcc::jit::recording::unary_op): Eliminate field m_result_type in
|
||
favor of m_type within the rvalue base class.
|
||
(gcc::jit::recording::unary_op::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::binary_op): Eliminate field m_result_type in
|
||
favor of m_type within the rvalue base class.
|
||
(gcc::jit::recording::binary_op::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::comparison): Eliminate field m_result_type
|
||
in favor of m_type within the rvalue base class.
|
||
(gcc::jit::recording::comparison::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::array_lookup::array_lookup): Initialize type
|
||
by dereferencing the type of the pointer.
|
||
(gcc::jit::recording::array_lookup::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::access_field_of_lvalue::
|
||
access_field_of_lvalue): Initialize type from that of the field.
|
||
(gcc::jit::recording::access_field_of_lvalue::
|
||
make_debug_string): New.
|
||
|
||
(gcc::jit::recording::access_field_rvalue::
|
||
access_field_of_rvalue): Initialize type from that of the field.
|
||
(gcc::jit::recording::access_field_rvalue::make_debug_string):
|
||
New.
|
||
|
||
(gcc::jit::recording::dereference_field_rvalue::
|
||
dereference_field_rvalue): Initialize type from that of the field.
|
||
(gcc::jit::recording::dereference_field_rvalue::
|
||
make_debug_string): New.
|
||
|
||
(gcc::jit::recording::dereference_rvalue::dereference_rvalue):
|
||
Initialize type by dereferencing the type of the pointer.
|
||
(gcc::jit::recording::dereference_rvalue::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::get_address_of_lvalue::
|
||
get_address_of_lvalue): Initialize type by dereferencing the type
|
||
of the pointer.
|
||
(gcc::jit::recording::get_address_of_lvalue::make_debug_string):
|
||
New.
|
||
|
||
(gcc::jit::recording::local): Eliminate field m_type in favor of
|
||
that within the rvalue ultimate base class (via lvalue).
|
||
(gcc::jit::recording::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::eval::make_debug_string): New.
|
||
(gcc::jit::recording::assignment::make_debug_string): New.
|
||
(gcc::jit::recording::assignment_op::make_debug_string): New.
|
||
(gcc::jit::recording::comment::make_debug_string): New.
|
||
(gcc::jit::recording::conditional::make_debug_string): New.
|
||
(gcc::jit::recording::place_label::make_debug_string): New.
|
||
(gcc::jit::recording::jump::make_debug_string): New.
|
||
(gcc::jit::recording::return_::make_debug_string): New.
|
||
(gcc::jit::recording::loop::make_debug_string): New.
|
||
(gcc::jit::recording::loop_end::make_debug_string): New.
|
||
|
||
* internal-api.c (gcc::jit::recording::context::context):
|
||
Initialize m_FILE_type and m_basic_types.
|
||
(gcc::jit::recording::context::record): Move here from
|
||
internal-api.h.
|
||
(gcc::jit::recording::context::replay_into): Add a disabled way to
|
||
log everything during a replay, exercising the stringification
|
||
machinery.
|
||
(gcc::jit::recording::context::get_type): Cache and reuse the
|
||
types, so that repeated calls on the context give the same object.
|
||
(gcc::jit::recording::context::get_opaque_FILE_type): New, for
|
||
the result of dereferencing (FILE*), mostly so that fuzz-testing
|
||
that tries this gets something sane back.
|
||
(gcc::jit::recording::memento::get_debug_string): New method,
|
||
giving a way to easily get a descriptive (const char *) for
|
||
an API entity. Internally, it lazily calls the make_debug_string
|
||
virtual function, storing the result in m_debug_string.
|
||
|
||
(gcc::jit::recording::string::string): Rename field m_copy to m_buffer.
|
||
(gcc::jit::recording::string::~string): Likewise.
|
||
(gcc::jit::recording::string::from_printf): New factory function,
|
||
to make it easy to implement the make_debug_string hooks.
|
||
|
||
(gcc::jit::recording::string::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::location::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::memento_of_get_type::dereference): New.
|
||
|
||
(get_type_strings): New table of strings, for use by...
|
||
(gcc::jit::recording::memento_of_get_type::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::memento_of_get_pointer::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::memento_of_get_const::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::field::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::struct_::struct_): Move here from
|
||
internal-api.h. Mark all fields as belonging to the new struct.
|
||
|
||
(gcc::jit::recording::struct_::dereference): New.
|
||
(gcc::jit::recording::struct_::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::function::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::label::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_int::
|
||
make_debug_string): New.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_double::
|
||
make_debug_string): New.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_ptr::
|
||
make_debug_string): New.
|
||
(gcc::jit::recording::memento_of_new_string_literal::
|
||
make_debug_string): New.
|
||
|
||
(gcc::jit::recording::unary_op::replay_into): Use get_type ()
|
||
rather than the now-defunct m_result_type.
|
||
(gcc::jit::recording::binary_op::replay_into): Likewise.
|
||
|
||
(unary_op_strings): New table of strings for use by...
|
||
(gcc::jit::recording::unary_op::make_debug_string): New.
|
||
|
||
(binary_op_strings): New table of strings for use by...
|
||
(gcc::jit::recording::binary_op::make_debug_string): New.
|
||
|
||
(comparison_strings): New table of strings for use by...
|
||
(gcc::jit::recording::comparison::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::call::call): Initialize the type.
|
||
(gcc::jit::recording::call::make_debug_string): New.
|
||
|
||
(gcc::jit::recording::array_lookup::make_debug_string): New.
|
||
(gcc::jit::recording::access_field_of_lvalue::
|
||
make_debug_string): New.
|
||
(gcc::jit::recording::access_field_rvalue::
|
||
make_debug_string): New.
|
||
(gcc::jit::recording::dereference_field_rvalue::
|
||
make_debug_string): New.
|
||
(gcc::jit::recording::dereference_rvalue::make_debug_string): New.
|
||
(gcc::jit::recording::get_address_of_lvalue::
|
||
make_debug_string): New.
|
||
(gcc::jit::recording::eval::make_debug_string): New.
|
||
(gcc::jit::recording::assignment::make_debug_string): New.
|
||
(gcc::jit::recording::assignment_op::make_debug_string): New.
|
||
(gcc::jit::recording::comment::make_debug_string): New.
|
||
(gcc::jit::recording::conditional::make_debug_string): New.
|
||
(gcc::jit::recording::place_label::make_debug_string): New.
|
||
(gcc::jit::recording::jump::make_debug_string): New.
|
||
(gcc::jit::recording::return_::make_debug_string): New.
|
||
(gcc::jit::recording::loop::make_debug_string): New.
|
||
(gcc::jit::recording::loop_end::make_debug_string): New.
|
||
|
||
2014-01-29 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_lvalue_access_field): Require
|
||
a (gcc_jit_field *) rather than a field name.
|
||
(gcc_jit_rvalue_access_field): Likewise.
|
||
(gcc_jit_rvalue_dereference_field): Likewise.
|
||
|
||
* libgccjit.c (gcc_jit_lvalue_access_field): Require
|
||
a (gcc_jit_field *) rather than a field name.
|
||
(gcc_jit_rvalue_access_field): Likewise.
|
||
(gcc_jit_rvalue_dereference_field): Likewise.
|
||
|
||
* internal-api.c (gcc::jit::recording::rvalue::access_field):
|
||
Require a field rather than a fieldname string.
|
||
(gcc::jit::recording::rvalue::dereference_field): Likewise.
|
||
(gcc::jit::recording::lvalue::access_field): Likewise.
|
||
|
||
(gcc::jit::recording::access_field_of_lvalue::replay_into): Update
|
||
given that this now has a field, rather than a fieldname.
|
||
(gcc::jit::recording::access_field_rvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::dereference_field_rvalue::replay_into): Likewise.
|
||
|
||
(get_field): Delete, as we no longer need to convert
|
||
from (struct, identifier) pairs to fields, instead directly using
|
||
fields.
|
||
|
||
(gcc::jit::playback::context::new_field_access): Require a field
|
||
rather than a fieldname, removing the need to look up the field by
|
||
name within the struct.
|
||
|
||
(gcc::jit::playback::lvalue::access_field): Likewise.
|
||
(gcc::jit::playback::rvalue::access_field): Likewise.
|
||
(gcc::jit::playback::rvalue::dereference_field): Likewise.
|
||
|
||
* internal-api.h (gcc::jit::recording::rvalue::access_field):
|
||
Require a field rather than a fieldname string.
|
||
(gcc::jit::recording::rvalue::dereference_field): Likewise.
|
||
(gcc::jit::recording::lvalue::access_field): Likewise.
|
||
|
||
(gcc::jit::recording::access_field_of_lvalue::access_field_of_lvalue):
|
||
Likewise.
|
||
(gcc::jit::recording::access_field_of_lvalue::m_fieldname): Drop
|
||
string field in favor of...
|
||
(gcc::jit::recording::access_field_of_lvalue::m_field):
|
||
..."field" field, as it were.
|
||
|
||
(gcc::jit::recording::access_field_of_rvalue::access_field_of_rvalue):
|
||
Likewise.
|
||
(gcc::jit::recording::access_field_of_rvalue::m_fieldname): Drop
|
||
string field in favor of...
|
||
(gcc::jit::recording::access_field_of_rvalue::m_field):
|
||
..."field" field.
|
||
|
||
(gcc::jit::recording::dereference_field_rvalue::
|
||
dereference_field_rvalue): Likewise.
|
||
(gcc::jit::recording::dereference_field_rvalue::m_fieldname): Drop
|
||
string field in favor of...
|
||
(gcc::jit::recording::dereference_field_rvalue::m_field):
|
||
..."field" field.
|
||
|
||
(gcc::jit::playback::context::new_field_access): Require a field
|
||
rather than a fieldname string.
|
||
(gcc::jit::playback::context::access_field): Likewise.
|
||
(gcc::jit::playback::context::dereference_field): Likewise.
|
||
(gcc::jit::playback::rvalue::access_field):
|
||
|
||
2014-01-28 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_context_new_child_context): New function.
|
||
|
||
* libgccjit.map (gcc_jit_context_new_child_context): New function.
|
||
|
||
* libgccjit.c (gcc_jit_context): Make the constructor explicit,
|
||
with a parent context as a parameter.
|
||
(gcc_jit_context_acquire): Create context with a NULL parent.
|
||
(gcc_jit_context_new_child_context): New function, creating a
|
||
context with the given parent.
|
||
|
||
* internal-api.h (gcc::jit::recording::context::context): New
|
||
explicit constructor, taking a parent context as a parameter.
|
||
(gcc::jit::recording::context::m_parent_ctxt): New field.
|
||
|
||
* internal-api.c (gcc::jit::recording::context::context): New
|
||
explicit constructor, taking a parent context as a parameter.
|
||
(gcc::jit::recording::context::replay_into): Replay parent contexts
|
||
before replaying the context itself.
|
||
|
||
2014-01-27 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::playback::context::compile): Removal
|
||
of the code-creation callback (96b218c9a1d5f39fb649e02c0e77586b180e8516)
|
||
accidentally removed the implementation of
|
||
GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE; reinstate it.
|
||
|
||
2014-01-27 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api (gcc::jit::recording::context::new_call): Verify
|
||
the argument count of the call against the parameter count of the
|
||
function, issuing an error if there's a mismatch.
|
||
|
||
* internal-api.h (gcc::jit::recording::function::get_name): New.
|
||
* (gcc::jit::recording::function::get_params): New.
|
||
* (gcc::jit::recording::function::is_variadic): New.
|
||
|
||
2014-01-27 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (enum gcc_jit_binary_op): Remove
|
||
GCC_JIT_BINARY_OP_FLOATING_DIVIDE, which I accidentally added
|
||
as part of a880c0d9c642730550f39d328f29a1d9935cb07e.
|
||
|
||
2014-01-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h: Update comments to eliminate the code-creation
|
||
callback. All "contextual" objects change from merely being
|
||
"alive" during the callback to having a lifetime equal to that
|
||
of the context they are created within, with automatic cleanup
|
||
when the context is released.
|
||
(gcc_jit_code_callback): Delete.
|
||
(gcc_jit_context_set_code_factory): Delete.
|
||
|
||
* libgccjit.map (gcc_jit_context_set_code_factory): Delete.
|
||
|
||
* dummy-frontend.c (my_walker): Update for rename of the singleton
|
||
reference-owning context.
|
||
(jit_langhook_parse_file): Rather than run a client-provided
|
||
callback, we now replay a recording of the client activity.
|
||
|
||
* internal-api.h (gcc::jit): Split the existing API into two
|
||
copies...
|
||
(gcc::jit::recording): ...a class hierarchy used to implement
|
||
the client-facing API, which records the API calls made to it
|
||
and...
|
||
(gcc::jit::playback): ...a class hierarchy used within the
|
||
dummy GCC frontend, which plays back the recorded API calls once
|
||
GCC is initialized.
|
||
|
||
* internal-api.c (gcc::jit::recording::playback_location): New
|
||
API, in which client API calls are recorded as a list of "memento"
|
||
objects, to be played back into GCC when the dummy frontend runs.
|
||
(gcc::jit::recording::playback_string): Likewise.
|
||
(gcc::jit::recording::playback_label): Likewise.
|
||
(gcc::jit::recording::context::~context): Likewise.
|
||
(gcc::jit::recording::context::replay_into): Likewise.
|
||
(gcc::jit::recording::context::disassociate_from_playback): Likewise.
|
||
(gcc::jit::recording::context::new_string): Likewise.
|
||
(gcc::jit::recording::context::new_location): Likewise.
|
||
(gcc::jit::recording::context::get_type): Likewise.
|
||
(gcc::jit::recording::context::new_field): Likewise.
|
||
(gcc::jit::recording::context::new_struct_type): Likewise.
|
||
(gcc::jit::recording::context::new_param): Likewise.
|
||
(gcc::jit::recording::context::new_function): Likewise.
|
||
(gcc::jit::recording::context::new_global): Likewise.
|
||
(gcc::jit::recording::context::new_rvalue_from_int): Likewise.
|
||
(gcc::jit::recording::context::new_rvalue_from_double): Likewise.
|
||
(gcc::jit::recording::context::new_rvalue_from_ptr): Likewise.
|
||
(gcc::jit::recording::context::new_string_literal): Likewise.
|
||
(gcc::jit::recording::context::new_unary_op): Likewise.
|
||
(gcc::jit::recording::context::new_binary_op): Likewise.
|
||
(gcc::jit::recording::context::new_comparison): Likewise.
|
||
(gcc::jit::recording::context::new_call): Likewise.
|
||
(gcc::jit::recording::context::new_array_lookup): Likewise.
|
||
(gcc::jit::recording::string::string): Likewise.
|
||
(gcc::jit::recording::string::~string): Likewise.
|
||
(gcc::jit::recording::location::replay_into): Likewise.
|
||
(gcc::jit::recording::type::get_pointer): Likewise.
|
||
(gcc::jit::recording::type::get_const): Likewise.
|
||
(gcc::jit::recording::memento_of_get_type::replay_into): Likewise.
|
||
(gcc::jit::recording::memento_of_get_pointer::replay_into): Likewise.
|
||
(gcc::jit::recording::memento_of_get_const::replay_into): Likewise.
|
||
(gcc::jit::recording::field::replay_into): Likewise.
|
||
(gcc::jit::recording::struct_::replay_into): Likewise.
|
||
(gcc::jit::recording::rvalue::access_field): Likewise.
|
||
(gcc::jit::recording::rvalue::dereference_field): Likewise.
|
||
(gcc::jit::recording::rvalue::dereference): Likewise.
|
||
(gcc::jit::recording::lvalue::access_field): Likewise.
|
||
(gcc::jit::recording::lvalue::get_address): Likewise.
|
||
(gcc::jit::recording::param::replay_into): Likewise.
|
||
(gcc::jit::recording::function::function): Likewise.
|
||
(gcc::jit::recording::function::replay_into): Likewise.
|
||
(gcc::jit::recording::function::new_local): Likewise.
|
||
(gcc::jit::recording::function::new_forward_label): Likewise.
|
||
(gcc::jit::recording::function::add_eval): Likewise.
|
||
(gcc::jit::recording::function::add_assignment): Likewise.
|
||
(gcc::jit::recording::function::add_assignment_op): Likewise.
|
||
(gcc::jit::recording::function::add_comment): Likewise.
|
||
(gcc::jit::recording::function::add_conditional): Likewise.
|
||
(gcc::jit::recording::function::add_label): Likewise.
|
||
(gcc::jit::recording::function::place_forward_label): Likewise.
|
||
(gcc::jit::recording::function::add_jump): Likewise.
|
||
(gcc::jit::recording::function::add_return): Likewise.
|
||
(gcc::jit::recording::function::new_loop): Likewise.
|
||
(gcc::jit::recording::label::replay_into): Likewise.
|
||
(gcc::jit::recording::global::replay_into): Likewise.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_int::replay_into):
|
||
Likewise.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_double::replay_into):
|
||
Likewise.
|
||
(gcc::jit::recording::memento_of_new_rvalue_from_ptr::replay_into):
|
||
Likewise.
|
||
(gcc::jit::recording::memento_of_new_string_literal::replay_into):
|
||
Likewise.
|
||
(gcc::jit::recording::unary_op::replay_into): Likewise.
|
||
(gcc::jit::recording::binary_op::replay_into): Likewise.
|
||
(gcc::jit::recording::comparison::replay_into): Likewise.
|
||
(gcc::jit::recording::call::call): Likewise.
|
||
(gcc::jit::recording::call::replay_into): Likewise.
|
||
(gcc::jit::recording::array_lookup::replay_into): Likewise.
|
||
(gcc::jit::recording::access_field_of_lvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::access_field_rvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::dereference_field_rvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::dereference_rvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::get_address_of_lvalue::replay_into): Likewise.
|
||
(gcc::jit::recording::local::replay_into): Likewise.
|
||
(gcc::jit::recording::eval::replay_into): Likewise.
|
||
(gcc::jit::recording::assignment::replay_into): Likewise.
|
||
(gcc::jit::recording::assignment_op::replay_into): Likewise.
|
||
(gcc::jit::recording::comment::replay_into): Likewise.
|
||
(gcc::jit::recording::conditional::replay_into): Likewise.
|
||
(gcc::jit::recording::place_label::replay_into): Likewise.
|
||
(gcc::jit::recording::jump::replay_into): Likewise.
|
||
(gcc::jit::recording::return_::replay_into): Likewise.
|
||
(gcc::jit::recording::loop::replay_into): Likewise.
|
||
(gcc::jit::recording::loop::end): Likewise.
|
||
(gcc::jit::recording::loop_end::replay_into): Likewise.
|
||
|
||
(gcc::jit::recording::context::set_str_option): Likewise.
|
||
Option setting and error-handling is now "owned" by the recording
|
||
context; the playback context delegates to the recording context
|
||
for these aspects.
|
||
(gcc::jit::recording::context::set_int_option): Likewise.
|
||
(gcc::jit::recording::context::set_bool_option): Likewise.
|
||
(gcc::jit::recording::context::compile): Likewise.
|
||
(gcc::jit::recording::context::add_error): Likewise.
|
||
(gcc::jit::recording::context::add_error_va): Likewise.
|
||
(gcc::jit::recording::context::get_first_error): Likewise.
|
||
|
||
(gcc::jit::context::context): Rename to...
|
||
(gcc::jit::playback::context::context): ...this.
|
||
(gcc::jit::context::~context): Rename to...
|
||
(gcc::jit::playback::context::~context): ...this.
|
||
(gcc::jit::context::gt_ggc_mx): Rename to...
|
||
(gcc::jit::playback::context::gt_ggc_mx): ...this.
|
||
|
||
(gcc::jit::context::set_code_factory): Eliminate.
|
||
|
||
(gcc::jit::context::get_type): Rename to...
|
||
(gcc::jit::playback::context::get_type): ...this.
|
||
(gcc::jit::context::new_field): Rename to...
|
||
(gcc::jit::playback::context::new_field): ...this.
|
||
(gcc::jit::context::new_struct_type): Rename to...
|
||
(gcc::jit::playback::context::new_struct_type): ...this, and
|
||
update to require a vec<field *>.
|
||
(gcc::jit::context::new_param): Rename to...
|
||
(gcc::jit::playback::context::new_param): ...this.
|
||
(gcc::jit::context::new_function): Rename to...
|
||
(gcc::jit::playback::context::new_function): ...this, and update
|
||
to require a vec<param *>.
|
||
(gcc::jit::context::new_global): Rename to...
|
||
(gcc::jit::playback::context::new_global): ...this.
|
||
(gcc::jit::context::new_rvalue_from_int): Rename to...
|
||
(gcc::jit::playback::context::new_rvalue_from_int): ...this.
|
||
(gcc::jit::context::new_rvalue_from_double): Rename to...
|
||
(gcc::jit::playback::context::new_rvalue_from_double): ...this.
|
||
(gcc::jit::context::new_rvalue_from_ptr): Rename to...
|
||
(gcc::jit::playback::context::new_rvalue_from_ptr): ...this.
|
||
(gcc::jit::context::new_string_literal): Rename to...
|
||
(gcc::jit::playback::context::new_string_literal): ...this.
|
||
(gcc::jit::context::as_truth_value): Rename to...
|
||
(gcc::jit::playback::context::as_truth_value): ...this.
|
||
(gcc::jit::context::new_unary_op): Rename to...
|
||
(gcc::jit::playback::context::new_unary_op): ...this.
|
||
(gcc::jit::context::new_binary_op): Rename to...
|
||
(gcc::jit::playback::context::new_binary_op): ...this.
|
||
(gcc::jit::context::new_comparison): Rename to...
|
||
(gcc::jit::playback::context::new_comparison): ...this.
|
||
(gcc::jit::context::new_call): Rename to...
|
||
(gcc::jit::playback::context::new_call): ...this, and update
|
||
to require a vec<rvalue *>.
|
||
(gcc::jit::context::new_array_lookup): Rename to...
|
||
(gcc::jit::playback::context::new_array_lookup): ...this.
|
||
(gcc::jit::context::new_field_access): Rename to...
|
||
(gcc::jit::playback::context::new_field_access): ...this.
|
||
(gcc::jit::context::new_dereference): Rename to...
|
||
(gcc::jit::playback::context::new_dereference): ...this.
|
||
|
||
(gcc::jit::lvalue::access_field): Rename to...
|
||
(gcc::jit::playback::lvalue::access_field): ...this.
|
||
(gcc::jit::lvalue::get_address): Rename to...
|
||
(gcc::jit::playback::lvalue::get_address): ...this.
|
||
|
||
(gcc::jit::rvalue::dereference_field): Rename to...
|
||
(gcc::jit::playback::rvalue::dereference_field): ...this.
|
||
|
||
(gcc::jit::rvalue::dereference): Rename to...
|
||
(gcc::jit::playback::rvalue::dereference): ...this.
|
||
|
||
(gcc::jit::wrapper::operator new): Rename to...
|
||
(gcc::jit::playback::wrapper::operator new): ...this.
|
||
|
||
(gcc::jit::function::function): Rename to...
|
||
(gcc::jit::playback::function::function): ...this.
|
||
(gcc::jit::function::gt_ggc_mx): Rename to...
|
||
(gcc::jit::playback::function::gt_ggc_mx): ...this.
|
||
(gcc::jit::function::get_return_type_as_tree): Rename to...
|
||
(gcc::jit::playback::function::get_return_type_as_tree): ...this.
|
||
(gcc::jit::function::new_local): Rename to...
|
||
(gcc::jit::playback::function::new_local): ...this.
|
||
(gcc::jit::function::new_forward_label): Rename to...
|
||
(gcc::jit::playback::function::new_forward_label): ...this.
|
||
(gcc::jit::function::postprocess): Rename to...
|
||
(gcc::jit::playback::function::postprocess): ...this.
|
||
(gcc::jit::function::add_eval): Rename to...
|
||
(gcc::jit::playback::function::add_eval): ...this.
|
||
(gcc::jit::function::add_assignment): Rename to...
|
||
(gcc::jit::playback::function::add_assignment): ...this.
|
||
(gcc::jit::function::add_comment): Rename to...
|
||
(gcc::jit::playback::function::add_comment): ...this.
|
||
(gcc::jit::function::add_conditional): Rename to...
|
||
(gcc::jit::playback::function::add_conditional): ...this.
|
||
(gcc::jit::function::add_label): Rename to...
|
||
(gcc::jit::playback::function::add_label): ...this.
|
||
(gcc::jit::function::place_forward_label): Rename to...
|
||
(gcc::jit::playback::function::place_forward_label): ...this.
|
||
(gcc::jit::function::add_jump): Rename to...
|
||
(gcc::jit::playback::function::add_jump): ...this.
|
||
(gcc::jit::function::add_return): Rename to...
|
||
(gcc::jit::playback::function::add_return): ...this.
|
||
(gcc::jit::function::new_loop): Rename to...
|
||
(gcc::jit::playback::function::new_loop): ...this.
|
||
|
||
(gcc::jit::label::label): Rename to...
|
||
(gcc::jit::playback::label::label): ...this.
|
||
|
||
(gcc::jit::loop::loop): Rename to...
|
||
(gc::jit::playback::loop::loop): ...this.
|
||
(gcc::jit::loop::end): Rename to...
|
||
(gcc::jit::playback::loop): ...this.
|
||
|
||
(gcc::jit::active_jit_ctxt): Eliminate in favor of...
|
||
(gcc::jit::active_playback_ctxt): ...this.
|
||
|
||
(gcc::jit::context::compile): Rename to...
|
||
(gcc::jit::playback::context::compile): ...this, and eliminate the
|
||
mutex handling; this is done for us by the caller.
|
||
|
||
(gcc::jit::context::invoke_code_factory): Rename to...
|
||
(gcc::jit::playback::context::replay): this. Rather than call
|
||
a client-provided callback, instead replay the recorded API
|
||
calls.
|
||
|
||
(gcc::jit::context::dump_generated_code): Rename to...
|
||
(gcc::jit::playback::context::dump_generated_code): ...this.
|
||
|
||
(location_comparator): Update for renamed types.
|
||
|
||
(gcc::jit::context::handle_locations): Rename to...
|
||
(gcc::jit::playback::context::handle_locations): ...this.
|
||
|
||
(gcc::jit::context::add_error): Rename to...
|
||
(gcc::jit::playback::context::add_error): this, and delegate to
|
||
the recording context's add_error_va.
|
||
|
||
(gcc::jit::context::add_error_va): Rename to...
|
||
(gcc::jit::playback::context::add_error_va): this, and delegate
|
||
to the recording context.
|
||
|
||
(gcc::jit::context::new_location): Rename to...
|
||
(gcc::jit::playback::context::new_location): ...this.
|
||
(gcc::jit::context::set_tree_location): Rename to...
|
||
(gcc::jit::playback::context::set_tree_location): ...this.
|
||
(gcc::jit::context::get_source_file): Rename to...
|
||
(gcc::jit::playback::context::get_source_file): ...this.
|
||
(gcc::jit::source_file::source_file): Rename to...
|
||
(gcc::jit::playback::source_file::source_file): ...this.
|
||
(gcc::jit::source_file::get_source_line): Rename to...
|
||
(gcc::jit::playback::source_file::get_source_line): ...this.
|
||
(gcc::jit::source_line::source_line): Rename to...
|
||
(gcc::jit::playback::source_line::source_line): ...this.
|
||
(gcc::jit::source_line::get_location): Rename to...
|
||
(gcc::jit::playback::source_line::get_location): ...this.
|
||
|
||
(gcc::jit::location::location): Rename to...
|
||
(gcc::jit::playback::location::location): ...this.
|
||
|
||
* libgccjit.c: Update classes to derive from the "jit::recording"
|
||
class hierarchy.
|
||
(RETURN_IF_NOT_INITIAL_CTXT): Eliminate, as it relates to
|
||
code-creation callbacks.
|
||
(RETURN_NULL_IF_NOT_INITIAL_CTXT): Likewise.
|
||
(RETURN_NULL_IF_NOT_CALLBACK_CTXT): Likewise.
|
||
(jit_error): There isn't an "active jit context" anymore, except
|
||
during actual compilation, so simplify the logic here.
|
||
(gcc_jit_context_set_code_factory): Delete.
|
||
|
||
(gcc_jit_context_new_location): Update preconditions now that we
|
||
don't have code-creation callbacks.
|
||
(gcc_jit_context_get_type): Likewise.
|
||
(gcc_jit_type_get_pointer): Likewise.
|
||
(gcc_jit_type_get_const): Likewise.
|
||
(gcc_jit_context_new_field): Likewise.
|
||
(gcc_jit_context_new_struct_type): Likewise.
|
||
(gcc_jit_context_new_param): Likewise.
|
||
(gcc_jit_param_as_lvalue): Likewise.
|
||
(gcc_jit_param_as_rvalue): Likewise.
|
||
(gcc_jit_context_new_function): Likewise.
|
||
(gcc_jit_context_new_function): Likewise.
|
||
(gcc_jit_function_new_forward_label): Likewise.
|
||
(gcc_jit_context_new_global): Likewise.
|
||
(gcc_jit_lvalue_as_rvalue): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_int): Likewise.
|
||
(gcc_jit_context_zero): Likewise.
|
||
(gcc_jit_context_one): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_double): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_ptr): Likewise.
|
||
(gcc_jit_context_new_string_literal): Likewise.
|
||
(gcc_jit_context_new_unary_op): Likewise.
|
||
(gcc_jit_context_new_binary_op): Likewise.
|
||
(gcc_jit_context_new_comparison): Likewise.
|
||
(gcc_jit_context_new_call): Likewise.
|
||
(gcc_jit_context_new_call): Likewise.
|
||
(gcc_jit_context_new_array_lookup): Likewise.
|
||
(gcc_jit_context_set_str_option): Likewise.
|
||
(gcc_jit_context_set_int_option): Likewise.
|
||
(gcc_jit_context_set_bool_option): Likewise.
|
||
(gcc_jit_context_compile): Likewise.
|
||
(gcc_jit_function_add_assignment_op): Likewise. Also,
|
||
reimplement as a separate kind of recording, since we can't know
|
||
the type of the lvalue at recording-time.
|
||
|
||
* notes.txt: Update diagram to reflect the new implementation.
|
||
|
||
2014-01-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (enum gcc_jit_binary_op): We will use the result
|
||
type to determine if GCC_JIT_BINARY_OP_DIVIDE should
|
||
truncate towards zero, or be floating-point division.
|
||
|
||
* internal-api.c (gcc::jit::context::new_binary_op): Likewise.
|
||
|
||
2014-01-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.h (gcc::jit::context::get_str_option): New access
|
||
method.
|
||
(gcc::jit::context::get_int_option): Likewise.
|
||
|
||
* internal-api.c (gcc::jit::context::~context): Use access methods
|
||
for options, rather than direct field access.
|
||
(gcc::jit::context::compile): Likewise.
|
||
|
||
2014-01-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (enum gcc_jit_bool_option): New value:
|
||
GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE.
|
||
|
||
* internal-api.c (gcc::jit::context::compile): Call
|
||
dump_generated_code if the user has requested it.
|
||
(gcc::jit::context::dump_generated_code): New, copying
|
||
from the .s file to stderr.
|
||
|
||
* internal-api.h (gcc::jit::context::dump_generated_code): New.
|
||
|
||
2014-01-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.h (gcc::jit::function): Add field
|
||
"m_inner_bind_expr".
|
||
* internal-api.c (gcc::jit::function::function): Create a BIND_EXPR
|
||
for all non-imported functions, and put the statement list within
|
||
it.
|
||
(gcc::jit::function::gt_ggc_mx): Visit m_inner_bind_expr.
|
||
(gcc::jit::function::new_local): Set the DECL_CONTEXT of the new
|
||
local to be the function's BIND_EXPR, and prepend the new local
|
||
to said BIND_EXPR's BIND_EXPR_VARS chain.
|
||
(gcc::jit::function::postprocess): Set the DECL_SAVED_TREE of the
|
||
FUNCTION_DECL to be the BIND_EXPR, rather than the statement list.
|
||
The latter is now contained within the former.
|
||
|
||
2014-01-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.h (gcc::jit::function::add_stmt): New.
|
||
|
||
* internal-api.c (gcc::jit::function::add_eval): Replace use of
|
||
tsi_link_stmt with call to add_stmt.
|
||
(gcc::jit::function::add_assignment): Likewise.
|
||
(gcc::jit::function::add_conditional): Likewise.
|
||
(gcc::jit::function::place_forward_label): Likewise.
|
||
(gcc::jit::function::add_jump): Likewise.
|
||
(gcc::jit::function::add_return): Likewise.
|
||
|
||
2014-01-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::function::add_comment): New.
|
||
* internal-api.h (gcc::jit::function::add_comment): New.
|
||
* libgccjit.c (gcc_jit_function_add_comment): New.
|
||
* libgccjit.h (gcc_jit_function_add_comment): New.
|
||
* libgccjit.map: Add gcc_jit_function_add_comment.
|
||
|
||
2013-10-24 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::function::add_eval): Handle non-NULL
|
||
locations.
|
||
(gcc::jit::context::handle_locations): Fix test for the various
|
||
kinds of declarations, replacing use of DECL_MINIMAL_CHECK,
|
||
which aborts on failure (such as if we saw a type).
|
||
* libgccjit.h (GCC_JIT_BOOL_OPTION_DEBUGINFO): Fix out-of-date
|
||
comment.
|
||
|
||
2013-10-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c: Update for rename of tree-flow.h to tree-cfg.h
|
||
in r203320, for declaration of dump_function_to_file.
|
||
* TODO.rst ("segfault seen in libbacktrace"): Remove - this was
|
||
fixed by Ian in r203810.
|
||
|
||
2013-10-23 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c: Add missing include of diagnostic-core.h
|
||
|
||
2013-10-22 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::add_error_va): Record the
|
||
first error that occurs on a context.
|
||
(gcc::jit::context::get_first_error): New.
|
||
* internal-api.h (gcc::jit::context::get_first_error): New.
|
||
(gcc::jit::context::m_first_error_str): New.
|
||
* libgccjit.c (gcc_jit_context_get_first_error): New.
|
||
* libgccjit.h (gcc_jit_context_get_first_error): New.
|
||
* libgccjit.map (gcc_jit_context_get_first_error): New.
|
||
|
||
2013-10-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::compile): Correctly cleanup
|
||
timevars in error-handling, preventing an issue where an error
|
||
on a context left timevar.c in an unstopped state, leading to an
|
||
assertion failure when restarting timevars in the next compile.
|
||
Found via fuzz-testing.
|
||
|
||
2013-10-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::postprocess): Show source
|
||
line numbers (if any) in gimple dump.
|
||
|
||
2013-10-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (gcc_jit_function_new_local): Use a more clear
|
||
error message for the case where someone tries to add a local
|
||
to a function imported from elsewhere.
|
||
|
||
2013-10-21 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst ("the C unary prefix "&" operator"): Remove completed item.
|
||
* internal-api.c (gcc::jit::lvalue::get_address): New.
|
||
* internal-api.h (gcc::jit::lvalue::get_address): New.
|
||
* libgccjit.c (gcc_jit_lvalue_get_address): New.
|
||
* libgccjit.h (gcc_jit_lvalue_get_address): New.
|
||
* libgccjit.map (gcc_jit_lvalue_get_address): New.
|
||
|
||
2013-10-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::new_param): Add context
|
||
argument to ctor for rvalue and its subclasses.
|
||
(gcc::jit::context::new_global): Likewise.
|
||
(gcc::jit::context::new_rvalue_from_int): Likewise.
|
||
(gcc::jit::context::new_rvalue_from_double): Likewise.
|
||
(gcc::jit::context::new_rvalue_from_ptr): Likewise.
|
||
(gcc::jit::context::new_string_literal): Likewise.
|
||
(gcc::jit::context::new_call): Likewise.
|
||
(gcc::jit::context::new_array_lookup): Likewise.
|
||
(gcc::jit::function::new_local): Likewise.
|
||
(gcc::jit::context::new_binary_op): Likewise; add new
|
||
operations.
|
||
(gcc::jit::context::new_comparison): Likewise; add new
|
||
comparisons.
|
||
(gcc::jit::context::as_truth_value): New.
|
||
(gcc::jit::context::new_unary_op): New.
|
||
(gcc::jit::context::new_field_access): Convert to a helper
|
||
method for use by the access_fields methods.
|
||
(gcc::jit::context::new_dereference): New.
|
||
(gcc::jit::lvalue::access_field): New.
|
||
(gcc::jit::rvalue::access_field): New.
|
||
(gcc::jit::rvalue::dereference_field): New.
|
||
(gcc::jit::rvalue::dereference): New.
|
||
* internal-api.h (gcc::jit::context::new_unary_op): New.
|
||
(gcc::jit::context::new_field_access): Work
|
||
(gcc::jit::context::new_dereference): New.
|
||
(gcc::jit::context::as_truth_value): New.
|
||
(gcc::jit::rvalue): Add a context field.
|
||
(gcc::jit::rvalue::access_field): New.
|
||
(gcc::jit::rvalue::dereference_field): New.
|
||
(gcc::jit::rvalue::dereference): New.
|
||
(gcc::jit::lvalue::lvalue): Add context to ctor.
|
||
(gcc::jit::lvalue::access_field): New.
|
||
(gcc::jit::param::param): Add context to ctor.
|
||
* libgccjit.c (gcc_jit_context_new_unary_op): New.
|
||
(gcc_jit_context_new_field_access): Remove.
|
||
(gcc_jit_lvalue_access_field): New.
|
||
(gcc_jit_rvalue_access_field): New.
|
||
(gcc_jit_rvalue_dereference_field): New.
|
||
(gcc_jit_rvalue_dereference): New.
|
||
*libgccjit.h (enum gcc_jit_unary_op): New.
|
||
(gcc_jit_context_new_unary_op): New.
|
||
(enum gcc_jit_binary_op): Document values, and add...
|
||
(GCC_JIT_BINARY_OP_DIVIDE): New.
|
||
(GCC_JIT_BINARY_OP_MODULO): New.
|
||
(GCC_JIT_BINARY_OP_BITWISE_AND): New.
|
||
(GCC_JIT_BINARY_OP_BITWISE_XOR): New.
|
||
(GCC_JIT_BINARY_OP_BITWISE_OR): New.
|
||
(GCC_JIT_BINARY_OP_LOGICAL_AND): New.
|
||
(GCC_JIT_BINARY_OP_LOGICAL_OR): New.
|
||
(enum gcc_jit_comparison): Document values, and add...
|
||
(GCC_JIT_COMPARISON_EQ): New.
|
||
(GCC_JIT_COMPARISON_NE): New.
|
||
(GCC_JIT_COMPARISON_LE): New.
|
||
(GCC_JIT_COMPARISON_GT): New.
|
||
(GCC_JIT_COMPARISON_GE): New.
|
||
(gcc_jit_context_new_field_access): Remove.
|
||
(gcc_jit_lvalue_access_field): New.
|
||
(gcc_jit_rvalue_access_field): New.
|
||
(gcc_jit_rvalue_dereference_field): New.
|
||
(gcc_jit_rvalue_dereference): New.
|
||
* libgccjit.map (gcc_jit_context_new_field_access): Remove.
|
||
(gcc_jit_lvalue_access_field): New.
|
||
(gcc_jit_rvalue_access_field): New.
|
||
(gcc_jit_rvalue_dereference_field): New.
|
||
(gcc_jit_rvalue_dereference): New.
|
||
* TODO.rst: Update
|
||
|
||
2013-10-18 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::get_type): Improve error
|
||
message, and report the bogus value.
|
||
(gcc::jit::context::new_binary_op): Likewise.
|
||
(gcc::jit::context::new_comparison): Likewise.
|
||
(gcc::jit::context::set_str_option): Likewise.
|
||
(gcc::jit::context::set_int_option): Likewise.
|
||
(gcc::jit::context::set_bool_option): Likewise.
|
||
(gcc::jit::context::compile): Likewise, and make the errors
|
||
block the creation of result, rather than just the return
|
||
value of the client callback.
|
||
(gcc::jit::context::add_error): Add varargs and provide
|
||
implementation, calling into...
|
||
(gcc::jit::context::add_error_va): New.
|
||
* internal-api.h (GNU_PRINTF): New.
|
||
(gcc::jit::context::add_error): Add varargs and GNU_PRINTF
|
||
attribute macro.
|
||
(gcc::jit::context::add_error_va): New.
|
||
(gcc::jit::context::errors_occurred): New.
|
||
(gcc::jit::context::m_error_count): New.
|
||
(gcc::jit::function::get_kind): New.
|
||
* libgccjit.c (JIT_BEGIN_STMT): New.
|
||
(JIT_END_STMT): New.
|
||
(RETURN_VAL_IF_FAIL): New.
|
||
(RETURN_NULL_IF_FAIL): New.
|
||
(RETURN_IF_FAIL): New.
|
||
(RETURN_IF_NOT_INITIAL_CTXT): New.
|
||
(RETURN_NULL_IF_NOT_INITIAL_CTXT): New.
|
||
(RETURN_NULL_IF_NOT_CALLBACK_CTXT): New.
|
||
(RETURN_IF_NOT_FUNC_DEFINITION): New.
|
||
(RETURN_NULL_IF_NOT_FUNC_DEFINITION): New.
|
||
(jit_error): New.
|
||
(gcc_jit_context_set_code_factory): Use new error-checking
|
||
macros.
|
||
(ASSERT_WITHIN_CALLBACK): Remove.
|
||
(ASSERT_NOT_WITHIN_CALLBACK): Remove.
|
||
(gcc_jit_context_new_location): Use new error-checking macros.
|
||
(gcc_jit_context_get_type): Likewise.
|
||
(gcc_jit_type_get_pointer): Likewise.
|
||
(gcc_jit_type_get_const): Likewise.
|
||
(gcc_jit_context_new_field): Likewise.
|
||
(gcc_jit_context_new_struct_type): Likewise.
|
||
(gcc_jit_context_new_param): Likewise.
|
||
(gcc_jit_param_as_lvalue): Likewise.
|
||
(gcc_jit_param_as_rvalue): Likewise.
|
||
(gcc_jit_context_new_function): Likewise.
|
||
(gcc_jit_function_new_forward_label): Likewise.
|
||
(gcc_jit_context_new_global): Likewise.
|
||
(gcc_jit_lvalue_as_rvalue): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_int): Likewise.
|
||
(gcc_jit_context_zero): Likewise.
|
||
(gcc_jit_context_one): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_double): Likewise.
|
||
(gcc_jit_context_new_rvalue_from_ptr): Likewise.
|
||
(gcc_jit_context_new_string_literal): Likewise.
|
||
(gcc_jit_context_new_binary_op): Likewise.
|
||
(gcc_jit_context_new_comparison): Likewise.
|
||
(gcc_jit_context_new_call): Likewise.
|
||
(gcc_jit_context_new_array_lookup): Likewise.
|
||
(gcc_jit_context_new_field_access): Likewise.
|
||
(gcc_jit_function_new_local): Likewise.
|
||
(gcc_jit_function_add_label): Likewise.
|
||
(gcc_jit_function_place_forward_label): Likewise.
|
||
(gcc_jit_function_add_eval): Likewise.
|
||
(gcc_jit_function_add_assignment): Likewise.
|
||
(gcc_jit_function_add_assignment_op): Likewise.
|
||
(gcc_jit_function_add_conditional): Likewise.
|
||
(gcc_jit_function_add_jump): Likewise.
|
||
(gcc_jit_function_add_return): Likewise.
|
||
(gcc_jit_function_new_loop): Likewise.
|
||
(gcc_jit_loop_end): Likewise.
|
||
(gcc_jit_context_set_str_option): Likewise.
|
||
(gcc_jit_context_set_int_option): Likewise.
|
||
(gcc_jit_context_set_bool_option): Likewise.
|
||
(gcc_jit_context_compile): Likewise.
|
||
(gcc_jit_result_get_code): Likewise.
|
||
(gcc_jit_result_release): Likewise.
|
||
* libgccjit.h (gcc_jit_function_new_forward_label): Clarify
|
||
behavior.
|
||
(gcc_jit_function_add_label): Likewise.
|
||
|
||
2013-10-17 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::get_void_type): Remove.
|
||
(gcc::jit::context::get_char_type): Remove.
|
||
(gcc::jit::context::get_int_type): Remove.
|
||
(gcc::jit::context::get_float_type): Remove.
|
||
(gcc::jit::context::get_double_type): Remove.
|
||
(get_tree_node_for_type): New.
|
||
(gcc::jit::context::get_type): New.
|
||
(gcc::jit::context::new_rvalue_from_double): New.
|
||
(gcc::jit::context::new_rvalue_from_ptr): New.
|
||
* internal-api.h (gcc::jit::context::get_void_type): Remove.
|
||
(gcc::jit::context::get_char_type): Remove.
|
||
(gcc::jit::context::get_int_type): Remove.
|
||
(gcc::jit::context::get_float_type): Remove.
|
||
(gcc::jit::context::get_double_type): Remove.
|
||
(gcc::jit::context::get_type): New.
|
||
(gcc::jit::context::new_rvalue_from_double): New.
|
||
(gcc::jit::context::new_rvalue_from_ptr): New.
|
||
* libgccjit.c (gcc_jit_context_get_void_type): Remove.
|
||
(gcc_jit_context_get_char_type): Remove.
|
||
(gcc_jit_context_get_int_type): Remove.
|
||
(gcc_jit_context_get_float_type): Remove.
|
||
(gcc_jit_context_get_double_type): Remove.
|
||
(gcc_jit_context_get_type): New.
|
||
(gcc_jit_context_new_rvalue_from_double): New.
|
||
(gcc_jit_context_new_rvalue_from_ptr): New.
|
||
* libgccjit.h (gcc_jit_context_get_void_type): Remove.
|
||
(gcc_jit_context_get_char_type): Remove.
|
||
(gcc_jit_context_get_int_type): Remove.
|
||
(gcc_jit_context_get_float_type): Remove.
|
||
(gcc_jit_context_get_double_type): Remove.
|
||
(enum gcc_jit_types): New.
|
||
(gcc_jit_context_get_type): New.
|
||
(gcc_jit_context_new_rvalue_from_double): New.
|
||
(gcc_jit_context_new_rvalue_from_ptr): New.
|
||
* libgccjit.map (gcc_jit_context_get_void_type): Remove.
|
||
(gcc_jit_context_get_char_type): Remove.
|
||
(gcc_jit_context_get_int_type): Remove.
|
||
(gcc_jit_context_get_float_type): Remove.
|
||
(gcc_jit_context_get_double_type): Remove.
|
||
(enum gcc_jit_types): New.
|
||
(gcc_jit_context_get_type): New.
|
||
(gcc_jit_context_new_rvalue_from_double): New.
|
||
(gcc_jit_context_new_rvalue_from_ptr): New.
|
||
* TODO.rst ("access to more primitive types"): Remove
|
||
completed item.
|
||
|
||
2013-10-17 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h: Add and reword comments throughout.
|
||
|
||
2013-10-17 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst: Update.
|
||
|
||
2013-10-16 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst (gcc_jit_context_new_local): Remove completed item.
|
||
* internal-api.c (gcc::jit::context::new_local): Replace with...
|
||
(gcc::jit::function::new_local): ...this, and change return type
|
||
from (local*) to (lvalue*).
|
||
* internal-api.h (gcc::jit::local): Eliminate.
|
||
(gcc::jit::context::new_local): Replace with...
|
||
(gcc::jit::function::new_local): ...this, and change return type
|
||
from (local*) to (lvalue*).
|
||
* libgccjit.c (gcc_jit_local): Eliminate.
|
||
(gcc_jit_context_new_local): Replace with...
|
||
(gcc_jit_function_new_local): ...this, and change return type
|
||
from (gcc_jit_local*) to (gcc_jit_lvalue*).
|
||
(gcc_jit_local_as_lvalue): Remove.
|
||
(gcc_jit_local_as_rvalue): Remove.
|
||
* libgccjit.h (gcc_jit_local): Remove.
|
||
(gcc_jit_context_new_local): Replace with...
|
||
(gcc_jit_function_new_local): ...this, and change return type
|
||
from (gcc_jit_local*) to (gcc_jit_lvalue*).
|
||
(gcc_jit_local_as_lvalue): Remove.
|
||
(gcc_jit_local_as_rvalue): Remove.
|
||
* libgccjit.map (gcc_jit_context_new_local): Replace with...
|
||
(gcc_jit_function_new_local): ...this.
|
||
(gcc_jit_local_as_lvalue): Remove.
|
||
(gcc_jit_local_as_rvalue): Remove.
|
||
|
||
2013-10-15 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (gcc_jit_location): Rewrite comment to reflect
|
||
that this part of the API is now implemented.
|
||
("Functions for use within the code factory."): Add notes on
|
||
memory-management and lifetimes.
|
||
* notes.txt: Update diagram to show handle_locations.
|
||
|
||
2013-10-15 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* TODO.rst: Update.
|
||
|
||
2013-10-14 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.map: Alphabetize the exported symbols.
|
||
|
||
2013-10-14 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::new_field): Implement
|
||
location support, by calling set_tree_location.
|
||
(gcc::jit::context::new_struct_type): Likewise.
|
||
(gcc::jit::context::new_param): Likewise.
|
||
(gcc::jit::context::new_function): Likewise.
|
||
(gcc::jit::context::new_global): Likewise.
|
||
(gcc::jit::context::new_local): Likewise.
|
||
(gcc::jit::context::new_binary_op): Likewise.
|
||
(gcc::jit::context::new_comparison): Likewise.
|
||
(gcc::jit::context::new_call): Likewise.
|
||
(gcc::jit::context::new_array_lookup): Likewise.
|
||
(gcc::jit::context::new_field_access): Likewise.
|
||
(gcc::jit::context::add_assignment): Likewise.
|
||
(gcc::jit::context::add_conditional): Likewise.
|
||
(gcc::jit::function::add_label): Likewise.
|
||
(gcc::jit::function::add_jump): Likewise.
|
||
(gcc::jit::function::add_return): Likewise.
|
||
(gcc::jit::function::place_forward_label): Likewise, adding
|
||
location parameter.
|
||
(gcc::jit::loop::loop): Add loc arg to place_forward_label.
|
||
(gcc::jit::loop::end): Likewise.
|
||
(gcc::jit::context::invoke_code_factory): Call handle_locations
|
||
after the client callback is done, before any GC can run.
|
||
(line_comparator): New.
|
||
(location_comparator): New.
|
||
(gcc::jit::context::handle_locations): New.
|
||
(gcc::jit::context::new_location): New.
|
||
(gcc::jit::context::set_tree_location): New.
|
||
(gcc::jit::context::get_source_file): New.
|
||
(gcc::jit::source_file::source_file): New.
|
||
(gcc::jit::source_file::get_source_line): New.
|
||
(gcc::jit::source_line::source_line): New.
|
||
(gcc::jit::source_line::get_location): New.
|
||
(gcc::jit::location::location): New.
|
||
* internal-api.h (gcc::jit::context::new_location): New.
|
||
(gcc::jit::context::set_tree_location): New.
|
||
(gcc::jit::context::handle_locations): New.
|
||
(gcc::jit::context::get_source_file): New.
|
||
(gcc::jit::context::m_source_files): New field.
|
||
(gcc::jit::context::m_cached_locations: New field.
|
||
(gcc::jit::function::place_forward_label): Add location
|
||
parameter.
|
||
(gcc::jit::function::set_tree_location): New.
|
||
(gcc::jit::source_file): New class.
|
||
(gcc::jit::source_line): New class.
|
||
(gcc::jit::location): New class.
|
||
* libgccjit.c (gcc_jit_context_new_location): New.
|
||
(gcc_jit_function_place_forward_label): Add location parameter,
|
||
changing public API.
|
||
* libgccjit.h (gcc_jit_context_new_location): New.
|
||
(gcc_jit_function_place_forward_label): Add location parameter,
|
||
changing public API.
|
||
* libgccjit.map (gcc_jit_context_new_location): New.
|
||
(main): Remove obsolete export.
|
||
(called_function): Likewise.
|
||
|
||
2013-10-11 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c: Update includes to reflect move of decl of
|
||
dump_function_to_file from tree-dump.h to tree-flow.h in
|
||
r203320.
|
||
|
||
2013-10-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (GCC_JIT_BOOL_OPTION_DUMP_SUMMARY): New.
|
||
* internal-api.c ((gcc::jit::context::compile): Implement
|
||
GCC_JIT_BOOL_OPTION_DUMP_SUMMARY.
|
||
|
||
2013-10-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (GCC_JIT_BOOL_OPTION_SELFCHECK_GC): Improve
|
||
documentation.
|
||
(GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE): Likewise.
|
||
|
||
2013-10-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h: Clarify the separation of the API into "outside
|
||
the callback" and "within the callback" entrypoints, moving the
|
||
latter to the bottom of the header.
|
||
|
||
2013-10-10 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h: Add comments throughout.
|
||
|
||
2013-10-09 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::~context): Fix indentation;
|
||
clean up memory allocations when using
|
||
GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES.
|
||
|
||
2013-10-09 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (enum gcc_jit_bool_option): Add
|
||
GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING.
|
||
* internal-api.c (gcc::jit::context::compile): Implement
|
||
GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING.
|
||
|
||
2013-10-09 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.h (enum gcc_jit_bool_option): Add
|
||
GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES.
|
||
* internal-api.c (gcc::jit::context::~context): Implement
|
||
GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES.
|
||
|
||
2013-10-08 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::compile): Use mkdtemp to
|
||
create a temporary directory and create the .s and .so files
|
||
there, rather than writing to "fake.s" and then reading it to
|
||
make "fake.so", then using it, fixing various possible race
|
||
attacks by processes that can write to the process' current
|
||
working directory.
|
||
(gcc::jit::context::~context): Clean up tempfiles and path
|
||
buffers.
|
||
* internal-api.h (gcc::jit::context): Add fields
|
||
m_path_template, m_path_tempdir, m_path_c_file, m_path_s_file,
|
||
m_path_so_file.
|
||
|
||
2013-10-08 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::new_function): Fix leak of
|
||
arg_types.
|
||
|
||
2013-10-08 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::~context): New.
|
||
* internal-api.h (gcc::jit::context::~context): New.
|
||
|
||
2013-10-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::compile): Implement
|
||
GCC_JIT_BOOL_OPTION_SELFCHECK_GC.
|
||
|
||
* libgccjit.h (enum gcc_jit_bool_option): Add
|
||
GCC_JIT_BOOL_OPTION_SELFCHECK_GC.
|
||
|
||
2013-10-07 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* Make-lang.in: Rename JIT_OBJS to jit_OBJS. Delete manual
|
||
dependencies.
|
||
|
||
2013-10-04 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::context::new_global): New.
|
||
* internal-api.h (gcc::jit::context::new_global): New.
|
||
* libgccjit.c (gcc_jit_context_new_global) New.
|
||
* libgccjit.h (gcc_jit_context_new_global) New.
|
||
* libgccjit.map: Add gcc_jit_context_new_global.
|
||
|
||
2013-10-03 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* libgccjit.c (gcc_jit_param_as_lvalue): New.
|
||
* libgccjit.h (gcc_jit_param_as_lvalue): New.
|
||
* libgccjit.map: Add gcc_jit_param_as_lvalue.
|
||
|
||
2013-10-03 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* internal-api.c (gcc::jit::function::postprocess): Dump gimple
|
||
using dump_function_to_file rather than debug_gimple_seq so that
|
||
we also get the declaration.
|
||
|
||
2013-10-03 David Malcolm <dmalcolm@redhat.com>
|
||
|
||
* Make-lang.in: New.
|
||
* TODO.rst: New.
|
||
* config-lang.in: New.
|
||
* dummy-frontend.c: New.
|
||
* internal-api.c: New.
|
||
* internal-api.h: New.
|
||
* libgccjit.c: New.
|
||
* libgccjit.h: New.
|
||
* libgccjit.map: New.
|
||
* notes.txt: New.
|
||
|
||
Copyright (C) 2013-2014 Free Software Foundation, Inc.
|
||
|
||
Copying and distribution of this file, with or without modification,
|
||
are permitted in any medium without royalty provided the copyright
|
||
notice and this notice are preserved.
|