Refactor `PtcInfo` (#2625)

* Refactor `PtcInfo`

This change reduces the coupling of `PtcInfo` by moving relocation
tracking to the backend. `RelocEntry`s remains as `RelocEntry`s through
out the pipeline until it actually needs to be written to the PTC
streams. Keeping this representation makes inspecting and manipulating
relocations after compilations less painful. This is something I needed
to do to patch relocations to 0 to diff dumps.

Contributes to #1125.

* Turn `Symbol` & `RelocInfo` into readonly structs

* Add documentation to `CompiledFunction`

* Remove `Compiler.Compile<T>`

Remove `Compiler.Compile<T>` and replace it by `Map<T>` of the
`CompiledFunction` returned.

1 files changed, 12 insertions, 13 deletions

diff --git a/ARMeilleure/Translation/Translator.cs b/ARMeilleure/Translation/Translator.cs
index 03ed4c5e..9974fb2d 100644
--- a/ARMeilleure/Translation/Translator.cs
+++ b/ARMeilleure/Translation/Translator.cs
@@ -1,3 +1,4 @@
+using ARMeilleure.CodeGen;
 using ARMeilleure.Common;
 using ARMeilleure.Decoders;
 using ARMeilleure.Diagnostics;
@@ -279,32 +280,30 @@ namespace ARMeilleure.Translation
 
             Logger.EndPass(PassName.RegisterUsage);
 
-            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
+            var retType = OperandType.I64;
+            var argTypes = new OperandType[] { OperandType.I64 };
 
-            CompilerOptions options = highCq ? CompilerOptions.HighCq : CompilerOptions.None;
+            var options = highCq ? CompilerOptions.HighCq : CompilerOptions.None;
 
-            GuestFunction func;
-
-            if (!context.HasPtc)
+            if (context.HasPtc)
             {
-                func = Compiler.Compile<GuestFunction>(cfg, argTypes, OperandType.I64, options);
+                options |= CompilerOptions.Relocatable;
             }
-            else
-            {
-                using PtcInfo ptcInfo = new PtcInfo();
 
-                func = Compiler.Compile<GuestFunction>(cfg, argTypes, OperandType.I64, options, ptcInfo);
+            CompiledFunction compiledFunc = Compiler.Compile(cfg, argTypes, retType, options);
 
+            if (context.HasPtc)
+            {
                 Hash128 hash = Ptc.ComputeHash(Memory, address, funcSize);
 
-                Ptc.WriteInfoCodeRelocUnwindInfo(address, funcSize, hash, highCq, ptcInfo);
+                Ptc.WriteCompiledFunction(address, funcSize, hash, highCq, compiledFunc);
             }
 
-            var result = new TranslatedFunction(func, counter, funcSize, highCq);
+            GuestFunction func = compiledFunc.Map<GuestFunction>();
 
             Allocators.ResetAll();
 
-            return result;
+            return new TranslatedFunction(func, counter, funcSize, highCq);
         }
 
         private struct Range