[LINUX] Compilateur ELF32

Anonyme · Message par **Anonyme** » sam. 07/mars/2009 4:25

Ouf, après des heures de docs , j'ai réussi à faire mon premier compilo sans rien comprendre à l'ASM ^^
Quoi que d'écrire un compilo , on apprends un peu l'ASM , surtout le dessous de l'ASM

Bon , rien de faramineux , mais quand même , c'est le 1° compilo écrit en PB4.3 !

Le compilo se présente en 3 fichiers

- Les entêtes du format ELF32 ( que j'éclaircirais plus tard )
- L'opcode , sert à rien pour le moment ( utile surtout pour le déssassemblage)
- Le compilateur , qui inclue les précédents.

Lancer le compilateur (F5) en mode console
Entrer un texte de taille variable
Appuyer sur entrer pour compilé.
Un fichier "MyCompiledProg" sera créer.

Autoriser via les propriété de MyCompiledProg" l'execution comme un executable" , et lancer le dans une console , votre texte apparaîtra !

Fred & sa clique n'ont plus qu'a bien se tenir

===>[]

Elf32.pbi

Code : Tout sélectionner

IncludeFile "OpCode.pbi"

#EI_MAG0		= 0		
#ELFMAG0		= $7F
#EI_MAG1		= 1
#ELFMAG1		= 'E'
#EI_MAG2		= 2
#ELFMAG2		= 'L'
#EI_MAG3		= 3
#ELFMAG3		= 'F'

; e_type
#ET_NONE =0             
#ET_REL=   1             
#ET_EXEC=   2              
#ET_DYN= 3   
#ET_CORE=  4           
#ET_NUM=5         
#ET_LOPROC=  $FF      
#ET_HIPROC=$FFFF            

;e_machine
#EM_NONE=0
#EM_M32=1
#EM_SPARC=2
#EM_386=3
#EM_68K=4
#EM_88K=5 
#EM_486=6
#EM_860=7
#EM_MIPS=8

;e_version
#EV_NONE=0
#EV_CURRENT=1
#EV_NUM=2

; Segment types - p_type 
#PT_NULL=0           ;    /* unused */
#PT_LOAD=1             ;  /* loadable segment */
#PT_DYNAMIC=2      ;         /* dynamic linking section */
#PT_INTERP=3        ;       /* the RTLD */
#PT_NOTE=4           ;    /* auxiliary information */
#PT_SHLIB=5            ;   /* reserved - purpose undefined */
#PT_PHDR=6            ;   /* program header */
#PT_NUM=7             ;  /* Number of segment types */
#PT_LOOS=$60000000     ; /* reserved range For OS */
#PT_HIOS=$6fffffff     ; /*  specific segment types */
#PT_LOPROC=$70000000     ; /* reserved range For processor */
#PT_HIPROC=$7fffffff    ;  /*  specific segment types */

;Segment flags - p_flags 
#PF_X=$1      ;       /* Executable */
#PF_W=$2    ;         /* Writable */
#PF_R=$4      ;       /* Readable */
#PF_MASKPROC=$f0000000   ;   /* reserved bits For processor */
                                    
; Special Section Indexes 
#SHN_UNDEF=0           ;    /* undefined */
#SHN_LORESERVE=$ff00   ;       /* lower bounds of reserved indexes */
#SHN_LOPROC=$ff00  ;        /* reserved range For processor */
#SHN_HIPROC=$ff1f  ;        /*   specific section indexes */
#SHN_ABS=$fff1     ;     /* absolute value */
#SHN_COMMON=$fff2      ;    /* common symbol */
#SHN_HIRESERVE=$ffff    ;      /* upper bounds of reserved indexes */

; sh_type 
#SHT_NULL=0       ;        /* inactive */
#SHT_PROGBITS=1;               /* program defined information */
#SHT_SYMTAB=2      ;         /* symbol table section */
#SHT_STRTAB=3    ;           /* string table section */
#SHT_RELA=4       ;        /* relocation section With addends*/
#SHT_HASH=5        ;       /* symbol hash table section */
#SHT_DYNAMIC=6  ;             /* dynamic section */
#SHT_NOTE=7        ;       /* note section */
#SHT_NOBITS=8    ;           /* no space section */
#SHT_REL=9          ;     /* relation section without addends */
#SHT_SHLIB=10       ;       /* reserved - purpose unknown */
#SHT_DYNSYM=11     ;         /* dynamic symbol table section */
#SHT_NUM=12         ;     /* number of section types */
#SHT_LOPROC=$70000000 ;     /* reserved range For processor */
#SHT_HIPROC=$7fffffff  ;    /*  specific section header types */
#SHT_LOUSER=$80000000   ;   /* reserved range For application */
#SHT_HIUSER=$ffffffff   ;   /*  specific indexes */



;- ELF HEADER
 #EI_NIDENT = 16
Structure Elf32_Ehdr
	  e_ident.c[#EI_NIDENT]
		e_type.w
		e_machine.w
 		e_version.l
    e_entry.l
    e_phoff.l
    e_shoff.l
    e_flags.l
		e_ehsize.w
		e_phentsize.w
		e_phnum.w
		e_shentsize.w
		e_shnum.w
		e_shstrndx.w
EndStructure

Structure Elf32_Phdr
			p_type.l
			p_offset.l
			p_vaddr.l
			p_paddr.l
			p_filesz.l
			p_memsz.l
			p_flags.l
			p_align.l
EndStructure

Structure Elf32_Shdr
			sh_name.l
			sh_type.l
			sh_flags.l
			sh_addr.l
			sh_offset.l
			sh_size.l
			sh_link.l
			sh_info.l
			sh_addralign.l
			sh_entsize.l
EndStructure 





Procedure.i ELF_MAGIC(*MEMORY.Elf32_Ehdr)

If PeekC(*MEMORY) & 255 <>  $7F And PeekC(*MEMORY+1) & 255 <>  #ELFMAG1 And PeekC(*MEMORY+2) & 255 <>  #ELFMAG2 And PeekC(*MEMORY+3) & 255 <>  #ELFMAG3
 	PrintN("Error , not valid ELF format.")
 	ProcedureReturn -1
EndIf 
ProcedureReturn 1
EndProcedure

Procedure.i ELF32_OPEN(File$)
Print(LSet("Opening "+File$+" : ",50,"."))

If ReadFile(0,File$)
*ELF.i = AllocateMemory(Lof(0))
ReadData(0,*ELF,Lof(0))

If ELF_MAGIC(*ELF)=-1
  ProcedureReturn -1
EndIf 
PrintN("Sucess.("+Str(Lof(0))+")" )
CloseFile(0)

ProcedureReturn *ELF
Else
PrintN("Failed.")
ProcedureReturn -1
EndIf 
EndProcedure

Procedure.i ELF32_CHECK_TYPE(*MEMORY.Elf32_Ehdr)
With *MEMORY

Print(LSet("Type : ",50,"."))

	Select  PeekW(*MEMORY+OffsetOf(Elf32_Ehdr\e_type)) & 255
							Case  #ET_NONE
									PrintN("Unknown.") : ProcedureReturn #ET_NONE
							Case  #ET_REL    
									PrintN(" Relocatable file.") : ProcedureReturn #ET_REL
							Case  #ET_EXEC
									PrintN("Executable file.") : ProcedureReturn #ET_EXEC
							Case  #ET_DYN
									PrintN("Shared object file.") : ProcedureReturn #ET_DYN
							Case  #ET_CORE
									PrintN("Core file.") : ProcedureReturn #ET_CORE
							Case  #ET_NUM
									PrintN("Number of type.") : ProcedureReturn #ET_NUM
							Case #ET_LOPROC
									PrintN("Reserved range for processor.") : ProcedureReturn #ET_LOPROC
							Case  #ET_HIPROC
									PrintN("Specific e_type.") : ProcedureReturn #ET_HIPROC
							Default 
									PrintN("Error. in the header.") : ProcedureReturn -1
	EndSelect
EndWith
EndProcedure

Procedure.i ELF32_CHECK_MACHINE(*MEMORY.Elf32_Ehdr)
With *MEMORY


Print(LSet("Running for processor :  ",50,"."))
	Select  PeekW(*MEMORY+OffsetOf(Elf32_Ehdr\e_machine)) & 255
							Case  #EM_NONE
									PrintN("Unknown.") : ProcedureReturn #EM_NONE
							Case  #EM_M32
									PrintN("AT&T WE 32100") : ProcedureReturn #EM_M32
							Case  #EM_SPARC
									PrintN("SPARC") : ProcedureReturn #EM_SPARC
							Case  #EM_386
									PrintN("Intel 80386") : ProcedureReturn #EM_386
							Case  #EM_68K
									PrintN("Motorola 68000") : ProcedureReturn #EM_68K
							Case  #EM_88K
									PrintN("Motorola 88000") : ProcedureReturn #EM_88K
							Case #EM_486
									PrintN("Intel 80486") : ProcedureReturn #EM_486
							Case  #EM_860
									PrintN("Intel 80860") : ProcedureReturn #EM_860
							Case  #EM_MIPS
									PrintN("MIPS R3000 Big-Endian only") : ProcedureReturn #EM_MIPS
							Default 
									PrintN("Error. in the header.") : ProcedureReturn -1
	EndSelect
EndWith
EndProcedure

Procedure.i ELF32_CHECK_VERSION(*MEMORY.Elf32_Ehdr)
Result.l =  PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_version))
	Print(LSet("ELF version :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure ELF32_HEADER_SIZE(*MEMORY.Elf32_Ehdr)
Result.l =  PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_ehsize)) & 255
	Print(LSet("Header size :  ",50,"."))
	PrintN( Str(Result  ))
