一直有个疑问是关于数据类型的

cnppk

高级语言中有数据类型，高级语言翻译成机器指令没有数据类型之说。比如说一条指令是访问一个内存地址也就是高级语言中的一个变量，那cpu怎么知道这个地址以后的几个字节都是属于这个变量的呢？也就是数据类型在机器语言级别是如何实现的？是不是有额外的表来记录程序每个需要用到的地址是几个字节，这个问题一直困扰着我，还请高人能解答。

cjaizss

每条指令都包含着到底要运算、搬移具体到多少个字节的信息

cnppk

cjaizss 发表于 2012-11-15 16:34
每条指令都包含着到底要运算、搬移具体到多少个字节的信息

谢谢版主的解答,也就是计算机从底层支持数据类型？

liuiang

可以这么说，但也不全是，大家支持的很微妙。简单说，大多数RISC处理器在数据load的时候，可以通过指令区分load位宽和符号（0扩展或者符号扩展），但对于数据处理指令则并不一定区分，典型的add指令就不会区分数据类型。

类型信息并不会被显示存储，而是编译器根据高级语言中数据类型信息，来编排汇编指令，比如：

对char变量，编译器会在load的时候，通过专用的字节load指令并进行符号扩展，完成内存到CPU内部寄存器的载入；
再比如unsigned short变脸，编译器也会在数据读取的时候安排一个0扩展的半字load；

而对于寄存器向外部存储器写入，则只控制位宽，不控制符号（你可以想想为什么）。

以上主要针对RISC，类似x86，则更为灵活，你可以深入研究研究。

cnppk

liuiang 发表于 2012-11-16 23:43
可以这么说，但也不全是，大家支持的很微妙。简单说，大多数RISC处理器在数据load的时候，可以通过指令区分 ...

你的意思就是说有不同位宽的指令来处理数据载入的问题而数据处理就没有？

liuiang

回复 5# cnppk


    RISC基本都是这样的，就算mips有add addu两条指令，后者的目的也不是专门用于u的。CISC没有深挖过。

cnppk

liuiang 发表于 2012-12-05 17:15
回复 5# cnppk

能不能拿mov 来举个列子呢？

liuiang

回复 7# cnppk


    x86木有研究过，你可以研究看看。

cnppk

liuiang 发表于 2012-12-05 17:33
回复 7# cnppk

不是x86的也可以呀，举个例子呗

liuiang

1. Disassembly of section .text:
   
2. 
   
3. 00000000 <fooChar>:
   
4. unsigned short unShA, unShB;
   
5. int inA, inB;
   
6. unsigned int unInA, unInB;
   
7. 
   
8. char fooChar()
   
9. {
   
10.    0:   e59f3014        ldr     r3, [pc, #20]   ; 1c <fooChar+0x1c>
    
11.    4:   e59f2014        ldr     r2, [pc, #20]   ; 20 <fooChar+0x20>
    
12.    8:   e5d30000        ldrb    r0, [r3]
    
13.    c:   e5d23000        ldrb    r3, [r2]
    
14.   10:   e0800003        add     r0, r0, r3
    
15.     return chA + chB;
    
16. }
    
17.   14:   e20000ff        and     r0, r0, #255    ; 0xff
    
18.   18:   e1a0f00e        mov     pc, lr
    
19.         ...
    
20. 
    
21. 00000024 <fooUnchar>:
    
22. unsigned char fooUnchar()
    
23. {
    
24.   24:   e59f3014        ldr     r3, [pc, #20]   ; 40 <fooUnchar+0x1c>
    
25.   28:   e59f2014        ldr     r2, [pc, #20]   ; 44 <fooUnchar+0x20>
    
26.   2c:   e5d30000        ldrb    r0, [r3]
    
27.   30:   e5d23000        ldrb    r3, [r2]
    
28.   34:   e0800003        add     r0, r0, r3
    
29.     return unChA + unChB;
    
30. }
    
31.   38:   e20000ff        and     r0, r0, #255    ; 0xff
    
32.   3c:   e1a0f00e        mov     pc, lr
    
33.         ...
    
34. 
    
35. 00000048 <fooShort>:
    
36. 
    
37. short fooShort()
    
38. {
    
39.   48:   e59f3018        ldr     r3, [pc, #24]   ; 68 <fooShort+0x20>
    
40.   4c:   e59f2018        ldr     r2, [pc, #24]   ; 6c <fooShort+0x24>
    
41.   50:   e1d300b0        ldrh    r0, [r3]
    
42.   54:   e1d230b0        ldrh    r3, [r2]
    
43.   58:   e0800003        add     r0, r0, r3
    
44.   5c:   e1a00800        lsl     r0, r0, #16
    
45.     return shA + shB;
    
46. }
    
47.   60:   e1a00840        asr     r0, r0, #16
    
48.   64:   e1a0f00e        mov     pc, lr
    
49.         ...
    
50. 
    
51. 00000070 <fooUnshort>:
    
52. unsigned short fooUnshort()
    
53. {
    
54.   70:   e59f3018        ldr     r3, [pc, #24]   ; 90 <fooUnshort+0x20>
    
55.   74:   e59f2018        ldr     r2, [pc, #24]   ; 94 <fooUnshort+0x24>
    
56.   78:   e1d300b0        ldrh    r0, [r3]
    
57.   7c:   e1d230b0        ldrh    r3, [r2]
    
58.   80:   e0800003        add     r0, r0, r3
    
59.   84:   e1a00800        lsl     r0, r0, #16
    
60.     return unShA + unShB;
    
61. }
    
62.   88:   e1a00820        lsr     r0, r0, #16
    
63.   8c:   e1a0f00e        mov     pc, lr
    
64.         ...
    
65. 
    
66. 00000098 <fooInt>:
    
67. 
    
68. int fooInt()
    
69. {
    
70.   98:   e59f3010        ldr     r3, [pc, #16]   ; b0 <fooInt+0x18>
    
71.   9c:   e59f2010        ldr     r2, [pc, #16]   ; b4 <fooInt+0x1c>
    
72.   a0:   e5931000        ldr     r1, [r3]
    
73.   a4:   e5920000        ldr     r0, [r2]
    
74.     return inA + inB;
    
75. }
    
76.   a8:   e0810000        add     r0, r1, r0
    
77.   ac:   e1a0f00e        mov     pc, lr
    
78.         ...
    
79. 
    
80. 000000b8 <fooUnint>:
    
81. unsigned int fooUnint()
    
82. {
    
83.   b8:   e59f3010        ldr     r3, [pc, #16]   ; d0 <fooUnint+0x18>
    
84.   bc:   e59f2010        ldr     r2, [pc, #16]   ; d4 <fooUnint+0x1c>
    
85.   c0:   e5931000        ldr     r1, [r3]
    
86.   c4:   e5920000        ldr     r0, [r2]
    
87.     return unInA + unInB;
    
88. }
    
89.   c8:   e0810000        add     r0, r1, r0
    
90.   cc:   e1a0f00e        mov     pc, lr
    
91.         ...
    

复制代码

仅供参考。