| 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. |