LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: logical_and_expr
static struct Expr *logical_and_expr(void)
{
  struct Expr *left,*new;

  left = inclusive_or_expr();
  skip();
  while (s[0]=='&' && s[1]=='&') {
    s += 2;
    skip();
    new = new_expr();
    new->type = LAND;
    skip();
    new->left = left;
    new->right = inclusive_or_expr();
    left = new;
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
callq 0x19090
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2ba96(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x26, %ecx
movb %al, 0x7(%rsp)
jne 0x18fed
movq 0x2ba81(%rip), %rax     # 0x44a60
movsbl 0x1(%rax), %eax
cmpl $0x26, %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x18ff7
jmp 0x19056
movq 0x2ba62(%rip), %rax     # 0x44a60
addq $0x2, %rax
movq %rax, 0x2ba57(%rip)     # 0x44a60
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x7, (%rax)
callq 0x18610
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x19090
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x18fc3
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: inclusive_or_expr
static struct Expr *inclusive_or_expr(void)
{
  struct Expr *left,*new;

  left = exclusive_or_expr();
  skip();
  while (s[0]=='|' && s[1]!='|') {
    s++;
    skip();
    new = new_expr();
    new->type = BOR;
    skip();
    new->left = left;
    new->right = exclusive_or_expr();
    left = new;
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
callq 0x19140
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2b9b6(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x7c, %ecx
movb %al, 0x7(%rsp)
jne 0x190cd
movq 0x2b9a1(%rip), %rax     # 0x44a60
movsbl 0x1(%rax), %eax
cmpl $0x7c, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x190d7
jmp 0x19136
movq 0x2b982(%rip), %rax     # 0x44a60
addq $0x1, %rax
movq %rax, 0x2b977(%rip)     # 0x44a60
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0xa, (%rax)
callq 0x18610
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x19140
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x190a3
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: exclusive_or_expr
static struct Expr *exclusive_or_expr(void)
{
  struct Expr *left,*new;

  left = and_expr();
  skip();
  while (*s=='^') {
    s++;
    skip();
    new = new_expr();
    new->type = XOR;
    skip();
    new->left = left;
    new->right = and_expr();
    left = new;
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
callq 0x191d0
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2b906(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x191be
movq 0x2b8f7(%rip), %rax     # 0x44a60
addq $0x1, %rax
movq %rax, 0x2b8ec(%rip)     # 0x44a60
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0xb, (%rax)
callq 0x18610
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x191d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x19153
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: and_expr
static struct Expr *and_expr(void)
{
  struct Expr *left,*new;

  left = equality_expr();
  skip();
  while (s[0]=='&' && s[1]!='&') {
    s++;
    skip();
    new = new_expr();
    new->type = BAND;
    skip();
    new->left = left;
    new->right = equality_expr();
    left = new;
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
callq 0x19280
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2b876(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x26, %ecx
movb %al, 0x7(%rsp)
jne 0x1920d
movq 0x2b861(%rip), %rax     # 0x44a60
movsbl 0x1(%rax), %eax
cmpl $0x26, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x19217
jmp 0x19276
movq 0x2b842(%rip), %rax     # 0x44a60
addq $0x1, %rax
movq %rax, 0x2b837(%rip)     # 0x44a60
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x9, (%rax)
callq 0x18610
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x19280
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x191e3
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: equality_expr
static struct Expr *equality_expr(void)
{
  struct Expr *left,*new;
  char m;

  left = relational_expr();
  skip();
  while ((s[0]=='!' || s[0]=='=') && s[1]=='=') {
    m = *s;
    s += 2;
    skip();
    new = new_expr();
    new->type = (m=='!') ? NEQ : EQ;
    skip();
    new->left = left;
    new->right = relational_expr();
    left = new;
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
callq 0x19360
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2b7c6(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x21, %eax
je 0x192b7
movq 0x2b7b7(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3d, %ecx
movb %al, 0x6(%rsp)
jne 0x192cc
movq 0x2b7a2(%rip), %rax     # 0x44a60
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x192d6
jmp 0x19353
movq 0x2b783(%rip), %rax     # 0x44a60
movb (%rax), %al
movb %al, 0x7(%rsp)
movq 0x2b776(%rip), %rax     # 0x44a60
addq $0x2, %rax
movq %rax, 0x2b76b(%rip)     # 0x44a60
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movsbl 0x7(%rsp), %edx
movl $0x14, %ecx
movl $0x13, %eax
cmpl $0x21, %edx
cmovel %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
callq 0x18610
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x19360
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x19293
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: relational_expr
static struct Expr *relational_expr(void)
{
  struct Expr *left,*new;
  char m1,m2=0;

  left = shift_expr();
  skip();
  while ((s[0]=='<' || s[0]=='>') && s[1]!=s[0]) {
    m1 = *s++;
    if (*s == '=')
      m2 = *s++;
    skip();
    new = new_expr();
    if (m1 == '<')
      new->type = m2 ? LEQ : LT;
    else
      new->type = m2 ? GEQ : GT;
    skip();
    new->left = left;
    new->right = shift_expr();
    left = new;
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
movb $0x0, 0x6(%rsp)
callq 0x194a0
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2b6e1(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x3c, %eax
je 0x1939c
movq 0x2b6d2(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3e, %ecx
movb %al, 0x5(%rsp)
jne 0x193ba
movq 0x2b6bd(%rip), %rax     # 0x44a60
movsbl 0x1(%rax), %eax
movq 0x2b6b2(%rip), %rcx     # 0x44a60
movsbl (%rcx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
testb $0x1, %al
jne 0x193c7
jmp 0x19492
movq 0x2b692(%rip), %rax     # 0x44a60
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x2b684(%rip)     # 0x44a60
movb (%rax), %al
movb %al, 0x7(%rsp)
movq 0x2b677(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x1940c
movq 0x2b668(%rip), %rax     # 0x44a60
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x2b65a(%rip)     # 0x44a60
movb (%rax), %al
movb %al, 0x6(%rsp)
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movsbl 0x7(%rsp), %eax
cmpl $0x3c, %eax
jne 0x19443
movsbl 0x6(%rsp), %edx
movl $0xf, %ecx
movl $0x11, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
jmp 0x1945f
movsbl 0x6(%rsp), %edx
movl $0x10, %ecx
movl $0x12, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
callq 0x18610
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x194a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x19378
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: shift_expr
static struct Expr *shift_expr(void)
{
  struct Expr *left,*new;
  char m;

  left = additive_expr();
  skip();
  while ((s[0]=='<' || s[0]=='>') && s[1]==s[0]) {
    m = *s;
    s += 2;
    skip();
    new = new_expr();
    new->type = (m=='<') ? LSH : RSH;
    new->left = left;
    new->right = additive_expr();
    left = new;
    skip();
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
callq 0x19590
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2b5a6(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x3c, %eax
je 0x194d7
movq 0x2b597(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3e, %ecx
movb %al, 0x6(%rsp)
jne 0x194f5
movq 0x2b582(%rip), %rax     # 0x44a60
movsbl 0x1(%rax), %eax
movq 0x2b577(%rip), %rcx     # 0x44a60
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x194ff
jmp 0x1957c
movq 0x2b55a(%rip), %rax     # 0x44a60
movb (%rax), %al
movb %al, 0x7(%rsp)
movq 0x2b54d(%rip), %rax     # 0x44a60
addq $0x2, %rax
movq %rax, 0x2b542(%rip)     # 0x44a60
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movsbl 0x7(%rsp), %edx
movl $0xe, %ecx
movl $0xd, %eax
cmpl $0x3c, %edx
cmovel %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x19590
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x18610
jmp 0x194b3
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: additive_expr
static struct Expr *additive_expr(void)
{
  struct Expr *left,*new;
  char m;

  left = multiplicative_expr();
  skip();
  while (*s=='+' || *s=='-') {
    m = *s++;
    skip();
    new = new_expr();
    new->type = (m=='+') ? ADD : SUB;
    new->left = left;
    new->right = multiplicative_expr();
    left = new;
    skip();
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
callq 0x19660
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2b4b6(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, 0x6(%rsp)
je 0x195cc
movq 0x2b4a1(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x195d6
jmp 0x1964c
movq 0x2b483(%rip), %rax     # 0x44a60
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x2b475(%rip)     # 0x44a60
movb (%rax), %al
movb %al, 0x7(%rsp)
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movsbl 0x7(%rsp), %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x2b, %edx
cmovel %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x19660
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x18610
jmp 0x195a3
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: multiplicative_expr
static struct Expr *multiplicative_expr(void)
{
  struct Expr *left,*new;
  char m;

  left = unary_expr();
  skip();
  while (*s=='*' || *s=='/' || *s=='%') {
    m = *s++;
    skip();
    new = new_expr();
    new->type = (m=='*') ? MUL : ( (m=='/') ? DIV : MOD );
    new->left = left;
    new->right = unary_expr();
    left = new;
    skip();
  }
  return left;
}

// Assembly:
subq $0x18, %rsp
callq 0x19760
movq %rax, 0x10(%rsp)
callq 0x18610
movq 0x2b3e6(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, 0x6(%rsp)
je 0x196b1
movq 0x2b3d1(%rip), %rax     # 0x44a60
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, 0x6(%rsp)
je 0x196b1
movq 0x2b3bc(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x25, %eax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x196be
jmp 0x19751
movq 0x2b39b(%rip), %rax     # 0x44a60
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x2b38d(%rip)     # 0x44a60
movb (%rax), %al
movb %al, 0x7(%rsp)
callq 0x18610
callq 0x19060
movq %rax, 0x8(%rsp)
movsbl 0x7(%rsp), %eax
cmpl $0x2a, %eax
jne 0x196fc
movl $0x2, %eax
movl %eax, (%rsp)
jmp 0x19714
movsbl 0x7(%rsp), %edx
movl $0x4, %eax
movl $0x3, %ecx
cmpl $0x2f, %edx
cmovel %ecx, %eax
movl %eax, (%rsp)
movl (%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x19760
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x18610
jmp 0x19673
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/expr.c
// Function: unary_expr
static struct Expr *unary_expr(void)
{
  struct Expr *new;
  char m;

  if (*s=='+' || *s=='-' || *s=='!' || *s=='~') {
    m = *s++;
    skip();
  }
  else
    return primary_expr();
  if (m == '+')
    return primary_expr();

  new = new_expr();
  new->type = (m=='-') ? NEG : ( (m=='!') ? NOT : CPL );
  new->left = primary_expr();
  return new;
}

// Assembly:
subq $0x18, %rsp
movq 0x2b2f5(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x197a0
movq 0x2b2e6(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x197a0
movq 0x2b2d7(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x21, %eax
je 0x197a0
movq 0x2b2c8(%rip), %rax     # 0x44a60
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x197c2
movq 0x2b2b9(%rip), %rax     # 0x44a60
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x2b2ab(%rip)     # 0x44a60
movb (%rax), %al
movb %al, 0x7(%rsp)
callq 0x18610
jmp 0x197ce
callq 0x19850
movq %rax, 0x10(%rsp)
jmp 0x1983f
movsbl 0x7(%rsp), %eax
cmpl $0x2b, %eax
jne 0x197e4
callq 0x19850
movq %rax, 0x10(%rsp)
jmp 0x1983f
callq 0x19060
movq %rax, 0x8(%rsp)
movsbl 0x7(%rsp), %eax
cmpl $0x2d, %eax
jne 0x19802
movl $0x5, %eax
movl %eax, (%rsp)
jmp 0x1981a
movsbl 0x7(%rsp), %edx
movl $0x6, %eax
movl $0xc, %ecx
cmpl $0x21, %edx
cmovel %ecx, %eax
movl %eax, (%rsp)
movl (%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
callq 0x19850
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: cmpsecflags
static uint8_t cmpsecflags(uint8_t oldflags,uint8_t newflags)
/* compare and verify target-specific section flags, */
/* return 0xff if sections are incompatible, otherwise return new flags */
{
  if (oldflags&SF_EHFPPC != newflags&SF_EHFPPC)
    return (0xff);
  if ((oldflags&(SF_CHIP|SF_FAST))==0 ||
      (newflags&(SF_CHIP|SF_FAST))==0 ||
      (oldflags&(SF_CHIP|SF_FAST)) == (newflags&(SF_CHIP|SF_FAST)))
    return (newflags | (oldflags&(SF_CHIP|SF_FAST)));
  return (0xff);
}

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rsp)
movb %al, -0x3(%rsp)
movzbl -0x2(%rsp), %eax
movzbl -0x3(%rsp), %edx
movl $0x20, %ecx
cmpl %edx, %ecx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x1b9d9
movb $-0x1, -0x1(%rsp)
jmp 0x1ba2d
movzbl -0x2(%rsp), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x1ba10
movzbl -0x3(%rsp), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x1ba10
movzbl -0x2(%rsp), %eax
andl $0xc0, %eax
movzbl -0x3(%rsp), %ecx
andl $0xc0, %ecx
cmpl %ecx, %eax
jne 0x1ba28
movzbl -0x3(%rsp), %eax
movzbl -0x2(%rsp), %ecx
andl $0xc0, %ecx
orl %ecx, %eax
movb %al, -0x1(%rsp)
jmp 0x1ba2d
movb $-0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: targetlink
static int targetlink(struct GlobalVars *gv,struct LinkedSection *ls,
                      struct Section *s)
/* returns 1, if target requires the combination of the two sections, */
/* returns -1, if target doesn't want to combine them, */
/* returns 0, if target doesn't care - standard linking rules are used. */
{
  static char *merged = "__MERGED";

  /* AmigaDOS doesn't merge unnamed sections, unless the Small- */
  /* Data/Code option was set */
  if (!(gv->small_code && s->type==ST_CODE) &&
      !(gv->small_data && (s->type==ST_DATA || s->type==ST_UDATA)))
    if (*(ls->name)==0 && *(s->name)==0)
      return (-1);

  /* sections with name "_NOMERGE" are never combined */
  if (!strcmp(s->name,"_NOMERGE"))
    return (-1);

  /* Executable only: */
  if (!gv->dest_object) {
    if (!strcmp(ls->name,merged) && !strcmp(s->name,merged)) {
      /* data and bss section with name __MERGED are always combined */
      if (s->type == ST_CODE)
        error(57,getobjname(s->obj)); /* Merging code section "__MERGED" */
      return (1);
    }
  }

  return (0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x70(%rax)
je 0x1ba6c
movq 0x8(%rsp), %rax
movzbl 0x2c(%rax), %eax
cmpl $0x1, %eax
je 0x1bac4
movq 0x18(%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0x1ba93
movq 0x8(%rsp), %rax
movzbl 0x2c(%rax), %eax
cmpl $0x2, %eax
je 0x1bac4
movq 0x8(%rsp), %rax
movzbl 0x2c(%rax), %eax
cmpl $0x3, %eax
je 0x1bac4
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1bac2
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1bac2
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1bb66
jmp 0x1bac4
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x1a4a1(%rip), %rsi     # 0x35f75
callq 0x5130
cmpl $0x0, %eax
jne 0x1bae8
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1bb66
movq 0x18(%rsp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x1bb5e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x2462d(%rip), %rsi     # 0x40130
callq 0x5130
cmpl $0x0, %eax
jne 0x1bb5c
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x24613(%rip), %rsi     # 0x40130
callq 0x5130
cmpl $0x0, %eax
jne 0x1bb5c
movq 0x8(%rsp), %rax
movzbl 0x2c(%rax), %eax
cmpl $0x1, %eax
jne 0x1bb52
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8f00
movq %rax, %rsi
movl $0x39, %edi
movb $0x0, %al
callq 0x8c00
movl $0x1, 0x24(%rsp)
jmp 0x1bb66
jmp 0x1bb5e
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: ehf_findsymbol
static struct Symbol *ehf_findsymbol(struct GlobalVars *gv,
                                     struct Section *sec,const char *name)
{
  struct Symbol *sym = gv->symbols[elf_hash(name)%SYMHTABSIZE];
  struct Symbol *second_choice = NULL;

  while (sym) {
    if (!strcmp(name,sym->name)) {
      if (second_choice == NULL)
        second_choice = sym;

      if (sec!=NULL && sym->type==SYM_RELOC) {
        /* we prefer symbols from a section which has the same CPU-flags
           as the caller's section */
        if ((sec->flags & SF_EHFPPC) == (sym->relsect->flags & SF_EHFPPC))
          break;
      }
      else
        break;
    }
    sym = sym->glob_chain;
  }

  /* accept symbol from a section for a different CPU, if it's the only one */
  if (!sym && second_choice)
    sym = second_choice;

  if (sym)
    if (sym->type == SYM_INDIR)
      return (ehf_findsymbol(gv,sec,sym->indir_name));

  return (sym);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x180(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x8760
movq %rax, %rcx
movq (%rsp), %rax
andq $0xffff, %rcx           # imm = 0xFFFF
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1bc3d
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x5130
cmpl $0x0, %eax
jne 0x1bc2d
cmpq $0x0, 0x8(%rsp)
jne 0x1bbef
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1bc29
movq 0x10(%rsp), %rax
movzbl 0x40(%rax), %eax
cmpl $0x2, %eax
jne 0x1bc29
movq 0x20(%rsp), %rax
movzbl 0x2d(%rax), %eax
andl $0x20, %eax
movq 0x10(%rsp), %rcx
movq 0x38(%rcx), %rcx
movzbl 0x2d(%rcx), %ecx
andl $0x20, %ecx
cmpl %ecx, %eax
jne 0x1bc27
jmp 0x1bc3d
jmp 0x1bc2b
jmp 0x1bc3d
jmp 0x1bc2d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1bbbd
cmpq $0x0, 0x10(%rsp)
jne 0x1bc57
cmpq $0x0, 0x8(%rsp)
je 0x1bc57
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1bc8e
movq 0x10(%rsp), %rax
movzbl 0x40(%rax), %eax
cmpl $0x4, %eax
jne 0x1bc8c
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdx
callq 0x1bb70
movq %rax, 0x30(%rsp)
jmp 0x1bc98
jmp 0x1bc8e
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: init_hunkinfo
static void init_hunkinfo(struct HunkInfo *hi,const char *name,uint8_t *p,
                          unsigned long plen)
{
  hi->hunkptr = hi->hunkbase = p;
  hi->hunkcnt = (long)plen;
  hi->filename = name;
  hi->exec = read32be(p) == HUNK_HEADER;  /* executable file? */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
callq 0x7a00
cmpl $0x3f3, %eax            # imm = 0x3F3
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: movehunkptr32
static void movehunkptr32(struct HunkInfo *hi,uint32_t n)
/* skip n 32-bit words */
{
  long offset = (long)n << 2;

  if ((hi->hunkcnt -= offset) < 0)
    error(13,hi->filename);  /* File format corrupted */
  hi->hunkptr += offset;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
shlq $0x2, %rax
movq %rax, (%rsp)
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rax
subq %rdx, %rax
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jge 0x1cf88
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movl $0xd, %edi
movb $0x0, %al
callq 0x8c00
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: nextword32
static uint32_t nextword32(struct HunkInfo *hi)
/* read next 32-bit word */
{
  uint32_t w;

  if ((hi->hunkcnt -= sizeof(uint32_t)) < 0)
    error(13,hi->filename);  /* File format corrupted */
  w = read32be(hi->hunkptr);
  hi->hunkptr += sizeof(uint32_t);
  return (w);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rax
subq $0x4, %rax
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jge 0x1cfd5
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movl $0xd, %edi
movb $0x0, %al
callq 0x8c00
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x7a00
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: nextword16
static uint16_t nextword16(struct HunkInfo *hi)
/* read next 16-bit word */
{
  uint16_t w;

  if ((hi->hunkcnt -= sizeof(uint16_t)) < 0)
    error(13,hi->filename);  /* File format corrupted */
  w = read16be(hi->hunkptr);
  hi->hunkptr += sizeof(uint16_t);
  return (w);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rax
subq $0x2, %rax
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jge 0x1d045
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movl $0xd, %edi
movb $0x0, %al
callq 0x8c00
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x79d0
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x8(%rax)
movw 0xe(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: movehunkptr16
static void movehunkptr16(struct HunkInfo *hi,uint32_t n)
/* skip n 16-bit words */
{
  long offset = (long)n << 1;

  if ((hi->hunkcnt -= offset) < 0)
    error(13,hi->filename);  /* File format corrupted */
  hi->hunkptr += offset;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
shlq %rax
movq %rax, (%rsp)
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rax
subq %rdx, %rax
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jge 0x1d0c7
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movl $0xd, %edi
movb $0x0, %al
callq 0x8c00
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: gethunkname
static char *gethunkname(struct HunkInfo *hi)
/* read 32-bit aligned name, the most significant byte of the */
/* length specifier is ignored (for HUNK_EXT names, for example) */
{
  uint32_t n;
  char *s=NULL;

  if (n = nextword32(hi) & 0xffffff) {  /* name given? */
    s = alloczero((n+1)<<2);
    strncpy(s,(char *)hi->hunkptr,n<<2);
    movehunkptr32(hi,n);
  }
  return (s);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x1cfa0
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x1d1cb
movl 0xc(%rsp), %eax
addl $0x1, %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x7290
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movl 0xc(%rsp), %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x5040
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1cf40
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: addlongrelocs
static bool addlongrelocs(struct GlobalVars *gv,struct HunkInfo *hi,
                          struct Section *s,uint8_t type,uint16_t size)
/* convert an amigahunk/ehf relocation hunk into an internal Reloc node */
{
  uint32_t n,id,offs;
  uint16_t pos = 0;
  lword mask = -1;
  struct Reloc *r;

  if (size == 24) {  /* EHF/PPC 26-bit branch */
    pos = 6;
    mask = ~3;  /* 0xfffffffc */
  }
  if (s) {
    nextword32(hi);
    while (n = nextword32(hi)) {
      id = nextword32(hi);  /* add base addr. of section with this index */
      while (n--) {
        offs = nextword32(hi);
        r = newreloc(gv,s,NULL,NULL,id,offs,type,
                     readsection(gv,type,s->data+offs,pos,size,mask));
        addreloc(s,r,pos,size,mask);
      }
    }
    return (TRUE);
  }
  return (FALSE);
}

// Assembly:
subq $0x88, %rsp
movw %r8w, %ax
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movb %cl, 0x67(%rsp)
movw %ax, 0x64(%rsp)
movw $0x0, 0x56(%rsp)
movq $-0x1, 0x48(%rsp)
movzwl 0x64(%rsp), %eax
cmpl $0x18, %eax
jne 0x1d22d
movw $0x6, 0x56(%rsp)
movq $-0x4, 0x48(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x1d362
movq 0x70(%rsp), %rdi
callq 0x1cfa0
movq 0x70(%rsp), %rdi
callq 0x1cfa0
movl %eax, 0x60(%rsp)
cmpl $0x0, %eax
je 0x1d355
movq 0x70(%rsp), %rdi
callq 0x1cfa0
movl %eax, 0x5c(%rsp)
movl 0x60(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x60(%rsp)
cmpl $0x0, %eax
je 0x1d350
movq 0x70(%rsp), %rdi
callq 0x1cfa0
movl %eax, 0x58(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x58(%rsp), %eax
movq %rax, 0x30(%rsp)
movb 0x67(%rsp), %al
movb %al, 0x3f(%rsp)
movq 0x78(%rsp), %rdi
movb 0x67(%rsp), %sil
movq 0x68(%rsp), %rax
movq 0x40(%rax), %rdx
movl 0x58(%rsp), %eax
addq %rax, %rdx
movw 0x56(%rsp), %cx
movw 0x64(%rsp), %ax
movq 0x48(%rsp), %r9
movzbl %sil, %esi
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0x10eb0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x2c(%rsp), %r8d
movq 0x30(%rsp), %r9
movb 0x3f(%rsp), %r10b
xorl %ecx, %ecx
movq %rcx, %rdx
movzbl %r10b, %r10d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10850
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rsi
movw 0x56(%rsp), %cx
movw 0x64(%rsp), %ax
movq 0x48(%rsp), %r8
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x109b0
jmp 0x1d268
jmp 0x1d243
movl $0x1, 0x84(%rsp)
jmp 0x1d36d
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: addshortrelocs32
static bool addshortrelocs32(struct GlobalVars *gv,struct HunkInfo *hi,
                             struct Section *s)
/* convert an amigahunk/ehf abs-reloc32 hunk into an internal Reloc node */
{
  uint32_t n,id,offs;
  struct Reloc *r;

  if (s) {
    nextword32(hi);
    while (n = (uint32_t)nextword16(hi)) {
      id = (uint32_t)nextword16(hi); /* add base addr. of sec. with this idx. */
      while (n--) {
        offs = (uint32_t)nextword16(hi);
        r = newreloc(gv,s,NULL,NULL,id,offs,R_ABS,
                     readsection(gv,R_ABS,s->data+offs,0,32,-1));
        addreloc(s,r,0,32,-1);  /* standard 32-bit reloc */
      }
    }
    alignhunkptr(hi);
    return (TRUE);
  }
  return (FALSE);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x1d4b8
movq 0x50(%rsp), %rdi
callq 0x1cfa0
movq 0x50(%rsp), %rdi
callq 0x1d010
movzwl %ax, %eax
movl %eax, 0x44(%rsp)
cmpl $0x0, %eax
je 0x1d4a4
movq 0x50(%rsp), %rdi
callq 0x1d010
movzwl %ax, %eax
movl %eax, 0x40(%rsp)
movl 0x44(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x44(%rsp)
cmpl $0x0, %eax
je 0x1d49f
movq 0x50(%rsp), %rdi
callq 0x1d010
movzwl %ax, %eax
movl %eax, 0x3c(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x3c(%rsp), %eax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x40(%rax), %rdx
movl 0x3c(%rsp), %eax
addq %rax, %rdx
movl $0x1, %esi
xorl %ecx, %ecx
movl $0x20, %r8d
movq $-0x1, %r9
callq 0x10eb0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %r8d
movq 0x28(%rsp), %r9
xorl %ecx, %ecx
movq %rcx, %rdx
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10850
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
xorl %edx, %edx
movl $0x20, %ecx
movq $-0x1, %r8
callq 0x109b0
jmp 0x1d3d4
jmp 0x1d3a9
movq 0x50(%rsp), %rdi
callq 0x1d0e0
movl $0x1, 0x64(%rsp)
jmp 0x1d4c0
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: create_xdef
static void create_xdef(struct GlobalVars *gv,struct Section *s,
                        char *name,int32_t val,uint8_t type,uint8_t bind)
/* add new symbol to the symbols list of the current object unit */
{
  struct Symbol *sym;
  uint32_t size = 0;

  if (type == SYM_COMMON) {
    /* Oh, a common symbol? A rare guest! :) */
    size = val;  /* its size was stored in val */
    val = 4;     /* how about a 32-bit alignment? */
    s = common_section(gv,s->obj);
  }

  if (sym = addsymbol(gv,s,name,NULL,(lword)val,
                      type,0,SYMI_NOTYPE,bind,size,FALSE)) {
    /* Symbol already defined. If defined globally, ignore it. */
    /* Otherwise, change into a global definition. */
    if (sym->bind != SYMB_GLOBAL) {
      if (bind == SYMB_GLOBAL) {
        sym->value = (lword)val;  /* redefine as global (xdef) symbol */
        sym->relsect = s;
        sym->type = type;
        sym->flags = 0;
        sym->info = SYMI_NOTYPE;
        sym->bind = SYMB_GLOBAL;
        sym->size = size;
        addglobsym(gv,sym);
      }
    }
  }
}

// Assembly:
subq $0x78, %rsp
movl %r8d, 0x30(%rsp)
movl %ecx, %eax
movl 0x30(%rsp), %ecx
movl %eax, 0x34(%rsp)
movq %rdx, %rax
movl 0x34(%rsp), %edx
movq %rax, 0x38(%rsp)
movq %rsi, %rax
movq 0x38(%rsp), %rsi
movq %rax, 0x40(%rsp)
movq %rdi, %r8
movq 0x40(%rsp), %rdi
movb %r9b, %al
movq %r8, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movb %cl, 0x5b(%rsp)
movb %al, 0x5a(%rsp)
movl $0x0, 0x4c(%rsp)
movzbl 0x5b(%rsp), %eax
cmpl $0x3, %eax
jne 0x1d55c
movl 0x5c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl $0x4, 0x5c(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x12780
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movslq 0x5c(%rsp), %r8
movb 0x5b(%rsp), %r9b
movb 0x5a(%rsp), %r10b
movl 0x4c(%rsp), %eax
xorl %ecx, %ecx
xorl %r11d, %r11d
movzbl %r9b, %r9d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
callq 0xfd00
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
je 0x1d635
movq 0x50(%rsp), %rax
movzbl 0x43(%rax), %eax
cmpl $0x2, %eax
je 0x1d633
movzbl 0x5a(%rsp), %eax
cmpl $0x2, %eax
jne 0x1d631
movslq 0x5c(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x68(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x38(%rax)
movb 0x5b(%rsp), %cl
movq 0x50(%rsp), %rax
movb %cl, 0x40(%rax)
movq 0x50(%rsp), %rax
movb $0x0, 0x41(%rax)
movq 0x50(%rsp), %rax
movb $0x0, 0x42(%rax)
movq 0x50(%rsp), %rax
movb $0x2, 0x43(%rax)
movl 0x4c(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, 0x44(%rax)
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xf750
jmp 0x1d633
jmp 0x1d635
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: create_xrefs
static void create_xrefs(struct GlobalVars *gv,struct HunkInfo *hi,
                         struct Section *s,char *name,
                         uint8_t rtype,uint16_t size)
/* add new unresolved symbol reference to the current section */
{
  uint32_t n = nextword32(hi);  /* number of references */
  uint32_t offs;
  uint16_t pos = 0;
  lword mask = -1;
  struct Reloc *r;

  if (size == 24) {  /* EHF/PPC 26-bit branch */
    pos = 6;
    mask = ~3;  /* 0xfffffffc */
  }
  while (n--) {
    offs = nextword32(hi);
    r = newreloc(gv,s,name,NULL,0,offs,rtype,
                 readsection(gv,rtype,s->data+offs,pos,size,mask));
    addreloc(s,r,pos,size,mask);
  }
}

// Assembly:
subq $0x98, %rsp
movl %r8d, 0x3c(%rsp)
movq %rcx, %rax
movl 0x3c(%rsp), %ecx
movq %rax, 0x40(%rsp)
movq %rdx, %rax
movq 0x40(%rsp), %rdx
movq %rax, 0x48(%rsp)
movq %rsi, %rax
movq 0x48(%rsp), %rsi
movq %rax, 0x50(%rsp)
movq %rdi, %r8
movq 0x50(%rsp), %rdi
movw %r9w, %ax
movq %r8, 0x90(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movb %cl, 0x77(%rsp)
movw %ax, 0x74(%rsp)
movq 0x88(%rsp), %rdi
callq 0x1cfa0
movl %eax, 0x70(%rsp)
movw $0x0, 0x6a(%rsp)
movq $-0x1, 0x60(%rsp)
movzwl 0x74(%rsp), %eax
cmpl $0x18, %eax
jne 0x1d6df
movw $0x6, 0x6a(%rsp)
movq $-0x4, 0x60(%rsp)
jmp 0x1d6e1
movl 0x70(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x70(%rsp)
cmpl $0x0, %eax
je 0x1d7dd
movq 0x88(%rsp), %rdi
callq 0x1cfa0
movl %eax, 0x6c(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x6c(%rsp), %eax
movq %rax, 0x30(%rsp)
movb 0x77(%rsp), %al
movb %al, 0x3b(%rsp)
movq 0x90(%rsp), %rdi
movb 0x77(%rsp), %sil
movq 0x80(%rsp), %rax
movq 0x40(%rax), %rdx
movl 0x6c(%rsp), %eax
addq %rax, %rdx
movw 0x6a(%rsp), %cx
movw 0x74(%rsp), %ax
movq 0x60(%rsp), %r9
movzbl %sil, %esi
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0x10eb0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %r9
movb 0x3b(%rsp), %r10b
xorl %ecx, %ecx
xorl %r8d, %r8d
movzbl %r10b, %r10d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10850
movq %rax, 0x58(%rsp)
movq 0x80(%rsp), %rdi
movq 0x58(%rsp), %rsi
movw 0x6a(%rsp), %cx
movw 0x74(%rsp), %ax
movq 0x60(%rsp), %r8
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x109b0
jmp 0x1d6e1
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: hunk_name_len
static void hunk_name_len(FILE *f,const char *name)
/* writes a string in hunk-format style, i.e. first longword contains */
/* strlen in longwords and then follows the string itself, long-aligned */
{
  size_t l=strlen(name);

  fwrite32be(f,l?((l+3)>>2):0);
  fwritex(f,name,l);
  fwrite_align(f,2,l);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x50c0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1de42
movq 0x10(%rsp), %rax
addq $0x3, %rax
shrq $0x2, %rax
movq %rax, (%rsp)
jmp 0x1de4a
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x1de4a
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movl %eax, %esi
callq 0x84d0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x8470
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl %eax, %edx
movl $0x2, %esi
callq 0x8640
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: fix_reloc_addends
static void fix_reloc_addends(struct GlobalVars *gv,struct LinkedSection *ls)
{
  struct Reloc *rel;

  for (rel=(struct Reloc *)ls->relocs.first;
       rel->n.next!=NULL; rel=(struct Reloc *)rel->n.next) {
    writesection(gv,ls->data+rel->offset,rel,rel->addend);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x1deec
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rsi
movq (%rsp), %rax
addq 0x20(%rax), %rsi
movq (%rsp), %rdx
movq (%rsp), %rax
movq 0x28(%rax), %rcx
callq 0x110c0
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x1deae
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: fix_xref_addends
static void fix_xref_addends(struct GlobalVars *gv,struct LinkedSection *ls)
{
  struct Reloc *xref;

  for (xref=(struct Reloc *)ls->xrefs.first;
       xref->n.next!=NULL; xref=(struct Reloc *)xref->n.next) {
    writesection(gv,ls->data+xref->offset,xref,xref->addend);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x1df5c
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rsi
movq (%rsp), %rax
addq 0x20(%rax), %rsi
movq (%rsp), %rdx
movq (%rsp), %rax
movq 0x28(%rax), %rcx
callq 0x110c0
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x1df1e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: unsupp_relocs
static void unsupp_relocs(struct LinkedSection *sec)
{
  struct Reloc *rel;

  while (rel = (struct Reloc *)remhead(&sec->relocs)) {
    error(32,fff_amigahunk.tname,reloc_name[rel->rtype],
          (int)rel->insert->bpos,(int)rel->insert->bsiz,
          rel->insert->mask,sec->name,rel->offset);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
addq $0x80, %rdi
callq 0x74d0
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1e5b6
movq 0x21a84(%rip), %rsi     # 0x3ffd0
movq 0x18(%rsp), %rax
movzbl 0x38(%rax), %eax
movl %eax, %ecx
leaq 0x21642(%rip), %rax     # 0x3fba0
movq (%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movzwl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movzwl 0xa(%rax), %r8d
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %r9
movq 0x20(%rsp), %rax
movq 0x18(%rax), %r10
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movl $0x20, %edi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x8c00
jmp 0x1e529
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: unsupp_symbols
static void unsupp_symbols(struct LinkedSection *sec)
{
  struct Symbol *sym;

  while (sym = (struct Symbol *)remhead(&sec->symbols)) {
    error(33,fff_amigahunk.tname,sym->name,sym_bind[sym->bind],
          sym_type[sym->type],sym_info[sym->info]);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
callq 0x74d0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1ee65
movq 0x211c4(%rip), %rsi     # 0x3ffd0
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rsp), %rax
movzbl 0x43(%rax), %eax
movl %eax, %ecx
leaq 0x20d59(%rip), %rax     # 0x3fb80
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movzbl 0x40(%rax), %eax
movl %eax, %edi
leaq 0x20ce3(%rip), %rax     # 0x3fb20
movq (%rax,%rdi,8), %r8
movq 0x8(%rsp), %rax
movzbl 0x42(%rax), %eax
movl %eax, %edi
leaq 0x20cfd(%rip), %rax     # 0x3fb50
movq (%rax,%rdi,8), %r9
movl $0x21, %edi
movb $0x0, %al
callq 0x8c00
jmp 0x1ede9
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_amigahunk.c
// Function: linedebug_hunks
static void linedebug_hunks(struct GlobalVars *gv,FILE *f,
                            struct LinkedSection *ls)
{
  struct Section *sec = (struct Section *)ls->sections.first;
  struct Section *nextsec;
  struct LineDebug *ldb;

  while (nextsec = (struct Section *)sec->n.next) {
    if (ldb = (struct LineDebug *)sec->special) {
      do {
        if (ldb->tgext.id==TGEXT_AMIGAOS && ldb->tgext.sub_id==SUBID_LINE) {
          uint32_t i,*lptr,*optr;

          fwrite32be(f,HUNK_DEBUG);
          fwrite32be(f,3 + strlen32(ldb->source_name) +
                     (ldb->num_entries<<1));
          fwrite32be(f,(uint32_t)sec->offset);
          fwrite32be(f,0x4c494e45);  /* "LINE" */
          hunk_name_len(f,ldb->source_name);
          for (i=0,lptr=ldb->lines,optr=ldb->offsets;
               i<ldb->num_entries; i++) {
            fwrite32be(f,*lptr++);
            fwrite32be(f,*optr++);
          }
        }
      }
      while (ldb = (struct LineDebug *)ldb->tgext.next);
    }
    sec = nextsec;
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x1f007
movq 0x38(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x1eff8
jmp 0x1eec5
movq 0x28(%rsp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x1, %eax
jne 0x1efdd
movq 0x28(%rsp), %rax
movzbl 0x9(%rax), %eax
cmpl $0x1, %eax
jne 0x1efdd
movq 0x48(%rsp), %rdi
movl $0x3f1, %esi            # imm = 0x3F1
callq 0x84d0
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f010
movq 0x8(%rsp), %rdi
movl %eax, %esi
addl $0x3, %esi
movq 0x28(%rsp), %rax
movl 0x18(%rax), %eax
shll %eax
addl %eax, %esi
callq 0x84d0
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x38(%rax), %rax
movl %eax, %esi
callq 0x84d0
movq 0x48(%rsp), %rdi
movl $0x4c494e45, %esi       # imm = 0x4C494E45
callq 0x84d0
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x1de00
movl $0x0, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x1efdb
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %esi
callq 0x84d0
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rsp)
movl (%rax), %esi
callq 0x84d0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1ef86
jmp 0x1efdd
jmp 0x1efdf
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
jne 0x1eec5
jmp 0x1eff8
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x1ee91
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]vlink/t_elf32.c
// Function: elf32_shstrtab
char *elf32_shstrtab(struct LinkFile *lf,struct Elf32_Ehdr *ehdr)
/* returns a pointer to the section header string table, if present, */
/* or NULL, otherwise */
{
  bool be = (ehdr->e_ident[EI_DATA] == ELFDATA2MSB);
  uint16_t i;
  struct Elf32_Shdr *shdr;
  char *stab;

  if (i = read16(be,ehdr->e_shstrndx)) {
    shdr = elf32_shdr(lf,ehdr,i);
    if (read32(be,shdr->sh_type) != SHT_STRTAB)
      error(45,lf->pathname,lf->objname);  /* illegal type */
    stab = ((char *)ehdr) + read32(be,shdr->sh_offset);
    if (((uint8_t *)stab < lf->data) || 
        ((uint8_t *)stab + read32(be,shdr->sh_size) > lf->data + lf->length))
      error(46,lf->pathname,lf->objname);  /* illegal offset */
    else
      return stab;
  }
  return NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %edi
movq 0x30(%rsp), %rsi
addq $0x32, %rsi
callq 0x8010
movw %ax, 0x2a(%rsp)
cmpw $0x0, %ax
je 0x1f7cf
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movzwl 0x2a(%rsp), %edx
callq 0x1f7f0
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %edi
movq 0x20(%rsp), %rsi
addq $0x4, %rsi
callq 0x8060
cmpl $0x3, %eax
je 0x1f725
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rdx
movl $0x2d, %edi
movb $0x0, %al
callq 0x8c00
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %edi
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
callq 0x8060
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x1f7a1
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %edi
movq 0x20(%rsp), %rsi
addq $0x14, %rsi
callq 0x8060
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq 0x38(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x38(%rsp), %rdx
addq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x1f7c1
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rdx
movl $0x2e, %edi
movb $0x0, %al
callq 0x8c00
jmp 0x1f7cd
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1f7d8
jmp 0x1f7cf
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)