Definición de Registro de procesador

  Anuncios

En microprocesadores, un registro es una porción de memoria ultrarrápida, de poca capacidad e integrado al microprocesador, que permite almacenar y acceder datos usados frecuentemente. Se emplean para aumentar la velocidad de ejecución de los programas.

La mayoría de las arquitecturas de computadora emplean registros, moviendo datos desde la memoria principal hacia los registros, se opera sobre éstos, y el resultado es movido nuevamente a la memoria principal.

Existen múltiples tipos de registros como ser:

* Registro de memoria: almacenan exclusivamente direcciones de memoria.

* Registro de datos: almacenan números enteros.

* Reigistro de propósito general (GPR o General Purpose Registers): permiten almacenar tanto datos como direcciones. La mayoría de las computadoras modernas emplean este tipo de registros.

* Registro de coma flotante: almacenan datos en formato de coma flotante. 

* Registro de constantes: almacenan datos constantes (que no se cambian).

* Registro de propósito específico: almacenan información específica sobre el estado del sistema, como el puntero de pila o el registro de estado.

REGISTROSEnviado por borjaoscar

Indice1. Concepto general2. Registros de segmento.

4. Registros de propósitos generales.5. Registro índice.

1. Concepto generalLos registros del procesador se emplean para controlar instrucciones en ejecución, manejar direccionamiento de memoria y proporcionar capacidad

aritmética. Los registros son espacios físicos dentro del microprocesador con capacidad de 4 bits hasta 64 bits dependiendo del microprocesador que se emplee. Los registros son direccionables por medio de una viñeta, que es una dirección de memoria. Los bits, por conveniencia, se numeran de derecha a izquierda (15,14,13…. 3,2,1,0), los registros están divididos en seis grupos los cuales tienen un fin especifico. Los registros se dividen en:

Registros de segmento Registros de apuntadores de instrucciones Registros apuntadores Registros de propósitos generales Registro índice Registro de bandera.

2. Registros de segmento.Un registro de segmento se utiliza para alinear en un limite de párrafo o dicho de otra forma codifica la dirección de inicio de cada segmento y su dirección en un registro de segmento supone cuatro bits 0 a su derecha.Un registro de segmento tiene 16 bits de longitud y facilita un área de memoria para direccionamientos conocidos como el segmento actual. Los registros de segmento son:

Registro CS Registro DS Registro SS Registro ES Registro FS y GS

Registro CS.El DOS almacena la dirección inicial del segmento de código de un programa en el registro CS. Esta dirección de segmento, mas un valor de desplazamiento en el registro de apuntado de instrucción (IP), indica la dirección de una instrucción que es buscada para sí ejecución. Para propósito de programación normal, no e necesita referenciar el registro CS.

Registro DS.La dirección inicial de un segmento de datos de programa es almacenada en el registro DS. En términos sencillos, esta dirección, mas un valor de desplazamiento en una instrucción, genera una referencia a la localidad de un bytes especifico en el segmento de datos.

Registro SS.El registro SS permite la colocación en memoria de una pila, para almacenamiento temporal de direcciones y datos. El DOS almacena la dirección de inicio del segmento de pila de un programa en el registro SS. Esta dirección de segmento, más un valor de desplazamiento en el registro del apuntador de la pila (SP), indica la palabra actual en la pila que está siendo direccionada. Para propósitos de programación normal, no se necesita referenciar el registro SS.

Registro ESAlgunas operaciones con cadenas de caracteres (datos de caracteres) utilizan el registro esta de segmento para manejar el direccionamiento de memoria. En este contexto, el registro ES esta asociado con el registro DI (índice) . un

programa que requiere el uso del registro ES puede inicializarlo con una dirección apropiada.

Registros FS y GS.Son registros extra de segmento en los procesadores 80386y posteriores a estos procesadores.

3. Registro Apuntador de instrucciones.(IP)El registro apuntador de instrucciones (IP) de 16 bits contiene el desplazamiento de dirección de la siguiente instrucción que se ejecuta.El registro IP esta asociado con el registro CS en el sentido de que el IP indica la instrucción actual dentro del segmento de código que se esta ejecutando actualmente.En el ejemplo siguiente, el registro CS contiene 25A4[0]H y el IP contiene 412H. Para encontrar la siguiente instrucción que será ejecutada el procesados combina las direcciones en el CS y el IP así:Segmento de dirección en el registro CS: 25A40HDesplazamiento de dirección en el registro IP: + 412HDirección de la siguiente instrucción: 25E52H

Registros apuntadores.Los registros apuntadores están asociados con el registro SS y permiten al procesador accesar datos en el segmento de pila los registros apuntadores son dos:

El registro SP El registro BP

Registro SP.El apuntador de pila IP de 16 bits esta asociado con el registro SS y proporciona un valor de desplazamiento que se refiere a la palabra actual que esta siendo procesada en la pila.El ejemplo siguiente el registro SS contiene la dirección de segmento 27B3[0]H y el SP el desplazamiento 312H Para encontrar la palabra actual que esta siendo procesada en la pila el microprocesador combina las direcciones en el SS y el PP:Dirección de segmento en el registro SS: 27B30HDesplazamiento en el registro SP: + 312HDirección en la Pila: 27E42H

…….

27B3[0]H 312HDirección del segmento SS Desplazamiento del SP

Registro BP.El registro BP de 16 bits facilita la referencia de parámetros, los cuales son datos y direcciones transmitidos vía lapida.

4. Registros de propósitos generales.Los registros de propósitos generales AX, BX, CX y DX son los caballos de batalla o las herramientas del sistema. Son los únicos en el sentido de que se puede direccionarlos como una palabra o como una parte de un byte. El ultimo byte de la izquierda es la parte "alta", y el ultimo byte de la derecha es la parte

"baja" por ejemplo, el registro CX consta de una parte CH (alta) y una parte CL (baja), y usted puede referirse a cualquier parte por si nombre. Ñas instrucciones siguientes mueven ceros a los registros CX, CH y CL respectivamente.Mov CX, 00Mov CH, 00Mov CL, 00Los procesadores 80386 y posteriores permiten el uso de todos registros de propósito general, mas versiones de 32 bits; EAX, EBX y EDCX.

Registros AX.El registro AX, el acumulador principal, es utilizado para operaciones que implican entrada/salida y la mayor parte de la aritmética. Por ejemplo, las instrucciones para multiplicar, dividir y traducir suponen el uso del AX. También, algunas operaciones generan código más eficientes si se refiere al AX en lugar de los otros registros.

Registro BX.El BX es conocido como el registro base ya que es el único registro de propósitos generales que pueden ser unos índices para direccionamiento indexado. También es común emplear al BX para cálculos.

Registro CX.El CX es conocido como el registro contador. Puede contener un valor para controlar el número de veces que un ciclo se repite o un valor para corrimiento de bits, hacia la derecha o hacia la izquierda. El CX también es usado para muchos cálculos.

Registro DX.El DX es conocido como el registro de datos. Algunas operaciones de entrada/salida requieren su uso, y las operaciones de multiplicación y división con cifras grandes suponen al DX y al AX trabajando juntos. Puede usar los registros de propósitos para suma y resta de cifras de 8, 16, 32 bits.

5. Registro índice.Los registros SI y DI están disponibles para direccionamientos indexados y para sumas y restas. Que son la operaciones de punta.

Registro SI.El registro índice de 16 bits es requerido por algunas operaciones con cadenas (de caracteres). En este contexto, el SI está asociado con el registro DS. Los procesadores 80386 y posteriores permiten el uso de un registro ampliado a 32 bits, el ESI.

Registro DI.El registro índice destino también es requerido por algunas operaciones con cadenas de caracteres. En este contexto, el Di está asociado con el registro ES. Los procesadores 80386 y posteriores permiten el uso de un registro ampliado a 32 bits, el EDI.

Registro de bandera.Los registros de banderas sirven parar indicar el estado actual de la maquina y el resultado del procesamiento, Cuando algunas instrucciones piden comparaciones o cálculos aritméticos cambian el estado de las banderas.Las banderas están en el registro de banderas en las siguientes posiciones:

