Modo de direccionamiento

 +----+------------------------------+ |salto| dirección | +----+------------------------------+ (Dirección efectiva del PC = dirección)

La dirección efectiva para una instrucción absoluta es el propio parámetro de dirección sin modificaciones.

 +----+------------------------------+ |salto| desplazamiento | salto relativo +----+------------------------------+ (Dirección efectiva del PC = dirección de la siguiente instrucción + desplazamiento; el desplazamiento puede ser negativo)

La dirección efectiva para una instrucción relativa al PC es el parámetro de desplazamiento sumado a la dirección de la siguiente instrucción. Este desplazamiento suele tener signo para permitir la referencia al código anterior y posterior a la instrucción. ^{[ 14 ]}

Esto es particularmente útil en relación con las instrucciones de salto , ya que los saltos típicos son a instrucciones cercanas (en un lenguaje de alto nivel, la mayoría de las sentencias if o while son razonablemente cortas). Las mediciones de programas reales sugieren que un desplazamiento de 8 o 10 bits es suficiente para aproximadamente el 90 % de los saltos condicionales (aproximadamente ±128 o ±512 bytes). ^{[ 15 ]} Para saltos a instrucciones que no están cerca, se utilizan otros modos de direccionamiento.

Otra ventaja del direccionamiento relativo al PC es que el código puede ser independiente de la posición , es decir, se puede cargar en cualquier lugar de la memoria sin necesidad de ajustar ninguna dirección.

 +-------+-----+ |saltarVía| reg | +-------+-----+ (Dirección efectiva del PC = contenido del registro 'reg')

La dirección efectiva para una instrucción indirecta de registro es la dirección en el registro especificado. Por ejemplo, (A7) para acceder al contenido del registro de dirección A7.

El efecto es transferir el control a la instrucción cuya dirección se encuentra en el registro especificado.

Muchas máquinas RISC, así como el IBM System/360 CISC y sus sucesores, tienen instrucciones de llamada a subrutinas que colocan la dirección de retorno en un registro de direcciones; el modo de direccionamiento indirecto por registro se utiliza para regresar de esa llamada a subrutina.

 +------+ | nop | ejecutar la siguiente instrucción +------+ (Dirección efectiva del PC = dirección de la siguiente instrucción)

Tras ejecutar una instrucción secuencial, la CPU ejecuta inmediatamente la siguiente instrucción.

En algunos ordenadores, la ejecución secuencial no se considera un modo de direccionamiento.

La mayoría de las instrucciones en la mayoría de las arquitecturas de CPU son instrucciones secuenciales. Debido a esto, los diseñadores de CPU suelen agregar características que sacrifican deliberadamente el rendimiento de las demás instrucciones (las instrucciones de salto) para que las instrucciones secuenciales se ejecuten más rápido.

Las bifurcaciones condicionales cargan el PC con uno de dos resultados posibles, dependiendo de la condición: la mayoría de las arquitecturas de CPU utilizan algún otro modo de direccionamiento para la bifurcación "tomada" y la ejecución secuencial para la bifurcación "no tomada".

Muchas características de las CPU modernas —la precarga de instrucciones , la segmentación más compleja , la ejecución fuera de orden , etc.— mantienen la ilusión de que cada instrucción termina antes de que comience la siguiente, lo que da los mismos resultados finales, aunque eso no sea exactamente lo que sucede internamente.

Cada " bloque básico " de dichas instrucciones secuenciales exhibe localidad de referencia tanto temporal como espacial .

Algunas arquitecturas informáticas cuentan con instrucciones condicionales (como ARM , aunque ya no para todas las instrucciones en modo de 64 bits) o instrucciones de carga condicional (como x86), que en algunos casos pueden hacer innecesarias las bifurcaciones condicionales y evitar el vaciado de la tubería de instrucciones . Una instrucción como 'compare' se utiliza para establecer un código de condición , y las instrucciones subsiguientes incluyen una comprobación de dicho código para determinar si se cumple o se ignora.

 +------+-----+-----+ |skipEQ| reg1| reg2| omitir la siguiente instrucción si reg1=reg2 +------+-----+-----+ (Dirección efectiva del PC = dirección de la siguiente instrucción + 1)

