Custom Query (1030 matches)

On Windows, one creates a new process with ​CreateProcess, which accepts a string parameter that contains the command line for the newly created process.

In the newly created process, C runtime code then parses this string and constructs argc and argv[]. The rules used to do this are described by ​http://msdn.microsoft.com/en-us/library/a1y7w461.aspx.

We need to apply the inverse of those rules to the command and arguments given to run-program so that the the newly created process sees the same argv[] that the user provided to run-program.

Currently, we just join the all the argument strings together with #\space and call it a day.

Here is what is expected:

[pjb@kuiper :0 swig]$ clisp -norc -ansi -q [1]> (defun diff1p (lon)

(every (lambda (a b)

(print (list a b (= 1 (- a b)))) (= 1 (- a b)))

lon (rest lon)))

DIFF1P [2]> (diff1p '(6 5 4 3 2 1))

(6 5 T) (5 4 T) (4 3 T) (3 2 T) (2 1 T) T [3]> (quit)

Here is what we get with ccl:

[pjb@kuiper :0 swig]$ ccl -norc Welcome to Clozure Common Lisp Version 1.6-RC1-r14432M (LinuxX8664)! ? (defun diff1p (lon)

(every (lambda (a b)

(print (list a b (= 1 (- a b)))) (= 1 (- a b)))

lon (rest lon)))

DIFF1P ? (diff1p '(6 5 4 3 2 1))

(6 5 T) (4 5 NIL) NIL ? (quit) [pjb@kuiper :0 swig]$ ccl --version Version 1.6-RC1-r14432M (LinuxX8664)

r11754 is workaround for a bug in how the lisp assembler encodes memory operands that are just a displacement.

To elaborate on that commit message, there are two ways on 32-bit x86 to encode a memory operand that's just a displacement.

For example, take the instruction:

0x806e6db:	mov    %fs:0x84,%ecx

The lisp assembler encodes this as:

0x806e6db:	0x64	0x8b	0x0c	0x25	0x84	0x00	0x00	0x00

Note that the modrm byte of 0x0c (00 001 100) means that a sib byte follows.

This could also be encoded as this shorter sequence (and the Unix assembler does so):

0x806e6db:	0x64	0x8b	0x0d	0x84	0x00	0x00	0x00

The modrm byte of 0x0d (00 001 101) here means that the displacement follows.

The reason that the lisp assembler selects the longer encoding is because it targeted x86-64 first. On x86-64, the modrm byte in the shorter sequence is redefined to mean that the displacement is RIP-relative. Therefore, the longer sib byte encoding is used to specify just a displacement.

The lisp assembler needs to be persuaded to emit the shorter encoding for 32-bit x86. When it does, we can recompile and bump fasl versions, etc., and remove the workaround in pc_luser_xp().