LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: sc_provide
static void sc_provide(struct GlobalVars *gv)
/* PROVIDE(symbol = expression); */
{
  if (startofblock('(')) {
    char *symname;

    if (symname = getword()) {
      if (getchr()=='=' && *symname!='\0') {
        symbol_assignment(gv,symname,SYMF_PROVIDED);
      }
      else {
        error(66,scriptname,getlineno(),'=');  /* '=' expected */
        back(1);
      }
    }
    else
      error(78,scriptname,getlineno());
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x28, %edi
callq 0xf8fc
testl %eax, %eax
je 0xd599
movl $0x1, %edi
callq 0xff64
testq %rax, %rax
je 0xd5d4
movq %rax, %r14
callq 0xfeed
cmpb $0x3d, %al
jne 0xd5a1
cmpb $0x0, (%r14)
je 0xd5a1
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe258
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x26078(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x42, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x3d, %ecx
xorl %eax, %eax
callq 0x6f14
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xff51
movq 0x26045(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x4e, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f14
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: sc_searchdir
static void sc_searchdir(struct GlobalVars *gv)
/* SEARCH_DIR(path) */
{
  if (startofblock('(')) {
    char *path;

    if (path = getfilename()) {
      struct LibPath *libp = alloc(sizeof(struct LibPath));

      libp->path = allocstring(path);
      addtail(&gv->libpaths,&libp->n);
    }
    else
      error(78,scriptname,getlineno());

    endofblock('(',')');
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x28, %edi
callq 0xf8fc
testl %eax, %eax
je 0xd641
callq 0xfb3b
testq %rax, %rax
je 0xd647
movq %rax, %r14
movl $0x18, %edi
callq 0x6638
movq %rax, %r15
movq %r14, %rdi
callq 0x669d
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6729
jmp 0xd664
popq %rbx
popq %r14
popq %r15
retq
movq 0x25fd2(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x4e, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f14
movl $0x28, %edi
movl $0x29, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xf9cc
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: update_address
void update_address(struct MemoryDescr *rmd,struct MemoryDescr *dmd,
                    unsigned long addbytes)
{
  const char *secname = current_ls ? current_ls->name : defmemname;

  rmd->current += (lword)addbytes;
  if (rmd->current > rmd->org + rmd->len) {
    /* Fatal: Size of memory region exceeded! */
    error(63,rmd->name,secname,rmd->current);
  }
  if (dmd != rmd) {
    dmd->current += addbytes;
    if (dmd->current > dmd->org + dmd->len) {
      /* Fatal: Size of memory region exceeded! */
      error(63,dmd->name,secname,dmd->current);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x25f38(%rip), %rax     # 0x33608
testq %rax, %rax
je 0xd6db
movq 0x18(%rax), %r15
jmp 0xd6e2
leaq 0x154d4(%rip), %r15     # 0x22bb6
movq 0x20(%r12), %rcx
addq %rbx, %rcx
movq %rcx, 0x20(%r12)
movq 0x18(%r12), %rax
addq 0x10(%r12), %rax
cmpq %rax, %rcx
jle 0xd712
movq 0x8(%r12), %rsi
movl $0x3f, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6f14
cmpq %r12, %r14
je 0xd74d
addq 0x20(%r14), %rbx
movq %rbx, 0x20(%r14)
movq 0x18(%r14), %rax
addq 0x10(%r14), %rax
cmpq %rax, %rbx
jle 0xd74d
movq 0x8(%r14), %rsi
movl $0x3f, %edi
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6f14
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: free_patterns
void free_patterns(char *fpat,char **spatlist)
/* free file-pattern and section-pattern list, allocated in next_pattern() */
{
  char **p;

  if (fpat)
    free(fpat);

  if (p = spatlist) {
    while (*p) {
      free(*p);
      p++;
    }
    free(spatlist);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0xd795
callq 0x5040
testq %rbx, %rbx
je 0xd7c6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd7b7
leaq 0x8(%rbx), %r14
callq 0x5040
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0xd7a6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5040
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: test_pattern
int test_pattern(struct GlobalVars *gv,char **fpat,char ***spatlist)
/* Returns next file/section-patterns, but doesn't execute any commands
   or assignments. It will remember the initial parsing state to
   do it a second time for real with next_pattern(). */
{
  char c,*keyword;

  if (!secdefbase) {
    secdefbase = gettxtptr();
    secdefline = getlineno();
  }
  *fpat = NULL;
  *spatlist = NULL;
  level = 2;

  do {
    while (keyword = getpattern()) {
      if (check_command(gv,keyword,SCMDF_IGNORE)) {
        continue;
      }
      else {
        c = getchr();
        if (c == '=') {
          skip_expr(0);
        }
        else if (c == '(') {
          if (parse_pattern(gv,keyword,fpat,spatlist))
            return 1;
        }
        else {
          /* unknown keyword ignored */
          error(65,scriptname,getlineno(),keyword);
          back(1);
        }
      }
    }
  }
  while (getchr() == ';');
  back(1);

  level = 1;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x25e28(%rip)     # 0x33610
jne 0xd801
callq 0xff5c
movq %rax, 0x25e1a(%rip)     # 0x33610
callq 0x103d5
movl %eax, 0x25e17(%rip)     # 0x33618
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, (%rbx)
movl $0x2, 0x25e09(%rip)     # 0x3361c
movl $0x5, %edi
callq 0xff64
testq %rax, %rax
je 0xd8b8
movq %rax, %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0xd8ec
testl %eax, %eax
je 0xd851
movl $0x5, %edi
callq 0xff64
movq %rax, %r12
testq %rax, %rax
jne 0xd829
jmp 0xd8b8
callq 0xfeed
cmpb $0x28, %al
je 0xd875
movzbl %al, %eax
cmpl $0x3d, %eax
jne 0xd88c
callq 0xfeed
testb %al, %al
je 0xd83d
movzbl %al, %eax
cmpl $0x3b, %eax
jne 0xd862
jmp 0xd83d
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xda2a
testl %eax, %eax
je 0xd83d
jmp 0xd8dd
movq 0x25d8d(%rip), %r13     # 0x33620
callq 0x103d5
movl $0x41, %edi
movq %r13, %rsi
movl %eax, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x6f14
movl $0x1, %edi
callq 0xff51
jmp 0xd83d
callq 0xfeed
cmpb $0x3b, %al
je 0xd813
movl $0x1, %edi
callq 0xff51
movl $0x1, 0x25d43(%rip)     # 0x3361c
xorl %eax, %eax
jmp 0xd8e2
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: check_command
static int check_command(struct GlobalVars *gv,char *name,uint32_t flags)
{
  struct ScriptCmd *scptr;

  for (scptr=ldCommands; scptr->name; scptr++) {
    if (!strcmp(scptr->name,name))
      break;
  }

  if (scptr->name) {
    if (scptr->flags & flags) {
      if (scptr->cmdptr) {
        scptr->cmdptr(gv);  /* execute linker-script command */
      }
      else {
        error(69,scriptname,getlineno(),name);  /* command ignored */
        if (scptr->flags & SCMDF_PAREN)
          skipblock(0,'(',')');
      }
    }
    else {
      if (!(flags & SCMDF_IGNORE)) {
        /* command not allowed outside SECTIONS block */
        error(107,scriptname,getlineno(),name);
      }
      if (scptr->flags & SCMDF_PAREN)
        skipblock(0,'(',')');
      if (scptr->flags & SCMDF_SEMIC)
        skip_expr(0);
    }
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x21b82(%rip), %rdi     # 0x2f480
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xd9f4
movl %edx, %ebp
movq %rsi, %r14
leaq 0x21b73(%rip), %r12     # 0x2f488
movq %r14, %rsi
callq 0x5160
testl %eax, %eax
je 0xd934
movq 0x10(%r12), %rdi
addq $0x18, %r12
testq %rdi, %rdi
jne 0xd915
jmp 0xd9f4
movl (%r12), %eax
testl %ebp, %eax
je 0xd955
movq 0x8(%r12), %rax
testq %rax, %rax
je 0xd9b6
movq %r15, %rdi
callq *%rax
movl $0x1, %ebx
jmp 0xd9f4
testw %bp, %bp
js 0xd97e
movq 0x25cbf(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x6b, %edi
movq %rbx, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x6f14
movl (%r12), %eax
btl $0xd, %eax
jae 0xd999
xorl %edi, %edi
movl $0x28, %esi
movl $0x29, %edx
callq 0xff0c
movl (%r12), %eax
movl $0x1, %ebx
btl $0xe, %eax
jae 0xd9f4
callq 0xfeed
cmpb $0x3b, %al
je 0xd9f4
movzbl %al, %eax
testl %eax, %eax
jne 0xd9a4
jmp 0xd9f4
movq 0x25c63(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x45, %edi
movq %rbx, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x6f14
movl $0x1, %ebx
testb $0x20, 0x1(%r12)
je 0xd9f4
xorl %edi, %edi
movl $0x28, %esi
movl $0x29, %edx
callq 0xff0c
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: find_phdr
static struct Phdr *find_phdr(struct GlobalVars *gv,const char *name,
                              struct MemoryDescr *vmreg,
                              struct MemoryDescr *lmreg)
{
  struct Phdr *p;

  if (p = gv->phdrlist) {
    do {
      if (!strcmp(p->name,name) && p->vmregion==vmreg && p->lmregion==lmreg)
        break;
    }
    while (p = p->next);
  }
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe77c
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x5160
testl %eax, %eax
jne 0xe774
cmpq %r15, 0x10(%rbx)
jne 0xe774
cmpq %r14, 0x18(%rbx)
je 0xe77e
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xe758
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: guess_special_segment
static uint16_t guess_special_segment(const char *secname,const char **segname)
{
  uint16_t type;

  if (!strncmp(secname,".interp",7)) {
    *segname = defint;
    type = PT_INTERP;
  }
  else if (!strncmp(secname,".dynamic",8)) {
    *segname = defdyn;
    type = PT_DYNAMIC;
  }
  else if (!strncmp(secname,".note",5)) {
    *segname = defnot;
    type = PT_NOTE;
  }
  else {
    *segname = NULL;
    type = 0;
  }

  return type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14527(%rip), %rsi     # 0x22cc5
movl $0x7, %edx
callq 0x5070
testl %eax, %eax
je 0xe7f3
leaq 0x1451a(%rip), %rsi     # 0x22ccd
movl $0x8, %edx
movq %r14, %rdi
callq 0x5070
testl %eax, %eax
je 0xe800
leaq 0x1450b(%rip), %rsi     # 0x22cd6
movl $0x5, %edx
movq %r14, %rdi
callq 0x5070
movl %eax, %ecx
xorl %edx, %edx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x144fa(%rip), %rcx     # 0x22ce4
cmoveq %rcx, %rdx
shll $0x2, %eax
jmp 0xe80b
movw $0x3, %ax
leaq 0x144de(%rip), %rdx     # 0x22cdc
jmp 0xe80b
movw $0x2, %ax
leaq 0x14d55(%rip), %rdx     # 0x23560
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: change_address
static void change_address(struct MemoryDescr *md,lword newval)
{
  const char *secname = current_ls ? current_ls->name : defmemname;

  md->current = newval;
  if ((md->current < md->org) || (md->current > md->org + md->len)) {
    /* Fatal: Size of memory region exceeded! */
    error(63,md->name,secname,md->current);
  }
}

// Assembly:
movq %rsi, %rcx
movq 0x24a9c(%rip), %rax     # 0x33608
testq %rax, %rax
je 0xeb77
movq 0x18(%rax), %rdx
jmp 0xeb7e
leaq 0x14038(%rip), %rdx     # 0x22bb6
movq %rcx, 0x20(%rdi)
movq 0x10(%rdi), %rax
cmpq %rcx, %rax
jg 0xeb94
addq 0x18(%rdi), %rax
cmpq %rcx, %rax
jge 0xeba4
movq 0x8(%rdi), %rsi
movl $0x3f, %edi
xorl %eax, %eax
jmp 0x6f14
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: add_memblock
static struct MemoryDescr *add_memblock(const char *name,lword org,lword len)
{
  struct MemoryDescr *last,*new = alloc(sizeof(struct MemoryDescr));

  if (last = memory_blocks) {
    while (last->next)
      last = last->next;
    last->next = new;
  }
  else
    memory_blocks = new;

  new->next = NULL;
  new->name = allocstring(name);
  new->org = new->current = org;
  if (org+len < org)
    len -= org+len+1;
  new->len = len;
  return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl $0x28, %edi
callq 0x6638
movq %rax, %r15
movq 0x24ab6(%rip), %rax     # 0x33680
testq %rax, %rax
je 0xebdc
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
jne 0xebcf
jmp 0xebe3
leaq 0x24a9d(%rip), %rcx     # 0x33680
movq %r15, (%rcx)
movq $0x0, (%r15)
movq %r12, %rdi
callq 0x669d
movq %rax, 0x8(%r15)
movq %r14, 0x20(%r15)
movq %r14, 0x10(%r15)
addq %rbx, %r14
notq %r14
movq %rbx, %rax
sarq $0x3f, %rax
andq %r14, %rax
addq %rbx, %rax
movq %rax, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: add_phdr
static struct Phdr *add_phdr(struct GlobalVars *gv,const char *name,
                             uint32_t type,uint16_t flags,lword addr,
                             struct MemoryDescr *vmreg,struct MemoryDescr *lmreg)
{
  struct Phdr *p,*new;

  if (type == PT_PHDR) {
    flags |= PHDR_USED;
  }
  else if ((flags&(PHDR_FILEHDR|PHDR_PHDRS))==PHDR_FILEHDR ||
           (flags&(PHDR_FILEHDR|PHDR_PHDRS))==PHDR_PHDRS) {
    /* must include both: FILEHDR and PHDR */
    error(77,scriptname,getlineno(),name);
    return NULL;
  }

  new = alloczero(sizeof(struct Phdr));
  new->name = allocstring(name);
  new->type = type;
  new->flags = flags;
  new->start = addr;
  new->start_vma = ADDR_NONE;
  new->vmregion = vmreg;
  new->lmregion = lmreg;

  if (type == PT_LOAD) {
    if (!gv->no_page_align)
      new->alignment = shiftcnt(fff[gv->dest_format]->page_size);
  }
  else if (type == PT_PHDR)
    new->alignment = 2;

  if (p = gv->phdrlist) {
    while (p->next) {
      if (type==PT_PHDR && p->type==PT_PHDR) {
        free(new);
        return NULL;  /* reject double PHDR segment */
      }
      p = p->next;
    }
    p->next = new;
  }
  else
    gv->phdrlist = new;

  return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %rbp
movl %ecx, %r15d
movl %edx, %ebx
movq %rsi, %r13
cmpl $0x6, %edx
jne 0xf7e4
orl $0x10, %r15d
jmp 0xf822
movl %r15d, %eax
andl $0xc00, %eax            # imm = 0xC00
cmpl $0x800, %eax            # imm = 0x800
je 0xf7fa
cmpl $0x400, %eax            # imm = 0x400
jne 0xf822
movq 0x23e1f(%rip), %rbx     # 0x33620
callq 0x103d5
xorl %r14d, %r14d
movl $0x4d, %edi
movq %rbx, %rsi
movl %eax, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x6f14
jmp 0xf8ea
movq %rdi, (%rsp)
movl $0x58, %edi
callq 0x6686
movq %rax, %r14
movq %r13, %rdi
callq 0x669d
movq %rax, 0x8(%r14)
movl %ebx, 0x20(%r14)
movw %r15w, 0x24(%r14)
movq %rbp, 0x30(%r14)
movq $-0x1, 0x28(%r14)
movq %r12, 0x10(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r14)
cmpl $0x1, %ebx
jne 0xf890
movq (%rsp), %rcx
cmpl $0x0, 0x7c(%rcx)
jne 0xf89f
movzbl 0x50(%rcx), %eax
leaq 0x1f905(%rip), %rcx     # 0x2f180
movq (%rcx,%rax,8), %rax
movl 0x98(%rax), %edi
callq 0x6dff
movq (%rsp), %rcx
jmp 0xf89b
movb $0x2, %al
cmpl $0x6, %ebx
movq (%rsp), %rcx
jne 0xf89f
movb %al, 0x26(%r14)
movq 0x1f8(%rcx), %rax
testq %rax, %rax
je 0xf8ce
movq (%rax), %rdx
testq %rdx, %rdx
je 0xf8d7
movq %rdx, %rcx
cmpl $0x6, %ebx
jne 0xf8c1
cmpl $0x6, 0x20(%rax)
je 0xf8df
movq (%rcx), %rdx
movq %rcx, %rax
testq %rdx, %rdx
jne 0xf8b3
jmp 0xf8da
movq %r14, 0x1f8(%rcx)
jmp 0xf8ea
movq %rax, %rcx
movq %r14, (%rcx)
jmp 0xf8ea
movq %r14, %rdi
callq 0x5040
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: startofblock
static bool startofblock(char c)
{
  if (getchr() != c) {
    error(66,scriptname,getlineno(),c);
    back(1);
    return FALSE;
  }
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
callq 0xfeed
movl $0x1, %ebx
cmpb %bpl, %al
je 0xf940
movzbl %bpl, %ebp
movq 0x23d04(%rip), %r14     # 0x33620
callq 0x103d5
xorl %ebx, %ebx
movl $0x42, %edi
movq %r14, %rsi
movl %eax, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x6f14
movl $0x1, %edi
callq 0xff51
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: getsection
static struct LinkedSection *getsection(struct GlobalVars *gv)
{
  struct LinkedSection *ls = NULL;
  char *sname;

  if (sname = getword()) {
    if (!(ls = find_lnksec(gv,sname,0,0,0,0)))
      error(79,scriptname,getlineno(),sname);  /* Undefined section */
  }
  else
    error(78,scriptname,getlineno());

  return ls;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, %edi
callq 0xff64
testq %rax, %rax
je 0xf9a3
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xbe13
movq %rax, %r14
testq %rax, %rax
jne 0xf9c3
movq 0x23c9b(%rip), %r15     # 0x33620
callq 0x103d5
xorl %r14d, %r14d
movl $0x4f, %edi
movq %r15, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6f14
jmp 0xf9c3
movq 0x23c76(%rip), %rbx     # 0x33620
callq 0x103d5
xorl %r14d, %r14d
movl $0x4e, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: endofblock
static bool endofblock(char c1,char c2)
{
  if (getchr() != c2) {
    error(66,scriptname,getlineno(),c2);
    skipblock(1,c1,c2);
    return FALSE;
  }
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebx
callq 0xfeed
movl $0x1, %ebp
cmpb %r14b, %al
je 0xfa1d
movq 0x23c32(%rip), %r15     # 0x33620
callq 0x103d5
movsbl %r14b, %r14d
xorl %ebp, %ebp
movl $0x42, %edi
movq %r15, %rsi
movl %eax, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x6f14
movsbl %bl, %esi
movl $0x1, %edi
movl %r14d, %edx
callq 0xff0c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: term_absexp
static lword term_absexp(void)
{
  lword val = 0;

  if (getchr() == '(') {
    if (!parse_expr(-1,&val))
      error(67,scriptname,getlineno());  /* Absolute number expected */
    if (getchr() != ')') {
      error(66,scriptname,getlineno(),')');  /* ')' expected */
      skipblock(1,'(',')');
    }
  }
  else
    error(66,scriptname,getlineno(),'(');  /* '(' expected */

  return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
callq 0xfeed
cmpb $0x28, %al
jne 0xfab4
leaq 0x8(%rsp), %rsi
movq $-0x1, %rdi
callq 0x1004a
testl %eax, %eax
jne 0xfa73
movq 0x23bc3(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x43, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f14
callq 0xfeed
cmpb $0x29, %al
je 0xfad6
movq 0x23b9d(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x42, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x29, %ecx
xorl %eax, %eax
callq 0x6f14
movl $0x1, %edi
movl $0x28, %esi
movl $0x29, %edx
callq 0xff0c
jmp 0xfad6
movq 0x23b65(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x42, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x28, %ecx
xorl %eax, %eax
callq 0x6f14
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: set_ctors_type
static void set_ctors_type(struct GlobalVars *gv,uint8_t type)
{
  if (gv->collect_ctors_type!=CCDT_NONE &&
      gv->collect_ctors_type!=type)
    error(71,scriptname,getlineno());  /* multiple constructor types */

  gv->collect_ctors_type = type;

  if (new_ls_name)
    gv->collect_ctors_secname = new_ls_name;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movb 0x203(%rdi), %al
testb %al, %al
sete %cl
cmpb %bpl, %al
sete %al
orb %cl, %al
jne 0xfb1c
movq 0x23b1a(%rip), %r14     # 0x33620
callq 0x103d5
movl $0x47, %edi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f14
movb %bpl, 0x203(%rbx)
movq 0x23b4e(%rip), %rax     # 0x33678
testq %rax, %rax
je 0xfb36
movq %rax, 0x208(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: getfilename
static char *getfilename(void)
{
  if (getchr() == '\"') {
    back(1);
    return getquoted();
  }

  back(1);
  return getarg(27);
}

// Assembly:
pushq %rbx
callq 0xfeed
movl %eax, %ebx
movl $0x1, %edi
callq 0xff51
cmpb $0x22, %bl
jne 0xfb58
popq %rbx
jmp 0xffd2
movl $0x1b, %edi
popq %rbx
jmp 0xff64
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: scriptsymbol
static void scriptsymbol(struct GlobalVars *gv,char *name,
                         lword val,uint8_t type,uint8_t flags)
{
  struct Symbol *sym;
  struct Symbol **chain = &script_obj->objsyms[elf_hash(name)%OBJSYMHTABSIZE];

  while (sym = *chain) {
    if (!strcmp(name,sym->name)) {
      error(109,scriptname,getlineno(),name);  /* already defined */
      return;
    }
    chain = &sym->obj_chain;
  }
  sym = alloczero(sizeof(struct Symbol));
  if (check_protection(gv,name))
    flags |= SYMF_PROTECTED;

  sym->name = allocstring(name);
  sym->value = val;
  sym->type = type;
  sym->flags = flags;
  sym->bind = SYMB_GLOBAL;

  /* These symbols will be moved from scriptsymbols list into
     LinkedSection.symbols during linker_copy() - at least
     the remaining, absolute ones. */
  if (addglobsym(gv,sym)) {
    *chain = sym;
    addtail(&gv->scriptsymbols,&sym->n);
  }
  else
    free(sym);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x23af0(%rip), %rax     # 0x33670
movq 0x48(%rax), %r12
movq %rsi, %rdi
callq 0x6d94
andl $0x1f, %eax
movq (%r12,%rax,8), %rcx
testq %rcx, %rcx
je 0xfbbe
movq %rcx, %r13
movq 0x20(%rcx), %rsi
movq %r14, %rdi
callq 0x5160
testl %eax, %eax
je 0xfc41
movq 0x18(%r13), %rcx
testq %rcx, %rcx
jne 0xfb98
addq $0x18, %r13
jmp 0xfbc2
leaq (%r12,%rax,8), %r13
movl $0x50, %edi
callq 0x6686
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7f1
movzbl %bpl, %ecx
orb $0x4, %bpl
testl %eax, %eax
movzbl %bpl, %ebp
cmovel %ecx, %ebp
movq %r14, %rdi
callq 0x669d
movq %rax, 0x20(%r12)
movq %r15, 0x30(%r12)
movb $0x1, 0x40(%r12)
movb %bpl, 0x41(%r12)
movb $0x2, 0x43(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa82b
testl %eax, %eax
je 0xfc6f
movq %r12, (%r13)
addq $0x190, %rbx            # imm = 0x190
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6729
movq 0x239d8(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x6d, %edi
movq %rbx, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6f14
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5040
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: get_dummy_sec
static struct Section *get_dummy_sec(const char *name)
/* return dummy section of our artificial script-object with name */
{
  struct Section *sec;

  for (sec=(struct Section *)script_obj->sections.first;
       sec->n.next!=NULL; sec=(struct Section *)sec->n.next) {
    if (!strcmp(sec->name,name))
      break;
  }
  if (sec->n.next == NULL)
    ierror("get_dummy_sec(): Dummy section \"%s\" not found",name);
  return sec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x239dc(%rip), %rax     # 0x33670
movq 0x20(%rax), %r15
movq %r15, %rbx
movq (%r15), %r15
testq %r15, %r15
je 0xfcb5
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x5160
testl %eax, %eax
jne 0xfc98
jmp 0xfcc6
leaq 0x12fb3(%rip), %rdi     # 0x22c6f
movq %r14, %rsi
xorl %eax, %eax
callq 0x52b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: readmemparam
static lword readmemparam(char *key)
{
  char *str;
  lword val = 0;

  if (str = getword()) {
    if (toupper((unsigned char)*str) == *key) {
      if (getchr() == '=') {
        if (!parse_expr(-1,&val))
          error(67,scriptname,getlineno());  /* Absolute number expected */
      }
      else
        error(66,scriptname,getlineno(),'=');
    }
    else
      error(68,scriptname,getlineno(),key);  /* keyword expected */
  }
  else
    error(68,scriptname,getlineno(),key);
  return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rsp)
movl $0x1, %edi
callq 0xff64
testq %rax, %rax
je 0xfd3f
movq %rax, %r14
callq 0x5030
movq (%rax), %rax
movzbl (%r14), %ecx
movsbl (%rbx), %edx
cmpl %edx, (%rax,%rcx,4)
jne 0xfd3f
callq 0xfeed
cmpb $0x3d, %al
jne 0xfd6b
movq %rsp, %rsi
movq $-0x1, %rdi
callq 0x1004a
testl %eax, %eax
jne 0xfd5f
movq 0x238f9(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x43, %edi
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x6f14
jmp 0xfd5f
movq 0x238da(%rip), %r14     # 0x33620
callq 0x103d5
movl $0x44, %edi
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6f14
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x238ae(%rip), %rbx     # 0x33620
callq 0x103d5
movl $0x42, %edi
movq %rbx, %rsi
movl %eax, %edx
movl $0x3d, %ecx
xorl %eax, %eax
callq 0x6f14
jmp 0xfd5f
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/ldscript.c
// Function: use_segment
static void use_segment(struct GlobalVars *gv,const char *name,uint32_t type,
                        struct MemoryDescr *vmreg,struct MemoryDescr *lmreg)
{
  struct Phdr *p;

  if (p = find_phdr(gv,name,vmreg,lmreg)) {
    if (p->type == PT_NULL)
      return;
  }
  else {
    if (!(p = add_phdr(gv,name,type,0,ADDR_NONE,vmreg,lmreg)))
      return;
  }
  p->flags |= PHDR_USED;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
movq 0x1f8(%rdi), %rdi
movq %rcx, %rdx
movq %r8, %rcx
callq 0xe73f
testq %rax, %rax
je 0xfdd7
cmpl $0x0, 0x20(%rax)
je 0xfdca
orb $0x10, 0x24(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movq $-0x1, %r8
movq %rbx, %r9
callq 0xf7c0
testq %rax, %rax
jne 0xfdc6
jmp 0xfdca
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/pmatch.c
// Function: patternlist_match
bool patternlist_match(char **patlist,const char *str)
/* match string against a list of patterns */
{
  if (patlist) {
    while (*patlist) {
      if (pattern_match(*patlist,str))
        return (TRUE);
      patlist++;
    }
  }
  return (FALSE);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0xfe56
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfe4f
movq %rsi, %rbx
addq $0x8, %r14
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5110
testl %eax, %eax
je 0xfe4a
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0xfe2c
xorl %eax, %eax
jmp 0xfe4f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/expr.c
// Function: skip
void skip(void)
/* skips blanks, tabs, newlines and comments */
{
  s = skipblanks(s);
  while (*s == '/' && *(s+1) == '*') {
    /* skip comment */
    s += 2;
    while (*s && (*s!='*' || *(s+1)!='/')) {
      if (*s=='\n')
        line++;
      s++;
    }
    s += 2;
    s = skipblanks(s);
  }
}

// Assembly:
pushq %rax
movq 0x23830(%rip), %rdi     # 0x33690
callq 0xfeb1
movq %rax, 0x23824(%rip)     # 0x33690
cmpb $0x2f, (%rax)
jne 0xfeaf
cmpb $0x2a, 0x1(%rax)
jne 0xfeaf
movl 0x2381b(%rip), %ecx     # 0x33698
addq $0x4, %rax
movzbl -0x2(%rax), %edx
cmpl $0xa, %edx
je 0xfe9d
cmpl $0x2a, %edx
je 0xfe95
testl %edx, %edx
jne 0xfea5
jmp 0xfeaa
cmpb $0x2f, -0x1(%rax)
jne 0xfea5
jmp 0xfeaa
incl %ecx
movl %ecx, 0x237f3(%rip)     # 0x33698
incq %rax
jmp 0xfe81
movq %rax, %rdi
jmp 0xfe60
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/expr.c
// Function: skipblanks
static char *skipblanks(char *sp)
{
  unsigned char c = (unsigned char)*sp;

  while (isspace(c)) {
    if (c == '\n')
      line++;
    c = (unsigned char)*(++sp);
  }
  return sp;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5290
movq (%rax), %rax
movzbl (%rbx), %edx
testb $0x20, 0x1(%rax,%rdx,2)
je 0xfee8
movl 0x237cb(%rip), %ecx     # 0x33698
cmpb $0xa, %dl
jne 0xfeda
incl %ecx
movl %ecx, 0x237be(%rip)     # 0x33698
movzbl 0x1(%rbx), %edx
incq %rbx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0xfecd
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/expr.c
// Function: getchr
char getchr(void)
{
  char c;

  skip();
  if (c = *s)
    s++;
  return c;
}

// Assembly:
pushq %rax
callq 0xfe58
movq 0x23796(%rip), %rcx     # 0x33690
movb (%rcx), %al
testb %al, %al
je 0xff0a
incq %rcx
movq %rcx, 0x23786(%rip)     # 0x33690
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/expr.c
// Function: skipblock
void skipblock(int level,char start,char end)
/* skips a block between the two specified start- and end-characters */
{
  char c;

  while (c = getchr()) {
    if (c == start) {
      ++level;
    }
    else if (c == end) {
      if (--level <= 0)
        break;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
callq 0xfe58
movq 0x2376d(%rip), %rcx     # 0x33690
movb (%rcx), %al
testb %al, %al
je 0xff4c
incq %rcx
movq %rcx, 0x2375d(%rip)     # 0x33690
cmpb %bpl, %al
jne 0xff3d
incl %r14d
jmp 0xff17
cmpb %bl, %al
jne 0xff17
cmpl $0x2, %r14d
jl 0xff4c
decl %r14d
jmp 0xff17
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/expr.c
// Function: getquoted
char *getquoted(void)
/* return characters between "quotes" */
{
  skip();
  if (*s == '\"') {
    static char buffer[MAXLEN];
    char c,*bp=buffer;

    s++;

    while (c = *s) {
      s++;

      if (c == '\n') {
        line++;
        break;  /* @@@ newline breaks string? */
      }
      else if (c == '\"')
        break;

      *bp++ = c;
      if (bp >= &buffer[MAXLEN-1])
        break;  /* buffer overflow */
    }
    *bp = '\0';
    return buffer;
  }

  return NULL;
}

// Assembly:
pushq %rax
callq 0xfe58
movq 0x236b1(%rip), %rcx     # 0x33690
cmpb $0x22, (%rcx)
jne 0x1003a
leaq 0x1(%rcx), %rax
movq %rax, 0x236a1(%rip)     # 0x33690
addq $0x2, %rcx
xorl %edx, %edx
leaq 0x237a4(%rip), %rax     # 0x337a0
movl $0xff, %edi
leaq (%rax,%rdi), %rsi
leaq (%rax,%rdx), %r8
movzbl -0x1(%rcx), %r9d
testl %r9d, %r9d
je 0x10044
movq %rcx, 0x23676(%rip)     # 0x33690
cmpl $0x22, %r9d
je 0x10044
cmpl $0xa, %r9d
je 0x1003e
movb %r9b, (%rdx,%rax)
incq %rdx
incq %rcx
cmpq %rdi, %rdx
jne 0x10005
movq %rsi, %r8
jmp 0x10044
xorl %eax, %eax
jmp 0x10048
incl 0x23654(%rip)           # 0x33698
movb $0x0, (%r8)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/expr.c
// Function: parse_expr
int parse_expr(lword current_addr,lword *result)
/* Tries to parse the input stream. Returns !0 for an absolute result.
   If current_addr = -1 then '.' is not defined and only references
   to absolute symbols are allowed.
   If current_addr = -2 then no expression evaluation takes place
   at all. The expression is just skipped. */
{
  lword saved_caddr = caddr;
  struct Expr *tree;
  int abs;

  caddr = current_addr;
  skip();
  tree = expression();
  abs = caddr==-2 ? 1 : eval_expr(tree,result);
  free_expr(tree);
  caddr = saved_caddr;
  return abs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x23845(%rip), %r15     # 0x338a0
movq %rdi, 0x2383e(%rip)     # 0x338a0
callq 0xfe58
callq 0x100a7
movq %rax, %r14
movl $0x1, %ebp
cmpq $-0x2, 0x23824(%rip)    # 0x338a0
je 0x1008b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10125
movl %eax, %ebp
movq %r14, %rdi
callq 0x103b0
movq %r15, 0x23806(%rip)     # 0x338a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/expr.c
// Function: expression
static struct Expr *expression(void)
{
  struct Expr *left,*new;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x103f8
movq %rax, %rbx
callq 0xfe58
movq 0x235d1(%rip), %rax     # 0x33690
cmpb $0x7c, (%rax)
jne 0x10117
cmpb $0x7c, 0x1(%rax)
jne 0x10117
addq $0x2, %rax
movq %rax, 0x235bb(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x8, (%rax)
callq 0xfe58
movq %rbx, 0x8(%r14)
callq 0x103f8
movq %rax, 0x10(%r14)
movq 0x23583(%rip), %rax     # 0x33690
cmpb $0x7c, (%rax)
movq %r14, %rbx
je 0x100c4
jmp 0x1011a
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/expr.c
// Function: free_expr
static void free_expr(struct Expr *tree)
{
  if (tree) {
    free_expr(tree->left);
    free_expr(tree->right);
    free(tree);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x103d4
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x103b0
movq 0x10(%rbx), %rdi
callq 0x103b0
movq %rbx, %rdi
popq %rbx
jmp 0x5040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
callq 0x10476
movq %rax, %rbx
callq 0xfe58
movq 0x23280(%rip), %rax     # 0x33690
cmpb $0x26, (%rax)
jne 0x10468
cmpb $0x26, 0x1(%rax)
jne 0x10468
addq $0x2, %rax
movq %rax, 0x2326a(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x7, (%rax)
callq 0xfe58
movq %rbx, 0x8(%r14)
callq 0x10476
movq %rax, 0x10(%r14)
movq 0x23232(%rip), %rax     # 0x33690
cmpb $0x26, (%rax)
movq %r14, %rbx
je 0x10415
jmp 0x1046b
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
callq 0x104f3
movq %rax, %rbx
callq 0xfe58
movq 0x23202(%rip), %rax     # 0x33690
cmpb $0x7c, (%rax)
jne 0x104e5
cmpb $0x7c, 0x1(%rax)
je 0x104e5
incq %rax
movq %rax, 0x231ed(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0xa, (%rax)
callq 0xfe58
movq %rbx, 0x8(%r14)
callq 0x104f3
movq %rax, 0x10(%r14)
movq 0x231b5(%rip), %rax     # 0x33690
cmpb $0x7c, (%rax)
movq %r14, %rbx
je 0x10493
jmp 0x104e8
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1056a
movq %rax, %rbx
callq 0xfe58
movq 0x23185(%rip), %rax     # 0x33690
cmpb $0x5e, (%rax)
jne 0x1055c
incq %rax
movq %rax, 0x23176(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0xb, (%rax)
callq 0xfe58
movq %rbx, 0x8(%r14)
callq 0x1056a
movq %rax, 0x10(%r14)
movq 0x2313e(%rip), %rax     # 0x33690
cmpb $0x5e, (%rax)
movq %r14, %rbx
je 0x10510
jmp 0x1055f
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
callq 0x105e7
movq %rax, %rbx
callq 0xfe58
movq 0x2310e(%rip), %rax     # 0x33690
cmpb $0x26, (%rax)
jne 0x105d9
cmpb $0x26, 0x1(%rax)
je 0x105d9
incq %rax
movq %rax, 0x230f9(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x9, (%rax)
callq 0xfe58
movq %rbx, 0x8(%r14)
callq 0x105e7
movq %rax, 0x10(%r14)
movq 0x230c1(%rip), %rax     # 0x33690
cmpb $0x26, (%rax)
movq %r14, %rbx
je 0x10587
jmp 0x105dc
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x10664
movq %rax, %rbx
callq 0xfe58
movq 0x23091(%rip), %rax     # 0x33690
movzbl (%rax), %ebp
cmpl $0x3d, %ebp
je 0x1060c
cmpl $0x21, %ebp
jne 0x1065c
cmpb $0x3d, 0x1(%rax)
jne 0x1065c
addq $0x2, %rax
movq %rax, 0x23073(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
cmpb $0x21, %bpl
setne %al
addl $0x13, %eax
movl %eax, (%r14)
callq 0xfe58
movq %rbx, 0x8(%r14)
callq 0x10664
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x105f8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x10716
movq %rax, %rbx
callq 0xfe58
xorl %ebp, %ebp
movl $0x3d, %r15d
movq 0x23008(%rip), %rax     # 0x33690
movzbl (%rax), %r12d
movl %r12d, %ecx
orl $0x2, %ecx
cmpl $0x3e, %ecx
jne 0x1070a
movb 0x1(%rax), %cl
cmpb %r12b, %cl
je 0x1070a
leaq 0x1(%rax), %rdx
addq $0x2, %rax
cmpb $0x3d, %cl
cmovneq %rdx, %rax
movzbl %bpl, %ebp
cmovel %r15d, %ebp
movq %rax, 0x22fd3(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
testb %bpl, %bpl
setne %al
cmpb $0x3c, %r12b
leal 0x10(%rax,%rax), %ecx
leal 0xf(%rax,%rax), %eax
cmovnel %ecx, %eax
movl %eax, (%r14)
callq 0xfe58
movq %rbx, 0x8(%r14)
callq 0x10716
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x10681
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x1078f
movq %rax, %rbx
callq 0xfe58
movq 0x22f62(%rip), %rax     # 0x33690
movzbl (%rax), %ebp
movl %ebp, %ecx
orl $0x2, %ecx
cmpl $0x3e, %ecx
jne 0x10787
cmpb %bpl, 0x1(%rax)
jne 0x10787
addq $0x2, %rax
movq %rax, 0x22f44(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
movq $0x0, 0x10(%rax)
xorl %eax, %eax
cmpb $0x3c, %bpl
setne %al
addl $0xd, %eax
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
callq 0x1078f
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x10722
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x107fe
movq %rax, %rbx
callq 0xfe58
movq 0x22ee9(%rip), %rax     # 0x33690
movzbl (%rax), %ebp
cmpl $0x2d, %ebp
je 0x107b4
cmpl $0x2b, %ebp
jne 0x107f6
incq %rax
movq %rax, 0x22ed2(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
movq $0x0, 0x10(%rax)
xorl %eax, %eax
cmpb $0x2b, %bpl
setne %al
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
callq 0x107fe
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x1079b
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x10891
movq %rax, %rbx
movabsq $0x842000000000, %r15   # imm = 0x842000000000
movl $0x2, %ebp
callq 0xfe58
movq 0x22e67(%rip), %rax     # 0x33690
movzbl (%rax), %r12d
cmpq $0x2f, %r12
ja 0x10885
btq %r12, %r15
jae 0x10885
incq %rax
movq %rax, 0x22e4d(%rip)     # 0x33690
callq 0xfe58
movl $0x20, %edi
callq 0x6638
movq %rax, %r14
movq $0x0, 0x10(%rax)
xorl %eax, %eax
cmpb $0x2f, %r12b
setne %al
addl $0x3, %eax
cmpb $0x2a, %r12b
cmovel %ebp, %eax
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
callq 0x10891
movq %rax, 0x10(%r14)
movq %r14, %rbx
jmp 0x1081d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq 0x22df4(%rip), %rax     # 0x33690
movzbl (%rax), %r14d
cmpq $0x2d, %r14
ja 0x108b6
movabsq $0x280200000000, %rcx   # imm = 0x280200000000
btq %r14, %rcx
jb 0x108bc
cmpl $0x7e, %r14d
jne 0x108d1
incq %rax
movq %rax, 0x22dca(%rip)     # 0x33690
callq 0xfe58
cmpb $0x2b, %r14b
jne 0x108da
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10921
movl $0x20, %edi
callq 0x6638
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
cmpb $0x21, %r14b
movl $0xc, %eax
movl $0x6, %ecx
cmovel %eax, %ecx
cmpb $0x2d, %r14b
movl $0x5, %eax
cmovnel %ecx, %eax
movl %eax, (%rbx)
callq 0x10921
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x70(%rdi)
je 0x11acd
cmpb $0x1, 0x2c(%rbx)
je 0x11aef
cmpl $0x0, 0x74(%r15)
je 0x11add
movb 0x2c(%rbx), %al
andb $-0x2, %al
cmpb $0x2, %al
je 0x11aef
movq 0x18(%r14), %rax
cmpb $0x0, (%rax)
jne 0x11aef
movq 0x20(%rbx), %rax
cmpb $0x0, (%rax)
je 0x11b5b
movq 0x20(%rbx), %r12
leaq 0x11667(%rip), %rsi     # 0x23161
movq %r12, %rdi
callq 0x5160
testl %eax, %eax
je 0x11b5b
xorl %ebp, %ebp
cmpl $0x0, 0x54(%r15)
jne 0x11b60
movq 0x18(%r14), %rdi
leaq 0x1163e(%rip), %rsi     # 0x23158
callq 0x5160
testl %eax, %eax
jne 0x11b60
leaq 0x1162e(%rip), %rsi     # 0x23158
movq %r12, %rdi
callq 0x5160
testl %eax, %eax
jne 0x11b60
movl $0x1, %ebp
cmpb $0x1, 0x2c(%rbx)
jne 0x11b60
movq 0x10(%rbx), %rdi
callq 0x7104
movl $0x39, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x6f14
jmp 0x11b60
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq