OSDev.org

GETHEX:
push rsi
push rbx
.HEXREAD:
mov rbx, 0x200000
mov rsi, rbx
call READLN
xor rbx, rbx
.loadchar: ;while i < #m200000 do
        lodsb
        xor al, 0
        jz .end
        cmp al, '0'
        jl .fail
        cmp al, '9'
        jg .net1
        sub al, '0'
        jmp .save
.net1:
        cmp al, 'A'
        jl .fail
        cmp al, 'F'
        jg  .net2
        sub al, 'A'
        add al, 10
        jmp .save
.net2:
        cmp al, 80h
        jl .fail
        cmp al, 85h
        jg .fail
        sub al, 80h
        add al, 10
        jmp .save
.end:
mov rax, rbx
pop rbx
pop rsi
ret

.save:
shl rbx, 4
or bl, al
jmp .loadchar

.fail:
;print something
mov rsi, TEXT.FAIL
call WRITELN
jmp .HEXREAD

TEXT:
.FAIL: "FAILED TO PARSE HEX",0

function hexread()
-- lua equivalent for debugging.
io.write("0x")
local m200000 = io.read()
-- now convert to hexadecimal. If it isn't a valid hexadecimal char, clear it and start over.
-- QUARRY
i = 1
local rbx = 0
while i <= #m200000 do
        al = m200000:byte(i)
        if al < string.byte("0") then
                -- fail
                print("FAILED TO PARSE HEX. INVALID CHARS")
                return hexread()
        else
                if al > string.byte("9") then
-- NET 1
                        if al < string.byte("A",1) then
                                print("FAILED TO READ HEX")
                                return hexread()
                        else
                                if al > string.byte("F") then
                                        -- NET TWO WOULD GO HERE, BUT IS BEYOND SCOPE
                                        print("FAILED TO READ HEX")
return hexread()
                                else
                                        -- subtract 'A' from al
                                        -- and then add ten
                                        al = al - string.byte("A")
                                        al = al + 10
                                end
                        end
                else
                        -- subtract '0'
                        al = al - string.byte("0")
                end
        end
        rbx = rbx << 4
        rbx = rbx | al
        i = i+1
end
return rbx
end

• Using m200000 to represent that slot in memory is pretty dumb. I have tested and the asm function is fetching the right characters from memory, so it is not a memleak causing it. EDIT: It totally was, but in a different way. However this strengthens the question. That said, are there better strategies for prototyping with memory slots. (also, I probably should have READLN place the value on the stack.)
• Since my lua "registers" are actually ordinary variables, I can see register related problems arising,
• lua uses a more structured approach to conditional execution that x86, so label related problems could go undetected. In some ways I think there is an advantage to it (like being able to express your idea in a basic fashion, and then adjust for assembly) but obviously without a GOTO that could be problematic.

JohnpaulTH wrote:What are some tips for prototyping asm in a higher level language?

JohnpaulTH wrote:When, if ever should this be done?

Octocontrabass wrote:Pick a language like C and use a compiler to turn it into assembly.

Octocontrabass wrote:or that JL and JG perform signed comparisons instead of unsigned comparisons.

JohnpaulTH wrote:Since the function complained of invalid input given valid input, I decided to rewrite it in lua.

for (;;) {
  size_t left = 2 * this + 1;
  size_t right = left + 1;
  if (right < nmemb) {
    if (cmp(this, left) < 0 || cmp(this, right) < 0) {
      if (cmp(left, right) < 0) {
        swap(this, right);
        this = right;
      } else {
        swap(this, left);
        this = left;
      }
    } else break;
  } else break;
}

JohnpaulTH wrote:However jl has not worked for me before. perhaps jb is better? I hadn't thought about the implications of that.

  sub al, '0'
  cmp al, 10
  jb .save
  sub al, 'A' - '0'
  cmp al, 7
  jb .save1
  sub al, 'a' - 'A'
  cmp al, 7
  jb .save1
  ; failure
  mov rsi, TEXT.FAIL
  call WRITELN
  jmp .HEXREAD
.save1:
  add al, 10
.save:
  shl rbx, 4
  or bl, al
  jmp .loadchar

nullplan wrote:That means you weren't actually prototyping.

nullplan wrote:This can be a good thing, but can also be a bad thing. In assembler you can do a lot of things different from the higher level languages.

or using a goto.

I really like to use the following trick:

nullplan wrote:Trying to implement that idea in C, however, I noticed that I had really no idea how to do it without either duplicating code or using a goto.

JohnpaulTH wrote:Good to know, what do you call what I was doing?

Octocontrabass wrote:GCC allows you to declare functions like cmp() as pure so the optimizer can remove redundant calls.

nullplan wrote:Ah, but the fact that they are redundant is only given in this case because `cmp' establishes an order on its inputs. Which GCC doesn't know about and, to my knowledge, can't be told about. If you don't know that, you only see three function calls with different arguments.

nullplan wrote:Also, I can't use that in the particular case here because `cmp' was actually a function pointer, and the code was abbreviated for readability.

JohnpaulTH wrote:Here are both snippets of code. Take a deep breath, my ASM is not the best.

Fantasy94 wrote:But haven't you thought about using the SSE2 suite? It would give more quality to your code,

JohnpaulTH wrote:Also bonus question, do these need to be taken into consideration when prototyping?

JohnpaulTH wrote:

Fantasy94 wrote:But haven't you thought about using the SSE2 suite? It would give more quality to your code,

Thanks for the tip! If I understand correctly, SSE2 is an extension to the x86 instruction set.
If I am correct, than looking over it I see things that could come in handy, but most of them seem to be about floating point. There are a few that could be useful, especially the packed ones. Can you give a specific example of how it might improve control flow?

Also bonus question, do these need to be taken into consideration when prototyping?

.section .text
.globl _start
.align 16

_start:

pushq %r8
pushq %r9
pushq %r12

movq %r8, %r9
pxor %xmm1, %xmm1

_x0:

movdqu (%r8), %xmm0
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r12
addq $16, %r8
andq $0xffffffffffffffff, %r12
jz _x0

bsf %r12, %r12
subq $16, %r8
subq %r9, %r8
addq %r12, %r8

popq %r12
popq %r12

Fantasy94 wrote:But haven't you thought about using the SSE2 suite? It would give more quality to your code, since the current one is full of comparisons and jumps.

  char* p = mmap(0, 8192, PROT_NONE, MAP_ANONYMOUS, -1, 0); /* two pages with no access. */
  mprotect(p, 4096, PROT_READ | PROT_WRITE); /* make the first of these accessible */
  strcpy(p + 4092, "bad"); /* write a C string right at the end of the first page */
  strlen(p + 4092); /* BOOM! */

nullplan wrote:For example, I once wrote a heap sort. And to heapify its internal heap, I wrote the standard algorithm:

Code: Select all

for (;;) {
  size_t left = 2 * this + 1;
  size_t right = left + 1;
  if (right < nmemb) {
    if (cmp(this, left) < 0 || cmp(this, right) < 0) {
      if (cmp(left, right) < 0) {
        swap(this, right);
        this = right;
      } else {
        swap(this, left);
        this = left;
      }
    } else break;
  } else break;
}

However, when you look at it, you will notice that it isn't optimal. It performs too much work. In the case where the left child is smaller or equal to the head node, but the right child is larger, evaluating the first comparison already gives you exactly that data. Two comparisons ought to be enough in that case. But this code will perform an unnecessary comparison anyway, because it is easier to write this way.

Trying to implement that idea in C, however, I noticed that I had really no idea how to do it without either duplicating code or using a goto. Luckily, in assembler, goto is the only way, anyway.