Searched refs:jit (Results 1 - 20 of 20) sorted by relevance

/haiku-buildtools/gcc/gcc/jit/
H A Ddummy-frontend.c0 /* jit.c -- Dummy "frontend" for use during JIT-compilation.
50 #include "jit-common.h"
51 #include "jit-logging.h"
52 #include "jit-playback.h"
103 if (gcc::jit::active_playback_ctxt)
104 gcc::jit::active_playback_ctxt->gt_ggc_mx ();
122 gcc_assert (gcc::jit::active_playback_ctxt);
123 JIT_LOG_SCOPE (gcc::jit::active_playback_ctxt->get_logger ());
151 gcc_assert (gcc::jit::active_playback_ctxt);
152 gcc::jit
[all...]
H A Djit-result.h26 namespace jit { namespace in namespace:gcc
47 } // namespace gcc::jit
H A Djit-tempdir.h24 #include "jit-logging.h"
28 namespace jit { namespace in namespace:gcc
30 /* A class to keep track of the jit::playback::context's tempdir.
79 } // namespace gcc::jit
H A Djit-tempdir.c25 #include "jit-tempdir.h"
66 /* The constructor for the jit::tempdir object.
67 The real work is done by the jit::tempdir::create method. */
69 gcc::jit::tempdir::tempdir (logger *logger, int keep_intermediates)
82 We do this here, rather than in the jit::tempdir constructor
86 gcc::jit::tempdir::create ()
112 /* The destructor for the jit::tempdir object, which
116 gcc::jit::tempdir::~tempdir ()
H A Djit-logging.h24 #include "jit-common.h"
28 namespace jit { namespace in namespace:gcc
30 /* A gcc::jit::logger encapsulates a logging stream: a way to send
57 /* The class gcc::jit::log_scope is an RAII-style class intended to make
72 /* The constructor for gcc::jit::log_scope.
93 /* The destructor for gcc::jit::log_scope; essentially the opposite of
106 /* A gcc::jit::log_user is something that potentially uses a
107 gcc::jit::logger (which could be NULL).
111 - class gcc::jit::recording::context
113 - class gcc::jit
[all...]
H A Dlibgccjit.c29 #include "jit-common.h"
30 #include "jit-logging.h"
31 #include "jit-recording.h"
32 #include "jit-result.h"
35 of the gcc::jit::recording classes. */
37 struct gcc_jit_context : public gcc::jit::recording::context
44 struct gcc_jit_result : public gcc::jit::result
48 struct gcc_jit_object : public gcc::jit::recording::memento
52 struct gcc_jit_location : public gcc::jit::recording::location
56 struct gcc_jit_type : public gcc::jit
[all...]
H A Djit-result.c25 #include "jit-common.h"
26 #include "jit-logging.h"
27 #include "jit-result.h"
28 #include "jit-tempdir.h"
31 namespace jit {
33 /* Constructor for gcc::jit::result. */
44 /* gcc::jit::result's destructor.
56 so that the cleanup can be delayed (see PR jit/64206).
116 } // namespace gcc::jit
H A Djit-logging.c26 #include "jit-logging.h"
30 namespace jit {
32 /* Implementation of class gcc::jit::logger. */
34 /* The constructor for gcc::jit::logger, used by
49 /* The destructor for gcc::jit::logger, invoked via
60 /* Increment the reference count of the gcc::jit::logger. */
71 /* Decrement the reference count of the gcc::jit::logger,
138 /* Implementation of class gcc::jit::log_user. */
140 /* The constructor for gcc::jit::log_user. */
148 /* The destructor for gcc::jit
[all...]
H A Djit-common.h49 In order to allow jit objects to be usable outside of a compile
51 C API is implemented in terms of a gcc::jit::recording::context,
104 namespace jit { namespace in namespace:gcc
109 class builtins_manager; // declared within jit-builtins.h
204 } // namespace gcc::jit
H A Djit-playback.h28 #include "jit-recording.h"
32 namespace jit { namespace in namespace:gcc
49 context (::gcc::jit::recording::context *ctxt);
286 ::gcc::jit::recording::context *m_recording_ctxt;
337 the jit::context, since it needs to stay alive during post-processing
664 } // namespace gcc::jit::playback
668 } // namespace gcc::jit
H A Djit-builtins.h0 /* jit-builtins.h -- Handling of builtin functions during JIT-compilation.
23 #include "jit-common.h"
27 namespace jit { namespace in namespace:gcc
166 } // namespace jit
H A Djit-builtins.c0 /* jit-builtins.c -- Handling of builtin functions during JIT-compilation.
26 #include "jit-common.h"
27 #include "jit-builtins.h"
28 #include "jit-recording.h"
29 #include "jit-playback.h"
33 namespace jit {
135 /* Constructor for gcc::jit::builtins_manager. */
579 } // namespace jit
H A Djit-playback.c68 #include "jit-common.h"
69 #include "jit-logging.h"
70 #include "jit-playback.h"
71 #include "jit-result.h"
72 #include "jit-builtins.h"
73 #include "jit-tempdir.h"
76 /* gcc::jit::playback::context::build_cast uses the convert.h API,
87 gcc_assert (gcc::jit::active_playback_ctxt);
88 gcc::jit::active_playback_ctxt->add_error (NULL, "unhandled conversion");
97 namespace jit {
[all...]
H A Djit-recording.h24 #include "jit-common.h"
25 #include "jit-logging.h"
29 namespace jit { namespace in namespace:gcc
876 jit-recording.c. */
1634 return ::gcc::jit::recording::playback_location (r, m_loc);
1850 } // namespace gcc::jit::recording
1869 } // namespace gcc::jit
H A Djit-recording.c31 #include "jit-common.h"
32 #include "jit-builtins.h"
33 #include "jit-logging.h"
34 #include "jit-recording.h"
35 #include "jit-playback.h"
38 namespace jit {
122 /* Construct a gcc::jit::recording::location instance for the current
200 /* gcc::jit::reproducer is a subclass of gcc::jit::dump, used for
246 /* gcc::jit
[all...]
/haiku-buildtools/gcc/gcc/testsuite/jit.dg/
H A Djit.exp3 # We will compile each of jit.dg/test-*.c into an executable
24 # However, for us, ${tool} is "jit".
29 set tool jit
292 # C tests within the testsuite: gcc/testsuite/jit.dg/test-*.c
295 # C++ tests within the testsuite: gcc/testsuite/jit.dg/test-*.cc
300 set tests [concat $tests [find $srcdir/../jit/docs/examples *.c]]
301 set tests [concat $tests [find $srcdir/../jit/docs/examples *.cc]]
341 proc jit-expand-vars {arg} {
342 verbose "jit-expand-vars: $arg"
354 global jit
[all...]
/haiku-buildtools/gcc/maintainer-scripts/
H A Dupdate_web_docs_svn112 # Note that we have to preserve gcc/jit/docs since the jit docs are
113 # not .texi files (Makefile, .rst and .png), and the jit docs use
114 # include directives to pull in content from jit/jit-common.h and
115 # jit/notes.txt, so we have to preserve those also.
122 -o -path "gcc/gcc/jit/docs/*" \
123 -o -path "gcc/gcc/jit/jit-common.h" \
124 -o -path "gcc/gcc/jit/note
[all...]
/haiku-buildtools/gcc/gcc/testsuite/g++.dg/opt/
H A Dpr56999.C131 JITScript *jit = script->getJIT (constructing, barriers); local
132 if (!jit)
/haiku-buildtools/gcc/
H A Dconfigure14830 # PR jit/64780: Require the user to explicitly specify
14831 # --enable-host-shared if the jit is enabled, hinting
14833 # the jit, to avoid users from slowing down the rest of the
14834 # compiler by enabling the jit.
14837 *jit*)
14839 Enabling language \"jit\" requires --enable-host-shared.
14844 If you want to build both the jit and the regular compiler, it is often
/haiku-buildtools/binutils/
H A Dconfigure14898 # PR jit/64780: Require the user to explicitly specify
14899 # --enable-host-shared if the jit is enabled, hinting
14901 # the jit, to avoid users from slowing down the rest of the
14902 # compiler by enabling the jit.
14905 *jit*)
14907 Enabling language \"jit\" requires --enable-host-shared.
14912 If you want to build both the jit and the regular compiler, it is often

Completed in 155 milliseconds