bits 15 14 13 12 11 10 9 8 7 6 54 3 2 1

O D I T S Z A P C

BanderaLas banderas mas comunes son las siguientes:OF (Over flow flag, desbordamiento).Indica el desbordamiento de un bit de orden alto (mas a la izquierda) después de una operación aritmética.DF (Direction flag, Direccion).Designa la dirección hacia la izquierda o hacia la derecha para mover o comparar cadenas de caracteres.IF (Interruption flag, Interrupcion).Indica que una interrupción externa, como la entrada desde el teclado sea procesada o ignorada.TF (Trap flag, Trampa).Examina el efecto de una instrucción sobre los registros y la memoria. Los programas depuradores como DEBUG, activan esta bandera de manera que pueda avanzar en la ejecución de una sola interrupción a un tiempo.SF (Sign flag, Signo).Contiene el signo resultante de una operación aritmética (0=positivo y 1= negativo).ZF (Zero flag, Zero).Indica el resultado de una operación aritmética o de comparación (0= resultado diferente de cero y 1=resultado igual a cero).AF (Auxiliary carry flag, Acarreo auxiliar).Contiene un acarreo externo del bit 3 en un dato de 8 bits, para aritmética especializadaPF (Parity flag, Paridad).Indica paridad par o impar de una operación en datos de ocho bits de bajo orden (mas a la derecha).CF (Carry flag, Acarreo).Contiene el acarreo de orden mas alto (mas a la izquierda) después de una operación aritmética; también lleva el contenido del ultimo bit en una operación de corrimiento o rotación.

Cuadro Comparativo

TIPOS DE REGISTROS FUNCION

Registros de Segmento Un registro de segmento tiene 16 bits de longitud y facilita un área de memoria para el direccionamiento conocida como el segmento actual

Registros de Apuntador de Instrucciones

Este registro esta compuesto por 16 bits y contiene el desplazamiento de la siguiente instrucción que se va a ejecutar. Los procesadores 80386 y posteriores tiene un IP ampliado de 32 bits llamado EIP.

Registros Apuntadores Permiten al sistema accesar datos al segmento de la pila. Los procesadores 80386 tiene un apuntador de pila de 32 bits llamado ESP. El sistema maneja de manera automática estos registros.

Registros de Propósito General Son los caballos de batalla del sistema y pueden ser direccionados como una palabra o como una parte de un bytes. Los procesadores 80386 y posteriores permiten el uso de todos los registros de propósitos general mas sus versiones ampliadas de 32 bits llamados EAX, EBX,ECX y EDX.

Registros Indices Sirven para el direccionamiento de indexado y para las operaciones de sumas y restas.

Registros de Banderas Sirven para indicar el estado actual de la maquina y el resultado del procesamiento. De los 16 bits de registro de bandera 9 son comunes a toda la familia de los procesadores 8086.

Ejemplo De Representacion De Los RegistrosDespués de haber conceptualizado e interpretado los diferente tipos de registro nos vemos en la necesidad de dar un ejemplo no muy practico pero si muy significativo en el cual se representan la forma estructurada de un programa en el lenguaje ensamblador y como se utilizan los diferentes termino que hemos investigado vemos que en el programa o en una pequeña porción de él se muestran como se colocan dentro los diferentes tipos registros.

 TITLE P17HANRD(EXE) Lectura secuencial de registros..MODEL SMALL.STACK 64/------------------------------------------------------------------------------------------,DATAENDCDE DB 00 ; FIN DEL INDICARDOR DE PROCESO.HANDLE DW ?IOAREA DB 32 DUP(´ ´)OPENMSG DB ´*** Open error ***´ 0DH, 0AHPATHNAM DB ´D:\NAMEFILE.SRT´, 0READMSD DB ´*** Read error ***´ 0DH, 0AHROW DB 00/---------------------------------------------------------------------------------------------.CODEBEGIN PROC FARMOV AX,@data ; inicializaMOV DS,AX ; registro deMOV ES,AX ; segmentoMOV AX,0600H

 

 

Autor:

Oscar borja

Un conjunto de instrucciones o repertorio de instrucciones, juego de

instrucciones o ISA (del inglés Instruction Set Architecture, Arquitectura del Conjunto de

Instrucciones) es unaespecificación que detalla las instrucciones que una CPU de un ordenador

puede entender y ejecutar, o el conjunto de todos los comandos implementados por un diseño

particular de una CPU. El término describe los aspectos del procesador generalmente visibles a

un programador, incluyendo los tipos de datos nativos, las instrucciones, los registros, la

arquitectura de memoria y las interrupciones, entre otros aspectos.

Existe principalmente de 3 tipos: CISC (Complex Instruction Set Computer), RISC (Reduced

Instruction Set Computer) y SISC (Simple Instruction Set Computing).

La arquitectura del conjunto de instrucciones (ISA) se emplea a veces para distinguir este

conjunto de características de la microarquitectura, que son los elementos y técnicas que se

emplean para implementar el conjunto de instrucciones. Entre estos elementos se encuentran

las microinstrucciones y los sistemas de caché.

Procesadores con diferentes diseños internos pueden compartir un conjunto de instrucciones;

por ejemplo, el Intel Pentium y AMD Athlon implementan versiones casi idénticas del conjunto

de instrucciones x86, aunque tienen diseños diferentes.

Índice

  [ocultar] 

1   El lenguaje máquina

2   Implementación del conjunto de instrucciones

3   Diseño del conjunto de instrucciones

4   Características que debe tener un conjunto de instrucciones

5   Tipos de instrucciones y ejemplos

6   Véase también

El lenguaje máquina[editar · editar código]

El lenguaje máquina está construido a partir de los estados discretos o instrucciones. En la

arquitectura de procesamiento, una instrucción dada puede especificar:

Registros particulares para operaciones aritméticas, de direccionamiento o de control.

Ubicaciones particulares de memoria

Modos de direccionamiento para interpretar operandos

Las operaciones más complejas se construyen a partir de estas, que(en una máquina Von

Neumann) se ejecutan secuencialmente, o según el control de flujo.

Muchas o pocas de las operaciones disponibles incluidas en la mayoría de conjuntos son:

Desplazamiento

Establecer un registro a un valor constante

Mover datos desde una posición de memoria a un registro y viceversa. Esto se realiza

para obtener datos para operaciones matemáticas y su almacenamiento.

Leer y escribir datos desde dispositivos de hardware

Operaciones matemáticas

Sumar, restar, multiplicar o dividir dos registros y colocar el resultado en alguno de

ellos.

Realizar operaciones bit a bit, teniendo el AND y el OR de cada bit en un par de

registros, o el NOT de cada bit en un registro.

Comparar dos valores que se encuentren en registros(por ejemplo, si son iguales o si

uno es mayor que otro)

Afectan al flujo de programa

Saltar a otra posición del programa y ejecutar instrucciones allí.

Saltar a otra posición si se cumple cierta condición

Saltar a otra posición, pero salvando la posición actual para poder volver (realizar una

llamada, por ejemplo call printf)

Algunos ordenadores incluyen instrucciones "complejas". Dichas instrucciones pueden tomar

muchas instrucciones en otros equipos. Estas se caracterizan por instrucciones que necesitan

varios pasos, como el control de múltiples unidades funcionales. Algunos ejemplos son:

Ahorro de registros en la pila

Mover grandes bloques de memoria

Complejas operaciones and/or con aritmética de coma flotante, tales como el seno o la raíz

cuadrada.

Instrucciones que combinan ALU con un operando de la memoria más que de registros.

Un tipo complejo de la instrucción que ha llegado a ser particularmente popular recientemente

es SIMD (Single Instruction, Multiple Data), una operación que realice la misma operación

aritmética en pedazos múltiples de datos al mismo tiempo. SIMD tienen la capacidad de

manipular vectores y matrices grandes en tiempo mínimo. Las instrucciones de SIMD permiten

la paralelización fácil de los algoritmos implicados comúnmente en sonido, imagen, y el proceso

video. Varias implementaciones de SIMD se han traído al mercado bajo nombres comerciales

tales como MMX, 3DNow! y AltiVec.