EndProcedure

Procedure.i ELF32_GET_SEGMENT_TABLE_OFFSET(*MEMORY.Elf32_Ehdr)
Result.l =  PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_phoff)) & 255
	Print(LSet("Segment table offset :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure.i ELF32_GET_SECTION_TABLE_OFFSET(*MEMORY.Elf32_Ehdr)
Result.l =  PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_shoff)) 
	Print(LSet("Section table offset :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure ELF32_GET_ENTRY_POINT(*MEMORY.Elf32_Ehdr)
Result.l =  PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_phoff)) 
	Print(LSet("Entry point offset :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure ELF32_SEGMENT_SIZE(*MEMORY.Elf32_Ehdr)
Result.l =  PeekW(*MEMORY+OffsetOf(Elf32_Ehdr\e_phentsize)) & 255
	Print(LSet("Segment header size :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure.w ELF32_COUNT_SEGMENT(*MEMORY.Elf32_Ehdr)
Result.w =  PeekW(*MEMORY+OffsetOf(Elf32_Ehdr\e_phnum)) & 255
	Print(LSet("Number of segment header :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure ELF32_SECTION_SIZE(*MEMORY.Elf32_Ehdr)
Result.l =  PeekW(*MEMORY+OffsetOf(Elf32_Ehdr\e_shentsize)) & 255
	Print(LSet("Section header size :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure.w ELF32_COUNT_SECTION_HEADER(*MEMORY.Elf32_Ehdr)
Result.w =  PeekW(*MEMORY+OffsetOf(Elf32_Ehdr\e_shnum)) & 255
	Print(LSet("Number of section header  :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure ELF32_STRING_TABLE_INDEX(*MEMORY.Elf32_Ehdr)
Result.l =  PeekW(*MEMORY+OffsetOf(Elf32_Ehdr\e_shstrndx)) & 255
	Print(LSet("String table index  :  ",50,"."))
	PrintN( Str(Result  ))
ProcedureReturn Result
EndProcedure

Procedure ELF32_GET_SEGMENT_TYPE(*MEMORY.Elf32_Phdr)

Print(LSet("Section type  :  ",50,".")) 
Select *MEMORY\p_type
					Case #PT_NULL :       PrintN("PT_NULL") : 							ProcedureReturn #PT_NULL
					Case #PT_LOAD :       PrintN("PT_LOAD") : 					  ProcedureReturn #PT_LOAD
					Case #PT_DYNAMIC:PrintN("PT_DYNAMIC") :   ProcedureReturn #PT_DYNAMIC
					Case #PT_INTERP :   PrintN("PT_INTERP") : 		  ProcedureReturn #PT_INTERP
					Case #PT_NOTE :       PrintN("PT_NOTE") : 				  ProcedureReturn #PT_NOTE
					Case #PT_SHLIB :       PrintN("PT_SHLIB") : 			  ProcedureReturn #PT_SHLIB
					Case #PT_PHDR :       PrintN("PT_PHDR") : 			  ProcedureReturn #PT_PHDR
					Case #PT_NUM :         PrintN("PT_NUM") : 						ProcedureReturn #PT_NUM
					Case #PT_LOOS :       PrintN("PT_LOOS") : 					ProcedureReturn #PT_LOOS
					Case #PT_HIOS :   PrintN("PT_HIOS") : 					  ProcedureReturn #PT_HIOS
					Case #PT_LOPROC : PrintN("PT_LOPROC") :			ProcedureReturn #PT_LOPROC
					Case #PT_HIPROC :  PrintN("PT_HIPROC") : 			ProcedureReturn #PT_HIPROC
					Default : PrintN("??????????")
EndSelect


EndProcedure

Procedure ELF32_GET_SECTION_OFFSET_IN_FILE(*MEMORY.Elf32_Phdr)
 Print(LSet("Offset in file  :  ",50,".")) 
 PrintN(Str(*MEMORY\p_offset))
 ProcedureReturn *MEMORY\p_offset
EndProcedure

Procedure ELF32_GET_SECTION_FILE_SIZE(*MEMORY.Elf32_Phdr)
 Print(LSet("File size  :  ",50,".")) 
 PrintN(Str(*MEMORY\p_filesz))
 ProcedureReturn *MEMORY\p_filesz
EndProcedure

Procedure ELF32_GET_SECTION_MEMORY_SIZE(*MEMORY.Elf32_Phdr)
 Print(LSet("Memory size  :  ",50,".")) 
 PrintN(Str(*MEMORY\p_memsz))
 ProcedureReturn *MEMORY\p_memsz
EndProcedure

Procedure.i ELF32_GET_SEGMENT(*MEMORY.Elf32_Ehdr,index.i) ; Renvois un pointeur de structure Elf32_Phdr
		Entry.l =  PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_phoff)) & 255
		Size.l  =  (PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_phentsize)) & 255) * index
		
		*Segment.Elf32_Phdr = AllocateMemory((PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_phentsize)) & 255))
		CopyMemory(*MEMORY+Entry+Size,*Segment,(PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_phentsize)) & 255))
		
		ProcedureReturn *Segment
EndProcedure

Procedure.i ELF32_GET_SECTION(*MEMORY.Elf32_Ehdr,index.i) ; Renvois un pointeur de structure Elf32_Shdr
		Entry.l =  PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_shoff)) 
		Size.l  =  (PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_shentsize)) & 255) * index
		
		*Section.Elf32_shdr = AllocateMemory((PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_shentsize)) & 255))
		CopyMemory(*MEMORY+Entry+Size,*Section,(PeekL(*MEMORY+OffsetOf(Elf32_Ehdr\e_shentsize)) & 255))
		
		ProcedureReturn *Section
