Gerar o código de montagem da arquitetura MIPS em uma máquina X86

Question

Eu preciso gerar um código específico MIPS na minha máquina quando executo meu programa em C. Quando eu simplesmente corro,

gcc -O2 -S -c hello.c

No meu sistema, recebo o hello.s , que parece gerar algum código assembly, mas não parece ser um código específico MIPS . O conteúdo do arquivo hello.s é como abaixo.

    .file   "hello.c"
    .section    .rodata.str1.1,"aMS",@progbits,1
.LC0:
    .string "Hello world"
    .text
    .p2align 4,,15
.globl main
    .type   main, @function
main:
.LFB11:
    .cfi_startproc
    movl    $.LC0, %edi
    xorl    %eax, %eax
    jmp printf
    .cfi_endproc
.LFE11:
    .size   main, .-main
    .ident  "GCC: (GNU) 4.4.7 20120313 (Red Hat 4.4.7-4)"
    .section    .note.GNU-stack,"",@progbits

Como posso gerar o código específico MIPS na minha máquina?

Os detalhes da minha máquina são os seguintes.

arch
x86_64

    

Answer 1

Entendendo o básico

A partir da entrada wiki da arquitetura MIPS, ela é descrita como

MIPS (originally an acronym for Microprocessor without Interlocked Pipeline Stages) is a reduced instruction set computer (RISC) instruction set (ISA) developed by MIPS Technologies (formerly MIPS Computer Systems, Inc.).

Na entrada wiki do x86-64, ele é descrito como

x86-64 (also known as x64, x86_64 and AMD64) is the 64-bit version of the x86 instruction set.

Portanto, conforme a saída arch da questão, é evidente que tenho uma máquina x86_64 e tento produzir o código específico da arquitetura MIPS após a execução gcc compilador.

Isso é semelhante a tentar e operar um carro a diesel em um motor a gasolina . Não importa o quanto tentemos, sem ajustar o motor a gasolina, não poderíamos operar o carro a diesel em um motor a gasolina.

Para descrevê-lo de maneira técnica , gcc pode produzir código assembly para um grande número de arquiteturas, incluir MIPS . Mas qual arquitetura uma determinada meta de gcc é decidida quando gcc é compilado. O binário pré-compilado que você encontrará em um sistema Ubuntu conhece o x86 (possivelmente ambos os modos de 32 e 64 bits) mas não o MIPS .

Como compilar um programa C para o código assembly do MIPS

Novamente citando a mesma resposta , compilando gcc com uma arquitetura de destino diferente da arquitetura na qual% co_de O próprio% será executado é conhecido como preparar uma cadeia de ferramentas de compilação cruzada. Ou em termos leigos, esta cadeia de ferramentas de compilação cruzada é semelhante a ajustar o motor a gasolina para operar o carro a diesel .

No entanto, a criação de uma cadeia de ferramentas de compilação cruzada é um pouco trabalhosa, então, em vez de descrever como configurá-la, descreverei como instalar um compilador MIPS nativo em uma máquina virtual MIPS. Isso envolve as etapas adicionais de configurar um emulador para a VM e instalar um sistema operacional nesse ambiente, mas permitirá que você use um compilador nativo pré-compilado em vez de compilar um compilador cruzado.

Nós iremos primeiro instalar gcc para fazer nosso sistema executar alguns sistemas operacionais virtualizados. Novamente, existem várias abordagens como a instalação de uma cadeia de ferramentas compilada cruzada como discutida aqui e usando um buildroot como sugerido na resposta que eu vinculei anteriormente.

• Faça o download da tarball do qemu daqui.

• Depois de baixar a bola de alcatrão, execute os seguintes comandos.

   bzip2 -d qe*
   tar -xvf qe*
   ./configure
   make
   make install
  

• Agora, depois de instalar o qemu na máquina, experimentei vários métodos de netboot para o sistema operacional debian como sugerido sobre aqui e aqui . Mas infelizmente não consegui realizar a instalação do sistema operacional debian usando o netboot porque os espelhos corretos não estavam disponíveis.

Eu tenho uma imagem para o debian que tem como alvo a arquitetura MIPS de     aqui e eu    baixou a imagem qemu e kernel e do link acima e executou as etapas abaixo.

• Eu iniciei o qemu como abaixo.

  qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda 
  debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0"
  

• Depois que o sistema debian surgiu, eu instalei o compilador qemu como abaixo.

  apt-get update && apt-get upgrade
  apt-get install build-essential
  

Agora, eu tenho um compilador gcc nativo trabalhando perfeitamente dentro da máquina virtual debian MIPS no qemu, que compila meu programa C para o código de assembly específico MIPS .

Teste

Dentro da minha máquina debian, eu coloquei um exemplo do programa Hello World e o salvei como gcc como abaixo.

#include<stdio.h>
int main()
{
    printf("Hello World");
}

Para gerar o código de arquitetura MIPS para o meu programa hello.c, executei o programa C usando o compilador hello.c como

gcc -O2 -S -c hello.c

O comando acima gerou um arquivo gcc que gerou meu código de arquitetura MIPS .

    .file   1 "hello.c"
    .section .mdebug.abi32
    .previous
    .gnu_attribute 4, 1
    .abicalls
    .section    .rodata.str1.4,"aMS",@progbits,1
    .align  2
$LC0:
    .ascii  "Hello World
 bzip2 -d qe*
 tar -xvf qe*
 ./configure
 make
 make install
0"
    .text
    .align  2
    .globl  main
    .set    nomips16
    .ent    main
    .type   main, @function
main:
    .frame  $sp,0,$31       # vars= 0, regs= 0/0, args= 0, gp= 0
    .mask   0x00000000,0
    .fmask  0x00000000,0
    .set    noreorder
    .set    nomacro

    lui $28,%hi(__gnu_local_gp)
    addiu   $28,$28,%lo(__gnu_local_gp)
    lui $4,%hi($LC0)
    lw  $25,%call16(printf)($28)
    nop
    jr  $25
    addiu   $4,$4,%lo($LC0)

    .set    macro
    .set    reorder
    .end    main
    .size   main, .-main
    .ident  "GCC: (Debian 4.4.5-8) 4.4.5"

Mas como saberei se o código gerado acima é o código de montagem MIPS ?

A saída do comando hello.s informará a arquitetura da máquina. Na minha máquina debian, ele produz a saída como arch e eu também não tenho nenhuma mips ou cadeias de ferramentas de compilador cruzado instaladas na máquina.

Portanto, o código de montagem gerado é específico de MIPS .

    

Answer 2

Você precisa de um toolchain cruzado, gcc (+ binutils), que é executado em x86_64, mas resulta em binários mips.

Você pode tentar construí-lo do zero (google por exemplos: build cross toolchain) ou baixar um pré-criado (como em Codesourcery )

Ou você pode criar o seu próprio com a ajuda de alguma ferramenta como crosstool-ng

Também sistemas como buildroot constroem (ou baixam) suas próprias ferramentas cruzadas (eu acho que também OpenWRT).

    

Answer 3

O projeto emdebian fez algum trabalho em cruzar os toolchains .

Como esses pacotes sofrem um pouco de podridão, eu questiono sobre o status atual do projeto emdebian, seja por meio da lista de discussão ou pelo IRC.