El diseño de sistemas de instrucción es una edición compleja. Había dos etapas en la historia

para el microprocesador. El primer era el CISC (Complex Instruction Set Computer) que tenía

muchas instrucciones diferentes. En los años 70 IBM hicieron la investigación y encontraron

que muchas instrucciones en el sistema podrían ser eliminadas. El resultado era el RISC

(Reduced Instruction Set Computer), una arquitectura que utiliza un sistema más pequeño de

instrucciones. Un conjunto de instrucción más simple puede ofrecer el potencial para

velocidades más altas, tamaño reducido del procesador, y consumo de energía reducido. Sin

embargo, un conjunto más complejo puede optimizar operaciones comunes, mejorar

memoria/eficiencia de cache, o simplificar la programación.

Implementación del conjunto de instrucciones[editar · editar código]

Cualquier conjunto de instrucciones se puede implementar de varias maneras. Todas las

maneras de implementar un conjunto de instrucciones dan el mismo modelo programado, y

todas pueden hacer funcionar los mismos ejecutables binarios. Las varias maneras de

implementar un conjunto de instrucciones dan diversas compensaciones entre el coste, el

funcionamiento, el consumo de energía, el tamaño, el etc.

Al diseñar microarquitecturas, los ingenieros usaron bloques de circuitos electrónicos

“duramente-conectados” (diseñado a menudo por separado) por ejemplo l, los multiplexores,

los contadores, los registros, ALUs etc. Un cierto tipo del lenguaje de transferencia de registros

es a menudo usado para describir la codificación y la secuencia de cada instrucción de ISA

usando esta microarquitectura física.

Hay también algunos nuevos diseños de CPU que compilan el conjunto de instrucción a una

RAM escribible o FLASH dentro de la CPU (tal como el procesador Recursiv y el Imsys Cjip), o

FPGA (computación reconfigurable). Western Digital MCP-1600 es un ejemplo antiguo, usando

una ROM dedicada, separada del microcódigo..

ISA se puede también emular en software por un intérprete. Naturalmente, debido a la

interpretación de “overhead”, es más lento que ejecutar programas directamente sobre el

hardware emulado. Hoy, es práctica para los vendedores de nuevos ISAs o microarchitectures

poner emuladores del software a disposición de los desarrolladores de programas informáticos

antes de que la implementación del hardware esté lista.

Los detalles de la implementación tienen una influencia fuerte en las instrucciones particulares

seleccionadas para el conjunto de instrucción. Por ejemplo, muchas implementaciones de la

instrucción “pipline” permiten solamente una carga de memoria (load) o almacén en memoria

(store) por instrucción, llevando a carga-almacena arquitectura (RISC). Por otro ejemplo,

algunas maneras de implementar la instrucción “pipline” llevaron a una ranura de retardo.

La demanda de procesamiento de señal digital de alta velocidad han empujado en el sentido

contrario, forzando la implementación de instrucción de manera particular. Por ejemplo, para

realizar los filtros digitales es bastante insuficiente, la instrucción del MAC en un procesador

típico de señal digital (DSP) se debe implementar usando una arquitectura de Harvard que

pueda traer una instrucción y dos palabras de datos simultáneamente, y requiere un solo ciclo.

Diseño del conjunto de instrucciones[editar · editar código]

La densidad del código

En computadoras antiguas, la memoria del programa era costosa, así que minimizar el tamaño

de un programa para asegurar que va a caber en la memoria limitada era a menudo central. Así

el tamaño combinado de todas las instrucciones necesitó realizar una tarea particular, la

densidad del código, era una característica importante de cualquier sistema de instrucción. Las

computadoras con alta densidad del código también tenían a menudo instrucciones complejas

para la entrada del procedimiento, los retornos parametrizados, los lazos etc. Sin embargo, "

instrucciones CISC" combinan simplemente una operación básica de la ALU, tal como " add",

con el acceso de uno o más operandos en memoria (usando modos de dirección tales como

directo, indirecto, indexado). Ciertas arquitecturas pueden permitir dos o tres operandos

(incluido el resultado) directamente en memoria o pueden permitir realizar funciones tales como

el incremento automático del puntero.

RISC, fueron los primeros implementados con profundidad en el período de rápido crecimiento

de las memorias de subsistemas, se reduce el código con el fin de simplificar el circuito de

aplicación y con ello tratar de aumentar el rendimiento a través de las frecuencias de reloj más

elevadas y el uso de más registros. Las instrucciones RISC suelen realizar sólo una operación,

como una "suma" de registros o una "carga" de una posición de memoria en un registro,

también suelen utilizar una longitud de instrucciones fijas, mientras que un conjunto de

instrucciones típicas CISC tiene instrucciones muchos más cortas que esta longitud fija. Las

instrucciones de longitud fija son menos complicadas de manejar que las instrucciones de

ancho variable, por varias razones (por ejemplo: no tener que comprobar si una instrucción se

extiende a ambos lados de una línea de caché o el límite de memoria virtual de la página), y

por lo tanto algo más fácil de optimizar la velocidad . Sin embargo, como los equipos RISC

normalmente requieren más y más para implementar las instrucciones que ejecutan una

determinada tarea, hacen menos óptimo el uso del ancho de banda y de la memoria caché.

Las computadoras mínimas del conjunto de instrucciones (MISC) son una forma de máquina

apilada, donde hay pocas instrucciones separadas (16-64), para poder caber instrucciones

múltiples en una sola palabra de máquina. Éstos tipo de núcleos llevan a menudo poco silicio

para implementarse, así que pueden ser observadas fácilmente en un FPGA o en una forma

multinucleo. La densidad del código es similar al RISC; la densidad creciente de la instrucción

es compensada requiriendo más de las instrucciones primitivas de hacer una tarea.

Número de operandos

El conjunto de instrucciones puede ser clasificado por el número máximo de operandos

explícitamente especificados en las instrucciones. (en los ejemplos que siguen, a, b y c se

refieren a celdas de memoria, mientras que reg1 y sucesivos se refieren a los registros de la

máquina).

0-operando, también llamada máquina de pila: todas las operaciones aritméticas se ejecutan en

la parte superior de una o dos posiciones de la pila, push y pop son las instrucciones utilizadas

para acceder a la memoria: push a, push b, add, pop c.

1-operando (máquinas de una dirección), también llamadas máquinas de acumulador, incluida

en la mayoría de las primeras computadoras y muchos microcontroladores pequeños: la

mayoría de instrucciones especifican un operando explícito a la derecha (un registro, una

posición de memoria, o una constante) y un operando a la izquierda: load a, add b, store c.

2-operando – la mayoría de las máquinas CISC y RISC entran en esta categoría: CISC – load

a, reg1, add reg1, b; store reg1, c RISC - cargas que requieren la memoria explícita, las

instrucciones serían: load a,reg1; load b,reg2; add reg1,reg2; store reg2,c

3-operando, permite una mejor reutilización de los datos: CISC - bien una sola instrucción: add

a, b, c, o más generalmente: move a,reg1; add reg1,b,c como la mayoría de las máquinas se

limitan a dos operandos de memoria. RISC - Debido a la gran cantidad de bits necesarios para

codificar los tres registros, este esquema no suele estar disponible en los procesadores RISC

con pequeñas instrucciones de 16 bits: load a,reg1; load b,reg2; add reg1+reg2->reg3; store

reg3,c;

más operandos, algunas máquinas CISC permiten una variedad de modos de direccionamiento

que permiten más de 3 operandos (registros o accesos a memoria), como el VAX "POLY",

instrucción de evaluación de polinomio.

Características que debe tener un conjunto de instrucciones[editar · editar código]

Las características que se pretende que tenga un conjunto de instrucciones son cuatro,

principalmente:

Completo: Que se pueda realizar en un tiempo finito cualquier tarea ejecutable con un

ordenador (computable o decidible).

Eficiente: Que permita alta velocidad de cálculo sin exigir una elevada complejidad en su

UC y ALU y sin consumir excesivos recursos (memoria), es decir, debe cumplir su tarea en

un tiempo razonable minimizando el uso de los recursos.

Autocontenidas: Esto es, que contengan en sí mismas toda la información necesaria para

