Fast addition on a list of values

CONSTANT:      EQU   123

RANGE_START:   DW    1234
RANGE_END:     DW    5678

           ; (Initialization can be done faster most likely, keeping it readable for now).
           LD   A,(RANGE_START + 0)
           LD   (DATA2 + 1),A
           LD   A,(RANGE_START + 1)
           LD   B,A          ; B = High byte of (RANGE_START).

           LD   A,(RANGE_END + 0)
           LD   (DATA1 + 1),A
           LD   A,(RANGE_END + 1)
           LD   C,A          ; C = High byte of (RANGE_END).

           LD   DE,CONSTANT  ; E = CONSTANT (8 bits).
                             ; D = 0 (Note: if CONSTANT were 16 bit, the algorithm would still work).

LOOP:
           ; Add to low byte.
           LD   A,E          ; 5
           ADD  A,(HL)       ; 8
           LD   (HL),A       ; 8
           INC  HL           ; 7
           EX   AF,AF'       ; 5   Keep the low byte for later when needed.

           ; Add to high byte and include carry.
           LD   A,D          ; 5   Set A to 0 but we don't loose the carry.
           ADC  A,(HL)       ; 8
           LD   (HL),A       ; 8
           INC  HL           ; 7

           ; Check with start of range (high byte).
           CP   B            ; 5
           RET  C            ; 6 or 12  If carry then value is definitely smaller than (RANGE_START).
           JR   Z,JUMP1      ; 8 or 13  If equal to high byte then check low byte as well.
                             ;          Otherwise value is definitely larger than (RANGE_START).
           
JUMP2:
           ; Check with end of range (high byte).
           CP   C            ; 5
           JP   C,LOOP       ; 11       If carry then value is definitely smaller than (RANGE_END).
           RET  NZ           ; 6 or 12  If not equal to high byte then value is definitely larger than (RANGE_END).

           ; Check with end of range (low byte).
           EX   AF,AF'       ; 5        A = Low byte.
           
DATA1:     CP   0            ; 8        0 becomes low byte of (RANGE_END).
           
           JP   C,LOOP       ; 11       If carry then value is definitely smaller than (RANGE_END).
           JP   Z,LOOP       ; 11       If zero then value is equal to (RANGE_END).
           RET

JUMP1:     ; Check with start of range (low byte).
           EX   AF,AF'       ; 5        A = Low byte.
DATA2:     CP   0            ; 8        0 becomes low byte of (RANGE_START).
           RET  C            ; 6 or 12  If carry then value is definitely smaller than (RANGE_START).
                             ;          Otherwise it is equal or larger.
           EX   AF,AF'       ; 5
           JP   JUMP2        ; 11

WARNING: not tested code!

The main idea behind it is that you don't need to do a full 16 bit comparison on the range values, but first inspect the high-byte to see if the value can actually be outside of the ranges or not. Only when the high byte matches would you then need to check the low byte, otherwise you can just skip it and move on.

This is not only a bit faster, it also means you need less Z80 registers for storing 16 bit computation results and you can thus use them for something else and/or don't need to switch to shadow registers and back.

Rough performance comparison:

Old solution:

Adding value = 64 T-states (but I think your code snippet is incomplete and you need an additional INC HL and EXX somewhere, which would bring it to 76 T-states).
Range check: 72 T-states

New solution:

Adding value: 61 T-states.
Range check: 41 T-states (best-case), 75 T-states (worst-case).

As you can see my solution performs worse in worst-case scenarios, however, those should be much rarer (depending on the data of course).

I would say, give it a try and see if it works better for you or not

(Ps.: This example uses some self-modifying code tricks, which will not work if your code is stored in ROM of course).

Very nice solutions
Thanks to both of you, now is the time to do some testing !

Note also that by offsetting the values and the ranges by 8000h, they become unsigned, and you can then test with the carry flag instead of the sign flag. Adding 8000h just needs flipping bit 15. The gain is small in this case, though, just 2*(17-12)-8 = 2 cycles.

Here's an example using your original code. Prepare range_start and range_end by flipping bit 15, then:

.loop	ld	a,e			;  5 | e = 8-bit constant
	exx				;  5 (std)
	add	(hl)			;  8
	ld	c,a			;  5
	ld	(hl),c			;  8
	inc	hl			;  7
	adc	(hl)			;  8
	sub	c			;  5
	ld	(hl),a			;  8
	xor	128			;  8 | flip bit 15 of BC
	ld	b,a			;  5

;-------------------------------------------------------------------------------
; test range
;-------------------------------------------------------------------------------
	ex	de,hl				;  5
	ld	hl,(range_stop)		; 17 | range_stop is a negative value
	add	hl,bc				; 12
	jp	nc,.off_range			; 11

	ld	bc,range_stop-range_start	; 11
	add	hl,bc				; 12
	jp	c,.off_range			; 11
	(...)

(untested)