EndProcedure


Procedure ELF32_GET_SECTION_NAME(*SECTION.Elf32_Shdr)
Print(LSet("Section name  :  ",50,".")) 
PrintN(Str(*SECTION\sh_name&255))
 ProcedureReturn *SECTION\sh_name & 255
EndProcedure

Procedure ELF32_GET_SECTION_TYPE(*SECTION.Elf32_Shdr)

Print(LSet("Section type  :  ",50,".")) 
Select *SECTION\sh_type
			Case #SHT_NULL			: PrintN("Inactive") 
			Case #SHT_PROGBITS	: PrintN("Program defined information")
			Case #SHT_SYMTAB		: PrintN("Symbol table")
			Case #SHT_STRTAB		: PrintN("String table")
			Case #SHT_RELA  		: PrintN("Relocation with addends")
			Case #SHT_HASH			: PrintN("Symbol hash table")
			Case #SHT_DYNAMIC		: PrintN("Dynamic section")
			Case #SHT_NOTE			: PrintN("Note section")
			Case #SHT_NOBITS		: PrintN("No space section")
			Case #SHT_REL				: PrintN("Relation whithout addends")
			Case #SHT_SHLIB			: PrintN("Reserved")
			Case #SHT_DYNSYM		: PrintN("Dynamic symbol table")
			Case #SHT_NUM				: PrintN("Number of section types")
			Case #SHT_LOPROC		: PrintN("Reserved range for processor")
			Case #SHT_HIPROC		: PrintN("Specific section header types")
			Case #SHT_LOUSER		: PrintN("Reserved range for application")
			Case #SHT_HIUSER		: PrintN("Specific indexes")
			Default 						: PrintN("?> 0x"+Hex(*SECTION\sh_type))
