1

voici un petit programme qui permet d'afficher en couleur et d effacer l'ecran .

C'est un prof de 2eme qui nous l'a filé.
Le probleme c est que je n est jamais fait de C
et j aimerai que qqun le transcrive en assembleur si ca vous derange pas

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcnt1.h>

int main (void) {
int h;
char bleu[] = "\033[0;34m"; // O;3X;4Y ou 1;3X;4Y X et Y = 0..7
char normal [] = "\033[0m";
char clear = "\033[H\033[2J"; //curseur en haut et effacer

h=open("/dev/tty" , O_WRONLY);
write(h,clear,sizeof(clear));
write(h,bleu,sizeof(bleu));
write(h,(coucou\n",7);
write(h,normal,sizeof(normal));
exit(0); }

2

        .file   "a.c"
        .def    ___main;        .scl    2;      .type   32;     .endef
        .section .rdata,"dr"
LC0:
        .ascii "\33[0;34m\0"
LC1:
        .ascii "\33[0m\0"
LC2:
        .ascii "\33[H\33[2J\0"
LC3:
        .ascii "/dev/tty\0"
LC4:
        .ascii "(coucou\12\0"
        .text
.globl _main
        .def    _main;  .scl    2;      .type   32;     .endef
_main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $88, %esp
        andl    $-16, %esp
        movl    $0, %eax
        addl    $15, %eax
        addl    $15, %eax
        shrl    $4, %eax
        sall    $4, %eax
        movl    %eax, -60(%ebp)
        movl    -60(%ebp), %eax
        call    __alloca
        call    ___main
        movl    LC0, %eax
        movl    LC0+4, %edx
        movl    %eax, -24(%ebp)
        movl    %edx, -20(%ebp)
        movl    LC1, %eax
        movl    %eax, -40(%ebp)
        movzbl  LC1+4, %eax
        movb    %al, -36(%ebp)
        movl    $LC2, %eax
        movb    %al, -41(%ebp)
        movl    $1, 4(%esp)
        movl    $LC3, (%esp)
        call    _open
        movl    %eax, -12(%ebp)
        movl    $1, 8(%esp)
        movsbl  -41(%ebp),%eax
        movl    %eax, 4(%esp)
        movl    -12(%ebp), %eax
        movl    %eax, (%esp)
        call    _write
        movl    $8, 8(%esp)
        leal    -24(%ebp), %eax
        movl    %eax, 4(%esp)
        movl    -12(%ebp), %eax
        movl    %eax, (%esp)
        call    _write
        movl    $7, 8(%esp)
        movl    $LC4, 4(%esp)
        movl    -12(%ebp), %eax
        movl    %eax, (%esp)
        call    _write
        movl    $5, 8(%esp)
        leal    -40(%ebp), %eax
        movl    %eax, 4(%esp)
        movl    -12(%ebp), %eax
        movl    %eax, (%esp)
        call    _write
        movl    $0, (%esp)
        call    _exit
        .def    _exit;  .scl    3;      .type   32;     .endef
        .def    _write; .scl    3;      .type   32;     .endef
        .def    _open;  .scl    3;      .type   32;     .endef


(de rien trigic)

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

3

ou sinon:

	.section __TEXT,__text,regular,pure_instructions
	.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
	.machine ppc
	.cstring
	.align 2
LC2:
	.ascii "\33[H\33[2J\0"
	.align 2
LC3:
	.ascii "/dev/tty\0"
	.align 2
LC4:
	.ascii "coucou\12\0"
	.align 2
LC0:
	.ascii "\33[0;34m\0"
	.align 2
LC1:
	.ascii "\33[0m\0"
	.text
	.align 2
	.globl _main
_main:
	mflr r0
	stmw r30,-8(r1)
	stw r0,8(r1)
	stwu r1,-112(r1)
	mr r30,r1
	bcl 20,31,"L00000000001$pb"
"L00000000001$pb":
	mflr r31
	addis r2,r31,ha16(LC0-"L00000000001$pb")
	la r2,lo16(LC0-"L00000000001$pb")(r2)
	lwz r3,4(r2)
	lwz r2,0(r2)
	stw r2,64(r30)
	stw r3,68(r30)
	addis r2,r31,ha16(LC1-"L00000000001$pb")
	la r2,lo16(LC1-"L00000000001$pb")(r2)
	lwz r0,0(r2)
	lbz r2,4(r2)
	stw r0,72(r30)
	stb r2,76(r30)
	addis r2,r31,ha16(LC2-"L00000000001$pb")
	la r0,lo16(LC2-"L00000000001$pb")(r2)
	stb r0,56(r30)
	addis r2,r31,ha16(LC3-"L00000000001$pb")
	la r3,lo16(LC3-"L00000000001$pb")(r2)
	li r4,1
	bl L_open$stub
	mr r0,r3
	stw r0,60(r30)
	lbz r0,56(r30)
	extsb r0,r0
	lwz r3,60(r30)
	mr r4,r0
	li r5,1
	bl L_write$stub
	addi r0,r30,64
	lwz r3,60(r30)
	mr r4,r0
	li r5,8
	bl L_write$stub
	lwz r3,60(r30)
	addis r2,r31,ha16(LC4-"L00000000001$pb")
	la r4,lo16(LC4-"L00000000001$pb")(r2)
	li r5,7
	bl L_write$stub
	addi r0,r30,72
	lwz r3,60(r30)
	mr r4,r0
	li r5,5
	bl L_write$stub
	li r3,0
	bl L_exit$stub
	.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
	.align 5
L_open$stub:
	.indirect_symbol _open
	mflr r0
	bcl 20,31,"L00000000001$spb"
"L00000000001$spb":
	mflr r11
	addis r11,r11,ha16(L_open$lazy_ptr-"L00000000001$spb")
	mtlr r0
	lwzu r12,lo16(L_open$lazy_ptr-"L00000000001$spb")(r11)
	mtctr r12
	bctr
	.lazy_symbol_pointer
L_open$lazy_ptr:
	.indirect_symbol _open
	.long	dyld_stub_binding_helper
	.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
	.align 5
L_write$stub:
	.indirect_symbol _write
	mflr r0
	bcl 20,31,"L00000000002$spb"
"L00000000002$spb":
	mflr r11
	addis r11,r11,ha16(L_write$lazy_ptr-"L00000000002$spb")
	mtlr r0
	lwzu r12,lo16(L_write$lazy_ptr-"L00000000002$spb")(r11)
	mtctr r12
	bctr
	.lazy_symbol_pointer
L_write$lazy_ptr:
	.indirect_symbol _write
	.long	dyld_stub_binding_helper
	.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
	.align 5
L_exit$stub:
	.indirect_symbol _exit
	mflr r0
	bcl 20,31,"L00000000003$spb"
"L00000000003$spb":
	mflr r11
	addis r11,r11,ha16(L_exit$lazy_ptr-"L00000000003$spb")
	mtlr r0
	lwzu r12,lo16(L_exit$lazy_ptr-"L00000000003$spb")(r11)
	mtctr r12
	bctr
	.lazy_symbol_pointer
L_exit$lazy_ptr:
	.indirect_symbol _exit
	.long	dyld_stub_binding_helper
	.subsections_via_symbols
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

4

L2:
        dc.b 40,99,111,117,99,111,117,10,0
L1:
        dc.b 47,100,101,118,47,116,116,121,0
main:
; line 7
        lea     -24(a7),a7
        movem.l d3/d4/d5/a2,-(a7)
        lea     write(pc),a2
        moveq   #91,d4
        moveq   #27,d5
; line 11
        move.b  d5,30(a7)
        move.b  d4,31(a7)
        move.b  #48,32(a7)
        move.b  #59,33(a7)
        move.b  #51,34(a7)
        move.b  #52,35(a7)
        move.b  #109,36(a7)
        clr.b   37(a7)
        move.b  d5,24(a7)
        move.b  d4,25(a7)
        move.b  #48,26(a7)
        move.b  #109,27(a7)
        clr.b   28(a7)
        move.b  d5,16(a7)
        move.b  d4,17(a7)
        move.b  #72,18(a7)
        move.b  d5,19(a7)
        move.b  d4,20(a7)
        move.b  #50,21(a7)
        move.b  #74,22(a7)
        clr.b   23(a7)
; line 13
        move.w  #1,-(a7)
        pea     L1(pc)
        jsr     open(pc)
        addq.l  #6,a7
        move.w  d0,d3
; line 14
        move.w  #8,-(a7)
        pea     18(a7)
        move.w  d3,-(a7)
        jsr     (a2)
        addq.l  #8,a7
; line 15
        move.w  #8,-(a7)
        pea     32(a7)
        move.w  d3,-(a7)
        jsr     (a2)
        addq.l  #8,a7
; line 16
        move.w  #7,-(a7)
        pea     L2(pc)
        move.w  d3,-(a7)
        jsr     (a2)
        addq.l  #8,a7
; line 18
        move.w  #5,-(a7)
        pea     26(a7)
        move.w  d3,-(a7)
        jsr     (a2)
        addq.l  #8,a7
        jsr     __exit(pc)
        movem.l (a7)+,d3/d4/d5/a2
        lea     24(a7),a7
        rts
; end of function

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

5

waou c est tres gentil de ta part

mais est ce que tu pourrai me dire comment on fait pour compiler linker et executer tout ca
et moi j traivaille avec nasm et je faisait comme ceci

nasm $1.asm -o $1.o -f elf
ld $1.o -o $1 -e main
./$1

au fait qu est ce qui change entre ces 3 codes
je suis un debutant
franhement j comprend pratiquement rien a ce que t as ecrit mais c est pas grave c est le prof qui nous a conseiller de faire ca

mais merci quand meme

en fait j dois programmer un jeu d oie et a chaque deplacement du pion j dois nettoyer l ecran et mettre le pion en couleur

voici l'enonce [url] [/url]

6

désolé pour l'up mais je me sens obligé de contribuer sparc cheeky
	.file	"a.c"
	.section	".rodata"
	.align 8
.LLC0:
	.asciz	"\033[0;34m"
	.align 8
.LLC1:
	.asciz	"\033[0m"
	.align 8
.LLC2:
	.asciz	"\033[H\033[2J"
	.align 8
.LLC3:
	.asciz	"/dev/tty"
	.align 8
.LLC4:
	.asciz	"coucou\n"
	.section	".text"
	.align 4
	.global main
	.type	main, #function
	.proc	04
main:
	!#PROLOGUE# 0
	save	%sp, -144, %sp
	!#PROLOGUE# 1
	sethi	%hi(.LLC0), %g1
	or	%g1, %lo(.LLC0), %g1
	ld	[%g1], %o4
	ld	[%g1+4], %o5
	std	%o4, [%fp-32]
	sethi	%hi(.LLC1), %g1
	or	%g1, %lo(.LLC1), %o5
	ld	[%o5], %g1
	st	%g1, [%fp-40]
	ldub	[%o5+4], %g1
	stb	%g1, [%fp-36]
	sethi	%hi(.LLC2), %g1
	or	%g1, %lo(.LLC2), %g1
	stb	%g1, [%fp-41]
	sethi	%hi(.LLC3), %g1
	or	%g1, %lo(.LLC3), %o0
	mov	1, %o1
	call	open, 0
	 nop
	mov	%o0, %g1
	st	%g1, [%fp-20]
	ldub	[%fp-41], %g1
	sll	%g1, 24, %g1
	sra	%g1, 24, %g1
	ld	[%fp-20], %o0
	mov	%g1, %o1
	mov	1, %o2
	call	write, 0
	 nop
	add	%fp, -32, %g1
	ld	[%fp-20], %o0
	mov	%g1, %o1
	mov	8, %o2
	call	write, 0
	 nop
	ld	[%fp-20], %o0
	sethi	%hi(.LLC4), %g1
	or	%g1, %lo(.LLC4), %o1
	mov	7, %o2
	call	write, 0
	 nop
	add	%fp, -40, %g1
	ld	[%fp-20], %o0
	mov	%g1, %o1
	mov	5, %o2
	call	write, 0
	 nop
	mov	0, %o0
	call	exit, 0
	 nop
	nop
	.size	main, .-main
	.ident	"GCC: (GNU) 3.4.3 (csl-sol210-3_4-branch+sol_rpath)"

7

        .cpu arm10tdmi
        .fpu softvfp
        .file   "test.c"
        .section        .rodata
        .align  2
.LC0:
        .ascii  "\033[0;34m\000"
        .align  2
.LC1:
        .ascii  "\033[0m\000"
        .align  2
.LC2:
        .ascii  "\033[H\033[2J\000"
        .align  2
.LC3:
        .ascii  "/dev/tty\000"
        .align  2
.LC4:
        .ascii  "coucou\n\000"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 32
        @ frame_needed = 1, uses_anonymous_args = 0
        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #32
        ldr     r3, .L2
        sub     r2, fp, #28
        ldmia   r3, {r0, r1}
        stmia   r2, {r0, r1}
        ldr     r3, .L2+4
        sub     r2, fp, #36
        ldmia   r3, {r0, r1}
        str     r0, [r2, #0]
        add     r2, r2, #4
        strb    r1, [r2, #0]
        ldr     r3, .L2+8
        strb    r3, [fp, #-37]
        ldr     r0, .L2+12
        mov     r1, #1
        bl      open
        str     r0, [fp, #-16]
        ldrb    r3, [fp, #-37]  @ zero_extendqisi2
        ldr     r0, [fp, #-16]
        mov     r1, r3
        mov     r2, #1
        bl      write
        sub     r3, fp, #28
        ldr     r0, [fp, #-16]
        mov     r1, r3
        mov     r2, #8
        bl      write
        ldr     r0, [fp, #-16]
        ldr     r1, .L2+16
        mov     r2, #7
        bl      write
        sub     r3, fp, #36
        ldr     r0, [fp, #-16]
        mov     r1, r3
        mov     r2, #5
        bl      write
        mov     r0, #0
        bl      exit
.L3:
        .align  2
.L2:
        .word   .LC0
        .word   .LC1
        .word   .LC2
        .word   .LC3
        .word   .LC4
        .size   main, .-main
        .ident  "GCC: (GNU) 3.4.4 (release) (CodeSourcery ARM 2005q3-2)"


ou alors :
        .cpu arm10tdmi
        .fpu softvfp
        .file   "test.c"
        .section        .rodata.str1.4,"aMS",%progbits,1
        .align  2
.LC0:
        .ascii  "\033[0;34m\000"
        .align  2
.LC1:
        .ascii  "\033[0m\000"
        .align  2
.LC2:
        .ascii  "\033[H\033[2J\000"
        .align  2
.LC3:
        .ascii  "/dev/tty\000"
        .align  2
.LC4:
        .ascii  "coucou\n\000"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 0, uses_anonymous_args = 0
        stmfd   sp!, {r4, r6, r7, lr}
        ldr     r3, .L2
        sub     sp, sp, #16
        ldr     ip, .L2+4
        ldr     r2, .L2+8
        add     r7, sp, #8
        ldmia   r3, {r0, r1}
        stmia   r7, {r0, r1}
        ldmia   ip, {r0, r1}
        str     r0, [sp, #0]
        strb    r1, [sp, #4]
        ldr     r0, .L2+12
        mov     r1, #1
        and     r4, r2, #255
        bl      open
        mov     r1, r4
        mov     r6, r0
        mov     r2, #1
        bl      write
        mov     r1, r7
        mov     r2, #8
        mov     r0, r6
        bl      write
        ldr     r1, .L2+16
        mov     r2, #7
        mov     r0, r6
        bl      write
        mov     r0, r6
        mov     r1, sp
        mov     r2, #5
        bl      write
        mov     r0, #0
        bl      exit
.L3:
        .align  2
.L2:
        .word   .LC0
        .word   .LC1
        .word   .LC2
        .word   .LC3
        .word   .LC4
        .size   main, .-main
        .ident  "GCC: (GNU) 3.4.4 (release) (CodeSourcery ARM 2005q3-2)"

        .cpu arm10tdmi
        .fpu softvfp
        .file   "test.c"
        .section        .rodata.str1.4,"aMS",%progbits,1
        .align  2
.LC0:
        .ascii  "\033[0;34m\000"
        .align  2
.LC1:
        .ascii  "\033[0m\000"
        .align  2
.LC2:
        .ascii  "\033[H\033[2J\000"
        .align  2
.LC3:
        .ascii  "/dev/tty\000"
        .align  2
.LC4:
        .ascii  "coucou\n\000"
        .text
        .align  2
        .global main
        .type   main, %function
main:
        @ args = 0, pretend = 0, frame = 16
        @ frame_needed = 0, uses_anonymous_args = 0
        stmfd   sp!, {r4, r6, r7, lr}
        ldr     r3, .L2
        sub     sp, sp, #16
        ldr     ip, .L2+4
        ldr     r2, .L2+8
        add     r7, sp, #8
        ldmia   r3, {r0, r1}
        stmia   r7, {r0, r1}
        ldmia   ip, {r0, r1}
        str     r0, [sp, #0]
        strb    r1, [sp, #4]
        ldr     r0, .L2+12
        mov     r1, #1
        and     r4, r2, #255
        bl      open
        mov     r1, r4
        mov     r6, r0
        mov     r2, #1
        bl      write
        mov     r1, r7
        mov     r2, #8
        mov     r0, r6
        bl      write
        ldr     r1, .L2+16
        mov     r2, #7
        mov     r0, r6
        bl      write
        mov     r0, r6
        mov     r1, sp
        mov     r2, #5
        bl      write
        mov     r0, #0
        bl      exit
.L3:
        .align  2
.L2:
        .word   .LC0
        .word   .LC1
        .word   .LC2
        .word   .LC3
        .word   .LC4
        .size   main, .-main
        .ident  "GCC: (GNU) 3.4.4 (release) (CodeSourcery ARM 2005q3-2)"

-O9 pawa cheeky

On peut avoir aussi :

        .file   1 "test.c"
        .section .mdebug.abi32
        .previous
        .abicalls
        .rdata
        .align  2
$LC2:
        .ascii  "\033[H\033[2J\000"
        .align  2
$LC3:
        .ascii  "/dev/tty\000"
        .align  2
$LC4:
        .ascii  "coucou\012\000"
        .align  2
$LC0:
        .ascii  "\033[0;34m\000"
        .align  2
$LC1:
        .ascii  "\033[0m\000"
        .text
        .align  2
        .globl  main
        .ent    main
        .type   main, @function
main:
        .frame  $fp,56,$31              # vars= 24, regs= 2/0, args= 16, gp= 8
        .mask   0xc0000000,-4
        .fmask  0x00000000,0
        .set    noreorder
        .cpload $25
        .set    nomacro

        addiu   $sp,$sp,-56
        sw      $31,52($sp)
        sw      $fp,48($sp)
        move    $fp,$sp
        .cprestore      16
        lw      $2,%got($LC0)($28)
        nop
        lw      $3,%lo($LC0)($2)
        addiu   $2,$2,%lo($LC0)
        lw      $2,4($2)
        sw      $3,32($fp)
        sw      $2,36($fp)
        lw      $3,%got($LC1)($28)
        nop
        lw      $2,%lo($LC1)($3)
        nop
        sw      $2,40($fp)
        addiu   $2,$3,%lo($LC1)
        lbu     $2,4($2)
        nop
        sb      $2,44($fp)
        lw      $2,%got($LC2)($28)
        nop
        addiu   $2,$2,%lo($LC2)
        sb      $2,24($fp)
        lw      $2,%got($LC3)($28)
        nop
        addiu   $4,$2,%lo($LC3)
        li      $5,1                    # 0x1
        lw      $25,%call16(open)($28)
        nop
        jalr    $25
        nop

        lw      $28,16($fp)
        sw      $2,28($fp)
        lb      $2,24($fp)
        lw      $4,28($fp)
        move    $5,$2
        li      $6,1                    # 0x1
        lw      $25,%call16(write)($28)
        nop
        jalr    $25
        nop

        lw      $28,16($fp)
        addiu   $2,$fp,32
        lw      $4,28($fp)
        move    $5,$2
        li      $6,8                    # 0x8
        lw      $25,%call16(write)($28)
        nop
        jalr    $25
        nop

        lw      $28,16($fp)
        lw      $4,28($fp)
        lw      $2,%got($LC4)($28)
        nop
        addiu   $5,$2,%lo($LC4)
        li      $6,7                    # 0x7
        lw      $25,%call16(write)($28)
        nop
        jalr    $25
        nop

        lw      $28,16($fp)
        addiu   $2,$fp,40
        lw      $4,28($fp)
        move    $5,$2
        li      $6,5                    # 0x5
        lw      $25,%call16(write)($28)
        nop
        jalr    $25
        nop

        lw      $28,16($fp)
        move    $4,$0
        lw      $25,%call16(exit)($28)
        nop
        jalr    $25
        nop

        .set    macro
        .set    reorder
        .end    main
        .ident  "GCC: (GNU) 4.1.1"


ou juste ça (proche)

        .file   1 "test.c"
        .section .mdebug.abi32
        .previous
        .abicalls
        .rdata
        .align  2
$LC0:
        .ascii  "\033[0;34m\000"
        .align  2
$LC1:
        .ascii  "\033[0m\000"
        .align  2
$LC2:
        .ascii  "\033[H\033[2J\000"
        .align  2
$LC3:
        .ascii  "/dev/tty\000"
        .align  2
$LC4:
        .ascii  "coucou\n\000"
        .text
        .align  2
        .globl  main
        .ent    main
        .type   main, @function
main:
        .frame  $fp,72,$31              # vars= 32, regs= 3/0, args= 16, extra= 8
        .mask   0xd0000000,-8
        .fmask  0x00000000,0
        .set    noreorder
        .cpload $25
        .set    reorder
        subu    $sp,$sp,72
        .cprestore 16
        sw      $31,64($sp)
        sw      $fp,60($sp)
        sw      $28,56($sp)
        move    $fp,$sp
        lw      $2,$LC0
        sw      $2,32($fp)
        lw      $2,$LC0+4
        sw      $2,36($fp)
        lw      $2,$LC1
        sw      $2,40($fp)
        lbu     $2,$LC1+4
        sb      $2,44($fp)
        la      $2,$LC2
        sb      $2,48($fp)
        la      $4,$LC3
        li      $5,1                    # 0x1
        la      $25,open
        jal     $31,$25
        sw      $2,24($fp)
        lb      $2,48($fp)
        lw      $4,24($fp)
        move    $5,$2
        li      $6,1                    # 0x1
        la      $25,write
        jal     $31,$25
        addu    $2,$fp,32
        lw      $4,24($fp)
        move    $5,$2
        li      $6,8                    # 0x8
        la      $25,write
        jal     $31,$25
        lw      $4,24($fp)
        la      $5,$LC4
        li      $6,7                    # 0x7
        la      $25,write
        jal     $31,$25
        addu    $2,$fp,40
        lw      $4,24($fp)
        move    $5,$2
        li      $6,5                    # 0x5
        la      $25,write
        jal     $31,$25
        move    $4,$0
        la      $25,exit
        jal     $31,$25
        .end    main
        .ident  "GCC: (GNU) 3.3.6"
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

8

manque quoi? le mips, le microblaze, et quelques trucs exotiques smile

oué le code arm c'est marrant comme c'est compressible/extensible

t1 le dernier code il fait que des load/store sick

(t'as oublié un pre)

9

les deux derniers sont du mipsel et du mips ^^

Manque de l'alpha
du 6502 (love)
du Super H
du PA-RISC
du PIC
...

avis au amateurs ^
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

10

LOL open et write en pic grin

(dsl j'connais pas mips, j'ai pas réalisé ^^)

11

Vous êtres graves quand même grin
avatar

12

ba, me faisait chier au boulot a attendre qu'un truc finisse de compiler cheeky
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

13

'est moche une fonction C dessasembler et encore plus quand c'est du x86



GT Toujours pour le 680x0
avatar
< SCPCD > j'aurais du dire "les doigts dans le cul vu que le java c'est de la merde"
Je suis Goto !

14

Pour la peine, 6502:

;
; File generated by cc65 v 2.11.0
;
.fopt compiler,"cc65 v 2.11.0"
.setcpu "6502"
.smart on
.autoimport on
.case on
.debuginfo off
.importzp sp, sreg, regsave, regbank, tmp1, ptr1, ptr2
.macpack longbranch
.import _open
.import _write
.import _exit
.export _main

.segment "RODATA"

L0001:
.byte $2F,$64,$65,$76,$2F,$74,$74,$79,$00,$63,$6F,$75,$63,$6F,$75,$0A
.byte $00

; ---------------------------------------------------------------
; int __near__ main (void)
; ---------------------------------------------------------------

.segment "CODE"

.proc _main: near

.segment "RODATA"

L0003:
.byte $1B,$5B,$30,$3B,$33,$34,$6D,$00
L0005:
.byte $1B,$5B,$30,$6D,$00
L0007:
.byte $1B,$5B,$48,$1B,$5B,$32,$4A,$00

.segment "CODE"

ldy #$0A
jsr subysp
ldy #$07
L0004: lda L0003,y
sta (sp),y
dey
bpl L0004
jsr decsp5
ldy #$04
L0006: lda L0005,y
sta (sp),y
dey
bpl L0006
jsr decsp8
ldy #$07
L0008: lda L0007,y
sta (sp),y
dey
bpl L0008
lda #<(L0001)
ldx #>(L0001)
jsr pushax
jsr push1
jsr _open
ldy #$15
jsr staxysp
jsr pushax
lda #$02
jsr leaasp
jsr pushax
lda #$08
jsr pusha0
jsr _write
ldy #$18
jsr pushwysp
lda #$0F
jsr leaasp
jsr pushax
lda #$08
jsr pusha0
jsr _write
ldy #$18
jsr pushwysp
lda #<(L0001+9)
ldx #>(L0001+9)
jsr pushax
jsr push7
jsr _write
ldy #$18
jsr pushwysp
lda #$0A
jsr leaasp
jsr pushax
jsr push5
jsr _write
jsr push0
jsr _exit
ldy #$17
jmp addysp

.endproc
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.