PIC18 - problemas para hacer que la rutina del ensamblador en línea funcione

Ya que desea reemplazar toda la subrutina, el ensamblador en línea es un poco tonto. Escribir toda la rutina en ensamblador. De esa manera, el compilador no puede interferir haciendo cosas al entrar y salir de la rutina y similares.

También sería mejor explicar qué es lo que realmente quiere que haga esta rutina que definirla implícitamente con el código C. Tienes:

  tmr0_temp = TMR0L;
  TMR0L = 0;
  tmr1_temp = TMR1L;
  TMR1L = 0;

  tmr0_value = tmr0_temp;
  tmr1_value = tmr1_temp;

Aparentemente desea una instantánea del temporizador 0 en modo de 16 bits en una variable separada. Tu código anterior no funcionará para eso en todos los casos, ya que no trataste el incremento de bytes alto entre las dos lecturas.

A menos que acceda a los dos registros finales en una rutina que podría ser interrumpida por este, no es necesario el registro temporal. En realidad, sin deshabilitar las interrupciones, no se puede garantizar que el valor final de 16 bits se escriba atómicamente de todos modos. O te importa la actualización atómica o no. Su método no tiene sentido ya que parece importarle en una parte, pero al final no lo garantiza.

También está restableciendo el temporizador a 0, lo que suele ser una mala idea. Este suele ser el resultado de querer realizar mediciones secuenciales de intervalos de tiempo sin haberlo pensado muy bien. Si la razón por la que necesita que esta rutina se ejecute tan rápido es porque desea minimizar las instrucciones que pierde debido al restablecimiento del temporizador, entonces esta es definitivamente la forma incorrecta de hacerlo. Tome una instantánea en cada punto en el que desee medir el intervalo, luego haga una resta de 16 bits sin firmar. Eso le dará el intervalo sin que se pierda ningún ciclo cuando se reinicie el temporizador.

Si puede permitir que el temporizador se apague por unos pocos ciclos, entonces apáguelo, léalo, bórrelo y reinícielo. Realmente no veo un caso donde tu método tenga sentido.

En cualquier caso, aquí hay un fragmento de código de ejemplo que toma una instantánea constante del temporizador 0 mientras lo deja en ejecución (sin probar, ni siquiera con la sintaxis marcada):

         extern  t0snapshot  ;16 bit snapshot of timer 0

;*********************************************************************
;
;   Subroutine T0_GRAB
;
;   Grab the current timer 0 value into T0SNAPSHOT.  The timer will
;   continue running the whole time.
;
         global  t0_grab
t0_grab
         banksel t0snapshot  ;set bank for access to output variable
t0_retry                     ;back here if high byte changed
         movf    tmr0h, w    ;get the timer high byte
         movwf   t0snapshot+1 ;save it
         movff   tmr0l, t0snapshot+0 ;grab the low byte
         xorwf   tmr0h, w    ;check the high byte again
         bnz     t0_retry    ;high byte changed, try again ?

         return

Note esta construcción llamada "comentarios" en esta rutina. Esas son cosas muy útiles que necesitas aprender. El código no documentado es en realidad ningún código.