EndSelect

 ProcedureReturn *SECTION\sh_type
EndProcedure

Procedure ELF32_GET_SECTION_OFFSET(*SECTION.Elf32_Shdr)
Print(LSet("Data offset  :  ",50,".")) 
PrintN(Str(*SECTION\sh_offset))
ProcedureReturn *SECTION\sh_offset
EndProcedure

Procedure ELF32_GET_SECTION_DATA_SIZE(*SECTION.Elf32_Shdr)
Print(LSet("Data size  :  ",50,".")) 
PrintN(Str(*SECTION\sh_size))
ProcedureReturn *SECTION\sh_size
EndProcedure

Procedure ELF32_EXTRACT_STRING_IN_SECTION(*SECTION.Elf32_Shdr,*ELF.Elf32_Phdr)
Print(LSet("DataString  :  ",50,".")) 

; Peeks() don't work with 0x00
For i = *ELF + *SECTION\sh_offset To *ELF + *SECTION\sh_offset + *SECTION\sh_size
 Char.c = PeekC(i)
 If Char=0
 		String$ + "|"
 EndIf 
 		String$ + Chr(Char)
Next 

PrintN( String$ )
EndProcedure

Procedure ELF32_EXTRACT_CODE_HEXA(*SECTION.Elf32_Shdr,*ELF.Elf32_Phdr)
PrintN("")

