[PROJECT] Check methods of "LowLevelMemory" regarding possible older compilers

[TheRedDaemon]

After trying another method again, the patterns still barely match.
My last try was 0x0046AE50 (copyStringUntilFirstDot).
It could still be possible they used very unusual loop forms or techniques, or simply structures I do not think of. But the only way I found so far for re-creating the match was using inline assembly for the whole function body, which properly formed the prolog and epilog to what is was.

---

We have to consider that older compilers or libraries may be involved. The may have used an older static support library in the exe.
So part of this issue would be testing one or two of the smaller "LowLevelMemory" functions with older compilers and checking if one gets better results.

---

An attempt with MSVC7.00 failed completely, since only 7.10 somewhat fixed the template support.

Therefore, tests need to be performed on a very small scale, maybe the resolvers can be excluded for these test from the header, to still keep the ENV.
Also, note that MSVC1400 is also mentioned in the CMakeLists.txt.

[TheRedDaemon]

The current list of things that could be the reason:

• Code structure not replicated/known
  • Starting to get very unlikely, since certain optimizations did not happen that MSVC2005 should actually perform on /O2, but it is not debug.
• Assembly
  • I feel like this is still very unlikely, maybe the most unlikely.
  • While using asm forces the prolog and epilog found in the code, that might actually just be the result of me stripping every other way by using asm.
• Static library with older compiler
  • Currently look likely
• Static library of old compiler and Link Time Code Optimization
  • I would hate that one.
  • The idea here is that LowLevelMemory is just a wrapper around a possible even C compiled static support library.
• Multi level build
  • Basically the worst case.
  • The result was created by linking a static lib compiled another way that wrapped another lib compiled another way,
  • If we reach this point, we should likely just replace the logic.

[TheRedDaemon]

Further tests did not offer too much insight.
Notable, I tested multiple compilers from archaic-msvc (700, 600-sp5, 600, 500, 420) and non of these got much closer to the structure.
Now, I also did not thoroughly test a lot of loop variants. Additionally, I used our CMake setup for this test (although I had to remove more and more includes and then switch to setting the env via the VS bat file, but I still could control the targets via CLI), so while it should not much, some settings might have influenced it.

The methods of the LowLevelMemory structure that received an attempted reimplementation so far share a common structure, where very clear function prologs and epilogs are present. Notably, the received parameters are usually loaded onto the stack and then directly loaded into registers again to use them.
Only inline assembly so far was able to match 100% by basically providing almost the complete body. The function epilog and prolog then generated fittingly.
ChatGPT insisted on it being likely MSVC5/6 assembly of lesser optimization, but I was not able to produces this. Nudged into the direction of inline assembly it was rather hesitant, but could be convinced by words along the lines of "look, this loop uses very simple opcodes and no tricks". That does not increase my case.

It is inconclusive to me, but at the same time points more and more into the direction of hand written assembly. This could still have been an older static library, but if most was assembly anyway, the effect can be ignored.
Preprompted by the discussion about the other function, I also mentioned the 256, 16, 1 byte copy structure to ChatGPT. It said in this case (although clearly influenced from before), that such copy loops would be old, often manually written techniques to improve copy behaviour on old systems. Especially the unrolled 256 byte loop (done using 64 int copies) would apparently be much too long for an automatic unroll. I did not test this one either.

@gynt How should we continue with the "LowLevelMemory"? Should we stop and see if more places with weird code appear? Or should we just continue implementing functions of this as asm if nothing fits? Any other idea?
Also, was it not actually said once that they wrote machine code for Stronghold? Maybe I am imagining things...