GitLab

at 2017-01-17T20:33:48-08:00

WIP: Add support for not-implmeented

Add support for not-implemented trap where a VOP can mark itself as
not implemented.  This causes a illtrap instruction to be inserted
followed by a branch always followed by a string (not necessarily nul
terminated) that represents the name of the VOP.

The signal handler currently catches the signal and sends prints out
the string and then continues.

Not yet debugged and definitely does not yet work.

We're just saving this in safe place for now.

@@ -114,6 +114,24 @@
  	      (backend-support-routines *target-backend*))
  	     #',local-name))))
 +(defmacro def-vm-support-routine (name ll &body body)
 +  (unless (member (intern (string name) (find-package "C"))
 +		  vm-support-routines)
 +    (warn (intl:gettext "Unknown VM support routine: ~A") name))
 +  (let ((local-name (symbolicate (backend-name *target-backend*) "-" name)))
 +    `(progn
 +       (defun ,local-name
 +	 ,ll
 +	 (macrolet ((vm::emit-not-implemented ()
 +		      `(vm::not-implemented ,',local-name)))
 +	   ,@body))
 +       (setf (,(intern (concatenate 'simple-string
 +				    "VM-SUPPORT-ROUTINES-"
 +				    (string name))
 +		       (find-package "C"))
 +	      (backend-support-routines *target-backend*))
 +	     #',local-name))))
++
  ;;;; The backend structure.

@@ -937,8 +937,10 @@
  		  ,@(binds))
  	     (declare (ignore ,@(vop-parse-ignores parse)))
  	     ,@(loads)
 -	     (new-assem:assemble (*code-segment* ,n-vop)
 -	       ,@(vop-parse-body parse))
 +	     (macrolet ((vm::emit-not-implemented ()
 +			  `(vm::not-implemented ,',(vop-parse-name parse))))
 +	       (new-assem:assemble (*code-segment* ,n-vop)
 +		 ,@(vop-parse-body parse)))
  	     ,@(saves))))))

@@ -179,6 +179,9 @@
      (dotimes (i (1- vm:function-code-offset))
        (inst word 0)
        (inst word 0))
++
 +    (emit-not-implemented)
++
      ;; The start of the actual code.
      ;; Fix CODE, cause the function object was passed in.
      (inst compute-code-from-fn code-tn code-tn start-lab temp)

@@ -1534,6 +1534,31 @@ about function addresses and register values.")
                         (sc-offsets)
                         (lengths))))))))
 +(defun snarf-not-implemented-name (stream dstate)
 +  (let* ((sap (disassem:dstate-segment-sap dstate))
 +	 (offset (disassem:dstate-next-offs dstate))
 +	 (branch-inst (sys:sap-ref-32 sap offset)))
 +    ;; sap + offset should point to the branch instruction after the
 +    ;; illtrap (unimp) instruction.  Make sure it's an unconditional
 +    ;; branch instrution.
 +    #+nil
 +    (unless (= (ldb (byte 8 24) branch-inst) #xea)
 +      (return-from snarf-not-implemented-name ""))
 +    ;; From the offset in the branch instruction, compute the max
 +    ;; length of the string that was encoded.
 +    (let ((max-length (+ (ash (ldb (byte 24 0) branch-inst) 2) 4)))
 +      ;; Skip the branch instruction
 +      (incf offset 4)
 +      ;; Print each following byte until max-length is reached or we
 +      ;; get a 0 byte.
 +      (with-output-to-string (s)
 +	(do* ((k 0 (+ k 1))
 +	      (octet (sys:sap-ref-8 sap (+ offset k))
 +		     (sys:sap-ref-8 sap (+ offset k))))
 +	     ((or (>= k max-length)
 +		  (zerop octet)))
 +	  (write-char (code-char octet) s))))))
++
  (defun unimp-control (chunk inst stream dstate)
    (declare (ignore inst))
    (flet ((nt (x) (if stream (disassem:note x dstate))))
@@ -1556,6 +1581,10 @@ about function addresses and register values.")
         (nt "Function end breakpoint trap"))
        (#.vm:object-not-instance-trap
         (nt "Object not instance trap"))
 +      (#.vm::not-implemented-trap
 +       (nt (concatenate 'string
 +			"Not-implemented trap: "
 +			(snarf-not-implemented-name stream dstate))))
      )))
  (eval-when (compile load eval)
@@ -2252,6 +2281,26 @@ about function addresses and register values.")
 +(defmacro not-implemented (&optional name)
 +  (let ((string (string name)))
 +    `(let ((length-label (gen-label)))
 +       (new-assem:without-scheduling ()
 +	 (inst unimp not-implemented-trap)
 +	 ;; NOTE: The branch offset helps estimate the length of the
 +	 ;; string.  The actual length of the string may be equal to the
 +	 ;; displacement or it may be up to three bytes shorter at the
 +	 ;; first trailing NUL byte.  The string may or may not be
 +	 ;; 0-terminated.
 +	 (inst b length-label)
 +	 (inst nop)
 +	 ,@(map 'list #'(lambda (c)
 +			  `(inst byte ,(char-code c)))
 +		string)
 +	 ;; Append enough zeros to end on a word boundary.
 +	 ,@(make-list (mod (- (length string)) 4)
 +		      :initial-element '(inst byte 0))
 +	 (emit-label length-label)))))
++
  ;;;; Instructions for dumping data and header objects.
  (define-instruction word (segment word)

@@ -74,6 +74,7 @@
  (define-move-function (store-stack 5) (vop x y)
    ((any-reg descriptor-reg) (control-stack))
 +  (not-implemented "DEFINE-MOVE STORE-STACK")
    (store-stack-tn y x))
  (define-move-function (store-number-stack 5) (vop x y)

Raymond Toy pushed to branch sparc64-dev at cmucl / cmucl

Commits:

8 changed files:

Changes:

@@ -243,6 +243,7 @@
  	  after-breakpoint-trap allocation-trap
  	  pseudo-atomic-trap
  	  object-not-list-trap object-not-instance-trap
 +	  not-implemented-trap
  	  trace-table-normal trace-table-call-site
  	  trace-table-function-prologue trace-table-function-epilogue))
@@ -263,10 +264,11 @@
    dynamic-space-overflow-warning
    #+heap-overflow-check
    dynamic-space-overflow-error
 +  not-implemented
+   )
  ;; Make sure this starts AFTER the last element of the above enum!
 -(defenum (:prefix object-not- :suffix -trap :start 16)
 +(defenum (:prefix object-not- :suffix -trap :start 20)
    list
    instance)

@@ -315,7 +315,7 @@ long *
  solaris_register_address(struct ucontext *context, int reg)
+ {
      if (reg == 0) {
 -	static int zero;
 +	static long zero;
  	zero = 0;
@@ -323,7 +323,7 @@ solaris_register_address(struct ucontext *context, int reg)
      } else if (reg < 16) {
  	return &context->uc_mcontext.gregs[reg + 3];
      } else if (reg < 32) {
 -	int *sp = (int *) context->uc_mcontext.gregs[REG_SP];
 +	long *sp = (long *) context->uc_mcontext.gregs[REG_SP];
  	return &sp[reg - 16];
      } else

@@ -510,6 +510,53 @@ sigill_handler(HANDLER_ARGS)
  					      os_context);
  	      break;
  #endif
 +#ifdef trap_NotImplemented
 +          case trap_NotImplemented:
 +          {
 +              /*
 +               * Print out the name.  The next instruction MUST be a
 +               * branch immediate.
 +               */
 +              unsigned char *string;
 +              int length;
++
 +              /*
 +               * Compute the maximum length of the string from the
 +               * offset in the branch instruction.  This code assumes
 +               * a ba,pt instruction which has a 19-bit word offset in
 +               * the low part of the instruction.  Because branches
 +               * have a delay slot, the string starts two words past
 +               * the branch instruction.
 +               */
 +              string = (unsigned char *) &pc[3];
 +              /*
 +               * The offset is in 32-bit words, so subtract one for
 +               * the instruction in the branch delay slot and scale up
 +               * the offet to be in bytes.
 +               */
 +              length = 4 * ((pc[1] & 0x7FFFF) - 1);
++
 +              while (string[length - 1] == '\0') {
 +                  --length;
 +              }
++
 +              /*
 +               * Don't want to use NOT_IMPLEMENTED here because we
 +               * don't actually want to abort.  We want to continue,
 +               * but print out a useful message.
 +               */
 +              printf("NOT-IMPLEMENTED: %p: \"%.*s\"\n", pc, length, string);
++
 +              /*
 +               * Skip over the illtrap instruction so if we can
 +               * continue.  This will execute the branch, skipping
 +               * over the string too.
 +               */
 +              SC_PC(os_context) = (unsigned long) (pc + 1);
++
 +          }
 +          break;
 +#endif
  	  default:
  	      interrupt_handle_now(signal, code, os_context);
  	      break;