For i = *ELF + *SECTION\sh_offset To *ELF + *SECTION\sh_offset + *SECTION\sh_size
 Code.c = PeekC(i) & 255
 Hexa$ = RSet(Hex(Code),2,"0")
 Print(ConvertByteToOpCode(Hexa$)) 
Next 


PrintN("")
EndProcedure


; 
; OpenConsole()
; *ELF = ELF32_OPEN("./elfdata")
; 
; If *ELF<>-1
; 		ELF32_CHECK_TYPE(*ELF)
; 		ELF32_CHECK_MACHINE(*ELF)
; 		ELF32_CHECK_VERSION(*ELF)
; 		
; 		ELF32_HEADER_SIZE(*ELF)
; 		
; 		ELF32_GET_ENTRY_POINT(*ELF)
; 		PrintN("")
; 		ELF32_GET_SEGMENT_TABLE_OFFSET(*ELF)
; 		ELF32_SEGMENT_SIZE(*ELF)
; 		SegCount = ELF32_COUNT_SEGMENT(*ELF)
; 		PrintN("")
; 		SectionOffset = ELF32_GET_SECTION_TABLE_OFFSET(*ELF)
; 		ELF32_SECTION_SIZE(*ELF)
; 		SecCount = ELF32_COUNT_SECTION_HEADER(*ELF)
; 		PrintN("")
; 		
; 		ELF32_STRING_TABLE_INDEX(*ELF)
; PrintN("")
; PrintN("==============================")
; PrintN("==========SEGMENTS============")
; PrintN("==============================")
; PrintN("")
; For i = 0 To SegCount-1
; PrintN("")
; 	*S.Elf32_Phdr = ELF32_GET_SEGMENT(*ELF,i)
;   		ELF32_GET_SEGMENT_TYPE(*S)
; 			ELF32_GET_SECTION_OFFSET_IN_FILE(*S)
; 			ELF32_GET_SECTION_FILE_SIZE(*S)
; 		  ELF32_GET_SECTION_MEMORY_SIZE(*S)
; 		PrintN("")
; Next 
; PrintN("")
; PrintN("==============================")
; PrintN("==========SECTIONS============")
; PrintN("==============================")
; 
; For i = 0 To SecCount-1
; PrintN("")
; *Section.Elf32_Shdr = ELF32_GET_SECTION(*ELF,i)
; ELF32_GET_SECTION_NAME(*Section)
; Type = ELF32_GET_SECTION_TYPE(*Section)
; ELF32_GET_SECTION_OFFSET(*Section)
; ELF32_GET_SECTION_DATA_SIZE(*Section)
; 
; If Type = #SHT_STRTAB
; 	ELF32_EXTRACT_STRING_IN_SECTION(*Section,*ELF)
; EndIf 
; 
; If type = #SHT_PROGBITS
; ELF32_EXTRACT_CODE_HEXA(*Section,*ELF)
; EndIf 
; 
; 
; PrintN("")
; Next 
; 
; 
; 
; EndIf 
; 
; 
; A$=Input()
; CloseConsole()
; 
; 
; 
; 
; End