El direccionamiento de salto puede considerarse un tipo especial de modo de direccionamiento relativo al PC con desplazamientos fijos. ^{[ a ]} ​​Al igual que el direccionamiento relativo al PC, algunas CPU tienen versiones de este modo de direccionamiento que solo hacen referencia a un registro ("saltar si reg1=0") o a ningún registro, haciendo referencia implícitamente a algún bit previamente establecido en el registro de estado . Otras CPU tienen una versión que selecciona un bit específico en un byte específico para comprobar ("saltar si el bit 7 de reg12 es 0").

A diferencia de todas las demás bifurcaciones condicionales, una instrucción "skip" nunca necesita vaciar la tubería de instrucciones , aunque puede que necesite provocar que se ignore la siguiente instrucción.

 +------+-----+-----+-----+ | mul | reg1| reg2| reg3| reg1 := reg2 * reg3; +------+-----+-----+-----+

Este "modo de direccionamiento" no tiene una dirección efectiva y no se considera un modo de direccionamiento en algunos ordenadores.

En este ejemplo, todos los operandos están en registros y el resultado se coloca en un registro.

A esto a veces se le denomina "base más desplazamiento" o "truncado".

 +------+-----+-----+----------------+ | cargar | reg | base | desplazamiento | reg := RAM[base + desplazamiento] +------+-----+-----+----------------+ (Dirección efectiva = desplazamiento + contenido del registro base especificado)

Si el desplazamiento es cero, esto se convierte en un ejemplo de direccionamiento indirecto por registro ; la dirección efectiva es simplemente el valor en el registro base.

En muchas máquinas RISC, el registro  0 está fijo en cero. Si  se utiliza el registro 0 como registro base, esto se convierte en un ejemplo de direccionamiento absoluto . Sin embargo, solo se puede acceder a una pequeña porción de la memoria.

El desplazamiento suele ser pequeño en relación con el tamaño de las memorias de los ordenadores actuales. Sin embargo, se aplica el principio de localidad de referencia : en un breve lapso de tiempo, la mayoría de los elementos de datos a los que un programa quiere acceder están bastante cerca unos de otros.

Este modo de direccionamiento está estrechamente relacionado con el modo de direccionamiento absoluto indexado.

Ejemplo 1 : Dentro de una subrutina, un programador estará interesado principalmente en los parámetros y las variables locales, para lo cual suele bastar con un registro base (el puntero de marco ). Si esta rutina es un método de clase en un lenguaje orientado a objetos, entonces se necesita un segundo registro base que apunte a los atributos del objeto actual ( this o self en algunos lenguajes de alto nivel).

Ejemplo 2 : Si el registro base contiene la dirección de un tipo compuesto (un registro o una estructura), el desplazamiento se puede utilizar normalmente para seleccionar un campo de ese registro.

 +------+-----+-----+----------------+ | sumar | reg1| reg2| constante | reg1 := reg2 + constante; +------+-----+-----+----------------+

Este "modo de direccionamiento" no tiene una dirección efectiva y no se considera un modo de direccionamiento en algunos ordenadores.

La constante puede ser con signo o sin signo. Por ejemplo, move.l #$FEEDABBA, D0para mover el valor hexadecimal inmediato de "FEEDABBA" al registro D0.

En lugar de utilizar un operando de la memoria, el valor del operando se almacena dentro de la propia instrucción. En la máquina DEC VAX, el tamaño literal de los operandos podía ser de 6, 8, 16 o 32 bits.

Andrew Tanenbaum demostró que el 98% de todas las constantes de un programa cabrían en 13 bits (véase la filosofía de diseño RISC ).

 +-----------------+ | bit de acarreo libre | +-----------------+ +-------------------+ | Borrar acumulador | +-------------------+

El modo de direccionamiento implícito, también llamado modo de direccionamiento implícito ( lenguaje ensamblador x86 ), no especifica explícitamente una dirección efectiva ni para el origen ni para el destino (o a veces para ambos).

El código de operación implica la dirección efectiva de origen (si la hay) o de destino (o a veces ambas).

