updated pass system, works good now. merge that shit

examples/demolib/main.cpp

@@ -15,7 +15,7 @@ test_t t = {"Hello", "World", {}};
 
 OBF extern "C" void EntryPoint() {
   t.buff[0] = 1;
-  t.buff[1] = 1;
+  t.buff[1] = 0;
 
   if (t.buff[0])
     MessageBoxA(nullptr, t.c, t.c2, nullptr);

include/recomp/reloc.hpp

@@ -27,14 +27,11 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // POSSIBILITY OF SUCH DAMAGE.
 //
-
 #pragma once
 #include <cstddef>
 #include <cstdint>
 #include <obf/transform/transform.hpp>
-
 namespace theo::recomp {
-
 /// <summary>
 /// meta data about a relocation for a symbol
 /// </summary>
@@ -53,19 +50,16 @@ class reloc_t {
                    std::size_t hash,
                    const std::string&& sym_name)
       : m_offset(offset), m_hash(hash), m_sym_name(sym_name) {}
-
   /// <summary>
   /// returns the hash of the relocation symbol.
   /// </summary>
   /// <returns>hash of the relocation symbol</returns>
   std::size_t hash() { return m_hash; }
-
   /// <summary>
   /// returns the name of the relocation symbol.
   /// </summary>
   /// <returns>returns the name of the relocation symbol.</returns>
   std::string name() { return m_sym_name; }
-
   /// <summary>
   /// returns the offset into the symbol to which the relocation will be
   /// applied. the offset is in bytes. zero based.
@@ -73,15 +67,35 @@ class reloc_t {
   /// <returns>returns the offset into the symbol to which the relocation will
   /// be applied. the offset is in bytes. zero based.</returns>
   std::uint32_t offset() { return m_offset; }
-
   /// <summary>
   /// sets the offset to which the relocation gets applied too.
   /// </summary>
   /// <param name="offset">offset to which the relocation gets applied
   /// too.</param>
   void offset(std::uint32_t offset) { m_offset = offset; }
+  /// <summary>
+  /// adds a transformation to be applied to the relocation prior to writing it
+  /// into the symbol.
+  /// </summary>
+  /// <param name="entry">a pair containing a lambda function that when executed
+  /// transforms a relocation. the second value in the pair is a random value
+  /// which is passed to the lambda.</param>
+  void add_transform(
+      std::pair<obf::transform::transform_t*, std::uint32_t> entry) {
+    m_transforms.push_back(entry);
+  }
+  /// <summary>
+  /// gets the vector of transformation.
+  /// </summary>
+  /// <returns>returns the vector of transformations.</returns>
+  std::vector<std::pair<obf::transform::transform_t*, std::uint32_t>>&
+  get_transforms() {
+    return m_transforms;
+  }
 
  private:
+  std::vector<std::pair<obf::transform::transform_t*, std::uint32_t>>
+      m_transforms;
   std::string m_sym_name;
   std::size_t m_hash;
   std::uint32_t m_offset;

src/recomp/recomp.cpp

@@ -158,7 +158,18 @@ void recomp_t::resolve() {
                                              reloc.offset()) = allocated_at;
           break;
         }
-        case decomp::sym_type_t::instruction:
+        case decomp::sym_type_t::instruction: {
+          auto& transforms = reloc.get_transforms();
+          std::for_each(
+              transforms.begin(), transforms.end(),
+              [&](std::pair<obf::transform::transform_t*, std::uint32_t>& t) {
+                allocated_at = (*t.first)(allocated_at, t.second);
+              });
+
+          *reinterpret_cast<std::uintptr_t*>(sym.data().data() +
+                                             reloc.offset()) = allocated_at;
+          break;
+        }
         case decomp::sym_type_t::function: {
           *reinterpret_cast<std::uintptr_t*>(sym.data().data() +
                                              reloc.offset()) = allocated_at;