| blob | 7323065d94ee46b996e259e7f2e563a793ccaffa |
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
23 \f
24 ;;;; the SEGMENT structure
26 ;;; This structure holds the state of the assembler.
28 ;; the type of this segment (for debugging output and stuff)
30 ;; Ordinarily this is a vector where instructions are written. If
31 ;; the segment is made invalid (e.g. by APPEND-SEGMENT) then the
32 ;; vector can be replaced by NIL. This used to be an adjustable
33 ;; array, but we now do the array size management manually for
34 ;; performance reasons (as of 2006-05-13 hairy array operations
35 ;; are rather slow compared to simple ones).
38 ;; whether or not to run the scheduler. Note: if the instruction
39 ;; definitions were not compiled with the scheduler turned on, this
40 ;; has no effect.
42 ;; If a function, then this is funcalled for each inst emitted with
43 ;; the segment, the VOP, the name of the inst (as a string), and the
44 ;; inst arguments.
46 ;; what position does this correspond to? Initially, positions and
47 ;; indexes are the same, but after we start collapsing choosers,
48 ;; positions can change while indexes stay the same.
51 ;; a list of all the annotations that have been output to this segment
53 ;; a pointer to the last cons cell in the annotations list. This is
54 ;; so we can quickly add things to the end of the annotations list.
56 ;; the number of bits of alignment at the last time we synchronized
58 ;; the position the last time we synchronized
60 ;; The posn and index everything ends at. This is not maintained
61 ;; while the data is being generated, but is filled in after.
62 ;; Basically, we copy CURRENT-POSN and CURRENT-INDEX so that we can
63 ;; trash them while processing choosers and back-patches.
66 ;; *** State used by the scheduler during instruction queueing.
67 ;;
68 ;; a list of postits. These are accumulated between instructions.
70 ;; ``Number'' for last instruction queued. Used only to supply insts
71 ;; with unique sset-element-number's.
73 ;; SIMPLE-VECTORs mapping locations to the instruction that reads them and
74 ;; instructions that write them
79 ;; The number of additional cycles before the next control transfer,
80 ;; or NIL if a control transfer hasn't been queued. When a delayed
81 ;; branch is queued, this slot is set to the delay count.
83 ;; *** These two slots are used both by the queuing noise and the
84 ;; scheduling noise.
85 ;;
86 ;; All the instructions that are pending and don't have any
87 ;; unresolved dependents. We don't list branches here even if they
88 ;; would otherwise qualify. They are listed above.
90 ;; list of queued branches. We handle these specially, because they
91 ;; have to be emitted at a specific place (e.g. one slot before the
92 ;; end of the block).
94 ;; *** state used by the scheduler during instruction scheduling
95 ;;
96 ;; the instructions who would have had a read dependent removed if
97 ;; it were not for a delay slot. This is a list of lists. Each
98 ;; element in the top level list corresponds to yet another cycle of
99 ;; delay. Each element in the second level lists is a dotted pair,
100 ;; holding the dependency instruction and the dependent to remove.
102 ;; The emittable insts again, except this time as a list sorted by depth.
104 ;; Whether or not to collect dynamic statistics. This is just the same as
105 ;; *COLLECT-DYNAMIC-STATISTICS* but is faster to reference.
106 #!+sb-dyncount
109 type)
118 ;; FIXME: It would be lovely to enforce this, but first FILL-IN will
119 ;; need to be convinced to stop rolling SEGMENT-CURRENT-INDEX
120 ;; backwards.
121 ;;
122 ;; Enforce an observed regularity which makes it easier to think
123 ;; about what's going on in the (legacy) code: The segment never
124 ;; shrinks. -- WHN the reverse engineer
130 ;; Make sure the array is big enough.
134 ;; When we have to increase the size of the array, we want to
135 ;; roughly double the vector length: that way growing the array
136 ;; to size N conses only O(N) bytes in total. But just doubling
137 ;; the length would leave a zero-length vector unchanged. Hence,
138 ;; take the MAX with 1..
144 ;; Now that the array has the intended next free byte, we can point to it.
147 ;;; Various functions (like BACK-PATCH-FUN or CHOOSER-WORST-CASE-FUN)
148 ;;; aren't cleanly parameterized, but instead use
149 ;;; SEGMENT-CURRENT-INDEX and/or SEGMENT-CURRENT-POSN as global
150 ;;; variables. So code which calls such functions needs to modify
151 ;;; SEGMENT-CURRENT-INDEX and SEGMENT-CURRENT-POSN. This is left over
152 ;;; from the old new-assem.lisp C-style code, and so all the
153 ;;; destruction happens to be done after other uses of these slots are
154 ;;; done and things basically work. However, (1) it's fundamentally
155 ;;; nasty, and (2) at least one thing doesn't work right: OpenMCL
156 ;;; properly points out that SUBSEQ's indices aren't supposed to
157 ;;; exceed its logical LENGTH, i.e. its FILL-POINTER, i.e.
158 ;;; SEGMENT-CURRENT-INDEX.
159 ;;;
160 ;;; As a quick fix involving minimal modification of legacy code,
161 ;;; we do such sets of SEGMENT-CURRENT-INDEX and SEGMENT-CURRENT-POSN
162 ;;; using this macro, which restores 'em afterwards.
163 ;;;
164 ;;; FIXME: It'd probably be better to cleanly parameterize things like
165 ;;; BACK-PATCH-FUN so we can avoid this nastiness altogether.
179 \f
180 ;;;; structures/types used by the scheduler
182 (!def-boolean-attribute instruction
183 ;; This attribute is set if the scheduler can freely flush this
184 ;; instruction if it thinks it is not needed. Examples are NOP and
185 ;; instructions that have no side effect not described by the
186 ;; writes.
187 flushable
188 ;; This attribute is set when an instruction can cause a control
189 ;; transfer. For test instructions, the delay is used to determine
190 ;; how many instructions follow the branch.
191 branch
192 ;; This attribute indicates that this ``instruction'' can be
193 ;; variable length, and therefore had better never be used in a
194 ;; branch delay slot.
195 variable-length)
202 ;; The function to envoke to actually emit this instruction. Gets called
203 ;; with the segment as its one argument.
205 ;; The attributes of this instruction.
207 ;; Number of instructions or cycles of delay before additional
208 ;; instructions can read our writes.
210 ;; the maximum number of instructions in the longest dependency
211 ;; chain from this instruction to one of the independent
212 ;; instructions. This is used as a heuristic at to which
213 ;; instructions should be scheduled first.
215 ;; Note: When trying remember which of the next four is which, note
216 ;; that the ``read'' or ``write'' always refers to the dependent
217 ;; (second) instruction.
218 ;;
219 ;; instructions whose writes this instruction tries to read
221 ;; instructions whose writes or reads are overwritten by this instruction
223 ;; instructions which write what we read or write
225 ;; instructions which read what we write
231 #!+sb-show-assem
235 stream)
243 name)
248 #!+sb-show-assem
252 \f
253 ;;;; the scheduler itself
257 #!+sb-doc
258 "Execute BODY (as a PROGN) without scheduling any of the instructions
259 generated inside it. This is not protected by UNWIND-PROTECT, so
260 DO NOT use THROW or RETURN-FROM to escape from it."
261 ;; FIXME: Why not just use UNWIND-PROTECT? Or is there some other
262 ;; reason why we shouldn't use THROW or RETURN-FROM?
270 ,@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.
323 "~&~S writes ~S[~W for ~W]~%"
324 inst write loc-num size)
326 ;; Iterate over all the locations for this TN.
331 ;; All previous reads of this location must have completed.
338 ;; All previous writes to the location must have completed.
343 ;; And we can forget about remembering them, because
344 ;; depending on us is as good as depending on them.
349 ;;; This routine is called by due to uses of the INST macro when the
350 ;;; scheduler is turned on. The change to the dependency graph has
351 ;;; already been computed, so we just have to check to see whether the
352 ;;; basic block is terminated.
356 " reads ~S~% writes ~S~%"
372 variable-length))))
389 ;;; Emit all the pending instructions, and reset any state. This is
390 ;;; called whenever we hit a label (i.e. an entry point of some kind)
391 ;;; and when the user turns the scheduler off (otherwise, the queued
392 ;;; instructions would sit there until the scheduler was turned back
393 ;;; on, and emitted in the wrong place).
397 ;; Quick blow-out if nothing to do.
406 ;; Note that any values live at the end of the block have to be
407 ;; computed last.
421 ;; If the value is live at the end of the block, we can't flush it.
423 nil)))))
425 ;; Grovel through the entire graph in the forward direction finding
426 ;; all the leaf instructions.
441 flushable))
443 "flushing ~S~%"
444 inst)
463 "queued branches: ~S~%"
466 "initially emittable: ~S~%"
469 "initially delayed: ~S~%"
472 ;; Accumulate the results in reverse order. Well, actually, this
473 ;; list will be in forward order, because we are generating the
474 ;; reverse order in reverse.
477 ;; Schedule all the branches in their exact locations.
482 ;; Each time through this loop we need to emit another
483 ;; instruction. First, we check to see whether there is
484 ;; any instruction that must be emitted before (i.e. must
485 ;; come after) the branch inst. If so, emit it. Otherwise,
486 ;; just pick one of the emittable insts. If there is
487 ;; nothing to do, then emit a nop. ### Note: despite the
488 ;; fact that this is a loop, it really won't work for
489 ;; repetitions other than zero and one. For example, if
490 ;; the branch has two dependents and one of them dpends on
491 ;; the other, then the stuff that grabs a dependent could
492 ;; easily grab the wrong one. But I don't feel like fixing
493 ;; this because it doesn't matter for any of the
494 ;; architectures we are using or plan on using.
497 ;; If do-sset-elements enters the body, then there is a
498 ;; dependent. Emit it.
500 ;; Remove it from the emittable insts.
505 ;; And if it was delayed, removed it from the delayed
506 ;; list. This can happen if there is a load in a
507 ;; branch delay slot.
520 ;; And return it.
529 "filling branch delay slot with ~S~%"
530 fill)
539 ;; Keep scheduling stuff until we run out.
547 ;; Now call the emitters, but turn the scheduler off for the duration.
555 ;; Clear out any residue left over.
563 ;; That's all, folks.
566 ;;; a utility for maintaining the segment-delayed list. We cdr down
567 ;;; list n times (extending it if necessary) and then push thing on
568 ;;; into the car of that cons cell.
575 list)))
577 ;;; Find the next instruction to schedule and return it after updating
578 ;;; any dependency information. If we can't do anything useful right
579 ;;; now, but there is more work to be done, return :NOP to indicate
580 ;;; that a nop must be emitted. If we are all done, return NIL.
588 variable-length))
589 ;; We've got us a live one here. Go for it.
591 ;; Delete it from the list of insts.
596 ;; Note that this inst has been emitted.
598 ;; And return.
600 ;; Are we wanting to flush this instruction?
602 ;; Nope, it's still a go. So return it.
603 inst
604 ;; Yes, so pick a new one. We have to start
605 ;; over, because note-resolved-dependencies
606 ;; might have changed the emittable-insts-queue.
608 ;; Nothing to do, so make something up.
610 ;; No emittable instructions, but we have more work to do. Emit
611 ;; a NOP to fill in a delay slot.
615 ;; All done.
616 nil)))
618 ;;; This function is called whenever an instruction has been
619 ;;; scheduled, and we want to know what possibilities that opens up.
620 ;;; So look at all the instructions that this one depends on, and
621 ;;; remove this instruction from their dependents list. If we were the
622 ;;; last dependent, then that dependency can be emitted now.
627 ;; These are the instructions who have to be completed before our
628 ;; write fires. Doesn't matter how far before, just before.
635 ;; These are the instructions who write values we read. If there
636 ;; is no delay, then just remove us from the dependent list.
637 ;; Otherwise, record the fact that in n cycles, we should be
638 ;; removed.
651 ;;; Process the next entry in segment-delayed. This is called whenever
652 ;;; anyone emits an instruction.
666 ;;; Note that inst is emittable by sticking it in the
667 ;;; SEGMENT-EMITTABLE-INSTS-QUEUE list. We keep the emittable-insts
668 ;;; sorted with the largest ``depths'' first. Except that if INST is a
669 ;;; branch, don't bother. It will be handled correctly by the branch
670 ;;; emitting code in SCHEDULE-PENDING-INSTRUCTIONS.
683 \f
684 ;;;; structure used during output emission
686 ;;; a constraint on how the output stream must be aligned
692 ;; the minimum number of low-order bits that must be zero
694 ;; the amount of filler we are assuming this alignment op will take
696 ;; the byte used as filling or :LONG-NOP, indicating to call EMIT-LONG-NOP
697 ;; to emit a filling pattern
701 ;;; a reference to someplace that needs to be back-patched when
702 ;;; we actually know what label positions, etc. are
706 ;; the area affected by this back-patch
708 ;; the function to use to generate the real data
711 ;;; This is similar to a BACK-PATCH, but also an indication that the
712 ;;; amount of stuff output depends on label positions, etc.
713 ;;; BACK-PATCHes can't change their mind about how much stuff to emit,
714 ;;; but CHOOSERs can.
716 (:constructor make-chooser
719 ;; the worst case size for this chooser. There is this much space
720 ;; allocated in the output buffer.
722 ;; the worst case alignment this chooser is guaranteed to preserve
724 ;; the function to call to determine if we can use a shorter
725 ;; sequence. It returns NIL if nothing shorter can be used, or emits
726 ;; that sequence and returns T.
728 ;; the function to call to generate the worst case sequence. This is
729 ;; used when nothing else can be condensed.
732 ;;; This is used internally when we figure out a chooser or alignment
733 ;;; doesn't really need as much space as we initially gave it.
737 ;; the number of bytes of filler here
739 \f
740 ;;;; output functions
742 ;;; interface: Emit the supplied BYTE to SEGMENT, growing SEGMENT if
743 ;;; necessary.
754 ;;; interface: Output AMOUNT bytes to SEGMENT, either copies of
755 ;;; PATTERN (if that is an integer), or by calling EMIT-LONG-NOP
756 ;;; (if PATTERN is :LONG-NOP).
764 ;; EMIT-LONG-NOP does not exist for most backends.
765 ;; Better to get an ECASE error than undefined-function.
766 #!+x86-64
771 ;;; This is used to handle the common parts of annotation emission. We
772 ;;; just assign the POSN and INDEX of NOTE and tack it on to the end
773 ;;; of SEGMENT's annotations list.
789 ;;; Note that the instruction stream has to be back-patched when label
790 ;;; positions are finally known. SIZE bytes are reserved in SEGMENT,
791 ;;; and function will be called with two arguments: the segment and
792 ;;; the position. The function should look at the position and the
793 ;;; position of any labels it wants to and emit the correct sequence.
794 ;;; (And it better be the same size as SIZE). SIZE can be zero, which
795 ;;; is useful if you just want to find out where things ended up.
800 ;;; Note that the instruction stream here depends on the actual
801 ;;; positions of various labels, so can't be output until label
802 ;;; positions are known. Space is made in SEGMENT for at least SIZE
803 ;;; bytes. When all output has been generated, the MAYBE-SHRINK
804 ;;; functions for all choosers are called with three arguments: the
805 ;;; segment, the position, and a magic value. The MAYBE-SHRINK
806 ;;; decides if it can use a shorter sequence, and if so, emits that
807 ;;; sequence to the segment and returns T. If it can't do better than
808 ;;; the worst case, it should return NIL (without emitting anything).
809 ;;; When calling LABEL-POSITION, it should pass it the position and
810 ;;; the magic-value it was passed so that LABEL-POSITION can return
811 ;;; the correct result. If the chooser never decides to use a shorter
812 ;;; sequence, the WORST-CASE-FUN will be called, just like a
813 ;;; BACK-PATCH. (See EMIT-BACK-PATCH.)
822 ;;; This is called in EMIT-CHOOSER and COMPRESS-SEGMENT in order to
823 ;;; recompute the current alignment information in light of this
824 ;;; chooser. If the alignment guaranteed by the chooser is less than
825 ;;; the segment's current alignment, we have to adjust the segment's
826 ;;; notion of the current alignment.
827 ;;;
828 ;;; The hard part is recomputing the sync posn, because it's not just
829 ;;; the chooser's posn. Consider a chooser that emits either one or
830 ;;; three words. It preserves 8-byte (3 bit) alignments, because the
831 ;;; difference between the two choices is 8 bytes.
837 ;; The chooser might change the alignment of the output. So we
838 ;; have to figure out what the worst case alignment could be.
847 ;;; This is used internally whenever a chooser or alignment decides it
848 ;;; doesn't need as much space as it originally thought.
849 ;;; This function used to extend an existing filler instead of creating
850 ;;; a new one when the previous segment annotation was a filler. Now
851 ;;; this is only done if the previous filler is immediately adjacent
852 ;;; to the new one in the segment, too. To see why this restriction is
853 ;;; necessary, consider a jump followed by an alignment made of
854 ;;; multi-byte NOPs when both are shrunk: The shortened alignment is
855 ;;; reemitted at its original _start_ position but the joined filler
856 ;;; would extend over this position and instead leave a subsequence of
857 ;;; the segment up to the alignment's original _end_ position visible.
872 ;;; EMIT-LABEL (the interface) basically just expands into this,
873 ;;; supplying the SEGMENT and VOP.
886 ;;; Called by the EMIT-ALIGNMENT macro to emit an alignment note. We check to
887 ;;; see if we can guarantee the alignment restriction by just outputting a
888 ;;; fixed number of bytes. If so, we do so. Otherwise, we create and emit an
889 ;;; alignment note.
900 ;; We need more bits of alignment. Emit an alignment note.
901 ;; The ALIGNMENT many least significant bits of (- OFFSET)
902 ;; give the amount of bytes to skip to get back in sync with
903 ;; ALIGNMENT, and one-bits to the left of that up to position
904 ;; BITS provide the remaining amount.
914 ;; The last alignment was more restrictive than this one.
915 ;; So we can just figure out how much noise to emit
916 ;; assuming the last alignment was met.
920 ;; But we emit an alignment with size=0 so we can verify
921 ;; that everything works.
925 ;;; This is used to find how ``aligned'' different offsets are.
926 ;;; Returns the number of low-order 0 bits, up to MAX-ALIGNMENT.
932 ;;; Emit a postit. The function will be called as a back-patch with
933 ;;; the position the following instruction is finally emitted. Postits
934 ;;; do not interfere at all with scheduling.
938 \f
939 ;;;; output compression/position assignment stuff
941 ;;; Grovel though all the annotations looking for choosers. When we
942 ;;; find a chooser, invoke the maybe-shrink function. If it returns T,
943 ;;; it output some other byte sequence.
961 posn)
965 ;; It emitted some replacement.
971 note new-size old-size))
976 preserves ~W bits of alignment."
986 ;; The chooser passed on shrinking. Make sure it didn't
987 ;; emit anything.
991 note
994 ;; Act like we just emitted this chooser.
998 ;; Adjust the alignment accordingly.
1000 ;; And keep this chooser for next time around.
1004 ;; Re-emit the alignment, letting it collapse if we know
1005 ;; anything more about the alignment guarantees of the
1006 ;; segment.
1018 and is ~W now."
1019 note old-size size))
1035 ;;; We have run all the choosers we can, so now we have to figure out
1036 ;;; exactly how much space each alignment note needs.
1059 posn)
1061 ;; We need to re-emit the alignment because a shorter
1062 ;; multi-byte NOP pattern is most of the time not a
1063 ;; prefix of a longer one.
1078 ;;; Grovel over segment, filling in any backpatches. If any choosers
1079 ;;; are left over, we need to emit their worst case variant.
1095 note new-size old-size)))
1110 ;;; Replace the SEGMENT-BUFFER of SEGMENT with a vector that contains
1111 ;;; only the valid content of the original buffer, that is, the parts
1112 ;;; not covered by fillers. Set FINAL-INDEX of SEGMENT to the length
1113 ;;; of the new vector and return this length.
1136 \f
1137 ;;;; interface to the rest of the compiler
1139 ;;; This holds the current segment while assembling. Use ASSEMBLE to
1140 ;;; change it.
1141 ;;;
1142 ;;; The double asterisks in the name are intended to suggest that this
1143 ;;; isn't just any old special variable, it's an extra-special
1144 ;;; variable, because sometimes MACROLET is used to bind it. So be
1145 ;;; careful out there..
1146 ;;;
1147 ;;; (This used to be called **CURRENT-SEGMENT** in SBCL until 0.7.3,
1148 ;;; and just *CURRENT-SEGMENT* in CMU CL. In both cases, the rebinding
1149 ;;; now done with MACROLET was done with SYMBOL-MACROLET instead. The
1150 ;;; rename-with-double-asterisks was because the SYMBOL-MACROLET made
1151 ;;; it an extra-special variable. The change over to
1152 ;;; %%CURRENT-SEGMENT%% was because ANSI forbids the use of
1153 ;;; SYMBOL-MACROLET on special variable names, and CLISP correctly
1154 ;;; complains about this when being used as a bootstrap host.)
1158 ;;; Just like %%CURRENT-SEGMENT%%, except this holds the current vop.
1159 ;;; This is used only to keep track of which vops emit which insts.
1160 ;;;
1161 ;;; The double asterisks in the name are intended to suggest that this
1162 ;;; isn't just any old special variable, it's an extra-special
1163 ;;; variable, because sometimes MACROLET is used to bind it. So be
1164 ;;; careful out there..
1168 ;;; We also MACROLET %%CURRENT-SEGMENT%% to a local holding the
1169 ;;; segment so uses of %%CURRENT-SEGMENT%% inside the body don't have
1170 ;;; to keep dereferencing the symbol. Given that ASSEMBLE is the only
1171 ;;; interface to **CURRENT-SEGMENT**, we don't have to worry about the
1172 ;;; special value becomming out of sync with the lexical value. Unless
1173 ;;; some bozo closes over it, but nobody does anything like that...
1176 #!+sb-doc
1177 "Execute BODY (as a progn) with SEGMENT as the current segment."
1191 inherited-labels))
1195 visible-labels)
1208 new-labels))
1210 ;; Must be done so that contribs and user code doing
1211 ;; low-level stuff don't need to worry about this.
1215 ;; KLUDGE: Some host lisps (CMUCL 18e Sparc at least)
1216 ;; can't deal with this declaration, so disable it on host.
1217 ;; Ditto for later ENABLE-PACKAGE-LOCKS %%C-S%% declaration.
1218 #-sb-xc-host
1225 form))
1226 body)))))))
1234 #!+sb-doc
1235 "Emit the specified instruction to the current segment."
1240 ;; An ordinary style-warning suffices to indicate missing emitters.
1244 ;;; Note: The need to capture MACROLET bindings of %%CURRENT-SEGMENT%%
1245 ;;; and %%CURRENT-VOP%% prevents this from being an ordinary function.
1247 #!+sb-doc
1248 "Emit LABEL at this location in the current segment."
1251 ;;; Note: The need to capture MACROLET bindings of
1252 ;;; %%CURRENT-SEGMENT%% prevents this from being an ordinary function.
1256 ;;; Note: The need to capture SYMBOL-MACROLET bindings of
1257 ;;; **CURRENT-SEGMENT* and (%%CURRENT-VOP%%) prevents this from being an
1258 ;;; ordinary function.
1260 #!+sb-doc
1261 "Emit an alignment restriction to the current segment."
1265 #!+sb-doc
1266 "Return the current position for LABEL. Chooser maybe-shrink functions
1267 should supply IF-AFTER and DELTA in order to ensure correct results."
1271 posn)))
1274 #!+sb-doc
1275 "Append OTHER-SEGMENT to the end of SEGMENT. Don't use OTHER-SEGMENT
1276 for anything after this."
1303 ;; This SEGMENT-LAST-ANNOTATION code is confusing. Is it really
1304 ;; worth enough in efficiency to justify it? -- WHN 19990322
1314 #!+sb-doc
1315 "Do any final processing of SEGMENT and return the total number of bytes
1316 covered by this segment."
1332 ;;; Return the contents of SEGMENT as a vector. We assume SEGMENT has
1333 ;;; been finalized so that we can simply return its buffer.
1339 ;;; Write the code accumulated in SEGMENT to STREAM, and return the
1340 ;;; number of bytes written. We assume that SEGMENT has been finalized.
1347 \f
1348 ;;;; interface to the instruction set definition
1350 ;;; Define a function named NAME that merges its arguments into a
1351 ;;; single integer and then emits the bytes of that integer in the
1352 ;;; correct order based on the endianness of the target-backend.
1361 total-bits assembly-unit-bits))
1362 quo))
1372 extends past the end."
1373 byte-spec-expr))
1382 assembly-unit-bits)))
1385 expr
1391 offset)
1397 offset)
1405 offset))
1409 assembly-unit-bits)))
1412 assembly-unit-bits
1413 len)
1416 offset))
1429 forms)))
1437 ;;; Return a list of forms involving VALUES that will pass the arguments from
1438 ;;; LAMBA-LIST by way of MULTIPLE-VALUE-CALL. Secondary value is the augmented
1439 ;;; lambda-list which has a supplied-p var for every &OPTIONAL and &KEY arg.
1451 new-spec)))
1457 optional))
1466 var
1469 keys))))
1495 (:emitter
1499 (:declare
1501 (:attributes
1503 (:cost
1505 (:dependencies
1507 (:delay
1511 (:pinned
1513 (:vop-var
1517 (:printer
1524 operands))
1535 emitter)
1538 emitter)
1540 #!+sb-dyncount
1550 emitter)
1567 #',flet-name
1586 ;; Must be done so that contribs and user code doing
1587 ;; low-level stuff don't need to worry about this.
1593 ;; KLUDGE: Some host lisps (CMUCL 18e Sparc at least)
1594 ;; can't deal with this declaration, so disable it on host
1595 ;; Ditto for earlier ENABLE-PACKAGE-LOCKS %%C-S%% %%C-V%%
1596 ;; declaration.
1597 #-sb-xc-host