El direccionamiento implícito era bastante común en las computadoras antiguas (hasta mediados de la década de 1970). Estas computadoras generalmente tenían un solo registro donde se podían realizar operaciones aritméticas: el acumulador. Estas máquinas con acumulador hacen referencia implícita a ese acumulador en casi todas las instrucciones. Por ejemplo, la operación < a  := b + c; > se puede realizar usando la secuencia < load b; add c; store a; >: el destino (el acumulador) está implícito en cada instrucción "load" y "add"; el origen (el acumulador) está implícito en cada instrucción "store".

Los ordenadores posteriores generalmente tenían más de un registro de propósito general o ubicación de RAM que podía ser el origen o el destino, o ambos, para las operaciones aritméticas; por lo tanto, los ordenadores posteriores necesitan algún otro modo de direccionamiento para especificar el origen y el destino de las operaciones aritméticas.

Entre las instrucciones x86, algunas utilizan registros implícitos para uno de los operandos o resultados (multiplicación, división, salto condicional con conteo).

Algunos conjuntos de instrucciones (como x86 y AVR) tienen un registro de propósito especial llamado puntero de pila , que se incrementa o decrementa implícitamente al insertar o extraer datos de la pila, y la dirección efectiva de origen o destino es (implícitamente) la dirección almacenada en ese puntero de pila.

Otros conjuntos de instrucciones (como m68k , ARM y PowerPC) tienen más de un registro que podría usarse como puntero de pila, por lo que utilizan el modo de direccionamiento "incremento automático de registro indirecto" para especificar cuál de esos registros debe usarse al insertar o extraer datos de una pila.

Algunos conjuntos de instrucciones informáticas actuales (por ejemplo, z/Architecture e IA-32 / x86-64 ) contienen algunas instrucciones con operandos implícitos para mantener la compatibilidad con diseños anteriores.

En algunos conjuntos de instrucciones, las instrucciones que invierten el bit de modo usuario/sistema, el bit de habilitación de interrupciones, etc., especifican implícitamente el registro especial que contiene esos bits. Esto simplifica el hardware necesario para interceptar esas instrucciones y cumplir con los requisitos de virtualización de Popek y Goldberg ; en un sistema de este tipo, la lógica de interceptación no necesita examinar ningún operando (ni la dirección efectiva final), sino solo el código de operación.

Se han diseñado algunos conjuntos de instrucciones en los que cada operando se especifica implícitamente en cada instrucción: las CPU de cero operandos .

 +------+-----+--------------------------------------+ | cargar | reg | dirección | +------+-----+--------------------------------------+ (Dirección efectiva = dirección indicada en la instrucción)

Esto requiere espacio en una instrucción para una dirección bastante grande. Suele estar disponible en máquinas CISC que tienen instrucciones de longitud variable, como x86 .

Algunas máquinas RISC cuentan con una instrucción especial llamada Load Upper Literal , que coloca una constante de 16 o 20 bits en la mitad superior de un registro. Esta constante puede utilizarse como registro base en un modo de direccionamiento base-más-desplazamiento, que proporciona los 16 o 12 bits de menor orden. Esta combinación permite un direccionamiento completo de 32 bits.

 +------+-----+-----+--------------------------------+ | cargar | reg |índice| dirección | +------+-----+-----+--------------------------------+ (Dirección efectiva = dirección + contenido del registro de índice especificado)

Esto también requiere espacio en una instrucción para una dirección bastante grande. La dirección podría ser el inicio de un arreglo o vector, y el índice podría seleccionar el elemento específico del arreglo requerido. El procesador puede escalar el registro de índice para tener en cuenta el tamaño de cada elemento del arreglo .

Tenga en cuenta que esto es más o menos lo mismo que el modo de direccionamiento base más desplazamiento, excepto que el desplazamiento en este caso es lo suficientemente grande como para direccionar cualquier ubicación de memoria.

Ejemplo 1 : Dentro de una subrutina, un programador puede definir una cadena como una constante local o una variable estática . La dirección de la cadena se almacena en la dirección literal de la instrucción. El desplazamiento (qué carácter de la cadena se utilizará en esta iteración del bucle) se almacena en el registro de índice.

