| /qemu/contrib/gitdm/ |
| H A D | filetypes.txt | 31 # ie. we want ltmain.sh -> 'build' instead of 'code'.
36 order build,interface,tests,code,documentation,devel-doc,blobs
40 # Code files (headers and the like included
43 filetype code \.c$ # C
44 filetype code \.c.inc$ # C
45 filetype code \.C$ # C++
46 filetype code \.cpp$ # C++
47 filetype code \.c\+\+$ # C++
48 filetype code \.cxx$ # C++
49 filetype code \.cc$ # C++
[all …]
|
| /qemu/tests/tcg/s390x/ |
| H A D | branch-relative-long.c | 20 const char *code; member
26 .code = brasl_r0,
30 .code = brcl_0xf,
42 size_t test_length = 0x100000000 + (tests[i].code_end - tests[i].code); in main()
58 void (*code)(void) = (void *)(buf + 0x100000000); in main() local
60 memcpy(code, tests[i].code, tests[i].code_end - tests[i].code); in main()
61 code(); in main()
62 memset(code, 0, tests[i].code_end - tests[i].code); in main()
|
| /qemu/docs/devel/ |
| H A D | multi-thread-tcg.rst | 41 In the general case of running translated code there should be no
53 Even when there is no code being generated there are a number of
61 As TB linking only occurs when blocks are in the same page this code
63 most common reason to exit the generated code.
71 are only taken when code generation is required or TranslationBlocks
80 We need to protect the entire code generation cycle including any post
81 generation patching of the translated code. This also implies a shared
82 translation buffer which contains code running on all cores. Any
84 mutex for code generation. This also includes times when we need flush
85 code or entries from any shared lookups/caches. Structures held on a
[all …]
|
| H A D | tcg.rst | 7 QEMU is a dynamic translator. When it first encounters a piece of code,
13 QEMU's dynamic translation backend is called TCG, for "Tiny Code
63 code address is returned, otherwise the address of the JIT epilogue is
71 The translation code usually implements branching by performing the
119 may change, causing the code at the destination address to change.
127 Self-modifying code and translated code invalidation
130 Self-modifying code is a special challenge in x86 emulation because no
131 instruction cache invalidation is signaled by the application when code
135 not already read-only) every time translated code is generated for a
137 a SEGV signal. QEMU then invalidates all the translated code in the page
[all …]
|
| H A D | style.rst | 35 * Tab indents push your code to the right, making your screen seriously
62 .. code-block:: c
77 .. code-block:: c
107 * Code and especially patches is much more readable if limited to a sane
131 Likewise, in device emulation code the common DeviceState is usually
174 .. code-block:: c
191 .. code-block:: c
210 .. code-block:: c
217 #ifdef or #ifndef block: if the code looks nicer, such declarations can
228 .. code-block:: c
[all …]
|
| H A D | multiple-iothreads.rst | 11 This document explains the ``IOThread`` feature and how to write code that runs
25 Side note: The main loop and ``IOThread`` are both event loops but their code is
38 to serialize execution of QEMU code. This mutex is necessary because a lot of
39 QEMU's code historically was not thread-safe.
53 The main difference between legacy code and new code that can run in an
55 (see ``include/block/aio.h``). Code that only works in the main loop
56 implicitly uses the main loop's ``AioContext``. Code that supports running
73 Since they implicitly work on the main loop they cannot be used in code that
93 ``qemu_get_aio_context()``. Code that takes an ``AioContext`` argument
120 This allows block layer code to process I/O inside the
[all …]
|
| H A D | control-flow-integrity.rst | 9 new and existing code in QEMU
19 function pointer declared in the source code.
22 the signature of every function and every function pointer used in the code.
57 Incompatible code with CFI
61 compile-time knowledge of the code. This means that, while generally supported
62 for most code, some specific use pattern can break CFI compatibility, and
65 * Just-in-time compiled code: since such code is created at runtime, the jump
66 to the buffer containing JIT code will fail.
82 5. Directly calling signal handlers from the QEMU source code, since the
97 * TCG creates binary blobs at runtime, with the transformed code.
[all …]
|
| H A D | uefi-vars.rst | 19 approach taken by physical hardware. Only privileged code running in
22 Communication with the firmware code running in SMM mode works by
24 mode via SMI. The SMM code processes the request, stores the reply in
30 Instead of running the privileged code inside the guest we can run it
46 complex code for SMM emulation from the linux kernel
51 attack surface of the host, and we are adding some code duplication
57 .. code::
65 .. code::
|
| H A D | code-of-conduct.rst | 3 Code of Conduct
43 This code of conduct applies to all spaces managed by the QEMU project.
46 community uses for communication. This code of conduct also applies
50 By adopting this code of conduct, project maintainers commit themselves
52 managing this project. If you believe someone is violating the code of
59 This document is based on the `Fedora Code of Conduct
60 <http://web.archive.org/web/20210429132536/https://docs.fedoraproject.org/en-US/project/code-of-con…
62 <https://www.contributor-covenant.org/version/1/3/0/code-of-conduct/>`__.
|
| H A D | rust.rst | 16 Building the Rust in QEMU code
19 The Rust in QEMU code is included in the emulators via Meson. Meson
21 together with the C code. This is completely automatic when you run
67 code. Note however that you cannot *build* or run tests via ``cargo``, because
68 they need support C code from QEMU that Cargo does not know about. Tests can
101 before QEMU can use them. For now, there is special code in
115 Writing Rust code in QEMU
120 * ``qemu_api`` for bindings to C code and useful functionality
123 writing C code
151 unsafe code; it might have soundness or type-safety issues
[all …]
|
| H A D | qom.rst | 35 .. code-block:: c
78 .. code-block:: c
106 .. code-block:: c
120 .. code-block:: c
145 .. code-block:: c
167 .. code-block:: c
234 .. code-block:: c
308 A lot of the code outlined above follows a standard pattern and naming
309 convention. To reduce the amount of boilerplate code that needs to be
318 .. code-block:: c
[all …]
|
| H A D | maintainers.rst | 29 patches that touch their area of code.
31 The file also describes the status of the area of code to give an idea
50 - Old obsolete code, should use something else.
54 the code comes with no warranty and the project makes no guarantees
63 is welcome to review code on the mailing list getting added to the
76 asked by others to keep an eye on an area of code. They have generally
77 demonstrated to the community, usually via contributions and code
84 series when a new sub-system is being added to the code base. This can
|
| H A D | secure-coding-practices.rst | 5 be aware of so that they can develop safe code and audit existing code
68 place when ``unit`` is dereferenced. The code must check that ``val`` is 0 or
74 moments. Device emulation code must not assume that the guest follows the
79 A related issue is that device emulation code must be prepared for unexpected
82 certain device registers. Device emulation code must handle the case where the
94 Live migration code must validate inputs when loading device state so an
101 Guests with multiple vCPUs may modify guest RAM while device emulation code is
102 running. Device emulation code must copy in descriptors and other guest RAM
|
| /qemu/tcg/tci/ |
| H A D | README | 7 TCG (Tiny Code Generator) is a code generator which translates
8 code fragments ("basic blocks") from target code (any of the
9 targets supported by QEMU) to a code representation which
12 QEMU can create native code for some hosts (arm, i386, ia64, ppc, ppc64,
15 By adding a code generator for a virtual machine and using an
19 This is what TCI (Tiny Code Interpreter) does.
23 Like each TCG host frontend, TCI implements the code generator in
41 additional code in configure which must be fixed when new native TCG
114 * Some TCG opcodes are either missing in the code generator and/or
116 possible to see where code must be added.
|
| H A D | tcg-target.h | 2 * Tiny Code Generator for QEMU
26 * This code implements a TCG which does not generate machine code for some
27 * real target machine but which generates virtual machine code for an
28 * interpreter. Interpreted pseudo code is slow, but it works on any host.
30 * Some remarks might help in understanding the code:
32 * "target" or "TCG target" is the machine which runs the generated code.
|
| /qemu/scripts/qapi/ |
| H A D | backend.py | 27 Generate code for the given schema into the target directory.
30 :param output_dir: The output directory to store generated code.
31 :param prefix: Optional C-code prefix for symbol names.
33 :param builtins: Generate code for built-in types?
50 Generate C code for the given schema into the target directory.
53 :param output_dir: The output directory to store generated code.
54 :param prefix: Optional C-code prefix for symbol names.
56 :param builtins: Generate code for built-in types?
|
| /qemu/roms/ |
| H A D | edk2-build.config | 31 # grub.efi uses EfiLoaderData for code
33 # shim.efi has broken MemAttr code
46 cpy1 = FV/OVMF_CODE.fd edk2-i386-code.fd
57 cpy1 = FV/OVMF_CODE.fd edk2-i386-secure-code.fd
69 cpy1 = FV/OVMF_CODE.fd edk2-x86_64-code.fd
79 cpy1 = FV/OVMF_CODE.fd edk2-x86_64-secure-code.fd
102 cpy1 = FV/QEMU_EFI.fd edk2-arm-code.fd
104 pad1 = edk2-arm-code.fd 64m
119 cpy1 = FV/QEMU_EFI.fd edk2-aarch64-code.fd
120 pad1 = edk2-aarch64-code.fd 64m
[all …]
|
| /qemu/target/hexagon/idef-parser/ |
| H A D | README.rst | 5 language into tinycode generator code, that can be easily integrated into QEMU.
16 .. code:: c
22 idef-parser will compile the above code into the following code:
24 .. code:: c
37 tinycode generator code, implementing the correct semantics. That function will
41 the architecture, integers representing the immediates that come from the code,
45 Let's begin by describing the input code. The ``add`` instruction is associated
62 Let's now observe the actual instruction description code, in this case:
64 .. code:: c
68 This code is composed by a subset of the C syntax, and is the result of the
[all …]
|
| /qemu/include/qemu/ |
| H A D | coroutine-tls.h | 19 * ..code-block:: c
34 * ..code-block:: c
55 * The compiler can still analyze noinline code and make optimizations based on
71 * .. code-block:: c
81 * equivalent to the following code:
83 * .. code-block:: c
105 * .. code-block:: c
111 * equivalent to the following code:
113 * .. code-block:: c
132 * .. code-block:: c
[all …]
|
| /qemu/pc-bios/ |
| H A D | meson.build | 4 'edk2-aarch64-code.fd',
5 'edk2-arm-code.fd',
7 'edk2-riscv-code.fd',
9 'edk2-i386-code.fd',
10 'edk2-i386-secure-code.fd',
12 'edk2-x86_64-code.fd',
13 'edk2-x86_64-secure-code.fd',
14 'edk2-loongarch64-code.fd',
|
| /qemu/docs/system/arm/ |
| H A D | orangepi.rst | 73 .. code-block:: bash
85 .. code-block:: bash
93 .. code-block:: bash
103 .. code-block:: bash
109 .. code-block:: bash
138 .. code-block:: bash
146 .. code-block:: bash
157 .. code-block:: bash
167 .. code-block:: bash
178 .. code-block:: bash
[all …]
|
| H A D | xlnx-versal-virt.rst | 75 .. code-block:: bash
88 .. code-block:: bash
101 .. code-block:: bash
114 .. code-block:: bash
126 .. code-block:: bash
139 .. code-block:: bash
154 .. code-block:: bash
168 .. code-block:: bash
192 .. code-block:: bash
198 .. code-block:: bash
[all …]
|
| /qemu/tests/qemu-iotests/tests/ |
| H A D | qemu-img-close-errors.out | 7 qemu-img commit exit code: 0
8 qemu-img bitmap --add exit code: 0
12 qemu-img bitmap --merge exit code: 1
20 qemu-img commit exit code: 1
21 qemu-img bitmap --add exit code: 0
22 qemu-img bitmap --merge exit code: 0
|
| /qemu/docs/system/riscv/ |
| H A D | virt.rst | 60 S-mode firmware code. It can be configured as read-only, with the
65 .. code-block:: bash
77 .. code-block:: bash
93 .. code-block:: bash
99 .. code-block:: bash
156 .. code-block:: bash
165 .. code-block:: bash
177 .. code-block:: bash
197 .. code-block:: bash
204 .. code-block:: bash
[all …]
|
| /qemu/target/hexagon/ |
| H A D | README | 13 …wc/qemu-hexagon-automatic-translation-of-the-isa-manual-pseudcode-to-tiny-code-instructions-of-a-v…
15 *** Tour of the code ***
19 Hexagon-specific code are
32 produces a C function generating equivalent tiny code instructions.
104 TCG code instead of a call to the helper. If defined, the macro takes 1
106 C semantics (aka short code)
108 This allows the code generator to override the auto-generated code. In some
117 The instruction semantics C code relies heavily on macros. In cases where the
119 the short semantics option and #define the macros to generate TCG code. One
129 There are also cases where we brute force the TCG code generation.
[all …]
|