| /openbsd-src/gnu/llvm/llvm/docs/HistoricalNotes/ |
| H A D | 2003-06-25-Reoptimizer1.txt | 6 We use opt to do Bytecode-to-bytecode instrumentation. Look at
14 exceeds a threshold, we identify a hot loop and perform second-level
16 target of the back-edge and the branch that causes the back-edge). We
23 We remove the first-level instrumentation by overwriting the CALL to
27 LLVM BasicBlock*s. We only keep track of paths that start at the
30 How do we keep track of which edges to instrument, and which edges are
41 3) Mark BBs which end in edges that exit the hot region; we need to
44 Assume that there is 1 free register. On SPARC we use %g1, which LLC
46 edge which corresponds to a conditional branch, we shift 0 for not
48 through the hot region. Silently fail if we need more than 64 bits.
[all …]
|
| /openbsd-src/gnu/llvm/llvm/docs/tutorial/MyFirstLanguageFrontend/ |
| H A D | LangImpl09.rst | 12 LLVM <index.html>`_" tutorial. In chapters 1 through 8, we've built a
19 source that the programmer wrote. In LLVM we generally use a format
23 The short summary of this chapter is that we'll go through the
27 Caveat: For now we can't debug via the JIT, so we'll need to compile
29 we'll make a few modifications to the running of the language and
30 how programs are compiled. This means that we'll have a source file
32 interactive JIT. It does involve a limitation that we can only
36 Here's the sample program we'll be compiling:
54 locations more difficult. In LLVM IR we keep the original source location
61 tutorial we're going to avoid optimization (as you'll see with one of the
[all …]
|
| H A D | LangImpl04.rst | 60 Well, that was easy :). In practice, we recommend always using
84 We'd really like to see this generate "``tmp = x+3; result = tmp*tmp;``"
121 For Kaleidoscope, we are currently generating functions on the fly, one
122 at a time, as the user types them in. We aren't shooting for the
123 ultimate optimization experience in this setting, but we also want to
124 catch the easy and quick stuff where possible. As such, we will choose
126 in. If we wanted to make a "static Kaleidoscope compiler", we would use
127 exactly the code we have now, except that we would defer running the
130 In order to get per-function optimizations going, we need to set up a
132 and organize the LLVM optimizations that we want to run. Once we have
[all …]
|
| H A D | LangImpl08.rst | 20 other architectures. In this tutorial, we'll target the current
23 To specify the architecture that you want to target, we use a string
28 As an example, we can see what clang thinks is our current target
39 Fortunately, we don't need to hard-code a target triple to target the
48 functionality. For example, if we're just using the JIT, we don't need
49 the assembly printers. Similarly, if we're only targeting certain
50 architectures, we can only link in the functionality for those
53 For this example, we'll initialize all the targets for emitting object
64 We can now use our target triple to get a ``Target``:
71 // Print an error and exit if we couldn't find the requested target.
[all …]
|
| H A D | LangImpl05.rst | 18 of "build that compiler", we'll extend Kaleidoscope to have an
30 Before we get going on "how" we add this extension, let's talk about
31 "what" we want. The basic idea is that we want to be able to write this
44 like any other. Since we're using a mostly functional form, we'll have
57 Now that we know what we "want", let's break this down into its
63 The lexer extensions are straightforward. First we add new enum values
73 Once we have that, we recognize the new keywords in the lexer. This is
94 To represent the new expression we add a new AST node for it:
115 Now that we have the relevant tokens coming from the lexer and we have
117 First we define a new parsing function:
[all …]
|
| /openbsd-src/gnu/llvm/llvm/lib/Target/WebAssembly/ |
| H A D | WebAssemblyExceptionInfo.cpp | 87 auto WE = std::make_unique<WebAssemblyException>(EHPad); in recalculate() local
88 discoverAndMapException(WE.get(), MDT, MDF); in recalculate()
89 Exceptions.push_back(std::move(WE)); in recalculate()
108 // We group exceptions in this analysis simply by including all BBs dominated in recalculate()
114 // Here we extract those unwind destinations from their (incorrect) parent in recalculate()
116 // children of the parent exception, so we have to traverse the parent chain. in recalculate()
118 // We should traverse BBs in the preorder of the dominator tree, because in recalculate()
121 // and A's unwind destination is B and B's is C. When we visit B before A, we in recalculate()
153 // subexception of Exception A, and we fix it by taking Exception B out of in recalculate()
158 // A because they were dominated by EHPad A. We fix this case by taking those in recalculate()
[all …]
|
| H A D | WebAssemblySortRegion.cpp | 19 const auto *WE = WEI.getExceptionFor(MBB); in getRegionFor() local
20 if (!ML && !WE) in getRegionFor()
22 // We determine subregion relationship by domination of their headers, i.e., in getRegionFor()
27 // dominated by its header. So here we should use in getRegionFor()
28 // WE->contains(ML->getHeader()), but not ML->contains(WE->getHeader()). in getRegionFor()
29 if ((ML && !WE) || (ML && WE && WE->contains(ML->getHeader()))) { in getRegionFor()
37 if (ExceptionMap.count(WE)) in getRegionFor()
38 return ExceptionMap[WE].get(); in getRegionFor()
39 ExceptionMap[WE] = in getRegionFor()
40 std::make_unique<ConcreteSortRegion<WebAssemblyException>>(WE); in getRegionFor()
[all …]
|
| /openbsd-src/gnu/llvm/llvm/docs/ |
| H A D | MergeFunctions.rst | 20 explains how we could combine equal functions correctly to keep the module
38 LLVM code fundamentals. In this article, we assume the reader is familiar with
44 We will use terms such as
85 Do we need to merge functions? The obvious answer is: Yes, that is quite a
86 possible case. We usually *do* have duplicates and it would be good to get rid
87 of them. But how do we detect duplicates? This is the idea: we split functions
89 we compare the "bricks" themselves, and then do our conclusions about functions
93 (let's assume we have only one address space), one function stores a 64-bit
95 mentioned above, and if functions are identical, except the parameter type (we
96 could consider it as a part of function type), then we can treat a ``uint64_t``
[all …]
|
| /openbsd-src/gnu/usr.bin/perl/pod/ |
| H A D | perlhacktut.pod | 35 How do we prepare to fix this up? First we locate the code in question
37 F<pp> files. Sure enough, C<pp_pack> is in F<pp.c>. Since we're going
43 Now let's look over C<pp_pack>: we take a pattern into C<pat>, and then
45 C<datum_type>. Then for each possible format character, we swallow up
50 How do we know if the C<U> is the first format in the C<pat>? Well, if
51 we have a pointer to the start of C<pat> then, if we see a C<U> we can
52 test whether we're still at the start of the string. So, here's where
62 We'll have another string pointer in there:
72 And just before we start the loop, we'll set C<patcopy> to be the start
81 Now if we see a C<U> which was at the start of the string, we turn on
[all …]
|
| H A D | perl5121delta.pod | 34 We fixed exporting of C<is_strict> and C<is_lax> from L<version>.
49 We upgraded L<CGI> to version 3.49 to incorporate fixes for regressions
50 introduced in the release we shipped with Perl 5.12.0.
54 We upgraded L<Pod::Simple> to version 3.14 to get an improvement to \C\<\< \>\>
59 We made a small fix to the L<CPANPLUS> test suite to fix an occasional spurious test failure.
63 We upgraded L<Safe> to version 2.27 to wrap coderefs returned by C<reval()> and C<rdo()>.
73 We added the new maintenance release policy to L<perlpolicy>
77 We've clarified the multiple-angle-bracket construct in the spec for POD
82 We added a missing explanation for a warning about C<:=> to L<perldiag>
86 We removed a false claim in L<perlunitut> that all text strings are Unicode strings in Perl.
[all …]
|
| /openbsd-src/bin/pax/ |
| H A D | buf_subs.c | 87 * does not specify a blocksize, we use the format default blocksize. in wr_start()
88 * We must be picky on writes, so we do not allow the user to create an in wr_start()
89 * archive that might be hard to read elsewhere. If all ok, we then in wr_start()
111 * we only allow wrblksz to be used with all archive operations in wr_start()
133 * leave space for the header pushback (see get_arc()). If we are in rd_start()
184 * position of the tape head) and the write point within the data we have
185 * stored in the read (soon to become write) buffer. We may have to move
190 * We first calculate which record has the first byte of the trailer. We
192 * up. We set the buffer write pointer to be at this byte (the byte where
193 * the trailer starts). We then move the OS file pointer back to the
[all …]
|
| H A D | ar_io.c | 74 static int can_unlnk = 0; /* do we unlink null archives? */
78 int force_one_volume; /* 1 if we ignore volume changes */
88 * Note: we may be called with name == NULL on the first open only.
183 * make sure beyond any doubt that we can unlink only regular files in ar_open()
184 * we created in ar_open()
189 * if we are writing, we are done in ar_open()
199 * On all new archive volumes, we shift to wrblksz (if the user in ar_open()
200 * specified one, otherwise we will continue to use rdblksz). We in ar_open()
210 * that support variable sized records, we must make large in ar_open()
211 * reads to make sure we get the entire record, otherwise we in ar_open()
[all …]
|
| /openbsd-src/gnu/usr.bin/perl/cpan/Test-Simple/t/Legacy/subtest/ |
| H A D | basic.t | 26 # Formatting may change if we're running under Test::Harness.
34 $tb->$ok( $_, "We're on $_" );
35 $tb->$diag("We ran $_");
40 $indented->$ok( 1, "We're on 1" );
41 $indented->$ok( 1, "We're on 2" );
42 $indented->$ok( 1, "We're on 3" );
46 $tb->$ok( $_, "We're on $_" );
51 ok 1 - We're on 1
52 # We ran 1
53 ok 2 - We're on 2
[all …]
|
| /openbsd-src/sys/uvm/ |
| H A D | uvm_vnode.c | 67 * we keep a list of writeable active vnode-backed VM objects for sync op.
68 * we keep a simpleq of vnodes that are currently being sync'd.
131 * => in fact, nothing should be locked so that we can sleep here.
144 /* if we're mapping a BLK device, make sure it is a disk. */ in uvn_attach()
160 * we can bump the reference count, check to see if we need to in uvn_attach()
165 /* regain vref if we were persisting */ in uvn_attach()
185 * block (due to I/O), so we want to unlock the object before calling. in uvn_attach()
186 * however, we want to keep anyone else from playing with the object in uvn_attach()
187 * while it is unlocked. to do this we se in uvn_attach()
[all...] |
| /openbsd-src/gnu/usr.bin/binutils/gdb/testsuite/gdb.base/ |
| H A D | watchpoint.c | 4 * Since using watchpoints can be very slow, we have to take some pains to
5 * ensure that we don't run too long with them enabled or we run the risk
6 * of having the test timeout. To help avoid this, we insert some marker
7 * functions in the execution stream so we can set breakpoints at known
9 * this file. We use null bodied functions are markers since gdb does
12 * One place we need is a marker for when we start executing our tests
13 * instructions rather than any process startup code, so we insert one
14 * right after entering main(). Another is right before we finish, before
15 * we start executing any process termination code.
17 * Another problem we have to guard against, at least for the test
[all …]
|
| /openbsd-src/gnu/llvm/clang/docs/analyzer/developer-docs/ |
| H A D | InitializerLists.rst | 14 I've seen a few false positives that appear because we construct
34 Ideally, we should be able to model the initializer list's methods precisely.
41 which would be of type ``T*`` and represent ``begin()``, so we'd trivially model ``begin()``
53 Approach (1): If only we enabled ``ProgramState::bindLoc(..., notifyChanges=true)``
57 conservative as the current patch's solution. Ideally, we do not want escapes to
58 happen so early. Instead, we'd prefer them to be delayed until the list itself
62 would be the right thing to do. Currently we didn't think about that because we
65 Approach (2): We could teach the Store to scan itself for bindings to
70 Approach (3): We could let checkers maintain the set of active metadata symbols
76 Approach (4): We could allow checkers to trigger pointer escapes in arbitrary
[all …]
|
| /openbsd-src/gnu/llvm/llvm/lib/Target/X86/ |
| H A D | X86SpeculativeLoadHardening.cpp | 143 // We mostly have one conditional branch, and in extremely rare cases have
235 // We have to insert the new block immediately after the current one as we in splitEdge()
236 // don't know what layout-successor relationships the successor has and we in splitEdge()
247 // we might have *broken* fallthrough and so need to inject a new in splitEdge()
257 // Update the unconditional branch now that we've added one. in splitEdge()
275 // If this is the only edge to the successor, we can just replace it in the in splitEdge()
276 // CFG. Otherwise we need to add a new entry in the CFG for the new in splitEdge()
324 /// FIXME: It's really frustrating that we have to do this, but SSA-form in MIR
325 /// isn't what you might expect. We may have multiple entries in PHI nodes for
326 /// a single predecessor. This makes CFG-updating extremely complex, so here we
[all …]
|
| /openbsd-src/gnu/usr.bin/gcc/gcc/ |
| H A D | tree-inline.c | 49 /* 0 if we should not perform inlining.
50 1 if we should expand functions calls inline at the tree level.
51 2 if we should consider *all* functions to be inline
58 o In order to make inlining-on-trees work, we pessimized
72 /* A stack of the functions we are inlining. For example, if we are
73 compiling `f', which calls `g', which calls `h', and we are
76 contain other functions that we know we should not recurse into,
89 /* Nonzero if we are currently within the cleanup for a
92 /* A stack of the TARGET_EXPRs that we are currently processing. */
96 /* The approximate number of statements we have inlined in the
[all …]
|
| /openbsd-src/lib/libkeynote/ |
| H A D | sample-app.c | 97 * Sample application. We do the following:
105 * Since this is a sample application, we won't be actually reading any
116 * We are creating a new KeyNote session here. A session may be temporary in main()
117 * (we create it, add policies, credentials, authorizers, action set, do in main()
118 * the query, and then we destroy it), or it may be persistent (if, for in main()
121 * In this example, we'll just assume the session is temporary, but there in main()
132 * Assume we have read a file, or somehow securely acquired our policy in main()
133 * assertions, and we have stored them in policy_assertions. in main()
136 /* Let's find how many policies we just "read". */ in main()
147 * we'll get a valid pointer back, which we need to free. Note that this in main()
[all …]
|
| /openbsd-src/gnu/llvm/lldb/source/Target/ |
| H A D | ThreadPlanStepOverRange.cpp | 98 // a step out, so we want to catch this case. in SetupAvoidNoDebug()
114 // It is okay to return to a different block of a straight function, we in IsEquivalentContext()
123 // Fall back to symbol if we have no decision from comp_unit/function/block. in IsEquivalentContext()
138 // If we're out of the range but in the same frame or in our caller's frame in ShouldStop()
139 // then we should stop. When stepping out we only stop others if we are in ShouldStop()
146 // If we're in an older frame then we should stop. in ShouldStop()
148 // A caveat to this is if we think the frame is older but we're actually in in ShouldStop()
151 // trampoline. So if we are in a trampoline we think the frame is older in ShouldStop()
152 // because the trampoline confused the backtracer. As below, we step in ShouldStop()
162 // Make sure we really are in a new frame. Do that by unwinding and seeing in ShouldStop()
[all …]
|
| /openbsd-src/gnu/usr.bin/perl/t/run/ |
| H A D | runenv_hashseed.t | 7 # We do this by first executing Perl with a given PERL_PERTURB_KEYS
12 # We do not ask perl to output any keys on this run, as our subsequent
14 # PERL_HASH_SEED) which will change any key order results we see.
16 # We then execute perl a further three times and ask perl to build a
17 # hash with a specific number of buckets and a specific set of keys. We
20 # For two of these three runs we supply the same seed, and both of those
21 # times we supply the same perturb mode, but in different ways, once as
28 # The third run we supply a different seed, with a 1 bit difference, but
29 # with the same PERL_PERTURB_KEYS mode. In this case we expect the key
31 # probabilistic and we may get the same key order in a small percentage
[all …]
|
| /openbsd-src/sys/dev/pci/drm/i915/ |
| H A D | i915_request.c | 73 * We could extend the life of a context to beyond that of all in i915_fence_get_timeline_name()
75 * or we just give them a false name. Since in i915_fence_get_timeline_name()
137 * freed when the slab cache itself is freed, and so we would get in i915_fence_release()
146 * We do not hold a reference to the engine here and so have to be in i915_fence_release()
147 * very careful in what rq->engine we poke. The virtual engine is in i915_fence_release()
148 * referenced via the rq->context and we released that ref during in i915_fence_release()
149 * i915_request_retire(), ergo we must not dereference a virtual in i915_fence_release()
150 * engine here. Not that we would want to, as the only consumer of in i915_fence_release()
155 * we know that it will have been processed by the HW and will in i915_fence_release()
161 * power-of-two we assume that rq->engine may still be a virtual in i915_fence_release()
[all …]
|
| /openbsd-src/gnu/llvm/llvm/lib/CodeGen/GlobalISel/ |
| H A D | RegBankSelect.cpp | 100 // We could preserve the information from these two analysis but in getAnalysisUsage()
113 // By default we assume we will have to repair something. in assignmentMatch()
142 assert(!NewVRegs.empty() && "We should not have to repair"); in repairReg()
146 // Assume we are repairing a use and thus, the original reg will be in repairReg()
151 // If we repair a definition, swap the source and destination for in repairReg()
157 "We are about to create several defs for Dst"); in repairReg()
214 // Check if MI is legal. if not, we need to legalize all the in repairReg()
215 // instructions we are going to insert. in repairReg()
238 assert(MO.isReg() && "We should only repair register operand"); in getRepairCost()
243 // If MO does not have a register bank, we should have just been in getRepairCost()
[all …]
|
| /openbsd-src/gnu/gcc/gcc/ |
| H A D | tree-ssa-threadupdate.c | 80 We further reduce the number of edges and statements we create by
82 step #1. We instead create a template block without the outgoing
91 To realize that implementation we create a list of incoming edges
93 #5 and #6 we traverse our hash table of outgoing edge information.
94 For each entry we walk the list of incoming edges which thread to
106 /* We need to efficiently record the unique thread destinations of this
107 block and specific information associated with those destinations. We
121 /* A list of incoming edges which we want to thread to
125 /* Flag indicating whether or not we should create a duplicate block
126 for this thread destination. This is only true if we are threading
[all …]
|
| /openbsd-src/sys/dev/usb/dwc2/ |
| H A D | dwc2_hcdqueue.c | 70 /* If we get a NAK, wait this long before retrying */
159 * @num_bits: The number of bits we need per period we want to reserve
161 * @interval: How often we need to be scheduled for the reservation this
165 * the interval or we return failure right away.
166 * @only_one_period: Normally we'll allow picking a start anywhere within the
167 * first interval, since we can still make all repetition
169 * here then we'll return failure if we can't fit within
172 * The idea here is that we want to schedule time for repeating events that all
177 * To keep things "simple", we'll represent our schedule with a bitmap that
179 * but does mean that we need to handle things specially (and non-ideally) if
[all …]
|