Ejemplo 2 : Un programador puede definir varios arreglos grandes como variables globales o variables de clase . El inicio del arreglo se almacena en la dirección literal (quizás modificada al cargar el programa por un cargador de reubicación ) de la instrucción que lo referencia. El desplazamiento (qué elemento del arreglo usar en esta iteración de un bucle) se almacena en el registro de índice. A menudo, las instrucciones de un bucle reutilizan el mismo registro para el contador del bucle y los desplazamientos de varios arreglos.

 +------+-----+-----+-----+ | cargar | reg | base|índice| +------+-----+-----+-----+ (Dirección efectiva = contenido del registro base especificado + contenido del registro índice especificado)

El registro base podría contener la dirección de inicio de un array o vector, y el índice podría seleccionar el elemento específico del array. El procesador podría ajustar el tamaño del registro de índice para que se ajuste al tamaño de cada elemento del array . Esto podría utilizarse para acceder a los elementos de un array pasado como parámetro.

 +------+-----+-----+-----+----------------+ | cargar | reg | base|índice| desplazamiento | +------+-----+-----+-----+----------------+ (Dirección efectiva = desplazamiento + contenido del registro base especificado + contenido del registro índice especificado)

El registro base podría contener la dirección de inicio de una matriz o vector de registros, el índice podría seleccionar el registro específico requerido y el desplazamiento podría seleccionar un campo dentro de ese registro. El procesador puede escalar el registro de índice para tener en cuenta el tamaño de cada elemento de la matriz .

 +------+-----+-----+-----+ | cargar | reg | base|índice| +------+-----+-----+-----+ (Dirección efectiva = contenido del registro base especificado + contenido escalado del registro índice especificado)

El registro base podría contener la dirección de inicio de una estructura de datos de matriz o vector , y el índice podría contener el desplazamiento del elemento de matriz específico requerido.

Este modo de direccionamiento ajusta dinámicamente el valor del registro de índice para tener en cuenta el tamaño de cada elemento de la matriz. Por ejemplo, si los elementos de la matriz son números de coma flotante de doble precisión que ocupan 8 bytes cada uno, el valor del registro de índice se multiplica por 8 antes de utilizarse en el cálculo de la dirección efectiva. El factor de escala suele estar restringido a ser una potencia de dos , de modo que se puede utilizar el desplazamiento en lugar de la multiplicación.

 +------+------+-----+ | cargar | reg1 | base| +------+------+-----+ (Dirección efectiva = contenido del registro base)

Algunos ordenadores tienen esto como un modo de direccionamiento distinto. Muchos ordenadores simplemente usan la base más el desplazamiento con un valor de desplazamiento de 0. Por ejemplo, (A7)

 +------+-----+-------+ | cargar | reg | base | +------+-----+-------+ (Dirección efectiva = contenido del registro base)

Tras determinar la dirección efectiva, el valor del registro base se incrementa en el tamaño del dato al que se va a acceder. Por ejemplo, (A7)+ accedería al contenido del registro de dirección A7 y, a continuación, incrementaría el puntero de dirección de A7 en 1 (normalmente 1 palabra). Dentro de un bucle, este modo de direccionamiento se puede utilizar para recorrer todos los elementos de un array o vector.

En lenguajes de alto nivel, se suele considerar conveniente que las funciones que devuelven un resultado no tengan efectos secundarios (la ausencia de efectos secundarios facilita enormemente la comprensión y validación del programa). Este modo de direccionamiento tiene como consecuencia la modificación del registro base. Si el acceso a memoria subsiguiente provoca un error (por ejemplo, fallo de página, error de bus, error de dirección) que genera una interrupción, reiniciar la instrucción se vuelve mucho más problemático, ya que puede ser necesario restablecer uno o más registros al estado en que se encontraban antes de que la instrucción comenzara originalmente.

Ha habido al menos tres arquitecturas informáticas que han tenido problemas de implementación con respecto a la recuperación de fallos cuando se utiliza este modo de direccionamiento:

