| blob | fd795d68f067d71e8e6f5e1b0ec18756e3208f07 |
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
21 \f
22 ;;;; the SEGMENT structure
24 ;;; This structure holds the state of the assembler.
26 ;; the type of this segment (for debugging output and stuff)
28 ;; Ordinarily this is a vector where instructions are written. If
29 ;; the segment is made invalid (e.g. by APPEND-SEGMENT) then the
30 ;; vector can be replaced by NIL. This used to be an adjustable
31 ;; array, but we now do the array size management manually for
32 ;; performance reasons (as of 2006-05-13 hairy array operations
33 ;; are rather slow compared to simple ones).
36 ;; whether or not to run the scheduler. Note: if the instruction
37 ;; definitions were not compiled with the scheduler turned on, this
38 ;; has no effect.
40 ;; If a function, then this is funcalled for each inst emitted with
41 ;; the segment, the VOP, the name of the inst (as a string), and the
42 ;; inst arguments.
44 ;; what position does this correspond to? Initially, positions and
45 ;; indexes are the same, but after we start collapsing choosers,
46 ;; positions can change while indexes stay the same.
49 ;; a list of all the annotations that have been output to this segment
51 ;; a pointer to the last cons cell in the annotations list. This is
52 ;; so we can quickly add things to the end of the annotations list.
54 ;; the number of bits of alignment at the last time we synchronized
56 ;; the position the last time we synchronized
58 ;; The posn and index everything ends at. This is not maintained
59 ;; while the data is being generated, but is filled in after.
60 ;; Basically, we copy CURRENT-POSN and CURRENT-INDEX so that we can
61 ;; trash them while processing choosers and back-patches.
64 ;; *** State used by the scheduler during instruction queueing.
65 ;;
66 ;; a list of postits. These are accumulated between instructions.
68 ;; ``Number'' for last instruction queued. Used only to supply insts
69 ;; with unique sset-element-number's.
71 ;; SIMPLE-VECTORs mapping locations to the instruction that reads them and
72 ;; instructions that write them
77 ;; The number of additional cycles before the next control transfer,
78 ;; or NIL if a control transfer hasn't been queued. When a delayed
79 ;; branch is queued, this slot is set to the delay count.
81 ;; *** These two slots are used both by the queuing noise and the
82 ;; scheduling noise.
83 ;;
84 ;; All the instructions that are pending and don't have any
85 ;; unresolved dependents. We don't list branches here even if they
86 ;; would otherwise qualify. They are listed above.
88 ;; list of queued branches. We handle these specially, because they
89 ;; have to be emitted at a specific place (e.g. one slot before the
90 ;; end of the block).
92 ;; *** state used by the scheduler during instruction scheduling
93 ;;
94 ;; the instructions who would have had a read dependent removed if
95 ;; it were not for a delay slot. This is a list of lists. Each
96 ;; element in the top level list corresponds to yet another cycle of
97 ;; delay. Each element in the second level lists is a dotted pair,
98 ;; holding the dependency instruction and the dependent to remove.
100 ;; The emittable insts again, except this time as a list sorted by depth.
102 ;; Whether or not to collect dynamic statistics. This is just the same as
103 ;; *COLLECT-DYNAMIC-STATISTICS* but is faster to reference.
104 #!+sb-dyncount
107 type)
116 ;; FIXME: It would be lovely to enforce this, but first FILL-IN will
117 ;; need to be convinced to stop rolling SEGMENT-CURRENT-INDEX
118 ;; backwards.
119 ;;
120 ;; Enforce an observed regularity which makes it easier to think
121 ;; about what's going on in the (legacy) code: The segment never
122 ;; shrinks. -- WHN the reverse engineer
128 ;; Make sure the array is big enough.
132 ;; When we have to increase the size of the array, we want to
133 ;; roughly double the vector length: that way growing the array
134 ;; to size N conses only O(N) bytes in total. But just doubling
135 ;; the length would leave a zero-length vector unchanged. Hence,
136 ;; take the MAX with 1..
142 ;; Now that the array has the intended next free byte, we can point to it.
145 ;;; Various functions (like BACK-PATCH-FUN or CHOOSER-WORST-CASE-FUN)
146 ;;; aren't cleanly parameterized, but instead use
147 ;;; SEGMENT-CURRENT-INDEX and/or SEGMENT-CURRENT-POSN as global
148 ;;; variables. So code which calls such functions needs to modify
149 ;;; SEGMENT-CURRENT-INDEX and SEGMENT-CURRENT-POSN. This is left over
150 ;;; from the old new-assem.lisp C-style code, and so all the
151 ;;; destruction happens to be done after other uses of these slots are
152 ;;; done and things basically work. However, (1) it's fundamentally
153 ;;; nasty, and (2) at least one thing doesn't work right: OpenMCL
154 ;;; properly points out that SUBSEQ's indices aren't supposed to
155 ;;; exceed its logical LENGTH, i.e. its FILL-POINTER, i.e.
156 ;;; SEGMENT-CURRENT-INDEX.
157 ;;;
158 ;;; As a quick fix involving minimal modification of legacy code,
159 ;;; we do such sets of SEGMENT-CURRENT-INDEX and SEGMENT-CURRENT-POSN
160 ;;; using this macro, which restores 'em afterwards.
161 ;;;
162 ;;; FIXME: It'd probably be better to cleanly parameterize things like
163 ;;; BACK-PATCH-FUN so we can avoid this nastiness altogether.
177 \f
178 ;;;; structures/types used by the scheduler
180 (!def-boolean-attribute instruction
181 ;; This attribute is set if the scheduler can freely flush this
182 ;; instruction if it thinks it is not needed. Examples are NOP and
183 ;; instructions that have no side effect not described by the
184 ;; writes.
185 flushable
186 ;; This attribute is set when an instruction can cause a control
187 ;; transfer. For test instructions, the delay is used to determine
188 ;; how many instructions follow the branch.
189 branch
190 ;; This attribute indicates that this ``instruction'' can be
191 ;; variable length, and therefore had better never be used in a
192 ;; branch delay slot.
193 variable-length)
200 ;; The function to envoke to actually emit this instruction. Gets called
201 ;; with the segment as its one argument.
203 ;; The attributes of this instruction.
205 ;; Number of instructions or cycles of delay before additional
206 ;; instructions can read our writes.
208 ;; the maximum number of instructions in the longest dependency
209 ;; chain from this instruction to one of the independent
210 ;; instructions. This is used as a heuristic at to which
211 ;; instructions should be scheduled first.
213 ;; Note: When trying remember which of the next four is which, note
214 ;; that the ``read'' or ``write'' always refers to the dependent
215 ;; (second) instruction.
216 ;;
217 ;; instructions whose writes this instruction tries to read
219 ;; instructions whose writes or reads are overwritten by this instruction
221 ;; instructions which write what we read or write
223 ;; instructions which read what we write
229 #!+sb-show-assem
233 stream)
241 name)
246 #!+sb-show-assem
250 \f
251 ;;;; the scheduler itself
255 "Execute BODY (as a PROGN) without scheduling any of the instructions
256 generated inside it. This is not protected by UNWIND-PROTECT, so
257 DO NOT use THROW or RETURN-FROM to escape from it."
258 ;; FIXME: Why not just use UNWIND-PROTECT? Or is there some other
259 ;; reason why we shouldn't use THROW or RETURN-FROM?
267 ,@body
282 "~&~S reads ~S[~W for ~W]~%"
283 inst read loc-num size)
285 ;; Iterate over all the locations for this TN.
292 ;; The inst that wrote the value we want to read must have
293 ;; completed.
298 ;; And it must have been completed *after* all other
299 ;; writes to that location. Actually, that isn't quite
300 ;; true. Each of the earlier writes could be done
301 ;; either before this last write, or after the read, but
302 ;; we have no way of representing that.
308 ;; And we don't need to remember about earlier writes any
309 ;; more. Shortening the writers list means that we won't
310 ;; bother generating as many explicit arcs in the graph.
320 "~&~S writes ~S[~W for ~W]~%"
321 inst write loc-num size)
323 ;; Iterate over all the locations for this TN.
328 ;; All previous reads of this location must have completed.
335 ;; All previous writes to the location must have completed.
340 ;; And we can forget about remembering them, because
341 ;; depending on us is as good as depending on them.
346 ;;; This routine is called by due to uses of the INST macro when the
347 ;;; scheduler is turned on. The change to the dependency graph has
348 ;;; already been computed, so we just have to check to see whether the
349 ;;; basic block is terminated.
353 " reads ~S~% writes ~S~%"
369 variable-length))))
386 ;;; Emit all the pending instructions, and reset any state. This is
387 ;;; called whenever we hit a label (i.e. an entry point of some kind)
388 ;;; and when the user turns the scheduler off (otherwise, the queued
389 ;;; instructions would sit there until the scheduler was turned back
390 ;;; on, and emitted in the wrong place).
394 ;; Quick blow-out if nothing to do.
403 ;; Note that any values live at the end of the block have to be
404 ;; computed last.
418 ;; If the value is live at the end of the block, we can't flush it.
420 nil)))))
422 ;; Grovel through the entire graph in the forward direction finding
423 ;; all the leaf instructions.
438 flushable))
440 "flushing ~S~%"
441 inst)
460 "queued branches: ~S~%"
463 "initially emittable: ~S~%"
466 "initially delayed: ~S~%"
469 ;; Accumulate the results in reverse order. Well, actually, this
470 ;; list will be in forward order, because we are generating the
471 ;; reverse order in reverse.
474 ;; Schedule all the branches in their exact locations.
479 ;; Each time through this loop we need to emit another
480 ;; instruction. First, we check to see whether there is
481 ;; any instruction that must be emitted before (i.e. must
482 ;; come after) the branch inst. If so, emit it. Otherwise,
483 ;; just pick one of the emittable insts. If there is
484 ;; nothing to do, then emit a nop. ### Note: despite the
485 ;; fact that this is a loop, it really won't work for
486 ;; repetitions other than zero and one. For example, if
487 ;; the branch has two dependents and one of them dpends on
488 ;; the other, then the stuff that grabs a dependent could
489 ;; easily grab the wrong one. But I don't feel like fixing
490 ;; this because it doesn't matter for any of the
491 ;; architectures we are using or plan on using.
494 ;; If do-sset-elements enters the body, then there is a
495 ;; dependent. Emit it.
497 ;; Remove it from the emittable insts.
502 ;; And if it was delayed, removed it from the delayed
503 ;; list. This can happen if there is a load in a
504 ;; branch delay slot.
517 ;; And return it.
526 "filling branch delay slot with ~S~%"
527 fill)
536 ;; Keep scheduling stuff until we run out.
544 ;; Now call the emitters, but turn the scheduler off for the duration.
552 ;; Clear out any residue left over.
560 ;; That's all, folks.
563 ;;; a utility for maintaining the segment-delayed list. We cdr down
564 ;;; list n times (extending it if necessary) and then push thing on
565 ;;; into the car of that cons cell.
572 list)))
574 ;;; Find the next instruction to schedule and return it after updating
575 ;;; any dependency information. If we can't do anything useful right
576 ;;; now, but there is more work to be done, return :NOP to indicate
577 ;;; that a nop must be emitted. If we are all done, return NIL.
585 variable-length))
586 ;; We've got us a live one here. Go for it.
588 ;; Delete it from the list of insts.
593 ;; Note that this inst has been emitted.
595 ;; And return.
597 ;; Are we wanting to flush this instruction?
599 ;; Nope, it's still a go. So return it.
600 inst
601 ;; Yes, so pick a new one. We have to start
602 ;; over, because note-resolved-dependencies
603 ;; might have changed the emittable-insts-queue.
605 ;; Nothing to do, so make something up.
607 ;; No emittable instructions, but we have more work to do. Emit
608 ;; a NOP to fill in a delay slot.
612 ;; All done.
613 nil)))
615 ;;; This function is called whenever an instruction has been
616 ;;; scheduled, and we want to know what possibilities that opens up.
617 ;;; So look at all the instructions that this one depends on, and
618 ;;; remove this instruction from their dependents list. If we were the
619 ;;; last dependent, then that dependency can be emitted now.
624 ;; These are the instructions who have to be completed before our
625 ;; write fires. Doesn't matter how far before, just before.
632 ;; These are the instructions who write values we read. If there
633 ;; is no delay, then just remove us from the dependent list.
634 ;; Otherwise, record the fact that in n cycles, we should be
635 ;; removed.
648 ;;; Process the next entry in segment-delayed. This is called whenever
649 ;;; anyone emits an instruction.
663 ;;; Note that inst is emittable by sticking it in the
664 ;;; SEGMENT-EMITTABLE-INSTS-QUEUE list. We keep the emittable-insts
665 ;;; sorted with the largest ``depths'' first. Except that if INST is a
666 ;;; branch, don't bother. It will be handled correctly by the branch
667 ;;; emitting code in SCHEDULE-PENDING-INSTRUCTIONS.
680 \f
681 ;;;; structure used during output emission
683 ;;; a constraint on how the output stream must be aligned
689 ;; the minimum number of low-order bits that must be zero
691 ;; the amount of filler we are assuming this alignment op will take
693 ;; the byte used as filling or :LONG-NOP, indicating to call EMIT-LONG-NOP
694 ;; to emit a filling pattern
698 ;;; a reference to someplace that needs to be back-patched when
699 ;;; we actually know what label positions, etc. are
703 ;; the area affected by this back-patch
705 ;; the function to use to generate the real data
708 ;;; This is similar to a BACK-PATCH, but also an indication that the
709 ;;; amount of stuff output depends on label positions, etc.
710 ;;; BACK-PATCHes can't change their mind about how much stuff to emit,
711 ;;; but CHOOSERs can.
713 (:constructor make-chooser
716 ;; the worst case size for this chooser. There is this much space
717 ;; allocated in the output buffer.
719 ;; the worst case alignment this chooser is guaranteed to preserve
721 ;; the function to call to determine if we can use a shorter
722 ;; sequence. It returns NIL if nothing shorter can be used, or emits
723 ;; that sequence and returns T.
725 ;; the function to call to generate the worst case sequence. This is
726 ;; used when nothing else can be condensed.
729 ;;; This is used internally when we figure out a chooser or alignment
730 ;;; doesn't really need as much space as we initially gave it.
734 ;; the number of bytes of filler here
736 \f
737 ;;;; output functions
739 ;;; interface: Emit the supplied BYTE to SEGMENT, growing SEGMENT if
740 ;;; necessary.
751 ;;; interface: Output AMOUNT bytes to SEGMENT, either copies of
752 ;;; PATTERN (if that is an integer), or by calling EMIT-LONG-NOP
753 ;;; (if PATTERN is :LONG-NOP).
761 ;; EMIT-LONG-NOP does not exist for most backends.
762 ;; Better to get an ECASE error than undefined-function.
763 #!+x86-64
768 ;;; This is used to handle the common parts of annotation emission. We
769 ;;; just assign the POSN and INDEX of NOTE and tack it on to the end
770 ;;; of SEGMENT's annotations list.
786 ;;; Note that the instruction stream has to be back-patched when label
787 ;;; positions are finally known. SIZE bytes are reserved in SEGMENT,
788 ;;; and function will be called with two arguments: the segment and
789 ;;; the position. The function should look at the position and the
790 ;;; position of any labels it wants to and emit the correct sequence.
791 ;;; (And it better be the same size as SIZE). SIZE can be zero, which
792 ;;; is useful if you just want to find out where things ended up.
797 ;;; Note that the instruction stream here depends on the actual
798 ;;; positions of various labels, so can't be output until label
799 ;;; positions are known. Space is made in SEGMENT for at least SIZE
800 ;;; bytes. When all output has been generated, the MAYBE-SHRINK
801 ;;; functions for all choosers are called with three arguments: the
802 ;;; segment, the position, and a magic value. The MAYBE-SHRINK
803 ;;; decides if it can use a shorter sequence, and if so, emits that
804 ;;; sequence to the segment and returns T. If it can't do better than
805 ;;; the worst case, it should return NIL (without emitting anything).
806 ;;; When calling LABEL-POSITION, it should pass it the position and
807 ;;; the magic-value it was passed so that LABEL-POSITION can return
808 ;;; the correct result. If the chooser never decides to use a shorter
809 ;;; sequence, the WORST-CASE-FUN will be called, just like a
810 ;;; BACK-PATCH. (See EMIT-BACK-PATCH.)
819 ;;; This is called in EMIT-CHOOSER and COMPRESS-SEGMENT in order to
820 ;;; recompute the current alignment information in light of this
821 ;;; chooser. If the alignment guaranteed by the chooser is less than
822 ;;; the segment's current alignment, we have to adjust the segment's
823 ;;; notion of the current alignment.
824 ;;;
825 ;;; The hard part is recomputing the sync posn, because it's not just
826 ;;; the chooser's posn. Consider a chooser that emits either one or
827 ;;; three words. It preserves 8-byte (3 bit) alignments, because the
828 ;;; difference between the two choices is 8 bytes.
834 ;; The chooser might change the alignment of the output. So we
835 ;; have to figure out what the worst case alignment could be.
844 ;;; This is used internally whenever a chooser or alignment decides it
845 ;;; doesn't need as much space as it originally thought.
846 ;;; This function used to extend an existing filler instead of creating
847 ;;; a new one when the previous segment annotation was a filler. Now
848 ;;; this is only done if the previous filler is immediately adjacent
849 ;;; to the new one in the segment, too. To see why this restriction is
850 ;;; necessary, consider a jump followed by an alignment made of
851 ;;; multi-byte NOPs when both are shrunk: The shortened alignment is
852 ;;; reemitted at its original _start_ position but the joined filler
853 ;;; would extend over this position and instead leave a subsequence of
854 ;;; the segment up to the alignment's original _end_ position visible.
869 ;;; EMIT-LABEL (the interface) basically just expands into this,
870 ;;; supplying the SEGMENT and VOP.
883 ;;; Called by the EMIT-ALIGNMENT macro to emit an alignment note. We check to
884 ;;; see if we can guarantee the alignment restriction by just outputting a
885 ;;; fixed number of bytes. If so, we do so. Otherwise, we create and emit an
886 ;;; alignment note.
897 ;; We need more bits of alignment. Emit an alignment note.
898 ;; The ALIGNMENT many least significant bits of (- OFFSET)
899 ;; give the amount of bytes to skip to get back in sync with
900 ;; ALIGNMENT, and one-bits to the left of that up to position
901 ;; BITS provide the remaining amount.
911 ;; The last alignment was more restrictive than this one.
912 ;; So we can just figure out how much noise to emit
913 ;; assuming the last alignment was met.
917 ;; But we emit an alignment with size=0 so we can verify
918 ;; that everything works.
922 ;;; This is used to find how ``aligned'' different offsets are.
923 ;;; Returns the number of low-order 0 bits, up to MAX-ALIGNMENT.
929 ;;; Emit a postit. The function will be called as a back-patch with
930 ;;; the position the following instruction is finally emitted. Postits
931 ;;; do not interfere at all with scheduling.
935 \f
936 ;;;; output compression/position assignment stuff
938 ;;; Grovel though all the annotations looking for choosers. When we
939 ;;; find a chooser, invoke the maybe-shrink function. If it returns T,
940 ;;; it output some other byte sequence.
958 posn)
962 ;; It emitted some replacement.
968 note new-size old-size))
973 preserves ~W bits of alignment."
983 ;; The chooser passed on shrinking. Make sure it didn't
984 ;; emit anything.
988 note
991 ;; Act like we just emitted this chooser.
995 ;; Adjust the alignment accordingly.
997 ;; And keep this chooser for next time around.
1001 ;; Re-emit the alignment, letting it collapse if we know
1002 ;; anything more about the alignment guarantees of the
1003 ;; segment.
1015 and is ~W now."
1016 note old-size size))
1032 ;;; We have run all the choosers we can, so now we have to figure out
1033 ;;; exactly how much space each alignment note needs.
1056 posn)
1058 ;; We need to re-emit the alignment because a shorter
1059 ;; multi-byte NOP pattern is most of the time not a
1060 ;; prefix of a longer one.
1075 ;;; Grovel over segment, filling in any backpatches. If any choosers
1076 ;;; are left over, we need to emit their worst case variant.
1092 note new-size old-size)))
1107 ;;; Replace the SEGMENT-BUFFER of SEGMENT with a vector that contains
1108 ;;; only the valid content of the original buffer, that is, the parts
1109 ;;; not covered by fillers. Set FINAL-INDEX of SEGMENT to the length
1110 ;;; of the new vector and return this length.
1133 \f
1134 ;;;; interface to the rest of the compiler
1136 ;;; This holds the current segment while assembling. Use ASSEMBLE to
1137 ;;; change it.
1138 ;;;
1139 ;;; The double asterisks in the name are intended to suggest that this
1140 ;;; isn't just any old special variable, it's an extra-special
1141 ;;; variable, because sometimes MACROLET is used to bind it. So be
1142 ;;; careful out there..
1143 ;;;
1144 ;;; (This used to be called **CURRENT-SEGMENT** in SBCL until 0.7.3,
1145 ;;; and just *CURRENT-SEGMENT* in CMU CL. In both cases, the rebinding
1146 ;;; now done with MACROLET was done with SYMBOL-MACROLET instead. The
1147 ;;; rename-with-double-asterisks was because the SYMBOL-MACROLET made
1148 ;;; it an extra-special variable. The change over to
1149 ;;; %%CURRENT-SEGMENT%% was because ANSI forbids the use of
1150 ;;; SYMBOL-MACROLET on special variable names, and CLISP correctly
1151 ;;; complains about this when being used as a bootstrap host.)
1155 ;;; Just like %%CURRENT-SEGMENT%%, except this holds the current vop.
1156 ;;; This is used only to keep track of which vops emit which insts.
1157 ;;;
1158 ;;; The double asterisks in the name are intended to suggest that this
1159 ;;; isn't just any old special variable, it's an extra-special
1160 ;;; variable, because sometimes MACROLET is used to bind it. So be
1161 ;;; careful out there..
1165 ;;; We also MACROLET %%CURRENT-SEGMENT%% to a local holding the
1166 ;;; segment so uses of %%CURRENT-SEGMENT%% inside the body don't have
1167 ;;; to keep dereferencing the symbol. Given that ASSEMBLE is the only
1168 ;;; interface to **CURRENT-SEGMENT**, we don't have to worry about the
1169 ;;; special value becoming out of sync with the lexical value. Unless
1170 ;;; some bozo closes over it, but nobody does anything like that...
1173 "Execute BODY (as a progn) with SEGMENT as the current segment."
1187 inherited-labels))
1191 visible-labels)
1204 new-labels))
1206 ;; Must be done so that contribs and user code doing
1207 ;; low-level stuff don't need to worry about this.
1211 ;; KLUDGE: Some host lisps (CMUCL 18e Sparc at least)
1212 ;; can't deal with this declaration, so disable it on host.
1213 ;; Ditto for later ENABLE-PACKAGE-LOCKS %%C-S%% declaration.
1214 #-sb-xc-host
1221 form))
1222 body)))))))
1230 "Emit the specified instruction to the current segment."
1243 ;;; Note: The need to capture MACROLET bindings of %%CURRENT-SEGMENT%%
1244 ;;; and %%CURRENT-VOP%% prevents this from being an ordinary function.
1246 "Emit LABEL at this location in the current segment."
1249 ;;; Note: The need to capture MACROLET bindings of
1250 ;;; %%CURRENT-SEGMENT%% prevents this from being an ordinary function.
1254 ;;; Note: The need to capture SYMBOL-MACROLET bindings of
1255 ;;; **CURRENT-SEGMENT* and (%%CURRENT-VOP%%) prevents this from being an
1256 ;;; ordinary function.
1258 "Emit an alignment restriction to the current segment."
1262 "Return the current position for LABEL. Chooser maybe-shrink functions
1263 should supply IF-AFTER and DELTA in order to ensure correct results."
1267 posn)))
1270 "Append OTHER-SEGMENT to the end of SEGMENT. Don't use OTHER-SEGMENT
1271 for anything after this."
1298 ;; This SEGMENT-LAST-ANNOTATION code is confusing. Is it really
1299 ;; worth enough in efficiency to justify it? -- WHN 19990322
1309 "Do any final processing of SEGMENT and return the total number of bytes
1310 covered by this segment."
1326 ;;; Return the contents of SEGMENT as a vector. We assume SEGMENT has
1327 ;;; been finalized so that we can simply return its buffer.
1333 ;;; Write the code accumulated in SEGMENT to STREAM, and return the
1334 ;;; number of bytes written. We assume that SEGMENT has been finalized.
1341 \f
1342 ;;;; interface to the instruction set definition
1344 ;;; Define a function named NAME that merges its arguments into a
1345 ;;; single integer and then emits the bytes of that integer in the
1346 ;;; correct order based on the endianness of the target-backend.
1355 total-bits assembly-unit-bits))
1356 quo))
1366 extends past the end."
1367 byte-spec-expr))
1376 assembly-unit-bits)))
1379 expr
1385 offset)
1391 offset)
1399 offset))
1403 assembly-unit-bits)))
1406 assembly-unit-bits
1407 len)
1410 offset))
1423 forms)))
1431 ;;; Return a list of forms involving VALUES that will pass the arguments from
1432 ;;; LAMBA-LIST by way of MULTIPLE-VALUE-CALL. Secondary value is the augmented
1433 ;;; lambda-list which has a supplied-p var for every &OPTIONAL and &KEY arg.
1445 new-spec)))
1451 optional))
1460 var
1463 keys))))
1489 (:emitter
1493 (:declare
1495 (:attributes
1497 (:cost
1499 (:dependencies
1501 (:delay
1505 (:pinned
1507 (:vop-var
1511 (:printer
1518 operands))
1529 emitter)
1532 emitter)
1534 #!+sb-dyncount
1544 emitter)
1561 #',flet-name
1580 ;; Must be done so that contribs and user code doing
1581 ;; low-level stuff don't need to worry about this.
1587 ;; KLUDGE: Some host lisps (CMUCL 18e Sparc at least)
1588 ;; can't deal with this declaration, so disable it on host
1589 ;; Ditto for earlier ENABLE-PACKAGE-LOCKS %%C-S%% %%C-V%%
1590 ;; declaration.
1591 #-sb-xc-host