ejecutarse.

Independientes: Que no dependan de la ejecución de alguna otra instrucción.

Se puede comprobar que para que un conjunto de instrucciones sea completo solo se

necesitan cuatro instrucciones:

-> escritura

-> mover a la izquierda una posición y leer

-> mover a la derecha una posición y leer

-> parar

En esta idea se basan las arquitecturas RISC, no obstante, con este conjunto no se puede

conseguir la eficiencia del repertorio de instrucciones por lo que en la práctica el conjunto suele

ser más amplio en aras de conseguir un mejor rendimiento, tanto en uso de recursos como en

consumo de tiempo.

Tipos de instrucciones y ejemplos[editar · editar código]

Transferencia de datos: Copian datos de un origen a un destino, sin modificar el origen y

normalmente sin afectar a los flags o indicadores de condición. Pueden transferir palabras,

fracciones de palabras (bytes, media palabra) o bloques completos de n bytes o palabras.

Estas operaciones pueden ser:

-> registro - registro

-> registro - memoria

-> memoria - registro

-> memoria - memoria

Nemotécnicos más frecuentes:

move: copia el contenido de un registro(o memoria) a otro.

store: copia el contenido de un registro a memoria.

load: copia el contenido de una posición de memoria a un registro.

move block: copia un bloque de datos de una posición de memoria a otra.

move multiple: copia del origen en varias posiciones de memoria.

exchange: intercambia el contenido de dos operandos.

clear: pone a 0 el destinto. (todos los bits)

set: pone a 1 el destino. (todos los bits)

push: introduce un dato en la cabecera de la pila. (indicada por el SP)

pop: saca un dato de la cabecera de la pila. (indicada por el SP)

Instrucciones aritméticas: Son efectuadas por la ALU y suelen cambiar los flags o

indicadores de condición.

Nemotécnicos más frecuentes:

add: Suma.

add with carry: Suma con acarreo.

subtract: Resta.

subtract with borrow: Resta teniendo en cuenta el adeudo anterior.

increment: incrementa en 1 un valor.

decrement: decrementa en 1 un valor.

multiply: multiplica.

divide: divide.

extend: aumenta el operando de tamaño.

negate: cambia de signo.

absolute: valor absoluto.

-> Pueden tener instrucciones para tratar con números en BCD e incluyen operaciones en

coma flotante, lo cual se identifica con una 'f' antes del nombre del nemotécnico como por

ejemplo:

fabsolute

Instrucciones de comparación: Suelen preceder a una instrucción de bifurcación

condicional y modifican los flags. No hay que pensar que las instrucciones de salto

condicional dependen de este repertorio, ya que lo único que hace el salto condicional es

consultar los flags y salta si precede, pero no depende de ninguna instrucción de

comparación. (de hecho cualquier operación aritmética realizada anteriormente a un salto

condicional puede provocar que este "salte").

Nemotécnicos más frecuentes:

compare: Resta los dos operandos pero no almacena el resultado, solo modifica los flags.

test: compara un cierto valor especificado con el 0.

Instrucciones lógicas: Realizan operaciones booleanas "bit a bit" entre dos operandos.

Como las aritméticas también modifican los flags.

Nemotécnicos más frecuentes:

and: el "y" lógico.

or: el "o inclusivo" lógico.

xor: el "o exclusivo" lógico.

not: la negación lógica. (complemento a 1, no confundir con el cambio de signo "negate"

que es el complemento a 2)

Instrucciones de Desplazamiento: Pueden ser aritmético o lógico y pueden incluir o no

rotaciones. Pueden ser de izquierda a derecha.

Nemotécnicos más frecuentes:

shift: desplazamiento aritmético o lógico.

rotate: rotación con o sin acarreo.

Instrucciones de bits: Comprueban un bit del operando y su valor lo reflejan en el

indicador de cero. Pueden poner un bit a 0 o complementarlo.

Nemotécnicos más frecuentes:

bit test: comprueba un bit.

bit clear: comprueba un bit y lo pone a 0.

bit set: comprueba un bit y lo pone a 1.

Instrucciones de control: Permiten modificar la secuencia normal de ejecución de un

programa, puede hacerse por salto condicional relativo o absoluto.

Se clasifican en cuatro grupos:

-> salto incondicional

-> salto condicional

-> Llamada a subrutinas

-> Gestión de las interrupciones

saltos: Pueden ser condicionales o incondicionales, se suelen especificar como jump o

brantch, y en el caso de los condicionales se suele llamar jcond o bcond donde cond es

una o más letras que indican la condición que ha de cumplirse para que el salto se

produzca.

-> Incondicional: salta sin comprobar ninguna condición.

Nemotécnicos más frecuentes: jump o brantch

-> Condicional: salta si la condición se cumple.

Nemotécnicos más frecuentes: jcond o bcond

Llamadas a subrutinas: Invoca la ejecución de funciones anteriormente definidas.

Nemotécnicos más frecuentes: call (llamada) y ret (retorno)

Gestión de interrupciones: Se usan para llamar a las rutinas de servicio de interrupción y

esto se puede hacer por hardware o bien por software. Necesita una instrucción similar a

return para retornar al contexto anterior pero restableciendo el estado de la máquina, para

no afectar a la aplicación a la cual se interrumpió (iret).

Instrucciones de E/S: Son instrucciones de transferencia salvo que el origen/destino de

dicho flujo es un puerto de un dispositivo de E/S. Estas instrucciones pueden darse

mediante dos alternativas:

->E/S "mapeada" en memoria: Los periféricos tienen direcciones asignadas de la MP por lo

que no se necesitan instrucciones especiales y las operaciones se realizan con las ya vistas,

como son: load, store y move.

->E/S independiente: Necesitan unas instrucciones especiales para indicarle al procesador

que nos estamos refiriendo al mapa de direcciones de E/S, ya que este mapa y el mapa de

memoria son disjuntos.

Nemotécnicos más frecuentes:

input o read: Pemite leer información de un puerto y trasladarla a memoria principal.

output o write: Permite escribir información en un puerto de un dispositivo.

test i/o: Lee información de control de un periférico.

control i/o: Envía información de control hacia un periférico.

Instrucciones de control y misceláneas:

Nemoténicos más frecuentes:

halt: Detiene la ejecución del programa hasta que una interrupción arranca otro programa.

wait: Sirve para deterner la ejecución de un programa hasta que sucede un determinado

evento que no es una interrupción (otra condición externa al primer programa).

nop: No realiza ninguna operación, sirve para rellenar huecos en un programa o

temporizar esperas.

enable: Habilita las interrupciones.

disable: Deshabilita las interrupciones.

test and set: Se utiliza para la implementación de la exclusión mutua, esto es, que un

procesador no pueda acceder a un determinado recurso que está siendo usado por otro

procesador en ese mismo momento.

Se usan como semáforos, esto es, se declara una variable entera que tendrá el valor 0 si el

recurso esta libre y 1 si está siendo utilizado, de manera que si un procesador comprueba y el

semáforo está en 1 tendrá que esperar hasta que este cambie a 0. (1 = s.rojo y 0 = s.verde)

Véase también[editar · editar código]

Anexo:Listados de instrucciones x86

4004, 4040

6800 (Motorola)

Alpha (DEC)

ARM (Advanced RISC Machines)

DLX (John Hennessy y David Patterson)

IA-64 (Intel)

MIPS (MIPS Computer Systems)

PA-RISC (HP)

POWER (IBM)

PowerPC (Alianza AIM)

SPARC (Sun Microsystems)

Z8, eZ8, etc.

Burroughs B5000/B6000/B7000 series

eSi-RISC

Mico32

PA-RISC

IBM 700/7000 series

System/360 y sucesores siguientes compatibles

System/370

System/390

z/Architecture

Power Architecture

PDP-11

SPARC

SuperH

Tricore

Transputer

UNIVAC 1100/2200 series

VAX

x86

IA-32 (i386, Pentium, Athlon)

x86-64 (64-bit superset of IA-32)

EISC (AE32K)

aritméticaRama de las matemáticas que se ocupa del estudio de los números, sus propiedades y las habilidades necesarias para trabajar con ellos.