• DEC PDP-11 . Podía tener uno o dos operandos de registro de autoincremento. ^{[ 17 ]} Algunos modelos, como el PDP-11/45 y el PDP-11/70, tenían un registro que registraba las modificaciones a los registros, lo que permitía al manejador de fallos deshacer las modificaciones de registro y volver a ejecutar la instrucción. ^{[ 18 ]}
• Serie Motorola 68000. Podría tener uno o dos operandos de registro de autoincremento. ^{[ 19 ]} Los procesadores 68010 y posteriores resolvieron el problema guardando el estado interno del procesador en caso de errores de bus o de dirección y restaurándolo al volver de la falla. ^{[ 20 ] [ 21 ] [ 22 ] [ 23 ]}
• DEC VAX. Could have up to 6 autoincrement register operands. The First Part Done bit in the saved processor status longword in a stack frame for a fault is set if the faulting instruction must not be restarted at the beginning, resolving the problem.^[24]

 +------+-----+-----+ | load | reg | base| +------+-----+-----+ (Effective address = new contents of base register)

Before determining the effective address, the value in the base register is decremented by the size of the data item which is to be accessed.

Within a loop, this addressing mode can be used to step backwards through all the elements of an array or vector. A stack can be implemented by using this mode in conjunction with the previous addressing mode (autoincrement).

See the discussion of side-effects under the autoincrement addressing mode.

Any of the addressing modes mentioned in this article could have an extra bit to indicate indirect addressing, i.e. the address calculated using some mode is in fact the address of a location (typically a complete word) which contains the actual effective address. On some machines the indirect word could indicate indexing, indirection, tallying^[b] or some combination.

Indirect addressing may be used for code or data. It can make implementation of pointers, references, or handles much easier, and can also make it easier to call subroutines which are not otherwise addressable. Indirect addressing does carry a performance penalty due to the extra memory access involved.

Some early minicomputers (e.g. DEC PDP-8, Data General Nova) had only a few registers and only a limited direct addressing range (8 bits). Hence the use of memory indirect addressing was almost the only way of referring to any significant amount of memory.

Half of the DEC PDP-11's eight addressing modes are deferred. Register deferred @Rn is the same as register indirect as defined above. Predecrement deferred @-(Rn), postincrement deferred @(Rn)+, and indexed deferred @nn(Rn) modes point to addresses in memory which are read to find the address of the parameter. The PDP-11's deferred mode, when combined with the program counter, provide its absolute addressing mode.

 +------+------+---------+----------------+ | load | reg1 | base=PC | offset | +------+------+---------+----------------+ reg1 := RAM[PC + offset] (Effective address = PC + offset)

El modo de direccionamiento relativo al contador de programa (PC) permite cargar un registro con un valor almacenado en la memoria de programa, a poca distancia de la instrucción actual. Puede considerarse un caso especial del modo de direccionamiento "base más desplazamiento", que selecciona el contador de programa (PC) como registro base.

Existen algunas CPU que admiten referencias de datos relativas a la PC. Dichas CPU incluyen:

La arquitectura x86-64 y la arquitectura ARMv8-A de 64 bits ^{[ 25 ]} tienen modos de direccionamiento relativo al PC, llamados "RIP-relativo" en x86-64 y "literal" en ARMv8-A. El Motorola 6809 también admite un modo de direccionamiento relativo al PC.

Las arquitecturas PDP-11 , VAX y ARM de 32 bits admiten el direccionamiento relativo al PC al tener el PC en el banco de registros.

La arquitectura IBM z/Architecture incluye instrucciones específicas, por ejemplo, Load Relative Long, con direccionamiento relativo al PC si la función General-Instructions-Extension Facility está activa.

Cuando se utiliza este modo de direccionamiento, el compilador suele colocar las constantes en un grupo de literales inmediatamente antes o inmediatamente después de la subrutina que las utiliza, para evitar que dichas constantes se ejecuten accidentalmente como instrucciones.

Este modo de direccionamiento, que siempre obtiene datos de la memoria o los almacena en ella y luego continúa secuencialmente para ejecutar la siguiente instrucción (la dirección efectiva apunta a los datos), no debe confundirse con el "salto relativo al contador de programa" (PC-relative jumper), que no obtiene ni almacena datos en la memoria, sino que salta a otra instrucción en el desplazamiento dado (la dirección efectiva apunta a una instrucción ejecutable).

Si el tamaño de la palabra es mayor que la dirección, la palabra a la que se hace referencia para el direccionamiento indirecto de memoria podría tener un indicador de indirección activado para señalar otro ciclo indirecto de memoria. Este indicador se denomina bit de indirección , y el puntero resultante es un puntero etiquetado , donde el bit de indirección indica si se trata de un puntero directo o indirecto. Es necesario tener cuidado para asegurar que una cadena de direcciones indirectas no se referencie a sí misma; de lo contrario, se puede producir un bucle infinito al intentar resolver una dirección.

