函数中返回char *类型
记录一次比较容易引起混淆的地方。
#include <stdio.h> char *str(void)
{
return "nihao\n";
} int main()
{
printf("%s\n", str);
}
如上图所示，打印出来的为乱码。
直接说结论：
此处打印的是str函数的地址，不是"nihao"，这个变量的地址，想要打印出"nihao",应该用 str()。
下边又长又屎的分析可以不看，自己犯的迷糊。
第一反应，字符串 ”nihao“ 是局部变量，从str中返回之后就成乱码了？
char *str(void)
{
return "nihao";
} .file "return_str.c"
.section .rodata
.LC0:
.string "nihao"
.text
.globl str
.type str, @function
str:
.LFB0:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset
.cfi_offset , -
movl %esp, %ebp
.cfi_def_cfa_register
movl $.LC0, %eax
popl %ebp
.cfi_restore
.cfi_def_cfa ,
ret
.cfi_endproc
.LFE0:
.size str, .-str
.ident "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609"
.section .note.GNU-stack,"",@progbits
在.text段，不确定，将地址打印出来看
#include <stdio.h>
#include <stdlib.h> int aa; char *test(void)
{
return "nihao";
} int main()
{
int bb;
static int cc;
int *p = (int *)malloc(sizeof(int)); char buff[] = {}; printf("%p\n", &aa);
printf("%p\n", &bb);
printf("%p\n", &cc);
printf("%p\n", p);
printf("%p\n", "nihao");
printf("%p\n", test); return ;
}
数据不贴出来了，很明显，局部变量bb地址跟其他的地址不一致，所以确定字符串”nihao“不是在栈上，不存在函数退出之后访问不到的情况。
第二反应，返回的是函数地址，通过objdump反汇编，查看返回的的确是函数地址。
a.out： 文件格式 elf32-i386 Disassembly of section .interp: <.interp>:
: 2f das
: 6c insb (%dx),%es:(%edi)
: 2f 6c 2d 6c imul $0x6c2d646c,0x2f(%edx),%esp
804815d: 6e 2e 6f imul $0x6f732e78,0x75(%esi),%ebp
: 2e xor %cs:(%eax),%al Disassembly of section .note.ABI-tag: <.note.ABI-tag>:
: add $0x0,%al
804816a: add %al,(%eax)
804816c: adc %al,(%eax)
804816e: add %al,(%eax)
: add %eax,(%eax)
: add %al,(%eax)
: inc %edi
: 4e dec %esi
: push %ebp
: add %al,(%eax)
: add %al,(%eax)
804817b: add %al,(%edx)
804817d: add %al,(%eax)
804817f: add %al,(%esi)
: add %al,(%eax)
: add %ah,(%eax)
: add %al,(%eax)
... Disassembly of section .note.gnu.build-id: <.note.gnu.build-id>:
: add $0x0,%al
804818a: add %al,(%eax)
804818c: adc $0x0,%al
804818e: add %al,(%eax)
: add (%eax),%eax
: add %al,(%eax)
: inc %edi
: 4e dec %esi
: push %ebp
: e4 add %ah,%ah
: 0a 2a or (%edx),%ch
804819b: 3c f8 cmp $0xf8,%al
804819d: ca 5a lret $0x615a
80481a0: 5d test %esp,0x5d(%esi)
80481a3: xchg %eax,%ecx
80481a4: b5 jb 804815b <_init-0x1b5>
80481a6: ca lret $0x1736
80481a9: 9f ja 804814a <_init-0x1c6>
80481ab: push %eax Disassembly of section .gnu.hash: 080481ac <.gnu.hash>:
80481ac: add (%eax),%al
80481ae: add %al,(%eax)
80481b0: push %es
80481b1: add %al,(%eax)
80481b3: add %al,(%ecx)
80481b5: add %al,(%eax)
80481b7: add %al,0x0
80481bd: and %al,(%eax)
80481bf: and %al,(%eax)
80481c1: add %al,(%eax)
80481c3: add %al,(%esi)
80481c5: add %al,(%eax)
80481c7: .byte 0x0
80481c8: ad lods %ds:(%esi),%eax
80481c9: 4b dec %ebx
80481ca: e3 c0 jecxz 804818c <_init-0x184> Disassembly of section .dynsym: 080481cc <.dynsym>:
...
80481dc: 2b sub (%eax),%eax
...
80481e6: add %al,(%eax)
80481e8: adc (%eax),%al
80481ea: add %al,(%eax)
80481ec: 1a sbb (%eax),%al
...
80481f6: add %al,(%eax)
80481f8: adc (%eax),%al
80481fa: add %al,(%eax)
80481fc: xor (%eax),%al
...
: add %al,(%eax)
: adc (%eax),%al
804820a: add %al,(%eax)
804820c: 4b dec %ebx
...
: add %al,(%eax)
: add %ah,(%eax)
: add %al,(%eax)
804821b: add %bh,(%ecx)
...
: add %al,(%eax)
: add %dl,(%edx)
: add %al,(%eax)
804822b: 0b add %cl,(%ebx)
804822d: add %al,(%eax)
804822f: ec add %ch,%ah
: test %eax,(%eax,%ecx,)
: add $0x0,%al
: add %al,(%eax)
: adc %eax,(%eax)
804823a: adc %al,(%eax) Disassembly of section .dynstr: 0804823c <.dynstr>:
804823c: 6c add %ch,0x62(%ecx,%ebp,)
: 2e arpl %bp,(%esi)
: 6f jae 80482b3 <_init-0x5d>
: 2e 5f cs add %bl,%ss:0x49(%edi)
: 4f dec %edi
804824a: 5f pop %edi
804824b: jae 80482c1 <_init-0x4f>
804824d: 6e 5f imul $0x64657375,%fs:0x5f(%esi),%ebp
:
: 5f 5f add %bl,0x5f(%edi)
: jae 80482ce <_init-0x42>
804825a: popa
804825b: 6b 5f arpl %bp,0x5f(%ebx)
804825e: 6b arpl %bp,0x6b(%eax)
: 5f pop %edi
: popaw
: 6c 6e imul $0x746e6972,0x70(%eax,%eax,),%ebp
804826b:
804826c: 6d data16 add %ch,0x61(%ebp)
: 6c insb (%dx),%es:(%edi)
: 6c insb (%dx),%es:(%edi)
: 6f outsl %ds:(%esi),(%dx)
: arpl %ax,(%eax)
: 5f pop %edi
: 5f pop %edi
: 6c insb (%dx),%es:(%edi)
: 5f imul $0x6174735f,0x63(%edx),%esp
804827f: jb 80482f5 <_init-0x1b>
: 5f pop %edi
: 6d insl (%dx),%es:(%edi)
: popa
: 6e 5f 5f 6d imul $0x6d675f5f,0x0(%esi),%ebp
804828b: 6f outsl %ds:(%esi),(%dx)
804828c: 6e outsb %ds:(%esi),(%dx)
804828d: 5f pop %edi
804828e: jae <_init-0xc>
: popa
: jb <_init-0x9>
: 5f pop %edi
: 5f pop %edi
: 4c add %al,0x4c(%edi)
: dec %ecx
: inc %edx
804829a: inc %ebx
804829b: 5f pop %edi
804829c: 2e xor (%esi),%ch
804829e: xor $0x0,%al
80482a0: inc %edi
80482a1: 4c dec %esp
80482a2: dec %ecx
80482a3: inc %edx
80482a4: inc %ebx
80482a5: 5f pop %edi
80482a6: 2e xor (%esi),%ch
80482a8: xor %al,(%eax) Disassembly of section .gnu.version: 080482aa <.gnu.version>:
80482aa: add %al,(%eax)
80482ac: add (%eax),%al
80482ae: add (%eax),%eax
80482b0: add (%eax),%al
80482b2: add %al,(%eax)
80482b4: add (%eax),%al
80482b6: add %eax,(%eax) Disassembly of section .gnu.version_r: 080482b8 <.gnu.version_r>:
80482b8: add %eax,(%eax)
80482ba: add (%eax),%al
80482bc: add %eax,(%eax)
80482be: add %al,(%eax)
80482c0: adc %al,(%eax)
80482c2: add %al,(%eax)
80482c4: add %al,(%eax)
80482c6: add %al,(%eax)
80482c8: adc $0x69,%al
80482ca: 0d 5a imul $0x5a,0x30000,%ecx
80482d1:
80482d4: adc %al,(%eax)
80482d6: add %al,(%eax)
80482d8: adc %ch,0x69(%ecx)
80482db: 0d or $0x20000,%eax
80482e0: add %al,%fs:(%eax)
80482e3: add %al,(%eax)
80482e5: add %al,(%eax)
... Disassembly of section .rel.dyn: 080482e8 <.rel.dyn>:
80482e8: fc cld
80482e9: 9f lahf
80482ea: add $0x8,%al
80482ec: push %es
80482ed: add $0x0,%al
... Disassembly of section .rel.plt: 080482f0 <.rel.plt>:
80482f0: 0c a0 or $0xa0,%al
80482f2: add $0x8,%al
80482f4: pop %es
80482f5: add %eax,(%eax)
80482f7: add %dl,(%eax)
80482f9: a0 mov 0x2070804,%al
80482fe: add %al,(%eax)
: a0 adc $0xa0,%al
: add $0x8,%al
: pop %es
: add (%eax),%eax
: add %bl,(%eax)
: a0 mov 0x5070804,%al
... Disassembly of section .init: <_init>:
: push %ebx
: ec sub $0x8,%esp
: e8 b7 call 80483d0 <__x86.get_pc_thunk.bx>
: c3 e7 1c add $0x1ce7,%ebx
804831f: 8b fc ff ff ff mov -0x4(%ebx),%eax
: c0 test %eax,%eax
: je 804832e <_init+0x1e>
: e8 call <__libc_start_main@plt+0x10>
804832e: c4 add $0x8,%esp
: 5b pop %ebx
: c3 ret Disassembly of section .plt: <printf@plt-0x10>:
: ff a0 pushl 0x804a004
: ff a0 jmp *0x804a008
804834c: add %al,(%eax)
... <printf@plt>:
: ff 0c a0 jmp *0x804a00c
: push $0x0
804835b: e9 e0 ff ff ff jmp <_init+0x30> <__stack_chk_fail@plt>:
: ff a0 jmp *0x804a010
: push $0x8
804836b: e9 d0 ff ff ff jmp <_init+0x30> <malloc@plt>:
: ff a0 jmp *0x804a014
: push $0x10
804837b: e9 c0 ff ff ff jmp <_init+0x30> <__libc_start_main@plt>:
: ff a0 jmp *0x804a018
: push $0x18
804838b: e9 b0 ff ff ff jmp <_init+0x30> Disassembly of section .plt.got: <.plt.got>:
: ff fc 9f jmp *0x8049ffc
: xchg %ax,%ax Disassembly of section .text: 080483a0 <_start>:
80483a0: ed xor %ebp,%ebp
80483a2: 5e pop %esi
80483a3: e1 mov %esp,%ecx
80483a5: e4 f0 and $0xfffffff0,%esp
80483a8: push %eax
80483a9: push %esp
80483aa: push %edx
80483ab: d0 push $0x80485d0
80483b0: push $0x8048570
80483b5: push %ecx
80483b6: push %esi
80483b7: a5 push $0x80484a5
80483bc: e8 bf ff ff ff call <__libc_start_main@plt>
80483c1: f4 hlt
80483c2: xchg %ax,%ax
80483c4: xchg %ax,%ax
80483c6: xchg %ax,%ax
80483c8: xchg %ax,%ax
80483ca: xchg %ax,%ax
80483cc: xchg %ax,%ax
80483ce: xchg %ax,%ax 080483d0 <__x86.get_pc_thunk.bx>:
80483d0: 8b 1c mov (%esp),%ebx
80483d3: c3 ret
80483d4: xchg %ax,%ax
80483d6: xchg %ax,%ax
80483d8: xchg %ax,%ax
80483da: xchg %ax,%ax
80483dc: xchg %ax,%ax
80483de: xchg %ax,%ax 080483e0 <deregister_tm_clones>:
80483e0: b8 a0 mov $0x804a027,%eax
80483e5: 2d a0 sub $0x804a024,%eax
80483ea: f8 cmp $0x6,%eax
80483ed: 1a jbe <deregister_tm_clones+0x29>
80483ef: b8 mov $0x0,%eax
80483f4: c0 test %eax,%eax
80483f6: je <deregister_tm_clones+0x29>
80483f8: push %ebp
80483f9: e5 mov %esp,%ebp
80483fb: ec sub $0x14,%esp
80483fe: a0 push $0x804a024
: ff d0 call *%eax
: c4 add $0x10,%esp
: c9 leave
: f3 c3 repz ret
804840b: nop
804840c: 8d lea 0x0(%esi,%eiz,),%esi <register_tm_clones>:
: b8 a0 mov $0x804a024,%eax
: 2d a0 sub $0x804a024,%eax
804841a: c1 f8 sar $0x2,%eax
804841d: c2 mov %eax,%edx
804841f: c1 ea 1f shr $0x1f,%edx
: d0 add %edx,%eax
: d1 f8 sar %eax
: 1b je <register_tm_clones+0x33>
: ba mov $0x0,%edx
804842d: d2 test %edx,%edx
804842f: je <register_tm_clones+0x33>
: push %ebp
: e5 mov %esp,%ebp
: ec sub $0x10,%esp
: push %eax
: a0 push $0x804a024
804843d: ff d2 call *%edx
804843f: c4 add $0x10,%esp
: c9 leave
: f3 c3 repz ret
: 8d lea 0x0(%esi,%eiz,),%esi
: 8d bc lea 0x0(%edi,%eiz,),%edi <__do_global_dtors_aux>:
: 3d a0 cmpb $0x0,0x804a024
: jne 804846c <__do_global_dtors_aux+0x1c>
: push %ebp
804845a: e5 mov %esp,%ebp
804845c: ec sub $0x8,%esp
804845f: e8 7c ff ff ff call 80483e0 <deregister_tm_clones>
: c6 a0 movb $0x1,0x804a024
804846b: c9 leave
804846c: f3 c3 repz ret
804846e: xchg %ax,%ax <frame_dummy>:
: b8 9f mov $0x8049f10,%eax
: 8b mov (%eax),%edx
: d2 test %edx,%edx
: jne <frame_dummy+0x10>
804847b: eb jmp <register_tm_clones>
804847d: 8d lea 0x0(%esi),%esi
: ba mov $0x0,%edx
: d2 test %edx,%edx
: f2 je 804847b <frame_dummy+0xb>
: push %ebp
804848a: e5 mov %esp,%ebp
804848c: ec sub $0x14,%esp
804848f: push %eax
: ff d2 call *%edx
: c4 add $0x10,%esp
: c9 leave
: e9 ff ff ff jmp <register_tm_clones> 0804849b <test>:
804849b: push %ebp
804849c: e5 mov %esp,%ebp
804849e: b8 f0 mov $0x80485f0,%eax
80484a3: 5d pop %ebp
80484a4: c3 ret 080484a5 <main>:
80484a5: 8d 4c lea 0x4(%esp),%ecx
80484a9: e4 f0 and $0xfffffff0,%esp
80484ac: ff fc pushl -0x4(%ecx)
80484af: push %ebp
80484b0: e5 mov %esp,%ebp
80484b2: push %ecx
80484b3: ec sub $0x14,%esp
80484b6: a1 mov %gs:0x14,%eax
80484bc: f4 mov %eax,-0xc(%ebp)
80484bf: c0 xor %eax,%eax
80484c1: ec 0c sub $0xc,%esp
80484c4: 6a push $0x4
80484c6: e8 a5 fe ff ff call <malloc@plt>
80484cb: c4 add $0x10,%esp
80484ce: f0 mov %eax,-0x10(%ebp)
80484d1: ec sub $0x8,%esp
80484d4: 2c a0 push $0x804a02c
80484d9: f6 push $0x80485f6
80484de: e8 6d fe ff ff call <printf@plt>
80484e3: c4 add $0x10,%esp
80484e6: ec sub $0x8,%esp
80484e9: 8d ec lea -0x14(%ebp),%eax
80484ec: push %eax
80484ed: f6 push $0x80485f6
80484f2: e8 fe ff ff call <printf@plt>
80484f7: c4 add $0x10,%esp
80484fa: ec sub $0x8,%esp
80484fd: a0 push $0x804a028
: f6 push $0x80485f6
: e8 fe ff ff call <printf@plt>
804850c: c4 add $0x10,%esp
804850f: ec sub $0x8,%esp
: ff f0 pushl -0x10(%ebp)
: f6 push $0x80485f6
804851a: e8 fe ff ff call <printf@plt>
804851f: c4 add $0x10,%esp
: ec sub $0x8,%esp
: f0 push $0x80485f0
804852a: f6 push $0x80485f6
804852f: e8 1c fe ff ff call <printf@plt>
: c4 add $0x10,%esp
: ec sub $0x8,%esp
804853a: 9b push $0x804849b
804853f: f6 push $0x80485f6
: e8 fe ff ff call <printf@plt>
: c4 add $0x10,%esp
804854c: b8 mov $0x0,%eax
: 8b f4 mov -0xc(%ebp),%edx
: xor %gs:0x14,%edx
804855b: je <main+0xbd>
804855d: e8 fe fd ff ff call <__stack_chk_fail@plt>
: 8b 4d fc mov -0x4(%ebp),%ecx
: c9 leave
: 8d fc lea -0x4(%ecx),%esp
: c3 ret
804856a: xchg %ax,%ax
804856c: xchg %ax,%ax
804856e: xchg %ax,%ax <__libc_csu_init>:
: push %ebp
: push %edi
: push %esi
: push %ebx
: e8 fe ff ff call 80483d0 <__x86.get_pc_thunk.bx>
: c3 1a add $0x1a87,%ebx
804857f: ec 0c sub $0xc,%esp
: 8b 6c mov 0x20(%esp),%ebp
: 8d b3 0c ff ff ff lea -0xf4(%ebx),%esi
804858c: e8 7f fd ff ff call <_init>
: 8d ff ff ff lea -0xf8(%ebx),%eax
: c6 sub %eax,%esi
: c1 fe sar $0x2,%esi
804859c: f6 test %esi,%esi
804859e: je 80485c5 <__libc_csu_init+0x55>
80485a0: ff xor %edi,%edi
80485a2: 8d b6 lea 0x0(%esi),%esi
80485a8: ec sub $0x4,%esp
80485ab: ff 2c pushl 0x2c(%esp)
80485af: ff 2c pushl 0x2c(%esp)
80485b3: push %ebp
80485b4: ff bb ff ff ff call *-0xf8(%ebx,%edi,)
80485bb: c7 add $0x1,%edi
80485be: c4 add $0x10,%esp
80485c1: f7 cmp %esi,%edi
80485c3: e3 jne 80485a8 <__libc_csu_init+0x38>
80485c5: c4 0c add $0xc,%esp
80485c8: 5b pop %ebx
80485c9: 5e pop %esi
80485ca: 5f pop %edi
80485cb: 5d pop %ebp
80485cc: c3 ret
80485cd: 8d lea 0x0(%esi),%esi 080485d0 <__libc_csu_fini>:
80485d0: f3 c3 repz ret Disassembly of section .fini: 080485d4 <_fini>:
80485d4: push %ebx
80485d5: ec sub $0x8,%esp
80485d8: e8 f3 fd ff ff call 80483d0 <__x86.get_pc_thunk.bx>
80485dd: c3 1a add $0x1a23,%ebx
80485e3: c4 add $0x8,%esp
80485e6: 5b pop %ebx
80485e7: c3 ret Disassembly of section .rodata: 080485e8 <_fp_hw>:
80485e8: add (%eax),%eax
... 080485ec <_IO_stdin_used>:
80485ec: add %eax,(%eax)
80485ee: add (%eax),%al
80485f0: 6e outsb %ds:(%esi),(%dx)
80485f1: 6f imul $0x7025006f,0x61(%eax),%ebp
80485f8: 0a or (%eax),%al Disassembly of section .eh_frame_hdr: 080485fc <__GNU_EH_FRAME_HDR>:
80485fc: 1b add %ebx,(%ebx)
80485fe: 3b add (%ebx),%edi
: xor %al,(%eax)
: add %al,(%eax)
: add $0x44000000,%eax
: fd std
804860a: ff (bad)
804860b: ff 4c decl 0x0(%eax,%eax,)
804860f: 9f fe ff ff add %bl,0x70fffffe(%edi)
: add %al,(%eax)
: a9 fe ff ff add %ch,-0x6f000002(%ecx)
804861d: add %al,(%eax)
804861f: ff ff add %dh,-0x1(%edi,%edi,)
: ff (bad)
: bc d4 mov $0xd4000000,%esp
: ff (bad)
804862a: ff (bad)
804862b: ff decl (%eax)
804862d: add %eax,(%eax)
... Disassembly of section .eh_frame: <__FRAME_END__-0xe8>:
: adc $0x0,%al
: add %al,(%eax)
: add %al,(%eax)
: add %al,(%eax)
: 7a add %edi,0x52(%edx)
804863b: add %al,(%ecx)
804863d: 7c jl <__GNU_EH_FRAME_HDR+0x4b>
804863f: 1b add %ebx,(%ebx)
: 0c or $0x4,%al
: add $0x88,%al
: add %eax,(%eax)
: add %ah,(%eax)
: add %al,(%eax)
804864b: 1c add %bl,(%eax,%eax,)
804864e: add %al,(%eax)
: f0 fc lock cld
: ff (bad)
: ff call *0x0(%eax)
: add %al,(%eax)
: 0e add %cl,(%esi)
804865a: 0e or %al,0xe(%esi)
804865d: 0c 4a or $0x4a,%al
804865f: 0f 0b ud2
: je <__GNU_EH_FRAME_HDR+0x6b>
: js <__GNU_EH_FRAME_HDR+0x69>
: 3f aas
: 1a 3b sbb (%ebx),%bh
: 2a sub (%edx),%dh
804866a: and $0x22,%al
804866c: 1c sbb $0x0,%al
804866e: add %al,(%eax)
: inc %eax
: add %al,(%eax)
: add %ah,(%edi)
: fe (bad)
: ff (bad)
: ff 0a decl (%edx)
: add %al,(%eax)
804867b: add %al,(%eax)
804867d: inc %ecx
804867e: 0e push %cs
804867f: 0d or %al,0x50d4202(%ebp)
: inc %esi
: c5 0c lds (%esp,%eax,),%ecx
: add $0x0,%al
804868b: add %ch,(%eax)
804868d: add %al,(%eax)
804868f: add %ah,0x0(%eax)
: add %al,(%eax)
: fe adc %edi,%esi
: ff (bad)
: ff c5 inc %ebp
: add %al,(%eax)
804869b: add %al,(%eax)
804869d: inc %esp
804869e: 0c or $0x1,%al
80486a0: add %al,0x10(%edi)
80486a3: add $0x43007502,%eax
80486a8: 0f 7c lsl 0x7c(%ebp),%esi
80486ac: push %es
80486ad: b2 0c add 0x4100010c(%edx),%dh
80486b3: c5 0c lds 0xc(%ebx),%eax
80486b6: add $0x4,%al
80486b8: dec %eax
80486b9: add %al,(%eax)
80486bb: 8c b0 fe add %cl,-0x1500000(%eax,%eax,)
80486c2: ff (bad)
80486c3: ff 5d lcall *0x0(%ebp)
80486c6: add %al,(%eax)
80486c8: 0e add %al,0xe(%ecx)
80486cb: 0e 0c or %al,0xc0e4102(%ebp)
80486d1: xchg %eax,(%ebx)
80486d3: inc %ecx
80486d4: 0e push %cs
80486d5: 0e adc %al,0x140e4104(%esi)
80486db: 4e 0e 0e addl $0xe,0x69200e4e
80486e2: and $0x44,%al
80486e4: 0e push %cs
80486e5: 0e 2c sub %al,0x2c(%esi,%ecx,)
80486e9: inc %ecx
80486ea: 0e push %cs
80486eb: 4d 0e xor %cl,0xe(%ebp)
80486ee: 0e and %al,0xe(%edi)
80486f1: adc $0x41,%al
80486f3: c3 ret
80486f4: 0e push %cs
80486f5: c6 adc %al,-0x3a(%ecx)
80486f8: 0e push %cs
80486f9: 0c or $0x41,%al
80486fb: c7 (bad)
80486fc: 0e push %cs
80486fd: c5 or %al,-0x3b(%ecx)
: 0e push %cs
: add $0x0,%al
: add %dl,(%eax)
: add %al,(%eax)
: d8 add %bl,%al
: add %al,(%eax)
804870b: c4 add %al,%ah
804870d: fe (bad)
804870e: ff (bad)
804870f: ff incl (%edx)
: add %al,(%eax)
: add %al,(%eax)
: add %al,(%eax)
... <__FRAME_END__>:
: add %al,(%eax)
... Disassembly of section .init_array: 08049f08 <__frame_dummy_init_array_entry>:
8049f08: jo 8049e8e <__FRAME_END__+0x1776>
8049f0a: add $0x8,%al Disassembly of section .fini_array: 08049f0c <__do_global_dtors_aux_fini_array_entry>:
8049f0c: push %eax
8049f0d: test %al,(%eax,%ecx,) Disassembly of section .jcr: 08049f10 <__JCR_END__>:
8049f10: add %al,(%eax)
... Disassembly of section .dynamic: 08049f14 <_DYNAMIC>:
8049f14: add %eax,(%eax)
8049f16: add %al,(%eax)
8049f18: add %eax,(%eax)
8049f1a: add %al,(%eax)
8049f1c: 0c or $0x0,%al
8049f1e: add %al,(%eax)
8049f20: 0d adc %al,0xd0804(%ebx)
8049f26: add %al,(%eax)
8049f28: d4 aam $0x85
8049f2a: add $0x8,%al
8049f2c: sbb %eax,(%eax)
8049f2e: add %al,(%eax)
8049f30: 9f 1b or %bl,0x1b0804(%edi)
8049f36: add %al,(%eax)
8049f38: add $0x0,%al
8049f3a: add %al,(%eax)
8049f3c: 1a sbb (%eax),%al
8049f3e: add %al,(%eax)
8049f40: 0c 9f or $0x9f,%al
8049f42: add $0x8,%al
8049f44: 1c sbb $0x0,%al
8049f46: add %al,(%eax)
8049f48: add $0x0,%al
8049f4a: add %al,(%eax)
8049f4c: f5 cmc
8049f4d: fe (bad)
8049f4e: ff 6f ac ljmp *-0x54(%edi)
8049f51: addl $0x5,(%eax,%ecx,)
8049f58: 3c cmp $0x82,%al
8049f5a: add $0x8,%al
8049f5c: push %es
8049f5d: add %al,(%eax)
8049f5f: cc add %cl,%ah
8049f61: 0a addl $0xa,(%eax,%ecx,)
8049f68: 6e outsb %ds:(%esi),(%dx)
8049f69: add %al,(%eax)
8049f6b: 0b add %cl,(%ebx)
8049f6d: add %al,(%eax)
8049f6f: add %dl,(%eax)
8049f71: add %al,(%eax)
8049f73: add %dl,0x0
8049f79: add %al,(%eax)
8049f7b: add %al,(%ebx)
8049f7d: add %al,(%eax)
8049f7f: add %al,(%eax)
8049f81: a0 mov 0x20804,%al
8049f86: add %al,(%eax)
8049f88: and %al,(%eax)
8049f8a: add %al,(%eax)
8049f8c: adc $0x0,%al
8049f8e: add %al,(%eax)
8049f90: adc %eax,(%eax)
8049f92: add %al,(%eax)
8049f94: pop %ss
8049f95: add %al,(%eax)
8049f97: f0 add %dh,%al
8049f99: (bad)
8049f9a: add $0x8,%al
8049f9c: adc %eax,(%eax)
8049f9e: add %al,(%eax)
8049fa0: e8 call 1a0ca427 <_end+0x120803f7>
8049fa5: add %al,(%eax)
8049fa7: add %cl,(%eax)
8049fa9: add %al,(%eax)
8049fab: add %dl,(%ebx)
8049fad: add %al,(%eax)
8049faf: add %cl,(%eax)
8049fb1: add %al,(%eax)
8049fb3: fe add %bh,%dh
8049fb5: ff (bad)
8049fb6: ff 6f b8 ljmp *-0x48(%edi)
8049fb9: (bad)
8049fba: add $0x8,%al
8049fbc: ff (bad)
8049fbd: ff (bad)
8049fbe: ff 6f ljmp *0x1(%edi)
8049fc1: add %al,(%eax)
8049fc3: f0 add %dh,%al
8049fc5: ff (bad)
8049fc6: ff 6f aa ljmp *-0x56(%edi)
8049fc9: (bad)
8049fca: add $0x8,%al
... Disassembly of section .got: 08049ffc <.got>:
8049ffc: add %al,(%eax)
... Disassembly of section .got.plt: 0804a000 <_GLOBAL_OFFSET_TABLE_>:
804a000: 9f adc $0x9f,%al
804a002: add $0x8,%al
...
804a00c: push %esi
804a00d: addl $0x66,(%eax,%ecx,)
804a011: addl $0x76,(%eax,%ecx,)
804a015: addl $0xffffff86,(%eax,%ecx,)
804a019: .byte 0x83
804a01a: add $0x8,%al Disassembly of section .data: 0804a01c <__data_start>:
804a01c: add %al,(%eax)
... 0804a020 <__dso_handle>:
804a020: add %al,(%eax)
... Disassembly of section .bss: 0804a024 <__bss_start>:
804a024: add %al,(%eax)
... 0804a028 <cc.>:
804a028: add %al,(%eax)
... 0804a02c <aa>:
804a02c: add %al,(%eax)
... Disassembly of section .comment: <.comment>:
: inc %edi
: inc %ebx
: inc %ebx
: 3a cmp (%eax),%ah
: sub %dl,0x62(%ebp)
: 6e jne <_init-0x8048298>
a: je <_init-0x804828f>
c: 2e 2e and %dh,0x302e342e
: 2d sub $0x75627536,%eax
: 6e outsb %ds:(%esi),(%dx)
: je 8f <_init-0x8048281>
1a: 7e xor %edi,0x31(%esi)
1d: 2e 2e ss xor %dh,%cs:(%esi,%ebp,)
: cmp %ebp,(%ecx)
: 2e 2e and %dh,0x302e342e
2a: and %dh,(%edx)
2c: xor %dh,(%ecx)
2e: xor %dh,%ss:(%esi)
: xor %bh,(%ecx)
...
继续懵逼，为什么strcpy可以返回指针，还特地找来glibc的code看了一下，没看到啥特殊处理。
又写了一个demo
int *test()
{
int *p = NULL; p = (int *)malloc(sizeof(int));
printf("...%p\n", p); return p;
} int main()
{
int *pp = test(); printf("%p\n", test);
printf("%p\n", pp);
}
最后终于瞅出来了
test() 是函数调用，打印时候是return的地址。
test 表示的是函数的指针。
学习任何东西，总有一个经常反复，越来越熟悉的过程。
有些觉得会了的东西，掌握的可能不够不透彻。
函数中返回char *类型的更多相关文章
- JAVA函数的返回值类型详解以及生成随机数的例题
函数的四要素:函数名.输入.输出(返回).加工. 函数分为两种:一种是有返回值得函数,一种是没有返回值的函数. 1. 定义:没有返回值的函数:(当我不需要函数的计算结果再拿出来进行运算的时候,我就不需 ...
- sv函数中返回队列
如果想从函数中,返回队列或者动态数组,我们应该怎么做呢? 答案就是自己用typedef定义一个类型. typedef int queue_of_int[$]; function queue_of_in ...
- C# 调用C/C++动态链接库，结构体中的char*类型
用C#掉用C++的dll直接import就可以之前有不同的类型对应,当要传递结构体的时候就有点麻烦了,这里有一个结构体里边有char*类型,这个类型在C#中调用没法声明,传string是不行的默认st ...
- JAVA中的char类型
1.JAVA中,char占2字节,16位.可在存放汉字 2.char赋值 char a='a'; //任意单个字符,加单引号. char a='中';//任意单个中文字,加单引号. char a=1 ...
- C++函数中返回引用和返回值的区别
一.主要讨论下面两个函数的区别: int& at() { return m_data_; } int at() { return m_data_; } 上面两个函数,第一个返回值是int的引用 ...
- JAVA数据类型中的char类型
1.JAVA中,char占2字节,16位.可在存放汉字 2.char赋值 char a='a'; //任意单个字符,加单引号. char a='中';//任意单个中文字,加单引号. char a=11 ...
- python函数中的参数类型
python函数中的参数 动态获取函数的参数 python的函数类型详解
- java中的char类型所占空间
java中统一使用unicode编码,所以每个字符都是2个字节16位.unicode包括中文,所以对String类计算长度的时候,一个中文和一个英文都是一个长度.String voice = &quo ...
- nodejs怎么同步从一个数据库查询函数中返回一个值
var sql=require('msnodesql'); var conn_str="Driver={SQL Server Native Client 11.0};Server={127. ...
随机推荐
- JavaScript的灵活应用
1.查找数组的最大值和最小值 (1) Math.max.qpply(null,array); Math.min.qpply(null,array); (2) eval("Math.max(& ...
- 网络性能测试工具iperf
参考网站:https://www.cnblogs.com/yingsong/p/5682080.html https://docs.azure.cn/zh-cn/articles/azure-oper ...
- Redis hash数据结构
1, 新增一个 hash 或者 新增数据 => hset key field value 2, 获取某个字段值 => hset key field 3, 获取所有字段值 => hge ...
- 关联github, 添加gitignore 规则
1. 新建Maven项目 2. 新建github repository 3. 执行命令 echo "# se" >> README.md git init git ad ...
- zookeeper的配置参数详解（zoo.cfg）
配置参数详解(主要是%ZOOKEEPER_HOME%/conf/zoo.cfg文件) 参数名 说明 clientPort 客户端连接server的端口,即对外服务端口,一般设置为2181吧. data ...
- pwa 概念
- ubuntu 16.04 install wine
from: https://wiki.winehq.org/Ubuntu If your system is 64 bit, enable 32 bit architecture (if you ha ...
- mongodb基础学习7-备份与恢复
下面来讲讲mongodb的备份与恢复 备份可以备份为二进制格式,如果是用于数据交换,可以备份成json或cvs格式 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通 ...
- 注册COM
可以用代码在程序中实现COM的注册. 举例如下: (假设需要注册的文件为test.ocx)uses OLEctl,....varOCXHand: THandle;RegFunc: TDllRegist ...
- delphi常用函数和方法
uses ShellApi, ActiveX, ComObj, ShlObj; function HasText(Text: string; const Values: array of strin ...