Revise basic arithmetics

[armoha]

See https://github.com/heinermann/llvm-bw/wiki/Instruction-Implementation

Implement followings:

• [x] in-place bitwise not: A = ~A -> 2A - Add 0xFFFFFFFF with mask b101010..., add 0xFFFFFFFF with mask b010101...
• [x] in-place negation: A = -A -> 3A - Same as bitwise not with extra +1.
• [x] constant xor: A ^= Constant -> 2A - Add constant with mask b01010101, add constant again with mask b10101010.
• [ ] constant xnor: A ^= Constant -> 2A - Add ~constant with mask b01010101, add ~constant again with mask b10101010.
• [x] in-place lshift:
  1. For each bit shifted (from highest to lowest):
     1. Set the range [destination bit, source bit) to 0 using a mask. (source bit excluded)
     2. Add b0111... (destination bit = 0, followed by n ones until the source bit) with mask of b11...n in [destination bit, source bit].
     3. Repeat until source bit at position 0.
  2. Set right-most n bits to 0 with a mask. This costs (2(32-n)+1)A since you can just run all these actions in a single shared trigger.
     • [x] in-place rshift: Abuse the property of never dipping below zero in subtraction to bit shift efficiently.
  3. Set the lowest n bits to 0.
  4. For each bit shifted (from lowest to highest):
     1. Subtract b0111... (source bit = 0, followed by n ones until the destination bit) with mask of b11...n in [source bit, destination bit].
     2. Repeat until source bit at position 31. This is a pretty effective (32-n + 1)A.
        • [ ] in-place rotr, rotl:
  5. Copy the least bits to a predefined fastvar with their appropriate shift. (nTnCnA)
  6. Perform the most performant shift operation from above on the larger portion of the problem.
  7. Set the temp fastvar to write the rotated bits back to the original value. (1T1A assuming modifier/mask/target were pre-set)

Revise these:

• [x] xor assign: A ^= B -> 3T10A
  1. Set fastvar target and modifier to add (2A).
  2. Set fastvar mask to b01010101 and jump address (1T2A), jump to fastvar assignment (1T1A).
  3. Set fastvar mask to b10101010 and jump address (2A), jump to fastvar assignment (1T1A).

[armoha]

Python (and other languages too?) does not have in-place bitwise not operator, but in-place not is special case of constant xor: ~A = A ^ -1

Related: https://stackoverflow.com/questions/20916404/python-in-place-complement-operator

[armoha]

Added ixor, ilshift, irshift by https://github.com/armoha/eudplib/commit/2c0ebd9b4b6ba99bb9ea411c41e29a806cb4ece2

[armoha]

Implemented for variables (EUDVariable, EUDLightVariable).

Should we expose these api for plain memory address? Or postpone it and rather focus on epScript compiler optimization?

[armoha]

Mostly added in https://github.com/armoha/eudplib/commit/f385a83dee3cff34f6f991ac7f56b2f85fdb77de, https://github.com/armoha/eudplib/commit/07c76e6c061bde36f4ffb836c82969cc2ff056eb

[armoha]

Mostly resolved and implemented by series of commits, released since euddraft 0.9.5.1: ^=, <<=, >>=: armoha/eudplib@2c0ebd9b4b6ba99bb9ea411c41e29a806cb4ece2 &=, |=: armoha/eudplib@3b3368062cb71b92807588743394ca35b413e0e4 , armoha/eudplib@2ee72cf8a7fce86a2063dfdbf5dcadecf68a0877 armoha/eudplib@e6d22884762e18ef044ff232bc7baf31cc2da30e armoha/eudplib@2a947b069dbedc02decbc8015199bc77a9802d21 &, |, ^, ~, -: armoha/eudplib@f385a83dee3cff34f6f991ac7f56b2f85fdb77de armoha/eudplib@9a9c89b8545c6d4d7f5990dad5c66f50ea7f334f <<: armoha/eudplib@07c76e6c061bde36f4ffb836c82969cc2ff056eb armoha/eudplib@78872f945b83ef0b3de2f8b573c484087b31aa4c armoha/eudplib@d834c38142b42d755c97355d8b40b4abe0f1b6c8

Further optimization on other types or simple memory address would be better implemented as compiler optimization.