Las computadoras IBM 1620 , Data General Nova y la serie HP 2100 cuentan con un direccionamiento indirecto de memoria multinivel de este tipo, lo que les permitía entrar en un bucle infinito de cálculo de direcciones. El modo de direccionamiento indirecto de memoria de la Nova influyó en la invención del código de subprocesos indirectos .

El ordenador DEC PDP-10, con direcciones de 18 bits y palabras de 36 bits, permitía el direccionamiento indirecto multinivel, con la posibilidad de utilizar un registro de índice en cada etapa. El sistema de interrupciones de prioridad se consultaba antes de la decodificación de cada palabra de dirección. ^{[ 28 ]} Por lo tanto, un bucle de direccionamiento indirecto no impediría la ejecución de las rutinas de servicio del dispositivo, incluido el controlador de expiración de intervalos de tiempo de cualquier planificador multitarea con prioridad . Una instrucción en bucle se trataría como cualquier otra tarea computacional.

En algunos ordenadores, había direcciones que se referían a registros en lugar de a almacenamiento primario, o a memoria primaria utilizada para implementar esos registros. Aunque en algunos ordenadores antiguos había direcciones de registro en el extremo superior del rango de direcciones, p. ej., IBM 650 , ^{[ 29 ] [ c ]} IBM 7070 , ^{[ 30 ] [ e ]} la tendencia ha sido usar solo direcciones de registro en el extremo inferior y usar solo las primeras 8 o 16 palabras de memoria (p. ej. ICL 1900 , DEC PDP-6/PDP-10). Esto significaba que no había necesidad de una instrucción separada de "sumar registro a registro"; bastaba con usar la instrucción de "sumar memoria a registro".

En el caso de los primeros modelos del PDP-10, que no tenían memoria caché, si se instalaba la opción de "registros rápidos", que proporcionaba circuitos más rápidos para almacenar los registros pero que aún permitía acceder a ellos como si estuvieran en la memoria, un bucle interno ajustado cargado en las primeras palabras de la memoria se ejecutaba mucho más rápido que si estuviera en una memoria de núcleo magnético.

Los modelos posteriores de la serie DEC PDP-11 asignaban los registros a direcciones en el área de entrada/salida, pero esto tenía como objetivo principal permitir el diagnóstico remoto. Curiosamente, los registros de 16 bits se asignaban a direcciones de bytes consecutivas de 8 bits.

El miniordenador DEC PDP-8 tenía ocho ubicaciones especiales (en las direcciones 8 a 15). Al acceder a ellas mediante direccionamiento indirecto de memoria, estas ubicaciones se incrementaban automáticamente antes de su uso. ^{[ 31 ]} Esto facilitaba recorrer la memoria en un bucle sin necesidad de usar el acumulador para incrementar la dirección.

La minicomputadora Data General Nova tenía 16 ubicaciones de memoria especiales en las direcciones 16 a 31. ^{[ 32 ]} Cuando se accedía a través del direccionamiento indirecto de memoria, las direcciones 16 a 23 se incrementaban automáticamente antes de su uso, y las direcciones 24 a 31 se decrementaban automáticamente antes de su uso.

Los procesadores Data General Nova , Motorola 6800 y MOS Technology 6502 tenían muy pocos registros internos. Las instrucciones aritméticas y lógicas se ejecutaban principalmente sobre valores en memoria, en lugar de sobre registros internos. Como resultado, muchas instrucciones requerían una ubicación de memoria de dos bytes (16 bits). Dado que los códigos de operación en estos procesadores tenían una longitud de solo un byte (8 bits), las direcciones de memoria podían representar una parte significativa del tamaño del código.

Los diseñadores de estos procesadores incluyeron una solución parcial conocida como direccionamiento de "página cero". Los primeros 256 bytes de memoria ($0000 – $00FF; también conocida como página "0") podían accederse mediante una dirección de memoria absoluta o indexada de un byte. Esto redujo el tiempo de ejecución de las instrucciones en un ciclo de reloj y la longitud de las instrucciones en un byte. Al almacenar los datos de uso frecuente en esta región, los programas podían ser más pequeños y rápidos.