Existen cuatro operaciones fundamentales en la aritmética: adición o suma, sustracción o resta, multiplicación y división. Éstas son las bases para desarrollar todas las demás operaciones, como elevación a potencias (cuadrado o cubo de un número), extracción de raíces (cuadrada o cúbica), porcentajes, fracciones y razones.

CODIGO ASCII, EBCDIC Y BCD

CODIGO ASCII, EBCDIC Y BCD

BCD

Significa decimal codificado en binario (binary coded decimal) y también se conoce por las siglas españolas CBD. Realmente no es un código de E/S, sino una forma de codificar los símbolos numéricos del 0 al 9 que se emplean en varios códigos de E/S, entre ellos ASCII que explicare mas tarde. BCD divide cada octeto en dos mitades o cuartetos, cada uno de los cuales almacena en binario un cifra. Con este código es muy fácil convertir el binario (b=2) al decimal (b=10). La representación de un numero decimal en BCD se realiza expresando el digito en su representación binaria -> 128 en BCD seria = 0001 0010 1000

EBCDIC

El código BCD se expandiría de este modo: extendido de caracteres decimales codificados en binario para el intercambio de información (extended BCD interchange intercode). ES un sistema de codificación que tiene como objetivo la representación de caracteres alfanuméricos. Es el utilizado por IBM para sus ordenadores de la serie IBM PC. En este sistema de caracteres, cada carácter tiene 8 bits, entonces, al tener 8 podremos representar hasta 2 elevado 8 = 256 caracteres. Sera posible almacenar letras mayúsculas, caracteres especiales etc… para los dispositivos de E/S.

ASCII 

Código estadunidense (para variar) Estándar para el intercambio de la información (american standard code for information interchange). Es el recomendado por en ANSI (instituto estadunidense de normas). Utiliza grupos de 7 bits por carácter, permitiendo 2 elevado 7 = 128 caracteres diferentes, lo que es

suficiente para el alfabeto con letras mayúsculas y minúsculas y símbolos de una máquina de escribir corriente. Un código ASCII extendido usa 8 bits por carácter, lo que añade otros 128 caracteres posibles. Este juego de códigos más amplio permite que se agreguen los símbolos de lenguajes extranjeros y varios símbolos gráficos. ASCII es el código más extendido y es utilizado por sistemas operativos como DOS, Windows, y UNIX.Un ejemplo: todo lo que introducimos en nuestro PC, suponiendo que este bajo un plataforma antes mencionada, o por ejemplo GNU/Linux, seria en código ASCII, claro que eso al procesarlo al ordenador, se pasaría a binario en paquetes de 8 bits ósea de 1 byte de información por carácter.

Tabla del código ASCII

32 77 M 122 z 167 º 212 ╘

