Why can't code be uncompiled?

Submitted ⁨⁨10⁩ ⁨months⁩ ago⁩ by ⁨Squizzy@lemmy.world⁩ to ⁨[deleted]⁩

I see a lot about source codes being leaked and I’m wondering how it that you could make something like an exact replica of Super Mario Bros without the source code or how you can’t take the finished product and run it back through the compilation software?

source

Comments

Sort:hotnew top

Feyr@lemmy.world ⁨10⁩ ⁨months⁩ ago
4+4 is 8 But so is 6+2 And 7+1

You can’t guess which two numbers I started with knowing just the answer

Code is the same, just with much bigger numbers and more of them

source
- Treczoks@lemmy.world ⁨10⁩ ⁨months⁩ ago
  Very nice explanation of a complex promlem.
  
  source
- MTK@lemmy.world ⁨10⁩ ⁨months⁩ ago
  I would say that it’s more like 4+4=8 but the original could have been (1+1+1+1)+(3+1) or (2+2)+(1+2+1) etc.
  
  Basically it’s the same thing but if you really want to understand the code and modify it in any meaningful way you have to know how it was intended and not just the results.
  
  source
trigg@lemmy.world ⁨10⁩ ⁨months⁩ ago
It can be

What it produces will typically not contain the original names for variables and functions, and will not retain comments. It takes a lot more effort to understand what the intention behind the code was.

There’s also legality issues.

source
fenynro@lemmy.world ⁨10⁩ ⁨months⁩ ago
The long answer involves a lot of technical jargon, but the short answer is that the compilation process turns high level source code into something that the machine can read, and that process usually drops a lot of unneeded data and does some low-level optimization to make things more efficient during actual processing.

One can use a decompiler to take that machine code and attempt to turn it back into something human readable, but will usually be missing data on variable names, function calls, comments, etc. which makes it nearly impossible to reconstruct fully

source
- Squizzy@lemmy.world ⁨10⁩ ⁨months⁩ ago
  Thank you, sorry to push further but my understanding is that computers deal with binary so every language is compiled to machine code, which I took as binary.
  
  So if the language has elements being removed and the machine doesn’t need them shouldn’t you get back out exactly what is needed to do the task? Like if you compiled some code and then uncompiled it you would get the most efficient version of it because the computer took what it needed, discarded the rest and gave it back to you?
  
  source
  - fenynro@lemmy.world ⁨10⁩ ⁨months⁩ ago
    It depends on the specifics of how the language is conlmpiled. I’ll use C# as an example since that’s what I’m currently working with, but the process is different between all of them.
    
    C#, when compiled, actually gets compressed down to what is known as an intermediate language (MSIL for C# specifically). This intermediate file is basically a set of genericized instructions that are not linked to any specific CPU. This is useful because different CPUs require different instructions.
    
    Then, when the program is run a second compiler, known as the Just In Time compiler, takes the intermediate commands and translates them into something directly relevant to the CPU being used.
    
    When we decompile a C# dll, we’re really converting from the intermediate language (generic CPU-agnostic instructions) and translating it back into source code.
    
    To your second point, you are correct that the decompiled version will be more efficient from a processing perspective, but that efficiency comes at the direct cost of being able to easily understand what is happening at a human level.
    
    source
    -> View More Comments
  - KoboldCoterie@pawb.social ⁨10⁩ ⁨months⁩ ago
    The main issue is that to make code human-readable, we include a lot of conventions that computers don’t need. We use specific formatting, name conventions, code structure, comments, etc. to help someone look at the code and understand its function.
    
    Let’s say I write code, and I have a function named ‘findUserName’ that takes a variable ‘text’ and checks it against a global variable ‘userName’, to see if the user name is contained in the text, and returns ‘true’ if so. If I compile and decompile that, the result will be (for example) a function named ‘function_002’ that takes a variable ‘var_local_000’ and checks it against ‘var_global_115’. Also, my comments will be gone, and finding where the function was called from will be difficult. Yes, you could look at that code and puzzle out what it’s doing, but you wouldn’t know that var_global_115 is a username, so you’d have to go find where that variable was set and try to puzzle out where it was coming from, and follow that rabbit hole backwards until you eventually find a request for user input which you’d have to use context clues to determine the purpose of.
    
    It’s not that the code you get back from a decompiler is incorrect or inefficient, it’s that it’s very much not human-readable without a lot of extra investigatory work.
    
    source
    -> View More Comments
  - litchralee@sh.itjust.works ⁨10⁩ ⁨months⁩ ago
    The implicit assumption with decompiling code is that the goal is either to inspect how the code works, or to try compiling for a different machine. I’ll try to explain why the latter is quite difficult.
    
    As you said, compilation to machine code only keeps the details needed for the CPU to accomplish what was instructed. And indeed, that is supposed to be efficient to run on that CPU, by reason of being targeted exactly for that CPU. But when decompiling, the resulting code will reflect the specificity to that same CPU. If you then try to compile that code for a different CPU, it will likely work, but will likely be inefficient because the second CPU’s unique advantages won’t be leveraged.
    
    To use an example, consider how someone might divide two large numbers. Person A learned long division in school, and so takes each number and breaks it down into a series of smaller multiplications and subtractions. Person B learned to do division using a calculator, which just involves entering the two numbers and requesting that they be divided.
    
    Trying to do division by blindly giving Person B that series of multiplications and subtractions to do on the calculator is extremely inefficient because Person B knows how to do division easily. But Person B is following Person A’s methods, without knowing that the whole point of this exercise is to just divide the two original numbers. Compilation loses context and intent, which cannot be recovered from decompilation, for non-trivial programs.
    
    source
    -> View More Comments
  - jayrhacker@kbin.social ⁨10⁩ ⁨months⁩ ago
    
    if you compiled some code and then uncompiled it you would get the most efficient version of it ... ?
    
    Sorta, an optimizing compiler will always trim dead code which isn't needed, but it will also do things that are more efficient but make the code harder to understand like unrolling loops. e.g. you might have some code that says "for numbers 1-100 call some function" the compiler can look at this and say "let's just go ahead and insert 100 calls to that function with the specific number" so instead of a small loop you'll see a big block of function calls almost the same.
    
    Other optimizations will similarly obfuscate the original programmers intent, and thinks like assertions are meant to be optimized out in production code so those won't appear in the de-compiled version of the sources.
    
    source
