From 6e5c24e786277417fedfea9a6844092de11775df Mon Sep 17 00:00:00 2001 From: Lutz Euler Date: Tue, 17 Apr 2012 15:20:05 +0200 Subject: [PATCH] Micro-optimize type tests using widetag on x86-64. Change %TEST-HEADERS not to load the widetag of the value to be tested into AL if only a single comparison is needed on it, instead do the comparison directly with the memory operand. This is smaller and needs fewer execution ressources. This is a port of what is done on x86 already, with two modifications: * Widetag ranges starting with the smallest widetag or ending with the largest widetag use the memory operand here but go through AL on x86. * x86 exploits the specially choosen widetag values of components of compound types (like BASE-STRING) to test for these types with only an additional "and" operation but still only a single comparison. This can't be done on x86-64 currently as under 64-bit wordsize the widetag values are different and don't have the necessary property (namely to differ in only a single bit). Additionally, when AL needs to be loaded, use EAX instead so as not to write a partial register (as recommended by the processors' optimization guides). Same code size, potentially faster. Silence a "deleting unreachable code" warning during build by removing an IF and the corresponding unreachable expression. --- src/compiler/x86-64/type-vops.lisp | 33 ++++++++++++++++++++++++--------- 1 file changed, 24 insertions(+), 9 deletions(-) diff --git a/src/compiler/x86-64/type-vops.lisp b/src/compiler/x86-64/type-vops.lisp index 0e8c9c4..47b18d3 100644 --- a/src/compiler/x86-64/type-vops.lisp +++ b/src/compiler/x86-64/type-vops.lisp @@ -83,7 +83,8 @@ (defun %test-headers (value target not-p function-p headers &optional (drop-through (gen-label))) (let ((lowtag (if function-p fun-pointer-lowtag other-pointer-lowtag))) - (multiple-value-bind (equal less-or-equal greater-or-equal when-true when-false) + (multiple-value-bind (equal less-or-equal greater-or-equal when-true + when-false) ;; EQUAL, LESS-OR-EQUAL, and GREATER-OR-EQUAL are the conditions ;; for branching to TARGET. WHEN-TRUE and WHEN-FALSE are the ;; labels to branch to when we know it's true and when we know @@ -92,14 +93,30 @@ (values :ne :a :b drop-through target) (values :e :na :nb target drop-through)) (%test-lowtag value when-false t lowtag) - (inst mov al-tn (make-ea :byte :base value :disp (- lowtag))) - (do ((remaining headers (cdr remaining))) + (do ((remaining headers (cdr remaining)) + ;; It is preferable (smaller and faster code) to directly + ;; compare the value in memory instead of loading it into + ;; a register first. Find out if this is possible and set + ;; WIDETAG-TN accordingly. If impossible, generate the + ;; register load. + ;; Compared to x86 we additionally optimize the cases of a + ;; range starting with BIGNUM-WIDETAG or ending with + ;; COMPLEX-ARRAY-WIDETAG. + (widetag-tn (if (and (null (cdr headers)) + (or (atom (car headers)) + (= (caar headers) bignum-widetag) + (= (cdar headers) complex-array-widetag))) + (make-ea :byte :base value :disp (- lowtag)) + (progn + (inst mov eax-tn (make-ea :dword :base value + :disp (- lowtag))) + al-tn)))) ((null remaining)) (let ((header (car remaining)) (last (null (cdr remaining)))) (cond ((atom header) - (inst cmp al-tn header) + (inst cmp widetag-tn header) (if last (inst jmp equal target) (inst jmp :e when-true))) @@ -108,12 +125,12 @@ (end (cdr header))) (cond ((= start bignum-widetag) - (inst cmp al-tn end) + (inst cmp widetag-tn end) (if last (inst jmp less-or-equal target) (inst jmp :be when-true))) ((= end complex-array-widetag) - (inst cmp al-tn start) + (inst cmp widetag-tn start) (if last (inst jmp greater-or-equal target) (inst jmp :b when-false))) @@ -121,9 +138,7 @@ (inst cmp al-tn start) (inst jmp :b when-false) (inst cmp al-tn end) - (if last - (inst jmp less-or-equal target) - (inst jmp :be when-true))) + (inst jmp :be when-true)) (t (inst sub al-tn start) (inst cmp al-tn (- end start)) -- 1.7.10.4