¿Cómo distingue el microcontrolador el carácter char, el sin signo o el int, los números rotos y enteros y el flotador?

  

¿Cómo representa el microcontrolador el número dual 1001,0001 en   Los registros con una coma? ¿Dónde está la coma?

No sé a qué te refieres con un "número dual" y mucho menos a uno "completo" y "roto". Si el número binario 1001,0001 aparece en el código del ensamblador con la coma para facilitar la lectura, para dividirlo en nibbles (como con un número decimal como 123,456 en la vida cotidiana para dividirlo en miles), eso será una función de el ensamblador No hay una coma almacenada en un registro.

  

¿Cómo sabe el microcontrolador que, por ejemplo, el número 1001 es   -1 o 9?

Cuando el número es un desplazamiento, por ejemplo, en una instrucción de indexación, o una instrucción de bifurcación, por lo general se trata como un desplazamiento signed .

El programador puede elegir usar las instrucciones de multiplicación y división signed o unsigned .

En aritmética general, el procesador no sabe si un operando es signed o unsigned . Esto viene del contexto. El procesador realiza la operación y establece varios indicadores, y luego el programador o compilador prueba las combinaciones de indicadores, según el contexto.

Por ejemplo, una comparación unsigned podría usar la instrucción de bifurcación ja (saltar si está arriba) que prueba las banderas Carry y Zero .

Pero una comparación de signed podría usar la instrucción de bifurcación jg (saltar si es mayor) que prueba las banderas Sign , Overflow y Zero .

Aparte: en la típica notación de complemento de 2 su valor binario de 4 bits 1001 es decimal -7 . El valor decimal -1 es binario 1111 .

  

¿Cómo puede distinguir entre los diferentes tipos?

El procesador de proceso no puede distinguir, que es el trabajo del programador o compilador, para usar las instrucciones apropiadas. Todo lo que tiene es un conjunto de bits y hace lo que el programador le dice.

Acabamos de cubrir esto en otra pregunta. El cpu (completo o micro no importa), no tiene noción de sin signo o firmado o flotante o ascii o decimal. es sólo bits ... El programador, el humano, a estas personas les importa, pero el procesador no. Al igual que preguntar al papel, ¿cómo sabe que el grafito o la tinta en él es una imagen o palabras, inglés o español, cálculo o álgebra? No sabe, no importa, son solo las moléculas que se han unido.

Para la computadora, estos son solo bits, por breves momentos de tiempo, un reloj o quizás unos pocos, los bits pueden ser operandos.

Digamos que tienes un puntero

char *p;

le asignas a ese puntero una dirección

p = (char *)0x1234;

modificas ese puntero

p++;

¿Sabe la CPU que la ubicación de la memoria es un puntero? Ciertamente no, la primera línea no hace nada pero hace que la cadena de herramientas declare algo de espacio en la memoria (suponiendo que esto no esté optimizado en registros) en algún lugar para este puntero. La segunda línea hace que se almacene un poco de inmediato en esa ubicación, definitivamente no parece una dirección para la CPU. La tercera línea hace que se lea la ubicación de la memoria, se agrega un 1 y se vuelve a escribir ese número. Entonces, los datos en esa ubicación de memoria son solo algunos números que, por un breve momento, fueron un operando en un agregado. ¿Sabe el procesador la adición sin firmar de la adición firmada? No, la belleza de dos complementos hace que no sea necesario. 1001 + 1 = 1010 es a la vez 9 + 1 = 10 y -7 + 1 = -6 al mismo tiempo, es el lector a quien no le importa el procesador. Para ambas operaciones puede tener un procesador con indicadores y, en general, aunque puede haber una excepción, se calculan los indicadores de desbordamiento firmados y no firmados. Luego, después de eso, tal vez el programador humano pueda decir que si esto es menor que usar una variable con signo en algún lenguaje de programación, se puede usar una u otra bandera o una combinación de todas las banderas. A la CPU no le importa, simplemente ejecuta las instrucciones (más bits, no puede decir una instrucción a partir de los datos, los bits deben ordenarse cuidadosamente para que, al ser interpretados por la CPU, no intente ejecutar lo que el humano piensa que es información) se le indica que ejecute, si dice comparar el indicador de desbordamiento firmado, lo hará si le dice que compare el indicador de desbordamiento sin signo.

char *p;
unsigned int x;
void fun ( void )
{
    p=(char *)0x1234;
    x=0x1234;
    p++;
    x++;
}

da

00000000 <fun>:
   0:   e59f3010    ldr r3, [pc, #16]   ; 18 <fun+0x18>
   4:   e59f1010    ldr r1, [pc, #16]   ; 1c <fun+0x1c>
   8:   e59f2010    ldr r2, [pc, #16]   ; 20 <fun+0x20>
   c:   e5813000    str r3, [r1]
  10:   e5823000    str r3, [r2]
  14:   e12fff1e    bx  lr
  18:   00001235    andeq   r1, r0, r5, lsr r2

el compilador tomó lo que el humano quería hacer y creó el código de máquina y los datos para hacerlo.

¿Observa cómo las instrucciones y, por lo tanto, la CPU no pueden distinguir un puntero desde una variable simple?

int sfun ( int x )
{
    return(x-9);
}
unsigned int ufun ( unsigned int x )
{
    return(x+0xFFFFFFF7);
}

da

00000000 <sfun>:
   0:   e2400009    sub r0, r0, #9
   4:   e12fff1e    bx  lr

00000008 <ufun>:
   8:   e2400009    sub r0, r0, #9
   c:   e12fff1e    bx  lr

hizo lo que le pedí de manera optimizada, la CPU no puede decir que ha firmado un signo sin firmar.