Dark_Arc@social.packetloss.gg ⁨10⁩ ⁨months⁩ ago
I actually work on a C++ compiler… I think I should weigh in. The general consensus here that things are lossy is correct but perhaps non-obvious if you’re not familiar with the domain.

When you compile a program you’re taking the source, turning into a graph that represents every aspect of the program, and then generating some kind of IR that then gets turned into machine code.

You lose things like code comments because the machine doesn’t care about the comments right off the bat.

Then you lose local variable and function parameter names because the machine doesn’t care about those things.

Then you lose your class structure … because the machine really just cares about the total size of the thing it’s passing around. You can recover some of this information by looking at the functions but it’s not always going to be straight forward because not every constructor initializes everything and things like unions add further complexity … and not every memory allocation uses a constructor. You won’t get any names of any data members/fields though because … again the machine doesn’t care.

So what you’re left with is basically the mangled names of functions and what you can derive from how instructions access memory.

The mangled names normally tell you a lot, the namespace, the class (if any), and the argument count and types. Of course that’s not guaranteed either, it’s just because that’s how we come up with unique stable names for the various things in your program. It could function with a bunch of UUIDs if you setup a table on the compilers side to associate everything.

But wait! There’s more! The optimizer can do some really wild things in the name of speed… Including combining functions. Those constructors? Gone, now they’re just some more operations in the function bodies. That function you wrote to help improve readability of your code? Gone. That function you wrote to deduplicate code? Gone. That eloquent recursive logic you wrote? Gone, now it’s the moral equivalent of a giant mess of goto statements. That template code that makes use of dozens of instantiated functions? Those functions are gone now too; instead it’s all the instantiated logic puked out into one giant function. That piece of logic computing a value? Well the compiler figured out it’s always 27, so the logic to compute it? Gone.

Now all of that stuff doesn’t happen every time, particularly not all of those things are always possible optimizations or good optimizations … But you can see how incredibly difficult it is to reconstruct a program once it’s been compiled and gone through optimization. There’s a very low chance if you do reconstruct it, that it will look anything like what you started with.

source
- Treczoks@lemmy.world ⁨10⁩ ⁨months⁩ ago
  Just wait until you see the crazy optimizers for embedded systems. They take the complete code of a system into consideration, and, in a number of compile passes, reuses code snippets from app, libraries, and OS layer to create one big tangled mess that is hard to follow even if you have the source code…
  
  source
fidodo@lemmy.world ⁨10⁩ ⁨months⁩ ago
You can. It’s called decompiling. Problem is you lose all the human friendly metadata that was in the original source code, meaning comments, variable names, certain code structures are lost forever because it was deleted in the compilation process. There are tools to help you reintroduce that stuff by going through the variables and trying to make sense out of what they were for but it’s super tedious. With new ai tech that can certainly be improved with AI guessing what they were for but you’ll never get the original meta data back.