33 ! 78 N 123 { 168 ¿ 213 ╒

34 “ 79 O 124 | 169 ¬ 214 ╓

35 # 80 P 125 } 170 ¬ 215 ╫

36 $ 81 Q 126 ~ 171 ½ 216 ╪

37 % 82 R 127 - 172 ¼ 217 ┘

38 & 83 S 128 Ç 173 ¡ 218 ┌

39 ' 84 T 129 ü 174 « 219 █

40 ( 85 U 130 é 175 » 220 ▄

41 ) 86 V 131 â 176 ░ 221 ▌

42 * 87 W 132 ä 177 ▒ 222 ▐

43 + 88 X 133 à 178 ▓ 223 ▄

44 , 89 Y 134 å 179 │ 224 α

45 - 90 Z 135 ç 180 ┤ 225 ß

46 . 91 [ 136 ê 181 ╡ 226 Γ

47 / 92 \ 137 ë 182 ╢ 227 π

48 0 93 ] 138 è 183 ╖ 228 Σ

49 1 94 ^ 139 ï 184 ╕ 229 σ

50 2 95 _ 140 î 185 ╣ 230 μ

51 3 96 ` 141 ì 186 ║ 231 τ

52 4 97 a 142 Ä 187 ╗ 232 Φ

53 5 98 b 143 Å 188 ╝ 233 θ

54 6 99 c 144 É 189 ╜ 234 Ω

55 7 100 d 145 æ 190 ╛ 235 δ

56 8 101 e 146 Æ 191 ┐ 236 ∞

57 9 102 f 147 ô 192 └ 237 Ǿ

58 : 103 g 148 ö 193 ┴ 238 ε

59 ; 104 h 149 ò 194 ┬ 239 ∩

60 < 105 i 150 û 195 ├ 240 ≡

61 = 106 j 151 ù 196 ─ 241 ±

62 > 107 k 152 ÿ 197 ┼ 242 ≥

63 ? 108 l 153 Ö 198 ╞ 243 ≤

64 @ 109 m 154 Ü 199 ╟ 244 ⌠

65 A 110 n 155 ¢ 200 ╚ 245 ⌡

66 B 111 o 156 £ 201 ╔ 246 ÷

67 C 112 p 157 ¥ 202 ╩ 247 ≈

68 D 113 q 158 Pt 203 ╦ 248 °

69 E 114 r 159 ƒ 204  ╠ 249 ·

70 F 115 s 160 á 205 ═ 250 ·

71 G 116 t 161 í 206 ╬ 251 √

72 H 117 u 162 ó 207 ╧ 252 n

73 I 118 v 163 ú 208 ╨ 253 ²

74 J 119 w 164 ñ 209 ╤ 254 ■

75 K 120 x 165 Ñ 210 ╥

76 L 121 y 166 ª 211 ╙

Publicado 20th October 2011 por estrella

  

 

Add a comment

Operador a nivel de bitsUna operación bit a bit o bitwise opera sobre números binarios a nivel de

sus bits individuales. Es una acción primitiva rápida, soportada directamente por

los procesadores. En procesadores simples de bajo costo, las operaciones de bit a bit, junto

con los de adición y sustracción, son típicamente sustancialmente más rápidas que la

multiplicación y la división, mientras que en los modernos procesadores de alto rendimiento

usualmente las operaciones se realizan a la misma velocidad.

Índice

  [ocultar] 

1   Tipos de operaciones

2   Operadores bit a bit

o 2.1   NOT

o 2.2   AND

2.2.1   Determinando el estado de bits

2.2.2   Extrayendo bits

2.2.3   Apagando bits

o 2.3   OR

2.3.1   Encendiendo bits

2.3.2   Copiando bits

2.3.3   Procedimiento genérico para copiar un grupo de bits

o 2.4   XOR

2.4.1   Invirtiendo bits selectivamente

2.4.2   Igualdad y desigualdad de bits

2.4.3   Asignar cero a un registro

o 2.5   En resumen

3   Operaciones de desplazamiento y rotación

o 3.1   Desplazamientos de bits

3.1.1   Desplazamiento lógico

3.1.1.1   Moviendo bits

3.1.1.2   Multiplicación y división por 2 n , de enteros sin signo

3.1.2   Desplazamiento aritmético

o 3.2   Rotación de bits

3.2.1   Rotación

3.2.2   Rotación a través del bit del acarreo

4   Véase también

Tipos de operaciones[editar · editar código]

1. Operaciones bit a bit: Ejecutan las operaciones lógicas AND, OR, XOR, NOT, etc,

sobre los bits individuales de los operandos.

2. Operaciones de Desplazamiento: Desplazan los bits de los operandos hacia la derecha

o hacia la izquierda una o más posiciones.

3. Operaciones de Rotación: Rotan los bits del operando hacia la derecha o hacia la

izquierda una o más posiciones. Pueden usar o no el flag del acarreo como un bit

adicional en la rotación.

Operadores bit a bit[editar · editar código]

En las explicaciones de abajo, cualquier indicación de una posición de un bit es contada de

derecha a izquierda a partir del bit menos significativo. Por ejemplo, el valor binario 0001 (el

decimal 1) tiene ceros en cada posición excepto en la primera.

NOT[editar · editar código]

El NOT bit a bit, o bitwise, o complemento, es una operación unaria que realiza

la negación lógica en cada bit, invirtiendo los bits del número, de tal manera que

los ceros se convierten en 1 y viceversa. Por ejemplo:

NOT 10011

= 01100

El NOT forma el complemento a uno de un valor binario dado.

En un número entero con signo en complemento a dos, el NOT da como resultado el inverso aditivo del número menos 1, es decir NOT x = -x - 1. Para obtener el

complemento a dos de un número, se debe sumar 1 al resultado, dando el negativo del

A NOT A

0 1

1 0

número. Esto equivale a un cambio de signo del número: +5 se convierte en -5, y -5 se

convierte en +5.

Para los enteros sin signo, el complemento bit a bit es la “reflexión de espejo” del número a

través del punto medio del rango del entero. Por ejemplo, para los enteros sin signo de 8 bits, NOT x = 255 - x, para los enteros sin

signo de 16 bits, NOT x = 65535 - x, y en general, para los enteros

sin signo de n bits, NOT x = (2n - 1) - x.

AND[editar · editar código]

El AND bit a bit, o bitwise, toma dos números enteros y realiza la

operación AND lógica en cada par correspondiente de bits. El resultado en

cada posición es 1 si el bit correspondiente de los dos operandos es 1, y 0

de lo contrario, por ejemplo:

0101

AND 0011

= 0001

El AND puede ser usado para filtrar determinados bits, permitiendo que unos bits pasen y los

otros no.

Determinando el estado de bits[editar · editar código]

El AND puede ser usado para determinar si un bit particular está encendido (1) o apagado (0).

Por ejemplo, dado un patrón de bits 0011, para determinar si el segundo bit está encendido se

usa una operación AND con una máscara que contiene encendido solo el segundo bit, que es

el que se quiere determinar:

0011

AND 0010 (máscara)

= 0010

Puesto que el resultado 0010 es diferente de cero, se sabe que el segundo bit en el patrón

original está encendido. Esto es a menudo llamado enmascaramiento del bit (bit masking). (Por

analogía, al uso de las cintas de enmascarar, que cubren o enmascaran porciones que no

deben ser alteradas o porciones que no son de interés. En este caso, los valores 0 enmascaran

los bits que no son de interés).

Extrayendo bits[editar · editar código]

El AND se puede usar para extraer determinados bits de un valor. Si en un byte, por ejemplo,

tenemos representados dos dígitos hexadecimales empaquetados, (uno en los 4 bits

superiores y el otro en los 4 bits inferiores), podemos extraer cada dígito hexadecimal usando

el AND con las máscaras adecuadas:

0011 0101 0011 0101

AND 1111 0000 (máscara) AND 0000 1111 (máscara)

= 0011 0000 = 0000 0101

A B A AND B

0 0 0

0 1 0

1 0 0

1 1 1

Hex. superior Hex. inferior

Apagando bits[editar · editar código]

El AND también se puede usar para apagar determinados bits. Solo hay que poner una

máscara con bits en cero en las posiciones de los bits que se quieren apagar y 1 en los demás

bits. Todos los demás bits con la máscara 1 pasarán inalterados, y los que tienen la máscara 0

se apagarán. Dado el ejemplo 0111, el segundo bit puede ser apagado usando un AND con el

patrón que tiene un cero en el segundo bit y un 1 en el resto de los bits:

0111

AND 1101 (máscara)

= 0101

OR[editar · editar código]

Una operación OR de bit a bit, o bitwise, toma dos números enteros y realiza

la operación OR inclusivo en cada par correspondiente de bits. El resultado

en cada posición es 1 si el bit correspondiente de cualquiera de los dos

operandos es 1, y 0 si ambos bits son 0, por ejemplo:

0101

OR 0011

= 0111

Encendiendo bits[editar · editar código]

El OR bit a bit, o bitwise, puede ser usado para encender un bit individual o un conjunto de bits.

Para ello se usa una máscara OR con los bits que se quieren encender en 1 y el resto de los

bits en cero. El resultado será que todos los bits originales quedarán como estaban excepto los

bits en donde la máscara tenga 1, que resultarán encendidos. Por ejemplo, si en el patrón de

bits 0101 se quiere encender el segundo bit se hará de la manera siguiente:

0101

OR 0010 (máscara)

= 0111

Copiando bits[editar · editar código]

El OR, y el desplazamiento lógico (explicado más adelante), puede ser usado para copiar un

grupo de bits a una posición determinada.

Supongamos que tenemos el signo, el exponente, y la parte significativa de un número, en

diferentes registros de 32 bits, y queremos empaquetarlos para formar un número en

representación depunto flotante de simple precisión de 32 bits:

Signo: 00000000000000000000000000000001

Exponente: 00000000000000000000000010000011

A B A OR B

0 0 0

0 1 1

1 0 1

1 1 1

Parte significativa: 00000000011100000111000000001110

Todos ellos tienen los valores correctos y tenemos que mover cada uno de ellos a su posición

para poder armar el punto flotante.

Se debe mover el signo 31 posiciones hacia la izquierda, el exponente 23 posiciones hacia la

izquierda, y la parte significativa no es necesaria moverla porque ya está en la posición

correcta. Estos desplazamientos se hacen con la operación de desplazamiento hacia la

izquierda descrito más adelante:

Signo: 10000000000000000000000000000000 <-- Se

desplaza el signo 31 posiciones hacia la izquierda

Exponente: 01000001100000000000000000000000 <-- Se

desplaza el exponente 23 posiciones hacia la izquierda

Parte significativa: 00000000011100000111000000001110 <-- La parte

significativa no se mueve, ya está en su lugar

Ahora que tenemos cada parte del número en su lugar, las combinamos para empaquetarlas y

formar el número en su representación de punto flotante de 32 bits. Para ello usamos el OR:

(Resultado final) = (Signo) OR (Exponente) OR (Parte significativa):

Signo: 10000000000000000000000000000000

Exponente: 01000001100000000000000000000000

Parte significativa: 00000000011100000111000000001110

Resultado final: 11000001111100000111000000001110

Ya tenemos el número en su representación de punto flotante definitiva.

Procedimiento genérico para copiar un grupo de bits[editar · editar código]

Para copiar una serie de bits en un lugar determinado usando OR, se necesita que ese lugar

donde se van a copiar tenga sus bits en cero (para hacer un espacio libre para poder copiar los

bits). También se necesita que el registro donde se encuentran los bits que se quieren copiar

tenga los demás bits (los que no se quieren copiar) apagados. Ambas operaciones, aclarar los

bits en el el lugar del destino, y aclarar los bits que no se quieren copiar se hacen con AND:

Tenemos dos registros de 16 bits:

Registro A: 1011 1100 0110 1100

Registro B: 1001 0001 1111 1010

Queremos copiar los cuatro bits menos significativos del registro A en el registro B.

Para ello, primero aclaramos los 4 bits menos significativos de B con una operación AND, y así

tener un espacio libre:

1001 0001 1111 1010 <-- Valor original del registro B

AND 1111 1111 1111 0000 <-- Máscara para aclarar los bits de

B donde se van a copiar los que vienen de A

= 1001 0001 1111 0000 <-- Registro B preparado para

recibir los 4 bits menos significativos de A

Luego, aclaramos los bits de A que no queremos copiar, dejando solo los bits que queremos

copiar:

1011 1100 0110 1100 <-- Valor original del registro A

AND 0000 0000 0000 1111 <-- Máscara para dejar solo los bits

de A que se quieren copiar

= 0000 0000 0000 1100 <-- Registro A con solo los bits que

se desean copiar

Ahora estamos listos para hacer el OR de A sobre B y combinar los 4 bits menos significativos

de A sobre B:

0000 0000 0000 1100 <-- Registro A con los 4 bits que se

desean copiar

OR 1001 0001 1111 0000 <-- Registro B con un espacio para

los 4 bits que desean copiar

= 1001 0001 1111 1100 <-- Registro B con los 4 bits menos

significativos de A copiados sobre él

Ahora, el registro B tiene copiado los 4 bits menos significativos de A. El

resto de los bits de B quedaron intactos.

XOR[editar · editar código]

El XOR bit a bit, o bitwise, toma dos números enteros y realiza la

operación OR exclusivo en cada par correspondiente de bits. El resultado en

cada posición es 1 si el par de bits son diferentes y cero si el par de bits son

iguales. Por ejemplo:

0101

XOR 0011

= 0110

Invirtiendo bits selectivamente[editar · editar código]

A diferencia del NOT, que invierte todos los bits de un operando, el XOR bit a bit, o bitwise,

puede ser usado para invertir selectivamente uno o más bits en un registro. Dado el patrón de

bits 0011, el segundo y el cuarto bit pueden ser invertidos por XOR con una máscara con un

patrón de bits conteniendo 1 en las posiciones que se quieren invertir, la segunda y cuarta, y 0

en las demás. Los bits de las posiciones con cero de la máscara resultarán inalterados:

A B A XOR B

0 0 0

0 1 1

1 0 1

1 1 0

0011

XOR 1010 (máscara)

= 1001

Igualdad y desigualdad de bits[editar · editar código]

XOR es equivalente y tiene la misma tabla de verdad que la desigualdad, XOR y desigualdad

son sinónimos:

A B A XOR B A <> B

0 0 0 0

0 1 1 1

1 0 1 1

1 1 0 0

El XOR puede usarse para saber si los bits correspondientes de dos operandos son iguales o

diferentes. Por ejemplo, si tenemos dos operandos, 1000 y 0010 y queremos saber si los bits

más significativos de ambos son iguales procedemos como sigue:

1000

XOR 0010

= 1010

Ahora, cada bit del resultado estará en 0 si el bit correspondiente de los dos operandos son

iguales, y en 1 si son diferentes. El bit más significativo del resultado está en 1 indicando que

son diferentes, pero tenemos que aislarlo de los demás con un AND para poder usarlo o tomar

una decisión:

1010 (resultado anterior)

AND 1000 (máscara para aislar el bit más significativo)

= 1000

Ahora lo tenemos aislado en el resultado final, que es diferente de cero indicando que los bits

más significativo de los operandos son diferentes.

Asignar cero a un registro[editar · editar código]

Los programadores avanzados de lenguaje ensamblador usan XOR como una manera eficiente

y rápida de asignar cero a un registro. Realizar XOR de un valor contra sí mismo siempre resulta en cero (A XOR A siempre es cero), y en muchas arquitecturas esta operación requiere

menos ciclos de reloj y/o memoria que cargar un valor cero a un registro (A = 0).

En resumen[editar · editar código]

Las operaciones bit a bit, o bitwise, pueden encender, apagar, dejar pasar, eliminar, o invertir,

bits individualmente o en conjunto, usando la máscara adecuada con un OR, AND, o XOR:

0011 1011 10101

10101 1010

OR 1000 (máscara) AND 1110 (máscara) AND 00111 (máscara) AND

11000 (máscara) XOR 1001 (máscara)

= 1011 = 1010 = 00101 =

10000 = 0011

Enciende el Apaga el Deja pasar los 3 Elimina

los 3 Invierte los bits

bit superior bit inferior bits inferiores bits

inferiores inferior y superior

NOT invierte los bits y XOR junto con AND permiten determinar si dos operandos tienen los bits

de una determinada posición iguales o diferentes:

NOT 1011 11010

= 0100 XOR 10100

invierte todos = 01110 (0 = bit iguales, 1 = bits diferentes)

los bits AND 00010 (se filtra el segundo bits, que es el que

interesa)

= 00010

Determina si los bits de la segunda posición

de los dos operandos son iguales o diferentes

0 = iguales

1 = diferentes

Operaciones de desplazamiento y rotación[editar · editar código]

Las operaciones de desplazamiento y rotación son:

Desplazamiento lógico

Desplazamiento aritmético

Rotación

Rotación a través del bit de acarreo

Desplazamientos de bits[editar · editar código]

Los desplazamientos de bit (bit shifts) son a veces considerados operaciones bit a bit, porque

operan en la representación binaria de un número entero en vez de sobre su valor numérico;

sin embargo, los desplazamientos de bits no operan en pares de bits correspondientes, y por lo

tanto no pueden ser llamados propiamente como "bit a bit" (bit-wise). En estas operaciones los

dígitos (bits) son movidos, o desplazados, hacia la izquierda o hacia la derecha.

Los registros en un procesador de computador tienen un ancho fijo, así que algunos bits “serán

desplazados hacia fuera” ("shifted out"), es decir, "salen" del registro por un extremo, mientras

que el mismo número de bits son “desplazados hacia adentro” ("shifted in"), es decir, "entran"

por el otro extremo; las diferencias entre los operadores de desplazamiento de bits están en

cómo éstos determinan los valores de los bits que entran al registro (desplazamiento hacia

adentro) (shifted-in).

Desplazamiento lógico[editar · editar código]

Artículo principal: Desplazamiento lógico

Desplazamiento lógico hacia la izquierda

Desplazamiento lógico hacia la derecha

Hay dos desplazamientos lógicos (logical shifts). El desplazamiento lógico hacia la izquierda

(left shift) y el desplazamiento lógico hacia la derecha (right shift). En el desplazamiento lógico

los bits de un registro son desplazados (movidos) una o más posiciones hacia la derecha o

hacia la izquierda. Los bit que salen del registro por un extremo se pierden y en el otro extremo

del registro se rellena con un bit cero por cada bit desplazado.

Por ejemplo. Si se tiene en un registro de 8 bits el valor 10110011, y se hace un

desplazamiento hacia la izquierda de un bit, todos los bits se mueven una posición hacia la

izquierda, el bit de la izquierda se pierde y entra un bit cero de relleno por el lado derecho. En

un desplazamiento de un bit hacia la derecha ocurre algo análogo, el bit de la derecha se

pierde y el de la izquierda se rellena con un cero:

10110011 10110011 <-- Bits antes del

desplazamiento

1 <-- 0110011 <-- 0 0 --> 1011001 --> 1 <-- Desplazamiento

01100110 01011001 <-- Bits después del

desplazamiento

Desplazamiento Desplazamiento

hacia la izquierda hacia la derecha

En determinados procesadores, queda almacenado el último bit que salió con el

desplazamiento del registro. En la serie de los procesadores x86dicho bit queda almacenado

en el flag del acarreo.

Moviendo bits[editar · editar código]

El desplazamiento lógico se usa para mover bits hacia la izquierda o hacia la derecha para

colocarlos en la posición adecuada.

Por ejemplo, supongamos que tenemos, en dos registros del tamaño de un byte, a dos dígitos

hexadecimales (en representación binaria de 4 bits cada uno), y se quiere empaquetarlos en un

solo byte, donde los 4 bits superiores es el hexadecimal más significativo y los 4 bits inferiores

es el hexadecimal menos significativo:

0000 1001 <-- Dígito hexadecimal más significativo (hexadecimal 9)

0000 1010 <-- Dígito hexadecimal menos significativo (hexadecimal A)

Para empaquetarlos en un solo byte, primero hay que desplazar el hexadecimal más

significativo 4 posiciones hacia la izquierda. (Esto se hace con el desplazamiento lógico hacia

la izquierda):

1001 0000 <-- hexadecimal 9, desplazado 4 bits hacia la izquierda

para colocarlo en la posición correcta dentro del byte

Luego, se hace un OR de los dos valores que contienen los dígitos hexadecimales para que

queden combinados en un solo byte:

0000 1010 <-- Hexadecimal menos significativo A

OR 1001 0000 <-- OR con el hexadecimal más significativo 9, el cual

ya está en su posición

1001 1010 <-- Byte con los dos hexadecimales empaquetados

(hexadecimal 9A)

Ahora tenemos un byte con el valor de 1001 1010, el cual tiene los dos dígitos hexadecimales

empaquetados.

Multiplicación y división por 2n, de enteros sin signo[editar · editar código]

En números enteros sin signo, el desplazamiento lógico hacia la izquierda equivale a una

multiplicación por 2 y el desplazamiento lógico hacia la derecha equivale a una división por 2.

En la división (desplazamiento hacia la derecha), se pierde el bit menos significativo, dando

como resultado un truncamiento del resultado (redondeo hacia abajo, hacia menos infinito). Así,

6 / 2 es igual a 3, pero 7 / 2 es igual a 3,5, pero el 0,5 se pierde quedando el resultado en 3.

Los programadores de lenguaje ensamblador usan esta propiedad para hacer multiplicaciones

y divisiones rápidas, de enteros sin signo, por una potencia de 2, en donde n desplazamientos

equivalen a multiplicar o dividir por 2n. También, si el procesador no tiene operaciones de

multiplicación y división de enteros, o si éstas son muy lentas, se puede multiplicar o dividir

usando desplazamientos y sumas para multiplicar y desplazamientos y restas para dividir. Por

ejemplo, para multiplicar un entero por 10, se procede como sigue (en el lenguaje ensamblador

del x86):

Se quiere multiplicar el contenido del registro EAX por 10:

En las instrucciones de abajo, EAX y EBX son registros del procesador, SHL (shift left),

desplaza el registro indicado una posición (un bit) hacia la izquierda (que equivale a multiplicar

por 2), MOV copia el registro de la derecha sobre el registro de la izquierda, y ADD suma el

registro de la derecha al registro de la izquierda.

SHL EAX, 1 ; EAX = EAX * 2 EAX = 2n ; desplaza a la

izquierda el contenido del registro EAX una posición,

; (multiplica EAX por

2)

MOV EBX, EAX ; EBX = EAX EBX = 2n ; copia el registro EAX

en EBX, ahora los dos registros tienen 2n

SHL EBX, 1 ; EBX = EBX * 2 EBX = 4n ; multiplica EBX por 2,

obteniendo 4n

SHL EBX, 1 ; EBX = EBX * 2 EBX = 8n ; vuelve a multiplicar

EBX por 2, obteniendo 8n

ADD EAX, EBX ; EAX = EAX + EBX EAX = 2n + 8n = 10n ; suma EBX

(8n) a EAX (2n),

; (ahora EAX

tiene el valor original multiplicado por 10)

Desplazamiento aritmético[editar · editar código]

Artículo principal: Desplazamiento aritmético

Desplazamiento aritmético hacia la izquierda

Desplazamiento aritmético hacia la derecha

Los desplazamientos aritméticos son similares a los desplazamientos lógicos, solo que los

aritméticos están pensados para trabajar sobre números enteros con signo en representación

de complemento a dos en lugar de enteros sin signo. Los desplazamientos aritméticos permiten

la multiplicación y la división por dos, de números enteros con signo, por una potencia de dos.

Desplazar n bits hacia la izquierda o a la derecha equivale a multiplicar o dividir por 2n,

(asumiendo que el valor no hace desbordamiento (overflow o underflow)).

El desplazamiento aritmético hacia la izquierda es exactamente igual al desplazamiento lógico

hacia la izquierda. De hecho son dos nombres diferentes para exactamente la misma

operación. Al desplazar los bits una posición hacia la izquierda es equivalente a una

multiplicación por 2 independientemente de si es un número entero con signo o sin signo. En

los procesadores x86, el ensamblador tiene dos pnemónicos para el desplazamiento lógico y el

aritmético hacia la izquierda, pero cuando el programa es ensamblado, solo hay un opcode

para ambos en la instrucción enlenguaje de máquina.

El desplazamiento aritmético hacia la derecha es diferente al desplazamiento lógico hacia la

derecha. En los enteros sin signo, para dividir por 2, se debe usar el desplazamiento lógico, el

cual siempre agrega un 0 en el extremo izquierdo por cada desplazamiento de un bit hacia la

derecha. En cambio, en los enteros con signo, se debe usar el desplazamiento aritmético hacia

la derecha, el cual copia el bit del signo (el bit más significativo(MSB)) en el espacio vacío que

queda en el extremo izquierdo cada vez que se hace un desplazamiento de un bit hacia la

derecha. De esta manera, se divide efectivamente por 2 al entero con signo.

Si el entero con signo es positivo, (con el bit del signo igual a 0), se insertará el bit 0 del signo

en el extremo izquierdo al desplazar un bit hacia la derecha (igual que el desplazamiento lógico

hacia la derecha), pero si es un entero negativo, (con el bit del signo igual a 1), se insertará el

bit 1 del bit del signo en el extremo izquierdo. De esta manera, el signo del número se preserva

con la división por 2 y el número resultante tiene sentido. Si se insertara un 0 a la izquierda a

un número negativo (como lo haría el desplazamiento lógico hacia la derecha), en primer lugar,

este número negativo cambiaría de signo a positivo, y en segundo lugar, la interpretación de los

bits restantes no tendrían sentido.

Estos ejemplos utilizan un registro de 8 bits:

00010111 (Decimal 23) (Desplazamiento aritmético hacia la izquierda

de un número positivo)

= 00101110 (Decimal 46) (El bit de la izquierda se pierde y un bit 0

se añade a la derecha)

11010111 (Decimal -41) (Desplazamiento aritmético hacia la izquierda

de un número negativo)

= 10101110 (Decimal -82) (El bit de la izquierda se pierde y un bit 0

se añade a la derecha)

00010111 (Decimal 23) (Desplazamiento aritmético hacia la derecha de

un número positivo)

= 00001011 (Decimal 11) (El bit de la derecha se pierde y el bit del

signo anterior se conserva en el resultado)

11010111 (Decimal -41) (Desplazamiento aritmético hacia la derecha

de un número negativo)

= 11101011 (Decimal -21) (El bit de la derecha se pierde y el bit del

signo anterior se conserva en el resultado)

Si el número binario es tratado como complemento a 1, entonces la misma operación de

desplazamiento hacia la derecha resulta en una división por 2n redondeando hacia el cero.

Rotación de bits[editar · editar código]

Rotación[editar · editar código]

Artículo principal: Desplazamiento circular

Otra forma de desplazamiento es el desplazamiento circular o rotación de bits. En esta

operación, los bits de un registro son “rotados” de una manera circular como si los extremos

izquierdo y derecho del registro estuvieran conectados. En la rotación hacia la izquierda, el bit

que sale por el extremo izquierdo entrará por el extremo derecho, y viceversa con la rotación

hacia la derecha. Esta operación es útil si es necesario conservar todos los bits existentes, y es

frecuentemente usada en criptografía digital.

Desplazamiento o rotación circular hacia la izquierdaDesplazamiento o rotación circular hacia la derecha

Rotación a través del bit del acarreo[editar · editar código]

Rotar a través del bit del acarreo es similar a la operación de rotar anterior (rotación sin

acarreo). La diferencia está en que los dos extremos del registro están unidos entre sí a través

del flag del acarreo, el cual queda en medio de ellos. El bit que sale por un extremo va al flag

del acarreo, y el bit original que estaba en el flag del acarreo entra al registro por el extremo

opuesto.

Si se fija el flag del acarreo de antemano, una rotación simple a través del acarreo puede

simular un desplazamiento lógico o aritmético de una posición. Por ejemplo, si el flag del

acarreo contiene 0, después de una rotación hacia la derecha a través del flag del acarreo,

equivale a un desplazamiento lógico hacia la derecha, y si el flag del acarreo contiene una

copia del bit del signo, equivale a un desplazamiento aritmético hacia la derecha. Por esta

razón, algunos microcontroladores tales como los PIC solo tienen las funciones de rotar y rotar

a través del acarreo, y no se preocupan de tener instrucciones de desplazamiento aritmético o

lógico.

Rotar a través del acarreo es especialmente útil cuando se hacen desplazamientos en números

más grandes que el tamaño nativo de la palabra del procesador, porque si, por por ejemplo, un

número grande es almacenado en dos registros y se quiere desplazar hacia la derecha un bit,

el bit que sale del extremo derecho del registro de la izquierda debe entrar por el extremo

izquierdo del registro de la derecha. Con rotación a través del acarreo, ese bit es “almacenado”

en el flag del acarreo durante el primer desplazamiento hacia la derecha sobre el registro de la

izquierda, listo para ser desplazado al registro de la derecha usando una simple rotación con

acarreo hacia la derecha y sin usar ninguna preparación extra.

Rotación hacia la izquierda a través del bit del acarreoRotación hacia la derecha a través del bit del acarreo