Como resultado, la página cero se utilizaba de forma similar a un archivo de registros. Sin embargo, en muchos sistemas, esto conllevaba una alta utilización del área de memoria de la página cero por parte del sistema operativo y los programas de usuario, lo que limitaba su uso debido a la escasez de espacio libre.

El modo de direccionamiento de página cero se mejoró en varios procesadores de 8 bits de última generación, incluidos el WDC 65816 , el CSG 65CE02 y el Motorola 6809. El nuevo modo, conocido como direccionamiento de "página directa", añadió la capacidad de mover la ventana de memoria de página cero de 256 bytes desde el inicio de la memoria (dirección de desplazamiento $0000) a una nueva ubicación dentro de los primeros 64  KB de memoria.

El CSG 65CE02 permitía mover la página directa a cualquier límite de 256 bytes dentro de los primeros 64  KB de memoria, almacenando un valor de desplazamiento de 8 bits en el nuevo registro de página base (B). El Motorola 6809 podía hacer lo mismo con su registro de página directa (DP). El WDC 65816 fue un paso más allá y permitió mover la página directa a cualquier ubicación dentro de los primeros 64  KB de memoria, almacenando un valor de desplazamiento de 16 bits en el nuevo registro directo (D).

Como resultado, un mayor número de programas pudieron utilizar el modo mejorado de direccionamiento directo de páginas en comparación con los procesadores antiguos que solo incluían el modo de direccionamiento de página cero.

Esto es similar al direccionamiento de índice escalado, excepto que la instrucción tiene dos operandos adicionales (normalmente constantes) y el hardware comprueba que el valor del índice esté comprendido entre estos límites.

Otra variante utiliza descriptores vectoriales para contener los límites; esto facilita la implementación de matrices asignadas dinámicamente y aún así permite una comprobación completa de los límites.

Algunos ordenadores disponían de modos especiales de direccionamiento indirecto para los subcampos dentro de las palabras.

La palabra indirecta de direccionamiento de caracteres de la serie GE/Honeywell 600 especificaba campos de caracteres de 6 o 9 bits dentro de su palabra de 36 bits .

El DEC PDP-10 , también de 36 bits, contaba con instrucciones especiales que permitían tratar la memoria como una secuencia de campos de bits de tamaño fijo o bytes de cualquier tamaño, desde 1 bit hasta 36 bits. Un descriptor de secuencia de una palabra en la memoria, llamado "puntero de byte", almacenaba la dirección de palabra actual dentro de la secuencia, una posición de bit dentro de la palabra y el tamaño de cada byte.

Existían instrucciones para cargar y almacenar bytes a través de este descriptor, y para incrementar el descriptor para que apuntara al siguiente byte (los bytes no se dividían entre límites de palabra). Gran parte del software de DEC utilizaba cinco bytes de 7 bits por palabra (caracteres ASCII simples), con un bit por palabra sin usar. Las implementaciones de C tenían que utilizar cuatro bytes de 9 bits por palabra, ya que la función 'malloc' en C asume que el tamaño de un int es algún múltiplo del tamaño de un char ; ^{[ 33 ]} el múltiplo real lo determina el operador de tiempo de compilación dependiente del sistema sizeof .

El Elliott 503 , ^{[ 34 ]} el Elliott 803 , ^{[ 34 ] [ 35 ]} y el Apollo Guidance Computer solo usaban direccionamiento absoluto y no tenían registros de índice. Por lo tanto, los saltos indirectos, o saltos a través de registros, no eran compatibles en el conjunto de instrucciones. En cambio, se podía instruir para agregar el contenido de la palabra de memoria actual a la siguiente instrucción . Agregar un valor pequeño a la siguiente instrucción a ejecutar podría, por ejemplo, cambiar a JUMP 0en a JUMP 20, creando así el efecto de un salto indexado. Nótese que la instrucción se modifica sobre la marcha y permanece sin cambios en la memoria, es decir, no es código automodificable . Si el valor que se agregaba a la siguiente instrucción era lo suficientemente grande, podría modificar el código de operación de esa instrucción, así como o en lugar de la dirección.