source
- Hjalamanger@feddit.nu ⁨10⁩ ⁨months⁩ ago
  Also if the code was run through an optimizer (which all modern games should be) the code is even harder to make sense of as it doesn’t necessarily have the same structure and the same variables as the original code
  
  source
  - BlackPenguins@lemmy.world ⁨10⁩ ⁨months⁩ ago
    This is also very similar to if they ran the source code through an obfuscation tool. Some people do this with chrome extensions. Since they need to give you the source code for it to work on your machine they just change the variables to a, b, c, d and route things though unneeded functions so you don’t know why anything is happening.
    
    source
howrar@lemmy.ca ⁨10⁩ ⁨months⁩ ago
The best and simplest explanation I’ve seen: The machine code tells the computer what to do while the source code tells the human why it’s doing it.

Your computer doesn’t need all the “why” information to run the game, so the compilation process gets rid of it. What you’re left with are instructions on exactly what computations to do, and that’s all the computer needs.

For example, you can see in the machine code that two numbers are being added together. What do those numbers mean and why are we adding them? The source code can tell you that this is code that controls movement, one of the numbers is a velocity, the other is the player’s current position.

source
- Squizzy@lemmy.world ⁨10⁩ ⁨months⁩ ago
  Okay, I think that is sinking in.
  
  I was under the impression it wasn’t possible or just complete gibberish but it being just the results or instructions is helpful.
  
  source
  - ook_the_librarian@lemmy.world ⁨10⁩ ⁨months⁩ ago
    Also, you only decompile to level of basic instructions that the processor understands. When you compile code to add two numbers, well, the processor only adds bytes. There are a quite a few steps that the compiler has to fill in.
    
    Ok, all that is not a big deal. But then you deal with compiler optimization. Optimizing basically tells the compiler to take its time and find some clever ways to save machine steps. So now the “standard way” for a compiler to implement adding numbers may have other stuff rolled into it because the compiler may see an opportunity to save steps in a seemly unrelated calculation by inserting steps into the addition it is implementing. Now it’s basically unrecognizable. A human didn’t write, and wouldn’t have written that mess that the decompiler gives.
    
    source
rikudou@lemmings.world ⁨10⁩ ⁨months⁩ ago
As I’ve read somewhere once: it’s easy to make a burger out of a cow. Making a cow out of a burger is slightly harder.

That means that compiling code is a lossy process - the original code is lost in the process and can never be recovered because it doesn’t exist anywhere anymore.

source
- Donebrach@lemmy.world ⁨10⁩ ⁨months⁩ ago
  This is the fundamental notion of nearly 95% of cyberpunk stories re: the human soul and yet everyone always is like “but I want my cool robot hand!”
  
  source
  - rikudou@lemmings.world ⁨10⁩ ⁨months⁩ ago
    Fuck soul, I want my cool robot hand!
    
    source
Moondance@sh.itjust.works ⁨10⁩ ⁨months⁩ ago
The compilation process discards information in the process leaving a many to one effect. A good decompiler allows one to retrieve a program that is functionally equivalent to the source code but not exactly the source code.

source
kirkmoodey@universeodon.com ⁨10⁩ ⁨months⁩ ago
@Squizzy
I mean, you can absolutely do disassembly work, it's just a pain in the rear.
But it's actually been done for Mario and Pokemon:
https://github.com/IsoFrieze/SMWDisX
source
the_q@lemmy.world ⁨10⁩ ⁨months⁩ ago
The same reason you can’t unbake a cake I’d imagine.

source
- Squizzy@lemmy.world ⁨10⁩ ⁨months⁩ ago
  Apparently not
  
  source
- NoIWontPickaName@kbin.social ⁨10⁩ ⁨months⁩ ago
  Has the cake been in closed in an airtight container since it was done baking?
  
  source
  - the_q@lemmy.world ⁨10⁩ ⁨months⁩ ago
    I dunno.
    
    source
    -> View More Comments
spudwart@spudwart.com ⁨10⁩ ⁨months⁩ ago
Well, actually it can be. It just takes a lot more to decompile code than compile it. Depending on the objective accuracy.

Example: the Super Mario 64 Decompilation project. This was a project that used various debug data that was left in the rom to decompile the game back to a source code that compiled a byte accurate version of the rom. This took about 3 years and a lot of skilled developers to accomplish.

Side note: Super Mario Bros wasn’t built using a compiled language, but rather Assembly. So technically that would be a Disassembly not a Decompilation.

source
ryathal@sh.itjust.works ⁨10⁩ ⁨months⁩ ago
Code can be decompiled, but generally the end result isn’t human readable. Just having the decompiler version isn’t that valuable. Having the source code as written is more helpful because you get the context of what things were named and how it was organized.