OpCode.pbi

Code : Tout sélectionner

Procedure.s ConvertByteToOpCode(Hexa$)

Protected CodeAsm$

Select Hexa$
; Case "00" : CodeAsm$ = " 00 "
; Case "10" : CodeAsm$ = " ADC "
; Case "20" : CodeAsm$ = " And "
; Case "30" : CodeAsm$ = " XOr "
; Case "40" : CodeAsm$ = " INC "
; Case "50" : CodeAsm$ = " PUSH "
; 
; Case "70" : CodeAsm$ = " JO "
; Case "80" : CodeAsm$ = " ADD "
; Case "90" : CodeAsm$ = " NOP "
; Case "A0" : CodeAsm$ = " MOV "
; Case "B0" : CodeAsm$ = " MOV "
;      
; Case "D0" : CodeAsm$ = " ROL "
; Case "E0" : CodeAsm$ = " LOOPNZ "
; Case "F0" : CodeAsm$ = " LOCK "
Case "XXXXX" : sd=3
Default : CodeAsm$ = Hexa$+" "
EndSelect

ProcedureReturn CodeAsm$
EndProcedure

Compiler.pb

Code : Tout sélectionner

IncludeFile "Elf32.pbi"

OpenConsole()


PrintN("Write your text and press enter to compile your ELF file.")
TextToPrint$ = Input()
; TextToPrint$ = ReplaceString(TextToPrint$,32,Chr(20))

; Debug SizeOf(Elf32_Ehdr)
; End 

OpenFile(0,"./MyCompiledProg")


*Header.Elf32_Ehdr = AllocateMemory(SizeOf(Elf32_Ehdr))

With *Header

	  \e_ident[0] = #ELFMAG0
	  \e_ident[1] = #ELFMAG1
	  \e_ident[2] = #ELFMAG2
	  \e_ident[3] = #ELFMAG3
	  \e_ident[4] = 1
	  \e_ident[5] = 1
	  \e_ident[6] = 1
	  
	  For i = 7 To 15
	  	\e_ident[i] = 0
	  Next 
	  
		\e_type 			= #ET_EXEC
		\e_machine 		= #EM_386
 		\e_version 		= #EV_CURRENT
    \e_entry 			= $08048074;SizeOf(Elf32_Ehdr) + SizeOf(Elf32_Phdr)*2
    \e_phoff 			= SizeOf(Elf32_Ehdr)
    \e_shoff 			= 0
    \e_flags 			= 0
		\e_ehsize 		= SizeOf(Elf32_Ehdr)
		\e_phentsize 	= 32
		\e_phnum 			= 2
		\e_shentsize 	= 0
		\e_shnum			= 0
		\e_shstrndx 	= 0
		
EndWith

WriteData(0,*Header,SizeOf(Elf32_Ehdr))


*Code_Descriptor.Elf32_Phdr = AllocateMemory(SizeOf(Elf32_Phdr))

With *Code_Descriptor
		\p_type			= 1
		\p_offset		= 0
		\p_vaddr		= $08048000  ; ? pourquoi il faut que je trouve...
		\p_paddr		= 0
		\p_filesz		= 156
		\p_memsz		= 156
		\p_flags		= 5 
		\p_align		= $00000004
EndWith

WriteData(0,*Code_Descriptor,SizeOf(Elf32_Phdr))

