| blob | 24dfee128698a8ace1ad70d80932663126be0af7 |
1 ;;;; scheduling assembler
3 ;;;; This software is part of the SBCL system. See the README file for
4 ;;;; more information.
5 ;;;;
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
13 \f
14 ;;;; assembly control parameters
24 \f
25 ;;;; the SEGMENT structure
27 ;;; This structure holds the state of the assembler.
29 ;; the name of this segment (for debugging output and stuff)
31 ;; Ordinarily this is a vector where instructions are written. If
32 ;; the segment is made invalid (e.g. by APPEND-SEGMENT) then the
33 ;; vector can be replaced by NIL. This used to be an adjustable
34 ;; array, but we now do the array size management manually for
35 ;; performance reasons (as of 2006-05-13 hairy array operations
36 ;; are rather slow compared to simple ones).
39 ;; whether or not to run the scheduler. Note: if the instruction
40 ;; definitions were not compiled with the scheduler turned on, this
41 ;; has no effect.
43 ;; If a function, then this is funcalled for each inst emitted with
44 ;; the segment, the VOP, the name of the inst (as a string), and the
45 ;; inst arguments.
47 ;; what position does this correspond to? Initially, positions and
48 ;; indexes are the same, but after we start collapsing choosers,
49 ;; positions can change while indexes stay the same.
52 ;; a list of all the annotations that have been output to this segment
54 ;; a pointer to the last cons cell in the annotations list. This is
55 ;; so we can quickly add things to the end of the annotations list.
57 ;; the number of bits of alignment at the last time we synchronized
59 ;; the position the last time we synchronized
61 ;; The posn and index everything ends at. This is not maintained
62 ;; while the data is being generated, but is filled in after.
63 ;; Basically, we copy CURRENT-POSN and CURRENT-INDEX so that we can
64 ;; trash them while processing choosers and back-patches.
67 ;; *** State used by the scheduler during instruction queueing.
68 ;;
69 ;; a list of postits. These are accumulated between instructions.
71 ;; ``Number'' for last instruction queued. Used only to supply insts
72 ;; with unique sset-element-number's.
74 ;; SIMPLE-VECTORs mapping locations to the instruction that reads them and
75 ;; instructions that write them
80 ;; The number of additional cycles before the next control transfer,
81 ;; or NIL if a control transfer hasn't been queued. When a delayed
82 ;; branch is queued, this slot is set to the delay count.
84 ;; *** These two slots are used both by the queuing noise and the
85 ;; scheduling noise.
86 ;;
87 ;; All the instructions that are pending and don't have any
88 ;; unresolved dependents. We don't list branches here even if they
89 ;; would otherwise qualify. They are listed above.
91 ;; list of queued branches. We handle these specially, because they
92 ;; have to be emitted at a specific place (e.g. one slot before the
93 ;; end of the block).
95 ;; *** state used by the scheduler during instruction scheduling
96 ;;
97 ;; the instructions who would have had a read dependent removed if
98 ;; it were not for a delay slot. This is a list of lists. Each
99 ;; element in the top level list corresponds to yet another cycle of
100 ;; delay. Each element in the second level lists is a dotted pair,
101 ;; holding the dependency instruction and the dependent to remove.
103 ;; The emittable insts again, except this time as a list sorted by depth.
105 ;; Whether or not to collect dynamic statistics. This is just the same as
106 ;; *COLLECT-DYNAMIC-STATISTICS* but is faster to reference.
107 #!+sb-dyncount
110 name)
119 ;; FIXME: It would be lovely to enforce this, but first FILL-IN will
120 ;; need to be convinced to stop rolling SEGMENT-CURRENT-INDEX
121 ;; backwards.
122 ;;
123 ;; Enforce an observed regularity which makes it easier to think
124 ;; about what's going on in the (legacy) code: The segment never
125 ;; shrinks. -- WHN the reverse engineer
131 ;; Make sure the array is big enough.
135 ;; When we have to increase the size of the array, we want to
136 ;; roughly double the vector length: that way growing the array
137 ;; to size N conses only O(N) bytes in total. But just doubling
138 ;; the length would leave a zero-length vector unchanged. Hence,
139 ;; take the MAX with 1..
145 ;; Now that the array has the intended next free byte, we can point to it.
148 ;;; Various functions (like BACK-PATCH-FUN or CHOOSER-WORST-CASE-FUN)
149 ;;; aren't cleanly parameterized, but instead use
150 ;;; SEGMENT-CURRENT-INDEX and/or SEGMENT-CURRENT-POSN as global
151 ;;; variables. So code which calls such functions needs to modify
152 ;;; SEGMENT-CURRENT-INDEX and SEGMENT-CURRENT-POSN. This is left over
153 ;;; from the old new-assem.lisp C-style code, and so all the
154 ;;; destruction happens to be done after other uses of these slots are
155 ;;; done and things basically work. However, (1) it's fundamentally
156 ;;; nasty, and (2) at least one thing doesn't work right: OpenMCL
157 ;;; properly points out that SUBSEQ's indices aren't supposed to
158 ;;; exceed its logical LENGTH, i.e. its FILL-POINTER, i.e.
159 ;;; SEGMENT-CURRENT-INDEX.
160 ;;;
161 ;;; As a quick fix involving minimal modification of legacy code,
162 ;;; we do such sets of SEGMENT-CURRENT-INDEX and SEGMENT-CURRENT-POSN
163 ;;; using this macro, which restores 'em afterwards.
164 ;;;
165 ;;; FIXME: It'd probably be better to cleanly parameterize things like
166 ;;; BACK-PATCH-FUN so we can avoid this nastiness altogether.
180 \f
181 ;;;; structures/types used by the scheduler
183 (!def-boolean-attribute instruction
184 ;; This attribute is set if the scheduler can freely flush this
185 ;; instruction if it thinks it is not needed. Examples are NOP and
186 ;; instructions that have no side effect not described by the
187 ;; writes.
188 flushable
189 ;; This attribute is set when an instruction can cause a control
190 ;; transfer. For test instructions, the delay is used to determine
191 ;; how many instructions follow the branch.
192 branch
193 ;; This attribute indicates that this ``instruction'' can be
194 ;; variable length, and therefore had better never be used in a
195 ;; branch delay slot.
196 variable-length)
203 ;; The function to envoke to actually emit this instruction. Gets called
204 ;; with the segment as its one argument.
206 ;; The attributes of this instruction.
208 ;; Number of instructions or cycles of delay before additional
209 ;; instructions can read our writes.
211 ;; the maximum number of instructions in the longest dependency
212 ;; chain from this instruction to one of the independent
213 ;; instructions. This is used as a heuristic at to which
214 ;; instructions should be scheduled first.
216 ;; Note: When trying remember which of the next four is which, note
217 ;; that the ``read'' or ``write'' always refers to the dependent
218 ;; (second) instruction.
219 ;;
220 ;; instructions whose writes this instruction tries to read
222 ;; instructions whose writes or reads are overwritten by this instruction
224 ;; instructions which write what we read or write
226 ;; instructions which read what we write
232 #!+sb-show-assem
236 stream)
244 name)
249 #!+sb-show-assem
253 \f
254 ;;;; the scheduler itself
258 #!+sb-doc
259 "Execute BODY (as a PROGN) without scheduling any of the instructions
260 generated inside it. This is not protected by UNWIND-PROTECT, so
261 DO NOT use THROW or RETURN-FROM to escape from it."
262 ;; FIXME: Why not just use UNWIND-PROTECT? Or is there some other
263 ;; reason why we shouldn't use THROW or RETURN-FROM?
271 ,@body
285 "~&~S reads ~S[~W for ~W]~%"
286 inst read loc-num size)
288 ;; Iterate over all the locations for this TN.
295 ;; The inst that wrote the value we want to read must have
296 ;; completed.
301 ;; And it must have been completed *after* all other
302 ;; writes to that location. Actually, that isn't quite
303 ;; true. Each of the earlier writes could be done
304 ;; either before this last write, or after the read, but
305 ;; we have no way of representing that.
311 ;; And we don't need to remember about earlier writes any
312 ;; more. Shortening the writers list means that we won't
313 ;; bother generating as many explicit arcs in the graph.
322 "~&~S writes ~S[~W for ~W]~%"
323 inst write loc-num size)
325 ;; Iterate over all the locations for this TN.
330 ;; All previous reads of this location must have completed.
337 ;; All previous writes to the location must have completed.
342 ;; And we can forget about remembering them, because
343 ;; depending on us is as good as depending on them.
348 ;;; This routine is called by due to uses of the INST macro when the
349 ;;; scheduler is turned on. The change to the dependency graph has
350 ;;; already been computed, so we just have to check to see whether the
351 ;;; basic block is terminated.
355 " reads ~S~% writes ~S~%"
371 variable-length))))
385 ;;; Emit all the pending instructions, and reset any state. This is
386 ;;; called whenever we hit a label (i.e. an entry point of some kind)
387 ;;; and when the user turns the scheduler off (otherwise, the queued
388 ;;; instructions would sit there until the scheduler was turned back
389 ;;; on, and emitted in the wrong place).
393 ;; Quick blow-out if nothing to do.
402 ;; Note that any values live at the end of the block have to be
403 ;; computed last.
417 ;; If the value is live at the end of the block, we can't flush it.
419 nil)))))
421 ;; Grovel through the entire graph in the forward direction finding
422 ;; all the leaf instructions.
437 flushable))
439 "flushing ~S~%"
440 inst)
459 "queued branches: ~S~%"
462 "initially emittable: ~S~%"
465 "initially delayed: ~S~%"
468 ;; Accumulate the results in reverse order. Well, actually, this
469 ;; list will be in forward order, because we are generating the
470 ;; reverse order in reverse.
473 ;; Schedule all the branches in their exact locations.
478 ;; Each time through this loop we need to emit another
479 ;; instruction. First, we check to see whether there is
480 ;; any instruction that must be emitted before (i.e. must
481 ;; come after) the branch inst. If so, emit it. Otherwise,
482 ;; just pick one of the emittable insts. If there is
483 ;; nothing to do, then emit a nop. ### Note: despite the
484 ;; fact that this is a loop, it really won't work for
485 ;; repetitions other then zero and one. For example, if
486 ;; the branch has two dependents and one of them dpends on
487 ;; the other, then the stuff that grabs a dependent could
488 ;; easily grab the wrong one. But I don't feel like fixing
489 ;; this because it doesn't matter for any of the
490 ;; architectures we are using or plan on using.
493 ;; If do-sset-elements enters the body, then there is a
494 ;; dependent. Emit it.
496 ;; Remove it from the emittable insts.
501 ;; And if it was delayed, removed it from the delayed
502 ;; list. This can happen if there is a load in a
503 ;; branch delay slot.
516 ;; And return it.
525 "filling branch delay slot with ~S~%"
526 fill)
535 ;; Keep scheduling stuff until we run out.
543 ;; Now call the emitters, but turn the scheduler off for the duration.
551 ;; Clear out any residue left over.
559 ;; That's all, folks.
562 ;;; a utility for maintaining the segment-delayed list. We cdr down
563 ;;; list n times (extending it if necessary) and then push thing on
564 ;;; into the car of that cons cell.
571 list)))
573 ;;; Find the next instruction to schedule and return it after updating
574 ;;; any dependency information. If we can't do anything useful right
575 ;;; now, but there is more work to be done, return :NOP to indicate
576 ;;; that a nop must be emitted. If we are all done, return NIL.
584 variable-length))
585 ;; We've got us a live one here. Go for it.
587 ;; Delete it from the list of insts.
592 ;; Note that this inst has been emitted.
594 ;; And return.
596 ;; Are we wanting to flush this instruction?
598 ;; Nope, it's still a go. So return it.
599 inst
600 ;; Yes, so pick a new one. We have to start
601 ;; over, because note-resolved-dependencies
602 ;; might have changed the emittable-insts-queue.
604 ;; Nothing to do, so make something up.
606 ;; No emittable instructions, but we have more work to do. Emit
607 ;; a NOP to fill in a delay slot.
611 ;; All done.
612 nil)))
614 ;;; This function is called whenever an instruction has been
615 ;;; scheduled, and we want to know what possibilities that opens up.
616 ;;; So look at all the instructions that this one depends on, and
617 ;;; remove this instruction from their dependents list. If we were the
618 ;;; last dependent, then that dependency can be emitted now.
623 ;; These are the instructions who have to be completed before our
624 ;; write fires. Doesn't matter how far before, just before.
631 ;; These are the instructions who write values we read. If there
632 ;; is no delay, then just remove us from the dependent list.
633 ;; Otherwise, record the fact that in n cycles, we should be
634 ;; removed.
647 ;;; Process the next entry in segment-delayed. This is called whenever
648 ;;; anyone emits an instruction.
662 ;;; Note that inst is emittable by sticking it in the
663 ;;; SEGMENT-EMITTABLE-INSTS-QUEUE list. We keep the emittable-insts
664 ;;; sorted with the largest ``depths'' first. Except that if INST is a
665 ;;; branch, don't bother. It will be handled correctly by the branch
666 ;;; emitting code in SCHEDULE-PENDING-INSTRUCTIONS.
679 \f
680 ;;;; structure used during output emission
682 ;;; common supertype for all the different kinds of annotations
685 ;; Where in the raw output stream was this annotation emitted?
687 ;; What position does that correspond to?
693 ;; (doesn't need any additional information beyond what is in the
694 ;; annotation structure)
695 )
702 ;;; a constraint on how the output stream must be aligned
708 ;; the minimum number of low-order bits that must be zero
710 ;; the amount of filler we are assuming this alignment op will take
712 ;; the byte used as filling
715 ;;; a reference to someplace that needs to be back-patched when
716 ;;; we actually know what label positions, etc. are
720 ;; the area affected by this back-patch
722 ;; the function to use to generate the real data
725 ;;; This is similar to a BACK-PATCH, but also an indication that the
726 ;;; amount of stuff output depends on label positions, etc.
727 ;;; BACK-PATCHes can't change their mind about how much stuff to emit,
728 ;;; but CHOOSERs can.
730 (:constructor make-chooser
733 ;; the worst case size for this chooser. There is this much space
734 ;; allocated in the output buffer.
736 ;; the worst case alignment this chooser is guaranteed to preserve
738 ;; the function to call to determine if we can use a shorter
739 ;; sequence. It returns NIL if nothing shorter can be used, or emits
740 ;; that sequence and returns T.
742 ;; the function to call to generate the worst case sequence. This is
743 ;; used when nothing else can be condensed.
746 ;;; This is used internally when we figure out a chooser or alignment
747 ;;; doesn't really need as much space as we initially gave it.
751 ;; the number of bytes of filler here
753 \f
754 ;;;; output functions
756 ;;; interface: Emit the supplied BYTE to SEGMENT, growing SEGMENT if
757 ;;; necessary.
768 ;;; interface: Output AMOUNT copies of FILL-BYTE to SEGMENT.
776 ;;; This is used to handle the common parts of annotation emission. We
777 ;;; just assign the POSN and INDEX of NOTE and tack it on to the end
778 ;;; of SEGMENT's annotations list.
794 ;;; Note that the instruction stream has to be back-patched when label
795 ;;; positions are finally known. SIZE bytes are reserved in SEGMENT,
796 ;;; and function will be called with two arguments: the segment and
797 ;;; the position. The function should look at the position and the
798 ;;; position of any labels it wants to and emit the correct sequence.
799 ;;; (And it better be the same size as SIZE). SIZE can be zero, which
800 ;;; is useful if you just want to find out where things ended up.
805 ;;; Note that the instruction stream here depends on the actual
806 ;;; positions of various labels, so can't be output until label
807 ;;; positions are known. Space is made in SEGMENT for at least SIZE
808 ;;; bytes. When all output has been generated, the MAYBE-SHRINK
809 ;;; functions for all choosers are called with three arguments: the
810 ;;; segment, the position, and a magic value. The MAYBE-SHRINK
811 ;;; decides if it can use a shorter sequence, and if so, emits that
812 ;;; sequence to the segment and returns T. If it can't do better than
813 ;;; the worst case, it should return NIL (without emitting anything).
814 ;;; When calling LABEL-POSITION, it should pass it the position and
815 ;;; the magic-value it was passed so that LABEL-POSITION can return
816 ;;; the correct result. If the chooser never decides to use a shorter
817 ;;; sequence, the WORST-CASE-FUN will be called, just like a
818 ;;; BACK-PATCH. (See EMIT-BACK-PATCH.)
827 ;;; This is called in EMIT-CHOOSER and COMPRESS-SEGMENT in order to
828 ;;; recompute the current alignment information in light of this
829 ;;; chooser. If the alignment guaranteed by the chooser is less than
830 ;;; the segment's current alignment, we have to adjust the segment's
831 ;;; notion of the current alignment.
832 ;;;
833 ;;; The hard part is recomputing the sync posn, because it's not just
834 ;;; the chooser's posn. Consider a chooser that emits either one or
835 ;;; three words. It preserves 8-byte (3 bit) alignments, because the
836 ;;; difference between the two choices is 8 bytes.
842 ;; The chooser might change the alignment of the output. So we
843 ;; have to figure out what the worst case alignment could be.
852 ;;; This is used internally whenever a chooser or alignment decides it
853 ;;; doesn't need as much space as it originally thought.
864 ;;; EMIT-LABEL (the interface) basically just expands into this,
865 ;;; supplying the SEGMENT and VOP.
878 ;;; Called by the ALIGN macro to emit an alignment note. We check to
879 ;;; see if we can guarantee the alignment restriction by just
880 ;;; outputting a fixed number of bytes. If so, we do so. Otherwise, we
881 ;;; create and emit an alignment note.
892 ;; We need more bits of alignment. First emit enough noise
893 ;; to get back in sync with alignment, and then emit an
894 ;; alignment note to cover the rest.
906 ;; The last alignment was more restrictive then this one.
907 ;; So we can just figure out how much noise to emit
908 ;; assuming the last alignment was met.
912 ;; But we emit an alignment with size=0 so we can verify
913 ;; that everything works.
917 ;;; This is used to find how ``aligned'' different offsets are.
918 ;;; Returns the number of low-order 0 bits, up to MAX-ALIGNMENT.
924 ;;; Emit a postit. The function will be called as a back-patch with
925 ;;; the position the following instruction is finally emitted. Postits
926 ;;; do not interfere at all with scheduling.
930 \f
931 ;;;; output compression/position assignment stuff
933 ;;; Grovel though all the annotations looking for choosers. When we
934 ;;; find a chooser, invoke the maybe-shrink function. If it returns T,
935 ;;; it output some other byte sequence.
953 posn)
957 ;; It emitted some replacement.
963 note new-size old-size))
968 preserves ~W bits of alignment."
978 ;; The chooser passed on shrinking. Make sure it didn't
979 ;; emit anything.
983 note
986 ;; Act like we just emitted this chooser.
990 ;; Adjust the alignment accordingly.
992 ;; And keep this chooser for next time around.
996 ;; Re-emit the alignment, letting it collapse if we know
997 ;; anything more about the alignment guarantees of the
998 ;; segment.
1010 and is ~W now."
1011 note old-size size))
1027 ;;; We have run all the choosers we can, so now we have to figure out
1028 ;;; exactly how much space each alignment note needs.
1051 posn)
1065 ;;; Grovel over segment, filling in any backpatches. If any choosers
1066 ;;; are left over, we need to emit their worst case variant.
1082 note new-size old-size)))
1096 \f
1097 ;;;; interface to the rest of the compiler
1099 ;;; This holds the current segment while assembling. Use ASSEMBLE to
1100 ;;; change it.
1101 ;;;
1102 ;;; The double asterisks in the name are intended to suggest that this
1103 ;;; isn't just any old special variable, it's an extra-special
1104 ;;; variable, because sometimes MACROLET is used to bind it. So be
1105 ;;; careful out there..
1106 ;;;
1107 ;;; (This used to be called **CURRENT-SEGMENT** in SBCL until 0.7.3,
1108 ;;; and just *CURRENT-SEGMENT* in CMU CL. In both cases, the rebinding
1109 ;;; now done with MACROLET was done with SYMBOL-MACROLET instead. The
1110 ;;; rename-with-double-asterisks was because the SYMBOL-MACROLET made
1111 ;;; it an extra-special variable. The change over to
1112 ;;; %%CURRENT-SEGMENT%% was because ANSI forbids the use of
1113 ;;; SYMBOL-MACROLET on special variable names, and CLISP correctly
1114 ;;; complains about this when being used as a bootstrap host.)
1118 ;;; Just like %%CURRENT-SEGMENT%%, except this holds the current vop.
1119 ;;; This is used only to keep track of which vops emit which insts.
1120 ;;;
1121 ;;; The double asterisks in the name are intended to suggest that this
1122 ;;; isn't just any old special variable, it's an extra-special
1123 ;;; variable, because sometimes MACROLET is used to bind it. So be
1124 ;;; careful out there..
1128 ;;; We also MACROLET %%CURRENT-SEGMENT%% to a local holding the
1129 ;;; segment so uses of %%CURRENT-SEGMENT%% inside the body don't have
1130 ;;; to keep dereferencing the symbol. Given that ASSEMBLE is the only
1131 ;;; interface to **CURRENT-SEGMENT**, we don't have to worry about the
1132 ;;; special value becomming out of sync with the lexical value. Unless
1133 ;;; some bozo closes over it, but nobody does anything like that...
1134 ;;;
1135 ;;; FIXME: The way this macro uses MACROEXPAND internally breaks my
1136 ;;; old assumptions about macros which are needed both in the host and
1137 ;;; the target. (This is more or less the same way that PUSH-IN,
1138 ;;; DELETEF-IN, and !DEF-BOOLEAN-ATTRIBUTE break my old assumptions,
1139 ;;; except that they used GET-SETF-EXPANSION instead of MACROEXPAND to
1140 ;;; do the dirty deed.) The quick and dirty "solution" here is the
1141 ;;; same as there: use cut and paste to duplicate the defmacro in a
1142 ;;; (SB!INT:DEF!MACRO FOO (..) .. CL:MACROEXPAND ..) #+SB-XC-HOST
1143 ;;; (DEFMACRO FOO (..) .. SB!XC:MACROEXPAND ..) idiom. This is
1144 ;;; disgusting and unmaintainable, and there are obviously better
1145 ;;; solutions and maybe even good solutions, but I'm disinclined to
1146 ;;; hunt for good solutions until the system works and I can test them
1147 ;;; in isolation.
1150 #!+sb-doc
1151 "Execute BODY (as a progn) with SEGMENT as the current segment."
1163 inherited-labels)))
1165 visible-labels)))
1177 new-labels))
1179 ;; Must be done so that contribs and user code doing
1180 ;; low-level stuff don't need to worry about this.
1184 ;; KLUDGE: Some host lisps (CMUCL 18e Sparc at least)
1185 ;; can't deal with this declaration, so disable it on host.
1186 ;; Ditto for later ENABLE-PACKAGE-LOCKS %%C-S%% declaration.
1187 #-sb-xc-host
1194 form))
1195 body)))))))
1196 #+sb-xc-host
1198 &body body
1200 #!+sb-doc
1201 "Execute BODY (as a progn) with SEGMENT as the current segment."
1214 inherited-labels)))
1216 visible-labels)))
1228 new-labels))
1237 form))
1238 body)))))))
1241 #!+sb-doc
1242 "Emit the specified instruction to the current segment."
1251 ;;; Note: The need to capture MACROLET bindings of %%CURRENT-SEGMENT%%
1252 ;;; and %%CURRENT-VOP%% prevents this from being an ordinary function.
1254 #!+sb-doc
1255 "Emit LABEL at this location in the current segment."
1258 ;;; Note: The need to capture MACROLET bindings of
1259 ;;; %%CURRENT-SEGMENT%% prevents this from being an ordinary function.
1263 ;;; Note: The need to capture SYMBOL-MACROLET bindings of
1264 ;;; **CURRENT-SEGMENT* and (%%CURRENT-VOP%%) prevents this from being an
1265 ;;; ordinary function.
1267 #!+sb-doc
1268 "Emit an alignment restriction to the current segment."
1270 ;;; FIXME: By analogy with EMIT-LABEL and EMIT-POSTIT, this should be
1271 ;;; called EMIT-ALIGNMENT, and the function that it calls should be
1272 ;;; called %EMIT-ALIGNMENT.
1275 #!+sb-doc
1276 "Return the current position for LABEL. Chooser maybe-shrink functions
1277 should supply IF-AFTER and DELTA in order to ensure correct results."
1281 posn)))
1284 #!+sb-doc
1285 "Append OTHER-SEGMENT to the end of SEGMENT. Don't use OTHER-SEGMENT
1286 for anything after this."
1309 ;; This SEGMENT-LAST-ANNOTATION code is confusing. Is it really
1310 ;; worth enough in efficiency to justify it? -- WHN 19990322
1320 #!+sb-doc
1321 "Do any final processing of SEGMENT and return the total number of bytes
1322 covered by this segment."
1338 ;;; Call FUNCTION on all the stuff accumulated in SEGMENT. FUNCTION
1339 ;;; should accept a single vector argument. It will be called zero or
1340 ;;; more times on vectors of the appropriate byte type. The
1341 ;;; concatenation of the vector arguments from all the calls is the
1342 ;;; contents of SEGMENT.
1343 ;;;
1344 ;;; KLUDGE: This implementation is sort of slow and gross, calling
1345 ;;; FUNCTION repeatedly and consing a fresh vector for its argument
1346 ;;; each time. It might be possible to make a more efficient version
1347 ;;; by making FINALIZE-SEGMENT do all the compacting currently done by
1348 ;;; this function: then this function could become trivial and fast,
1349 ;;; calling FUNCTION once on the entire compacted segment buffer. --
1350 ;;; WHN 19990322
1367 ;;; Write the code accumulated in SEGMENT to STREAM, and return the
1368 ;;; number of bytes written.
1377 result))
1378 \f
1379 ;;;; interface to the instruction set definition
1381 ;;; Define a function named NAME that merges its arguments into a
1382 ;;; single integer and then emits the bytes of that integer in the
1383 ;;; correct order based on the endianness of the target-backend.
1392 total-bits assembly-unit-bits))
1393 quo))
1403 extends past the end."
1404 byte-spec-expr))
1413 assembly-unit-bits)))
1416 expr
1422 offset)
1428 offset)
1436 offset))
1440 assembly-unit-bits)))
1443 assembly-unit-bits
1444 len)
1447 offset))
1460 forms)))
1487 (&optional
1499 name)
1501 (&key
1516 (&rest
1519 param))))))))
1522 segment-name
1523 vop-var
1524 reconstructor))))))
1531 list-of-lists)))
1532 list-of-lists-of-lists))
1556 (:emitter
1560 (:declare
1562 (:attributes
1564 (:cost
1566 (:dependencies
1568 (:delay
1572 (:pinned
1574 (:vop-var
1578 (:printer
1582 name
1585 pdefs))
1586 (:printer-list
1587 ;; same as :PRINTER, but is EVALed first, and is a list of
1588 ;; printers
1595 ',name
1597 printer
1598 nil)))
1600 pdefs))
1613 emitter)
1616 emitter)
1618 #!+sb-dyncount
1628 emitter)
1645 #',flet-name
1660 ;; Must be done so that contribs and user code doing
1661 ;; low-level stuff don't need to worry about this.
1667 ;; KLUDGE: Some host lisps (CMUCL 18e Sparc at least)
1668 ;; can't deal with this declaration, so disable it on host
1669 ;; Ditto for earlier ENABLE-PACKAGE-LOCKS %%C-S%% %%C-V%%
1670 ;; declaration.
1671 #-sb-xc-host
1680 ',name
1687 'instruction-macro
1692 ,@local-defs
1698 name)