Decompiled code is a bit like reading a book with all the nouns being random letters and verbs being random numbers.

source
- TheVillageGuy@kbin.social ⁨10⁩ ⁨months⁩ ago
  Not completely random, every noun/verb would be translatable to a specific word/name. But also characters, there'd be many characters whose names, intentions and goals, relationships/links would also be in the same unreadable state. The storyline would likely not be chronological, but several actions and decisions by all kinds of actors would intertwine. It would be very hard to translate into a readable story, let alone so that it makes sense
  
  source
Kolanaki@yiffit.net ⁨10⁩ ⁨months⁩ ago
You can certainly decompile things back down to machine code, but there could be gaps and things lost in translation between the programming language used to create the program, and the machine code that results when you take it apart again.

When you program, like actually write the code, you’re using one language. When you compile it, you’re passing it off to an interpreter into another language. There could be even more layers of this depending on what you’re doing.

Now think about what happens when you open a translator, enter some words, translate it to one language, and then another, and back to the original. It comes out all wrong; the same thing happens with code. There’s nuance and flavor imparted by the language itself that isn’t kept through the interpretation of that language to the language that actually is used by the computer to do its tasks.

source
amio@kbin.social ⁨10⁩ ⁨months⁩ ago
The general difference is that you lose out on metadata - names, comments and organization that helps the source code in whatever programming language make sense, but which is not needed to actually execute the desired behavior on your CPU. Usually stuff like sensible names for bits of your code - functions/reusable logic, storage locations for "health" or "armor" or "current powerup", movement states, types of objects etc.

However, most of these are just another kind of number to the computer itself, so a lot of compilation processes strip a lot of this information. You could still reverse engineer it, but you're missing context (like all those names) from the original code and that makes the work potentially pretty difficult. Bear in mind that reading actual original source code is sometimes cryptic enough, then compare "if player is dead, show game over screen" to if (sdfdfgsdfg == jgdfg) { lkghku(); } because the "decompiler" has to invent some kind of name for everything that's missing. Now you have to deal with thousands of jfdsghklgs, and figure out what it all means.

source
GlitzyArmrest@lemmy.world ⁨10⁩ ⁨months⁩ ago
You can get close depending on the language by using decompilers. Usually though, they’re rough translations of what the decompiler thinks that the (compiled) machine code does. It’s not a 1:1 deal.

Basically, a compiler translates the human-readable code to machine code that can actually be recognized and executed by your computer. A decompiler attempts to do the opposite, it translates the machine code back into the original language. But like some “translators”, it’s not always correct. That’s the hard part - once decompiled you will likely have a lot of blanks to fill in and bugs to fix before anything will be compilable again. You’ll likely never be able to get an exact copy of the original source code via decompiler.

source
RightHandOfIkaros@lemmy.world ⁨10⁩ ⁨months⁩ ago
Code can be decompiled into code that can be recompiled, but compilers translate the human readable code into code that is easier to understand for machines. So decompiled code often ends up being mearly undecipherable for humans, and can take a long time to try and decipher.

source
Moondance@sh.itjust.works ⁨10⁩ ⁨months⁩ ago
But generally speaking it’s not a reversible process and it is more difficult to do in reverse.

source
schnurrito@discuss.tchncs.de ⁨10⁩ ⁨months⁩ ago
Others have explained that decompiling is a thing.

I mainly work in Java where (due to the way Java bytecode works) decompiled code is actually very close to the original source code.

Most games are written in low level languages like C++ where that is not the case, variable and function names are lost during compilation.

source
Valmond@lemmy.mindoki.com ⁨10⁩ ⁨months⁩ ago
It can, but it would just be the assembly instructions.

Usually we use high level programming languages when developing software, you’d make the cat class, the dog class, both inheriting from the animal class etc. to make our job easier.

When you compile the code, all the cute stuff gets removed, and the resulting code gets optimized as much as possible, which means you can’t get back to the nice cat and dog code anymore.

A bit like a painter uses thousands of brush strokes to make a painting, it would be very hard to figure out which ones he made to make that specific painting, even if you have access to the painting.

source
pizza_the_hutt@sh.itjust.works ⁨10⁩ ⁨months⁩ ago
It highly depends on the programming language used and how much debug information is left in the build. Production builds of software usually have debug symbols and other information useful during development stripped out to save space and improve runtime performance. Even when it is technically possible to decompile built code, the decompiled result may not be human-readable to the point of being useful. Imagine reading source code that has random names for variables, functions, modules, etc, or code that does not have any discernable organization.

source