*Data_Descriptor.Elf32_Phdr = AllocateMemory(SizeOf(Elf32_Phdr))

With *Data_Descriptor
		\p_type			= 1
		\p_offset		= 156
		\p_vaddr		= $0804809c  ; ? pourquoi il faut que je trouve...
		\p_paddr		= 0
		\p_filesz		= Len(TextToPrint$);$00000013
		\p_memsz		= Len(TextToPrint$);$00000013
		\p_flags		= 6
		\p_align		= $00000004
EndWith

WriteData(0,*Data_Descriptor,SizeOf(Elf32_Phdr))
start:
Restore debut_instruction_machine:
For opcode = 1 To  ?fin_instruction_machine - ?debut_instruction_machine
Read.c MyByteCode.c

 If MyByteCode = 20
 	WriteByte(0,Val(Hex(Len(TextToPrint$)+3+CountString(TextToPrint$,Chr(32))+3  )))
 Else
	WriteByte(0,MyByteCode)
 EndIf 
Next 

For i = 1 To Len(TextToPrint$)
 Char.c = Asc(Mid(TextToPrint$,i,1))
  WriteByte(0,Char)
Next 

WriteByte(0,$0A)

CloseFile(0)


RunProgram("chmod","777 ./MyCompiledProg","")


End 



DataSection:
debut_instruction_machine:
Data.c $90,$90,$90,$90,$b8,$04,$00,$00,$00,$bb,$01,$00,$00,$00,$b9,$9c,$80,$04,$08,$ba,$14,$00,$00,$00,$cd,$80,$b8,$01,$00,$00,$00,$bb,$00,$00,$00,$00,$cd,$80,$90,$90
fin_instruction_machine:
EndDataSection

Hs:

En Purebasic , lorsque l'on ne défini pas de type aux variables
elles sont en long ou integer automatiquement.
donc elles doivent être dans un registre 32 bits EAX ?
en fouillant les OpCode avec un éditeur Hexa , j'ai remarqué
que les variables indéfini vont dans des registres 16bits EX

Ex, Code pb:

Code : Tout sélectionner

D=45

OpCode :

C7 05 ... 2D

C7 = MOV
05 = AX
2d = 45

Est ce que je me plante ?

KarLKoX · Message par **KarLKoX** » sam. 07/mars/2009 17:04

Interessant

Pour les types non définis, je serais tenté de dire qu'il faut les caster en integer, elle auront ainsi la taille de la machine cible (32 bits sur x86 32 bits, 64 bits sur x86 64 bits etc).

cha0s · Message par **cha0s** » sam. 07/mars/2009 17:20

je pense que le mieux c'est de forcer le typage, cela est plus cohérent.

Cls · Message par **Cls** » lun. 09/mars/2009 12:35

Très joli code

Ollivier · Message par **Ollivier** » jeu. 12/mars/2009 22:18

Cpl.Bator a écrit : Hs:

En Purebasic , lorsque l'on ne défini pas de type aux variables
elles sont en long ou integer automatiquement.
donc elles doivent être dans un registre 32 bits EAX ?
en fouillant les OpCode avec un éditeur Hexa , j'ai remarqué
que les variables indéfini vont dans des registres 16bits EX

Ex, Code pb:
Code : Tout sélectionner
D=45
OpCode :

C7 05 ... 2D

C7 = MOV
05 = AX
2d = 45
Est ce que je me plante ?

Pas top, en fait cette traduction

C7.05.GG.HH.II.JJ.KK.LL.MM.NN,
1) Sous réserve que le suffixe 32bits suivant corresponde à un pointage de segment non privilégié de donnée,
2) donne MOV DWORD PTR [0x JJIIHHGG], 0x NNMMLLKK

= PokeL(0x JJIIHHGG, 0x NNMMLLKK)

Woilà, tschuess!
Ollivier

Message par **Fred** » sam. 21/mars/2009 6:16

Cpl.Bator a écrit :Fred & sa clique n'ont plus qu'a bien se tenir

Enfin une concurrence à la hauteur

.

PureBasic

[LINUX] Compilateur ELF32

[LINUX] Compilateur ELF32

Re: [LINUX] Compilateur ELF32

Re: [LINUX] Compilateur ELF32