How does such a minimal binary take up 300+ bytes?
Name:
Anonymous2014-04-26 23:56
Please help me learn assembly
I want to use as but I guess ill switch to nasm if it's better. Look I just need a tutorial that teaches me how to program assembly step by step on linux. Please?
Name:
Anonymous2014-04-26 23:59
How does such a minimal binary take up 300+ bytes?
probably the elf header and shit, try objdump -d to see maybe?
>>5 So according to this, my text and data segments only take up 26 bytes, and the other 314 bytes of my program are in the ELF header. What the fuck.
Also, confirmed that the data segment is writeable. Another what the fuck.
Name:
Anonymous2014-04-27 5:41
>>7 Of course data segment is writeable, as is bss segment. I think data is where your `int g_foo = 42; global variable goes, so you need that to be writeable so your variable is mutable.
Name:
Anonymous2014-04-27 5:46
>>7 A writeable .data segment is the norm. If you want fuck to be immutable, put it in .text or .rodata.
>>10 Actually 32 bit code is more efficient because all pointers are half as large; this has a significant effect on code density and instruction cache hit rate. In many cases this outweighs the benefits of the extra general purpose registers that are available in long mode.
Actually real mode is more efficient because all pointers are half as large; this has a significant effect on code density and int 21h cost. In many cases this outweighs the benefits of the extra register width and flat address space that are available in protected mode.
>>11 That's because the DOS COM ``format'' isn't an executable format in any modern sense. DOS just dumped the contents of a .COM file into memory at a fixed address and jumped into it. So you have no dynamic linking, no position independent code, no relocation, nothing. If you want any of that, you need that header ``boilerplate''.
Name:
Anonymous2014-04-27 7:28
>>14 nothing stops COM code from relocating itself.
Name:
Anonymous2014-04-27 7:37
>>13 The functional improvement going from real mode to protected mode is much larger than going from protected mode to long mode. Nearly all modern programs benefit (or even require) memory protection and a 4 GiB virtual address space. Conversely only certain workloads benefit from a 128 TiB virtual address space; for other applications the benefit of sticking with 32 bit pointers in long mode is so large that the Linux kernel supports a whole second 32-bit ABI specifically to allow for it.
Name:
Anonymous2014-04-27 7:40
>>15 It's a pointless exercise to write special purpose loader code for every program that needs to be relocated. The whole point of having a standard executable format is to make it possible for multiple programs to share the same loader.
It's a pointless exercise to write special purpose loader code for every program that needs to be relocated.
That is why we have compiler and static linker. OS kernel shouldn't do anything more than providing hardware abstraction layer. Everything else should be reconfigurable.
>>18 When did this become an operating systems discussion?
You are free to reinvent the wheel for every program you write. However I imagine after you've written the same dumb boilerplate loader code for three or four programs I imagine you will end up rearranging the combined result into something that looks a lot like loaders others have already written.
>>18 Also, as a side note - dynamic linkers need not be part of the kernel, and in practice they often are not. On Linux systems the dynamic linkers are just libraries can indeed be replaced.
Works just as okey. For example, Windows 3.1 provided it's own linker.
Name:
Anonymous2014-04-27 9:56
>>8,9 Ah, ok. I relocated fuck to .rodata and bork segfaulted as expected. I also objdump -x'd this program and confirmed that it sticks the string in .rodata:
>>33 You need to be careful that you only use each segment for its intended use. The text segment (.text) can contain both code and data (keeping in mind that any data you place in the text segment cannot be changed by your program during execution). The initialized part of the data segment (.data) should contain just data, not code. And the uninitialized part of the data segment (.bss) cannot have values placed in it as assembly time at all -- all you can do here is allocate memory (that is, add to the total amount of memory to be included as uninitialized data). In all three types of segment, you can define symbolic labels; such a label has as its value an address within that segment.
section .text global foo foo: push ebp ; save ebp onto the stack mov ebp,esp ; save the stack pointer in ebp push msg ; push argument onto the stack call puts add esp,4 ; skip past 'msg' on the stack mov esp,ebp ; reset the stack??? pop ebp ; restore ebp
mov eax,1 ; sys_exit mov ebx,0 ; 0 int 0x80
not totally sure its correct.. and I'd like to do it without a .c file
Name:
Anonymous2014-04-29 0:06
>>34 Fuck you, I make a new segment for every function I need and it's never bitten me in the ass.
Who cares about Windows asm any more anyway. Is it because AT&T syntax is such ugly garbage? Yeah, GCC made a blunder choosing that one.
Also, FASM is better than nasm.
Name:
Anonymous2014-04-29 0:15
>>36 FASM is the CL of assemblers, that is, for niggers
>>38 What assembler is better than FASM? And what the fuck do you mean by ``hipster''? You could say ``normalfag'' as fucking every ``normal'' person uses ruby or python.
Name:
Anonymous2014-04-29 10:49
>>38 i think you're stuck with at&t syntax for inline asm though
>>45-47 That program can be written entirely in assembly and linked against libc. No need to write your own startup code. Just call printf directly (the call to fflush can be totally omitted since stdout will be flushed automatically when main returns).
Cracking becomes useless skill today, because software moves to the cloud. It was really funny, when these faggots found that Diablo 3 cannot be cracked, because the game logic is in the cloud.
Today it is mostly reverse engineering (when Chinese manage steal American aircraft and want to RE its stuffing) and supporting legacy code (when employer lost his sources).
Name:
Anonymous2014-05-04 15:30
>>54 Now machine learning can be used to construct a model of game logic to fit recorded data.
Name:
Anonymous2014-05-05 15:03
I've written game of life in assembly!!!
Not sure what to try next, but I need to keep leaning - help me out?
Name:
Anonymous2014-05-05 15:22
>>56 Write 2A03 emulator in x86 assembly. Contrib your code to some major NES emulator project.
Name:
Anonymous2014-05-05 15:56
>>57 That sounds like a project I'd work on, except 5A22 in MIPS. Damn mode 7 fps rates.
A game, like Diablo 3, has a lot of instances of some CObject class, which has a some (many) of dimensions on it's own (like monster's health and damage, which itself correlates with weapon's damage and monster's strength). Software pirates can't just simply record statistics from the server and curve-fit observations into the alternative server implementation. Moreover, pirates are usually college dropouts, while analyzing statistics requires a lot of math skills.
Name:
Anonymous2014-05-05 21:19
>>59 I'm sure one of us could do it. It would be a fun project. Especially if the work done could be reused on other games like this.
Name:
Anonymous2014-05-06 9:28
* Sections: global variables go in the .data section, you can also reserve space in the .bss section but they start out as having the value 0. Your actual code goes in the .text section.
* Labels: assembly programming is all about gotos, there is jmp to go to a label, and then there are various conditional jumps jne (jump not equal), jc (jump if carry) they look at EFLAGS register which notes down information about the last arithmetic calculation you did.
* Registers: So there's a few 32 bit registers, eax, ebx, ecx, edx and they have ax, al, ah parts (so you can work with 16 or 8 bits) - you can zero or sign extend a number to go from one number type to a higher width one. There's also ebp and esp registers for the base and stack pointers.
* Stacks: The stack grows down so you subtract from sp to get more stack space. push and pop are useful.
* C function calls: To call a c function you put the parameters on the stack them 'call' it, once it returns you have to clear up too. c functions will preserve some registers but others you have to store on the stack and restore them once it returns.
* linux syscalls: you can do linux syscalls by putting parameters into registers then using the int 0x80 interrupt. This lets you write programs that don't use libc.
>>59 How to get a working crack for games like that: 1: borrow $50,000 from mafia 2: give $49,999 and a soda of her choice to studio programmer in exchange for the source 3: insert malware into cracked versions to steal data and be a botnet 4: monetize 5: pay $100,000 back to mafia
Alternatively, you can just fly to India and walk around the slums until you find the sub-sub-sub-contractor and pay him $50 for it, but it's less safe.
When you finally compile a half-broken implementation of the game server, Blizzard would already releasing Diablo 5 and no one would care about the years of your work.
That was the case with Ultima Online. When hobbyists managed to get up the servers, the game was long outdated and replaced with World of Warcraft.
Name:
Anonymous2014-05-06 15:25
>>63 It would be faster if it was automated. And why so negative?
pop eax push ebx ;need to save ebx dec eax push eax call fib add esp,4 mov ebx,eax
pop eax add eax,ebx
ret
Name:
fibsiter.s2014-05-18 8:37
extern print_number
section .text global asm_main asm_main: enter 0,0 pusha
;; The loop instruction decrements ECX and jumps to the address specified by arg unless decrementing ECX caused its value to become zero. ;;; calculate fib(ecx), must be 2 or more mov ecx,1507
mov eax,0 mov ebx,1 dec ecx
iter: mov edx,ebx add ebx,eax mov eax,edx loop iter
Love the "leave" mnemonic - it is 1-char less than the return from C/C++
Name:
Anonymous2014-05-21 13:59
>>71-73 enter, leave, loop and friends are effectively deprecated and will use a slow micro-coded implementation on newer CPUs. push, pop, movs and stos are among a few complex instructions that are still aggressively optimized.
Name:
Anonymous2014-05-21 19:30
According to Agner Fog movs and stos are still slower than manual mov&add, though they do take up less icache.
And the manuals say...? Suppose you are using a rep prefix, what then?
>>76 No, because then they would have to write a comprehensible specification of how their microcode is implemented and promise not to change it (very much). The former could be hard given that the micro-op interface has been a closely guarded trade secret for so long. The latter would be contrary to Intel's x86 compatibility religion, and given how the the whole P6/Netburst/Nehalem history has gone I doubt they'd want to tie their hands anyway.
Technically, the micro-op architecture is almost certainly designed with on-chip generation in mind (optimized for simple translation and ease of execution) and probably wouldn't perform well if the frontend were just thrown away leaving micro-ops to be fetched from Lx SRAM and then from DRAM.
Finally, who would care enough to write their own microcode anyway, if the x86 frontend was maintained? DEC went a somewhat similar route with their PALcode and nobody other than Microsoft and Digital themselves ever bothered have custom microcode written for their OS.
Name:
Anonymous2014-05-26 7:15
Is it true that MMU considerably slows down memory access and a single address space solution would be several times more efficient? As I understand it, spawning a process is a very expensive operation, due to MMU.
C/C++ sucks because you can't attach metainfo to a function, determine it's size or copy it to another location (GCC cannot into position-independent code).
So the only way to attach meta info to a function pointer is through a hashtable, which is very inefficient compared to something like char *getFunctionName(void (*f)()) { return *((char**)f-1); }
Name:
Anonymous2014-05-26 9:38
>>80 can you tell me one portable language that can do this? you can always use non-portable extencions
Name:
Anonymous2014-05-26 10:09
>>80 "very inefficient"...? REALLY? Honestly, are you 12? I think you must be. It isn't inefficient at all, it's just you're to damned lazy and immature to do anything for yourself if the language doesn't do for you. If you want to tabulate data about functions make a fucking TABLE.
If you want to tabulate data about functions make a fucking TABLE.
Table lookup is O(log2(N)). And you have to initialize it, after addresses become known.
Name:
Anonymous2014-05-26 19:00
>>83 Umb, hashtable lookup is O(1) if the size of the key is bounded by a constant. Though this would be interesting to have. A lisp to assembly compiler should implement the documentation string this way. Although I don't know if a page with execute permissions is the best place to store it. It might clog the instruction cache.
that O(1) is order of magnitude slower than array[i]'s O(1)
Name:
Anonymous2014-05-26 19:41
>>83 Lookup can be O(1), especially with a non-hash table. Bury the fp in a global struct. (But globals! Functions are global symbols too, deal with it.)
>>85 O(10) is still O(1). You're going to have to switch to cyclomatic complexity if you want to whine about large multipliers.
Name:
Anonymous2014-05-26 20:25
>>86 Computers have finite amount of memory (i.e, they are FSMs), meaning that any computation is O(1), yet this O(1) tells you nothing.
>>87 That isn't true. It means many computations could be written as O(1) with a large constant multiplier. Some could not, in fact, because some computations cannot be made to fit in memory in an O(1) form. Others cannot be expressed in a general O(1) form if P!=NP, and even if P=NP, the memory required might exceed what is available.
Name:
Anonymous2014-05-26 21:29
>>87 You must be the Reuleaux triangle faggot from a few years back.
>>90 It's not O(1) and can't be generalized to O(1) in finite space, which was the point of >>88. The original point remains that O(k*n) for k=10 is still pretty great.
>>93 That's called a siezure and you should be on medication.