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

cnppk

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

cnppk

tianhuo7766 发表于 2012-12-26 10:25
草真想骂人，这么多人都没一个回答到点子，都是些不完全懂的人！我来说说吧，大家知道，高级语言和汇编相对 ...

说的简单易懂，归根结底就是字节大小不同机器指令不同

tianhuo7766

草真想骂人，这么多人都没一个回答到点子，都是些不完全懂的人！我来说说吧，大家知道，高级语言和汇编相对应，那么从汇编语言层次看，比如MOV ECS $88,这条汇编，因为有寄存器的参与，所以他是4字节的，如果MOV CS $88，他是2字节的，寄存器起到识别后边内存到底是几个；另外，汇编有DD DB一些伪指令也表示字节数，如果是把内存11移动到内存22，那么是这样MOV  byte ptr内存22 byte ptr内存11， byte ptr这个来表示到底是几个字节的，最后，如果从机器码看，实际每条汇编就是一个机器指令，那么机器指令实际已经决定了操作数据的类型。大概就这样，里面例子可能不正确，但是就是这样的，想说清楚还真得打好几百子，真说不清楚，将就看吧！

cnppk

dyyseo 发表于 2012-12-06 17:29
每条指令都包含着到底要运算、搬移具体到多少个字节的信息

在opcode的那部分？

dyyseo

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

cnppk

liuiang 发表于 2012-12-06 14:30
b  字节
h  半字
-  字

非常感谢，x86指令集中可能不是这种每种位宽都有一个指令

liuiang

b  字节
h  半字
-  字
d  双字

一般都是这样的。

cnppk

liuiang 发表于 2012-12-06 09:38
仅供参考。

ldr ldrb ldrh就是你说的不同位宽使用不同的指令，ldrb中的b是指的字节吗？

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.         ...
    

复制代码

仅供参考。

cnppk

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

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