LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::attachNames(std::vector<SleighSymbol*, std::allocator<SleighSymbol*>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void SleighCompile::attachNames(vector<SleighSymbol *> *symlist,vector<string> *names)

{
  SleighSymbol *dupsym = dedupSymbolList(symlist);
  if (dupsym != (SleighSymbol *)0)
    reportWarning("\"attach names\" list contains duplicate entries: "+dupsym->getName(),true);
  for(int4 i=0;i<symlist->size();++i) {
    ValueSymbol *sym = (ValueSymbol *)(*symlist)[i];
    if (sym == (ValueSymbol *)0) continue;
    PatternValue *patval = sym->getPatternValue();
    if (patval->maxValue() + 1 != names->size()) {
      reportError("Attach name " + sym->getName() + " is wrong size for list", true);
    }
    symtab.replaceSymbol(sym,new NameSymbol(sym->getName(),patval,*names));
  }
  delete names;
  delete symlist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %r12
movq %rsi, (%rsp)
callq 0x2b89a
testq %rax, %rax
je 0x2bb29
addq $0x8, %rax
leaq 0x2ba6c(%rip), %rsi     # 0x5756d
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x10cd1
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2a3a2
leaq 0x18(%rsp), %rdi
callq 0xf1a0
movq %r12, 0x8(%rsp)
leaq 0x198(%r12), %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movq (%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x2bc1b
movq (%rax,%r12,8), %r13
testq %r13, %r13
je 0x2bc13
movq (%r13), %rax
movq %r13, %rdi
callq *0x60(%rax)
movq %rax, %rbp
movq (%rax), %rax
movq %rbp, %rdi
callq *0x58(%rax)
incq %rax
movq 0x8(%r14), %rcx
movq %r14, %rbx
subq (%r14), %rcx
sarq $0x5, %rcx
cmpq %rcx, %rax
je 0x2bbe3
leaq 0x8(%r13), %rdx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
leaq 0x2b9f9(%rip), %rsi     # 0x5759e
callq 0x10cd1
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
leaq 0x2b999(%rip), %rdx     # 0x57555
callq 0x2eb71
movq 0x8(%rsp), %rdi
movq %r14, %rsi
pushq $0x1
popq %rdx
callq 0x292f0
movq %r14, %rdi
callq 0xf1a0
leaq 0x38(%rsp), %rdi
callq 0xf1a0
pushq $0x58
popq %rdi
callq 0xf370
movq %rax, %r15
leaq 0x8(%r13), %rsi
movq %rax, %rdi
movq %rbp, %rdx
movq %rbx, %r14
movq %rbx, %rcx
callq 0x2ede4
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x405ee
incq %r12
jmp 0x2bb3e
testq %r14, %r14
je 0x2bc28
movq %r14, %rdi
callq 0x12d80
pushq $0x18
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xf380
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x2fa2a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf380
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x2bc7e
movq %rax, %rbx
jmp 0x2bc79
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf1a0
leaq 0x38(%rsp), %rdi
callq 0xf1a0
jmp 0x2bc93
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r15, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::newTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
SubtableSymbol *SleighCompile::newTable(string *nm)

{
  SubtableSymbol *sym = new SubtableSymbol(*nm);
  addSymbol(sym);
  tables.push_back(sym);
  delete nm;
  return sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0xf370
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x45b44
movq %rsp, %r12
movq %r15, (%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x29992
addq $0x288, %r14            # imm = 0x288
movq %r14, %rdi
movq %r12, %rsi
callq 0x2ea76
movq %rbx, %rdi
callq 0xf1a0
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0xf380
movq (%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::newOperand(Constructor*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void SleighCompile::newOperand(Constructor *ct,string *nm)

{
  int4 index = ct->getNumOperands();
  OperandSymbol *sym = new OperandSymbol(*nm,index,ct);
  addSymbol(sym);
  ct->addOperand(sym);
  delete nm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rsi), %r13
subq 0x18(%rsi), %r13
shrq $0x3, %r13
pushq $0x60
popq %rdi
callq 0xf370
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movl %r13d, %edx
movq %r14, %rcx
callq 0x43048
movq %r15, %rdi
movq %r12, %rsi
callq 0x29992
movq %r14, %rdi
movq %r12, %rsi
callq 0x4422e
movq %rbx, %rdi
callq 0xf1a0
pushq $0x20
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf380
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r12, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::constrainOperand(OperandSymbol*, PatternExpression*)
PatternEquation *SleighCompile::constrainOperand(OperandSymbol *sym,PatternExpression *patexp)

{				// Create constraint on operand
  PatternEquation *res;
  FamilySymbol *famsym = dynamic_cast<FamilySymbol *>(sym->getDefiningSymbol());
  if (famsym != (FamilySymbol *)0) { // Operand already defined as family symbol
				// This equation must be a constraint
    res = new EqualEquation(famsym->getPatternValue(),patexp);
  }
  else {			// Operand is currently undefined, so we can't constrain
    PatternExpression::release(patexp);
    res = (PatternEquation *)0;
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x2c022
leaq 0x59a80(%rip), %rsi     # 0x85a68
leaq 0x59b11(%rip), %rdx     # 0x85b00
xorl %ecx, %ecx
callq 0xf3f0
testq %rax, %rax
je 0x2c022
movq %rax, %r15
pushq $0x48
popq %rdi
callq 0xf370
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x60(%rax)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2ee46
jmp 0x2c02d
movq %rbx, %rdi
callq 0x363ba
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::defineOperand(OperandSymbol*, PatternExpression*)
void SleighCompile::defineOperand(OperandSymbol *sym,PatternExpression *patexp)

{				// Define operand in terms of PatternExpression
  try {
    sym->defineOperand(patexp);
    sym->setOffsetIrrelevant();	// If not a self-definition, the operand has no
				// pattern directly associated with it, so
				// the operand's offset is irrelevant
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
    PatternExpression::release(patexp);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x430b2
orb $0x2, 0x58(%r15)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x2c0a8
movq %r15, %rdi
callq 0xf170
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x292f0
movq %rbx, %rdi
callq 0x363ba
popq %rbx
popq %r14
popq %r15
jmp 0xf650
movq %rax, %r15
callq 0xf650
movq %r15, %rdi
callq 0xf6e0
movq %rax, %rdi
callq 0x1178d
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::defineInvisibleOperand(TripleSymbol*)
PatternEquation *SleighCompile::defineInvisibleOperand(TripleSymbol *sym)

{
  int4 index = curct->getNumOperands();
  OperandSymbol *opsym = new OperandSymbol(sym->getName(),index,curct);
  addSymbol(opsym);
  curct->addInvisibleOperand(opsym);
  PatternEquation *res = new OperandEquation(opsym->getIndex());
  SleighSymbol::symbol_type tp = sym->getType();
  try {
    if ((tp==SleighSymbol::value_symbol)||(tp==SleighSymbol::context_symbol)) {
      opsym->defineOperand(sym->getPatternExpression());
    }
    else {
      opsym->defineOperand(sym);
      //      reportWarning("Defining invisible operand "+sym->getName(),true);
    }
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movq 0x2d0(%rdi), %r14
movq 0x20(%r14), %r13
subq 0x18(%r14), %r13
shrq $0x3, %r13
pushq $0x60
popq %rdi
callq 0xf370
movq %rax, %r15
leaq 0x8(%r12), %rsi
movq %rax, %rdi
movl %r13d, %edx
movq %r14, %rcx
callq 0x43048
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29992
movq 0x2d0(%rbx), %rdi
movq %r15, %rsi
callq 0x44218
pushq $0x40
popq %rdi
callq 0xf370
movq %rax, %r14
movl 0x3c(%r15), %esi
movq %rax, %rdi
callq 0x2ee60
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
cmpl $0xf, %eax
je 0x2c13d
cmpl $0x3, %eax
jne 0x2c154
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x430b2
jmp 0x2c15f
movq %r15, %rdi
movq %r12, %rsi
callq 0x43144
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
pushq $0x40
popq %rsi
movq %r14, %rdi
jmp 0x2c180
movq %rax, %r12
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0xf380
movq %r12, %rdi
callq 0xf6e0
movq %rax, %r12
cmpl $0x1, %edx
jne 0x2c185
movq %r12, %rdi
callq 0xf170
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x292f0
callq 0xf650
jmp 0x2c15f
movq %rax, %r12
callq 0xf650
jmp 0x2c185
movq %rax, %rdi
callq 0x1178d
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::selfDefine(OperandSymbol*)
void SleighCompile::selfDefine(OperandSymbol *sym)

{				// Define operand as global symbol of same name
  TripleSymbol *glob = dynamic_cast<TripleSymbol *>(symtab.findSymbol(sym->getName(),1));
  if (glob == (TripleSymbol *)0) {
    reportError(sym->getName()+": No matching global symbol",true);
    return;
  }
  SleighSymbol::symbol_type tp = glob->getType();
  try {
    if ((tp==SleighSymbol::value_symbol)||(tp==SleighSymbol::context_symbol)) {
      sym->defineOperand(glob->getPatternExpression());
    }
    else
      sym->defineOperand(glob);
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x198, %rdi            # imm = 0x198
leaq 0x8(%rsi), %r15
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x2ee88
testq %rax, %rax
je 0x2c23a
leaq 0x5ae99(%rip), %rsi     # 0x87090
leaq 0x5986a(%rip), %rdx     # 0x85a68
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xf3f0
testq %rax, %rax
je 0x2c23a
movq %rax, %r12
movq (%rax), %rax
movq %r12, %rdi
callq *0x10(%rax)
cmpl $0xf, %eax
je 0x2c223
cmpl $0x3, %eax
jne 0x2c275
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x430b2
jmp 0x2c269
leaq 0x2b3e5(%rip), %rdx     # 0x57626
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ebc0
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x292f0
leaq 0x8(%rsp), %rdi
callq 0xf1a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r12, %rsi
callq 0x43144
jmp 0x2c269
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xf1a0
movq %r14, %rdi
callq 0xf6e0
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2c28f
movq %r14, %rdi
callq 0xf170
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x292f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf650
movq %rax, %r14
callq 0xf650
jmp 0x2c28f
movq %rax, %rdi
callq 0x1178d
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::setResultVarnode(ConstructTpl*, VarnodeTpl*)
ConstructTpl *SleighCompile::setResultVarnode(ConstructTpl *ct,VarnodeTpl *vn)

{				// Set constructors handle to indicate given varnode
  HandleTpl *res = new HandleTpl(vn);
  delete vn;
  ct->setResult(res);
  return ct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movl $0xe0, %edi
callq 0xf370
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21ddc
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0xf380
movq %rbx, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xe0, %esi
movq %rbx, %rdi
callq 0xf380
movq %r14, %rdi
callq 0xf6e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::setResultStarVarnode(ConstructTpl*, StarQuality*, VarnodeTpl*)
ConstructTpl *SleighCompile::setResultStarVarnode(ConstructTpl *ct,StarQuality *star,VarnodeTpl *vn)

{				// Set constructors handle to be the value pointed
				// at by -vn-
  HandleTpl *res = new HandleTpl(star->id,ConstTpl(ConstTpl::real,star->size),vn,
				   getUniqueSpace(),getUniqueAddr());
  delete star;
  delete vn;
  ct->setResult(res);
  return ct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movl $0xe0, %edi
callq 0xf370
movq %rax, %r14
movl 0x20(%r12), %edx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x20de4
movq 0xc8(%r13), %r8
movl 0x124(%r13), %r9d
movl %r9d, %eax
shrl $0x4, %eax
cmpl $0xffffffe, %eax        # imm = 0xFFFFFFE
ja 0x2c387
leal 0x10(%r9), %eax
movl %eax, 0x124(%r13)
movq %rsp, %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x21e6c
pushq $0x28
popq %rsi
movq %r12, %rdi
callq 0xf380
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0xf380
movq %r14, 0x20(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xe0, %esi
movq %r14, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::contextMod(std::vector<ContextChange*, std::allocator<ContextChange*>>*, ContextSymbol*, PatternExpression*)
bool SleighCompile::contextMod(vector<ContextChange *> *vec,ContextSymbol *sym,PatternExpression *pe)

{ // A temporary change to a context variable (within the parsing of a single instruction)
  // Because we are in the middle of parsing, the "inst_next" value has not been computed yet
  // So we check to make sure the value expression doesn't use this symbol
  vector<const PatternValue *> vallist;
  pe->listValues(vallist);
  for(uint4 i=0;i<vallist.size();++i)
    if (dynamic_cast<const EndInstructionValue *>(vallist[i]) != (const EndInstructionValue *)0)
      return false;
  // Otherwise we generate a "temporary" change to context instruction  (ContextOp)
  ContextField *field = (ContextField *)sym->getPatternValue();
  ContextOp *op = new ContextOp(field->getStartBit(),field->getEndBit(),pe);
  vec->push_back(op);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq (%rcx), %rax
movq %rcx, %rdi
callq *0x20(%rax)
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rbp
subq %r15, %rbp
sarq $0x3, %rbp
xorl %ebx, %ebx
leaq 0x596ff(%rip), %r12     # 0x85b28
leaq 0x59710(%rip), %r13     # 0x85b40
movl %ebx, %ebx
cmpq %rbx, %rbp
jbe 0x2c456
movq (%r15,%rbx,8), %rdi
testq %rdi, %rdi
je 0x2c452
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xf3f0
testq %rax, %rax
jne 0x2c495
incl %ebx
jmp 0x2c430
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0xf370
movq %rax, %r15
movl 0xc(%r12), %esi
movl 0x10(%r12), %edx
movq %rax, %rdi
movq %r14, %rcx
callq 0x471f2
leaq 0x30(%rsp), %rsi
movq %r15, (%rsi)
movq (%rsp), %rdi
callq 0x2fd22
cmpq %rbx, %rbp
setbe %bl
leaq 0x10(%rsp), %rdi
callq 0x32162
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c4cc
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0xf380
jmp 0x2c4cf
jmp 0x2c4cc
jmp 0x2c4cc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x32162
movq %rbx, %rdi
callq 0xf6e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::contextSet(std::vector<ContextChange*, std::allocator<ContextChange*>>*, TripleSymbol*, ContextSymbol*)
void SleighCompile::contextSet(vector<ContextChange *> *vec,TripleSymbol *sym,
				ContextSymbol *cvar)

{ // A permanent (global) change to context.  During parsing of an instruction, this change
  // is put off until the full instruction has been parsed.  The existing value in the context
  // field is set permanently to that value starting at the address given by the address expression
  ContextField *field = (ContextField *)cvar->getPatternValue();
  ContextCommit *op = new ContextCommit(sym,field->getStartBit(),field->getEndBit(),cvar->getFlow());
  vec->push_back(op);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq (%rcx), %rax
movq %rcx, %rdi
callq *0x60(%rax)
movq %rax, %r13
pushq $0x20
popq %rdi
callq 0xf370
movq %rax, %r14
movl 0xc(%r13), %edx
movl 0x10(%r13), %ecx
movzbl 0x48(%r15), %r8d
movq %rax, %rdi
movq %r12, %rsi
callq 0x476e2
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x2fd22
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createMacro(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
MacroSymbol *SleighCompile::createMacro(string *name,vector<string> *params)

{				// create a macro symbol (with parameter names)
  curct = (Constructor *)0;	// Not currently defining a Constructor
  curmacro = new MacroSymbol(*name,macrotable.size());
  delete name;
  addSymbol(curmacro);
  symtab.addScope();		// New scope for the body of the macro definition
  pcode.resetLabelCount();	// Macros have their own labels
  for(int4 i=0;i<params->size();++i) {
    OperandSymbol *oper = new OperandSymbol((*params)[i],i,(Constructor *)0);
    addSymbol(oper);
    curmacro->addOperand(oper);
  }
  delete params;
  return curmacro;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x2d0(%rdi)
pushq $0x58
popq %rdi
callq 0xf370
movq %rax, %r12
movq 0x260(%rbx), %rdx
subq 0x258(%rbx), %rdx
shrq $0x3, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2eeae
movq %r12, 0x2d8(%rbx)
movq %r15, %rdi
callq 0xf1a0
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0xf380
movq 0x2d8(%rbx), %rsi
movq %rbx, %rdi
callq 0x29992
leaq 0x198(%rbx), %rdi
callq 0x403c4
andl $0x0, 0x200(%rbx)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rbp
movq 0x8(%r14), %rax
subq %rbp, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x2c636
pushq $0x60
popq %rdi
callq 0xf370
movq %rax, %r13
addq %r15, %rbp
movq %rax, %rdi
movq %rbp, %rsi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x43048
movq %rbx, %rdi
movq %r13, %rsi
callq 0x29992
movq 0x2d8(%rbx), %rdi
movq %r13, %rsi
callq 0x2eee4
incq %r12
addq $0x20, %r15
jmp 0x2c5e2
movq %r14, %rdi
callq 0x12d80
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0xf380
movq 0x2d8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
jmp 0x2c673
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r13, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::compareMacroParams(MacroSymbol*, std::vector<ExprTree*, std::allocator<ExprTree*>> const&)
void SleighCompile::compareMacroParams(MacroSymbol *sym,const vector<ExprTree *> &param)

{ // Match up any qualities of the macro's OperandSymbols with
  // any OperandSymbol passed into the macro
  for(uint4 i=0;i<param.size();++i) {
    VarnodeTpl *outvn = param[i]->getOut();
    if (outvn == (VarnodeTpl *)0) continue;
    // Check if an OperandSymbol was passed into this macro
    if (outvn->getOffset().getType() != ConstTpl::handle) continue;
    int4 hand = outvn->getOffset().getHandleIndex();

    // The matching operands
    OperandSymbol *macroop = sym->getOperand(i);
    OperandSymbol *parentop;
    if (curct == (Constructor *)0)
      parentop = curmacro->getOperand(hand);
    else
      parentop = curct->getOperand(hand);

    // This is the only property we check right now
    if (macroop->isCodeAddress())
      parentop->setCodeAddress();
  }
}

// Assembly:
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq 0x2d0(%rdi), %r8
movq 0x2d8(%rdi), %rdx
leaq 0x18(%r8), %rdi
addq $0x40, %rdx
testq %r8, %r8
cmovneq %rdi, %rdx
xorl %edi, %edi
movl %edi, %edi
cmpq %rdi, %rcx
jbe 0x2c6ee
movq (%rax,%rdi,8), %r8
movq 0x8(%r8), %r8
testq %r8, %r8
je 0x2c6ea
cmpl $0x1, 0x20(%r8)
jne 0x2c6ea
movslq %edi, %r9
movq 0x40(%rsi), %r10
movq (%r10,%r9,8), %r9
testb $0x1, 0x58(%r9)
je 0x2c6ea
movq (%rdx), %r9
movslq 0x28(%r8), %r8
movq (%r9,%r8,8), %r8
orl $0x1, 0x58(%r8)
incl %edi
jmp 0x2c6ad
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createMacroUse(MacroSymbol*, std::vector<ExprTree*, std::allocator<ExprTree*>>*)
vector<OpTpl *> *SleighCompile::createMacroUse(MacroSymbol *sym,vector<ExprTree *> *param)

{ // Create macro build directive, given symbol and parameters
  if (sym->getNumOperands() != param->size()) {
    string errmsg = "Invocation of macro \"" + sym->getName();
    if (param->size() > sym->getNumOperands())
      errmsg += "\" passes too many parameters";
    else
      errmsg += "\" passes too few parameters";
    reportError(errmsg,true);
    return new vector<OpTpl *>;
  }
  compareMacroParams(sym,*param);
  OpTpl *op = new OpTpl(MACROBUILD);
  VarnodeTpl *idvn = new VarnodeTpl(ConstTpl(getConstantSpace()),
				      ConstTpl(ConstTpl::real,sym->getIndex()),
				      ConstTpl(ConstTpl::real,4));
  op->addInput(idvn);
  return ExprTree::appendParams(op,param);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq 0x48(%rsi), %rax
subq 0x40(%rsi), %rax
movq %rdi, %r15
shrq $0x3, %rax
cltq
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x2c7c2
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2c680
pushq $0x28
popq %rdi
callq 0xf370
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl $0x40, 0x8(%rax)
andq $0x0, (%rax)
pushq $0x68
popq %rdi
callq 0xf370
movq %rax, %r14
movq 0x98(%r15), %rsi
movq %rsp, %rdi
callq 0x20e14
movslq 0x30(%r12), %rdx
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x20de4
leaq 0x20(%rsp), %rdi
pushq $0x4
popq %rdx
xorl %esi, %esi
callq 0x20de4
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
callq 0x21aea
movq %r13, %rdi
movq %r14, %rsi
callq 0x1deb2
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1bec4
movq %rax, %rbx
jmp 0x2c83e
leaq 0x8(%r12), %rdx
leaq 0x2ae74(%rip), %rsi     # 0x57642
movq %rsp, %r14
movq %r14, %rdi
callq 0x10cd1
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movq 0x48(%r12), %rcx
subq 0x40(%r12), %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
leaq 0x2ae59(%rip), %rax     # 0x57658
leaq 0x2ae6f(%rip), %rsi     # 0x57675
cmovaq %rax, %rsi
movq %r14, %rdi
callq 0xf730
movq %rsp, %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x292f0
pushq $0x18
popq %rdi
callq 0xf370
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rsp, %rdi
callq 0xf1a0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2c853
jmp 0x2c853
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0xf380
jmp 0x2c86e
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf1a0
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::nextNamedSection(SectionVector*, ConstructTpl*, SectionSymbol*)
SectionVector *SleighCompile::nextNamedSection(SectionVector *vec,ConstructTpl *section,SectionSymbol *sym)

{ // Add additional named p-code sections
  sym->incrementDefineCount();
  symtab.popScope();		// Pop the scope of the last named section
  SymbolScope *curscope = symtab.getCurrentScope(); // This should now be the Constructor scope
  SymbolScope *parscope = curscope->getParent();
  if (parscope != symtab.getGlobalScope())
    throw LowlevelError("nextNamedSection called when not in section scope"); // Unrecoverable
  symtab.addScope();		// Add new scope under the Constructor scope (not the last section scope)
  vec->append(section,curscope); // Associate finished section
  vec->setNextIndex(sym->getTemplateId()); // Set index for the NEXT section (not been fully parsed yet)
  return vec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
incl 0x34(%rcx)
leaq 0x198(%rdi), %r12
movq %r12, %rdi
callq 0x40412
movq 0x1b0(%r13), %rax
movq 0x1c8(%r13), %r13
movq (%r13), %rcx
cmpq (%rax), %rcx
jne 0x2c9f1
movq %r12, %rdi
callq 0x403c4
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x268a8
movl 0x30(%r14), %eax
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0xf1d0
movq %rax, %rbx
leaq 0x2acc5(%rip), %rsi     # 0x576c8
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x10c3a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10d48
xorl %ebp, %ebp
leaq 0x57005(%rip), %rsi     # 0x83a30
leaq -0x1bcb2(%rip), %rdx    # 0x10d80
movq %rbx, %rdi
callq 0xf690
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xf1a0
testb %bpl, %bpl
jne 0x2ca51
jmp 0x2ca59
movq %rax, %r14
movq %rbx, %rdi
callq 0xf2a0
movq %r14, %rdi
callq 0xf6e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::finalNamedSection(SectionVector*, ConstructTpl*)
SectionVector *SleighCompile::finalNamedSection(SectionVector *vec,ConstructTpl *section)

{ // Fill-in final named section to match the previous SectionSymbol
  vec->append(section,symtab.getCurrentScope());
  symtab.popScope();		// Pop the section scope
  return vec;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c8(%rdi), %rax
addq $0x198, %r14            # imm = 0x198
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x268a8
movq %r14, %rdi
callq 0x40412
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createCrossBuild(VarnodeTpl*, SectionSymbol*)
vector<OpTpl *> *SleighCompile::createCrossBuild(VarnodeTpl *addr,SectionSymbol *sym)

{ // Create the crossbuild directive as a pcode template
  unique_allocatemask = 1;
  vector<OpTpl *> *res = new vector<OpTpl *>();
  VarnodeTpl *sectionid = new VarnodeTpl(ConstTpl(getConstantSpace()),
                                         ConstTpl(ConstTpl::real,sym->getTemplateId()),
                                         ConstTpl(ConstTpl::real,4));
  // This is simply a single pcodeop (template), where the opcode indicates the crossbuild directive
  OpTpl *op = new OpTpl( CROSSBUILD );
  op->addInput(addr);		// The first input is the VarnodeTpl representing the address
  op->addInput(sectionid);	// The second input is the indexed representing the named pcode section to build
  res->push_back(op);
  sym->incrementRefCount();	// Keep track of the references to the section symbol
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movl $0x1, 0x1d4(%rdi)
pushq $0x18
popq %rdi
callq 0xf370
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x68
popq %rdi
callq 0xf370
movq %rax, %r14
movq 0x98(%r13), %rsi
leaq 0x8(%rsp), %rdi
callq 0x20e14
movslq 0x30(%rbx), %rdx
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x20de4
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %rdx
xorl %esi, %esi
callq 0x20de4
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
callq 0x21aea
pushq $0x28
popq %rdi
callq 0xf370
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl $0x42, 0x8(%rax)
andq $0x0, (%rax)
leaq 0x8(%rsp), %rbp
movq %rax, (%rbp)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1deb2
movq %r13, %rdi
movq %r14, %rsi
callq 0x1deb2
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1de74
incl 0x38(%rbx)
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cb8a
jmp 0x2cb8a
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createConstructor(SubtableSymbol*)
Constructor *SleighCompile::createConstructor(SubtableSymbol *sym)

{
  if (sym == (SubtableSymbol *)0)
    sym = WithBlock::getCurrentSubtable(withstack);
  if (sym == (SubtableSymbol *)0)
    sym = root;
  curmacro = (MacroSymbol *)0;	// Not currently defining a macro
  curct = new Constructor(sym);
  curct->setLineno(lineno.back());
  sym->addConstructor(curct);
  symtab.addScope();		// Make a new symbol scope for our constructor
  pcode.resetLabelCount();
  return curct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x2cbbf
leaq 0x2b8(%rbx), %rdi
callq 0x26c2c
movq %rax, %r14
testq %r14, %r14
jne 0x2cbcb
movq 0x190(%rbx), %r14
andq $0x0, 0x2d8(%rbx)
movl $0x98, %edi
callq 0xf370
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x440f2
movq %r15, 0x2d0(%rbx)
movq 0x320(%rbx), %rax
movl -0x4(%rax), %eax
movl %eax, 0x90(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2eefa
leaq 0x198(%rbx), %rdi
callq 0x403c4
andl $0x0, 0x200(%rbx)
movq 0x2d0(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x98, %esi
movq %r15, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::expandMacros(ConstructTpl*, std::vector<ConstructTpl*, std::allocator<ConstructTpl*>> const&)
bool SleighCompile::expandMacros(ConstructTpl *ctpl,const vector<ConstructTpl *> &macrotable)

{
  vector<OpTpl *> newvec;
  vector<OpTpl *>::const_iterator iter;
  OpTpl *op;
  
  for(iter=ctpl->getOpvec().begin();iter!=ctpl->getOpvec().end();++iter) {
    op = *iter;
    if (op->getOpcode() == MACROBUILD) {
      MacroBuilder builder(this,newvec,ctpl->numLabels());
      int4 index = op->getIn(0)->getOffset().getReal();
      if (index >= macrotable.size())
	return false;
      builder.setMacroOp(op);
      ConstructTpl *macro_tpl = macrotable[index];
      builder.build(macro_tpl,-1);
      ctpl->setNumLabels( ctpl->numLabels() + macro_tpl->numLabels() );
      delete op;		// Throw away the place holder op
      if (builder.hasError())
	return false;
    }
    else
      newvec.push_back(op);
  }
  ctpl->setOpvec(newvec);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbp
movq %rdi, 0x28(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
leaq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsi), %r15
leaq 0x50(%rsp), %r14
movq %rsi, 0x8(%rsp)
movq 0x10(%rbp), %r13
cmpq %r13, %r15
je 0x2cda5
movq (%r15), %rsi
movq %rsi, 0x18(%rsp)
cmpl $0x40, 0x8(%rsi)
jne 0x2cd8f
movl 0x4(%rbp), %eax
movl %eax, 0x5c(%rsp)
movl %eax, 0x58(%rsp)
leaq 0x58e97(%rip), %rax     # 0x85b68
movq %rax, 0x50(%rsp)
movq %r12, %rbp
movq %r12, 0x78(%rsp)
leaq 0x80(%rsp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
movb $0x0, 0x70(%rsp)
movq 0x10(%rsi), %rax
movq (%rax), %rax
movslq 0x30(%rax), %r12
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
cmpq %rax, %r12
jae 0x2cdb6
movq %r14, %rbx
movq %r14, %rdi
callq 0x293ce
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r12,8), %r12
movq %rbx, %rdi
movq %r12, %rsi
pushq $-0x1
popq %rdx
callq 0x22c0a
movl 0x4(%r12), %eax
movq 0x8(%rsp), %rcx
addl %eax, 0x4(%rcx)
movq 0x18(%rsp), %r12
testq %r12, %r12
je 0x2cd68
movq %r12, %rdi
callq 0x221fa
movq %r12, %rdi
pushq $0x28
popq %rsi
callq 0xf380
movb 0x70(%rsp), %r12b
movq %r14, %rdi
callq 0x2ef24
testb %r12b, %r12b
movq %rbp, %r12
movq 0x8(%rsp), %rbp
je 0x2cd9c
jmp 0x2cdc0
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
callq 0x1de74
addq $0x8, %r15
jmp 0x2cca0
leaq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x1dede
jmp 0x2cdc0
leaq 0x50(%rsp), %rdi
callq 0x2ef24
cmpq %r13, %r15
sete %bl
leaq 0x30(%rsp), %rdi
callq 0x1e25a
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cdf7
jmp 0x2cde8
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2ef24
jmp 0x2cdfa
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1e25a
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueVn(VarnodeTpl*, int)
void SleighCompile::shiftUniqueVn(VarnodeTpl *vn,int4 sa)

{ // If the varnode is in the unique space, shift its offset up by -sa- bits
  if (vn->getSpace().isUniqueSpace() && (vn->getOffset().getType() == ConstTpl::real)) {
    uintb val = vn->getOffset().getReal();
    val <<= sa;
    vn->setOffset(val);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x20e34
testb %al, %al
je 0x2d443
cmpl $0x0, 0x20(%rbx)
je 0x2d44a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x30(%rbx), %rsi
movl %ebp, %ecx
shlq %cl, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2eb10
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueOp(OpTpl*, int)
void SleighCompile::shiftUniqueOp(OpTpl *op,int4 sa)

{ // Shift the offset up by -sa- bits for any varnode used by this -op- in the unique space
  VarnodeTpl *outvn = op->getOut();
  if (outvn != (VarnodeTpl *)0)
    shiftUniqueVn(outvn,sa);
  for(int4 i=0;i<op->numInput();++i)
    shiftUniqueVn(op->getIn(i),sa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2d47b
movl %ebx, %esi
callq 0x2d42c
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0x2d4a5
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x2d42c
incq %r15
jmp 0x2d47e
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueHandle(HandleTpl*, int)
void SleighCompile::shiftUniqueHandle(HandleTpl *hand,int4 sa)

{ // Shift the offset up by -sa- bits, for either the dynamic or static varnode aspects that are in the unique space
  if (hand->getSpace().isUniqueSpace() && (hand->getPtrSpace().getType() == ConstTpl::real)
      && (hand->getPtrOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getPtrOffset().getReal();
    val <<= sa;
    hand->setPtrOffset(val);
  }
  else if (hand->getPtrSpace().isUniqueSpace() && (hand->getPtrOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getPtrOffset().getReal();
    val <<= sa;
    hand->setPtrOffset(val);
  }
  
  if (hand->getTempSpace().isUniqueSpace() && (hand->getTempOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getTempOffset().getReal();
    val <<= sa;
    hand->setTempOffset(val);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x20e34
testb %al, %al
je 0x2d4c9
cmpl $0x0, 0x40(%rbx)
jne 0x2d4c9
cmpl $0x0, 0x60(%rbx)
je 0x2d4dc
leaq 0x40(%rbx), %rdi
callq 0x20e34
testb %al, %al
je 0x2d4ed
cmpl $0x0, 0x60(%rbx)
jne 0x2d4ed
movq 0x70(%rbx), %rsi
movl %ebp, %ecx
shlq %cl, %rsi
movq %rbx, %rdi
callq 0x2ef44
leaq 0xa0(%rbx), %rdi
callq 0x20e34
testb %al, %al
je 0x2d506
cmpl $0x0, 0xc0(%rbx)
je 0x2d50d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xd0(%rbx), %rsi
movl %ebp, %ecx
shlq %cl, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2ef7a
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueConstruct(ConstructTpl*, int)
void SleighCompile::shiftUniqueConstruct(ConstructTpl *tpl,int4 sa)

{ // Shift the offset up by -sa- bits, for any varnode in the unique space associated with this template
  HandleTpl *result = tpl->getResult();
  if (result != (HandleTpl *)0)
    shiftUniqueHandle(result,sa);
  const vector<OpTpl *> &vec( tpl->getOpvec() );
  for(int4 i=0;i<vec.size();++i)
    shiftUniqueOp(vec[i],sa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x2d542
movl %ebx, %esi
callq 0x2d4ac
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x2d569
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x2d462
incq %r15
jmp 0x2d545
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::buildConstructor(Constructor*, PatternEquation*, std::vector<ContextChange*, std::allocator<ContextChange*>>*, SectionVector*)
void SleighCompile::buildConstructor(Constructor *big,PatternEquation *pateq,vector<ContextChange *> *contvec,SectionVector *vec)

{ // Take all the different parse pieces for a Constructor and build the Constructor object
  bool noerrors = true;
  if (vec != (SectionVector *)0) { // If the sections were implemented
    noerrors = finalizeSections(big,vec);
    if (noerrors) {		// Attach the sections to the Constructor
      big->setMainSection(vec->getMainSection());
      int4 max = vec->getMaxId();
      for(int4 i=0;i<max;++i) {
	ConstructTpl *section = vec->getNamedSection(i);
	if (section != (ConstructTpl *)0)
	  big->setNamedSection(section,i);
      }
    }
    delete vec;
  }
  if (noerrors) {
    pateq = WithBlock::collectAndPrependPattern(withstack, pateq);
    contvec = WithBlock::collectAndPrependContext(withstack, contvec);
    big->addEquation(pateq);
    big->removeTrailingSpace();
    if (contvec != (vector<ContextChange *> *)0) {
      big->addContext(*contvec);
      delete contvec;
    }
  }
  symtab.popScope();		// In all cases pop scope
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
testq %r8, %r8
je 0x2d6b5
movq %r8, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r8, %rdx
callq 0x2ce0c
testb %al, %al
je 0x2d682
movq %rbp, (%rsp)
movq %r13, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x60(%r14)
leaq 0x18(%r12), %rbp
movq 0x20(%r12), %r13
subq 0x18(%r12), %r13
shrq $0x4, %r13
xorl %ebx, %ebx
testl %r13d, %r13d
cmovlel %ebx, %r13d
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x2d694
movq (%rbp), %rax
movq (%rax,%rbx), %rsi
testq %rsi, %rsi
je 0x2d679
movq %r14, %rdi
movl %r15d, %edx
callq 0x443e2
incq %r15
addq $0x10, %rbx
jmp 0x2d65c
leaq 0x18(%r12), %rdi
callq 0x2f874
pushq $0x30
popq %rsi
movq %r12, %rdi
jmp 0x2d70d
movq %rbp, %rdi
callq 0x2f874
pushq $0x30
popq %rsi
movq %r12, %rdi
callq 0xf380
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r13
movq (%rsp), %rbp
leaq 0x2b8(%rbx), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x26abe
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
callq 0x26b2e
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x443da
movq %r14, %rdi
callq 0x4462e
testq %r15, %r15
je 0x2d712
addq $0x48, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f8a8
movq %r15, %rdi
callq 0x2fa7c
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0xf380
addq $0x198, %rbx            # imm = 0x198
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40412
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::buildMacro(MacroSymbol*, ConstructTpl*)
void SleighCompile::buildMacro(MacroSymbol *sym,ConstructTpl *rtl)

{
  string errstring = checkSymbols(symtab.getCurrentScope());
  if (errstring.size() != 0) {
    reportError(" in definition of macro "+sym->getName(),false);
    cerr << errstring;
    return;
  }
  if (!expandMacros(rtl,macrotable)) {
    reportError("Could not expand submacro in definition of macro "+sym->getName(),true);
    return;
  }
  PcodeCompile::propagateSize(rtl); // Propagate size information (as much as possible)
  sym->setConstruct(rtl);
  symtab.popScope();		// Pop local variables used to define macro
  macrotable.push_back(rtl);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq 0x1c8(%rdi), %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x2a9f4
cmpq $0x0, 0x8(%r12)
je 0x2d7a3
addq $0x8, %r14
leaq 0x2a069(%rip), %rsi     # 0x577d9
movq %rsp, %rdi
movq %r14, %rdx
callq 0x10cd1
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x292f0
movq %rsp, %rdi
callq 0xf1a0
movq 0x5a859(%rip), %rdi     # 0x87ff0
leaq 0x28(%rsp), %rsi
callq 0xf320
jmp 0x2d812
leaq 0x258(%rbx), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2cc58
testb %al, %al
je 0x2d7e6
movq %r15, %rdi
callq 0x1c61e
addq $0x198, %rbx            # imm = 0x198
movq %r15, 0x38(%r14)
movq %rbx, %rdi
callq 0x40412
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x2efcc
jmp 0x2d812
addq $0x8, %r14
leaq 0x29fcf(%rip), %rsi     # 0x577c0
movq %rsp, %rdi
movq %r14, %rdx
callq 0x10cd1
movq %rsp, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x292f0
movq %rsp, %rdi
callq 0xf1a0
leaq 0x28(%rsp), %rdi
callq 0xf1a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2d82c
jmp 0x2d83b
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf1a0
jmp 0x2d83e
jmp 0x2d83b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf1a0
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: findSlaSpecs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void findSlaSpecs(vector<string> &res, const string &dir, const string &suffix)

{
  FileManage::matchListDir(res, suffix, true, dir, false);
  
  vector<string> dirs;
  FileManage::directoryList(dirs, dir);
  vector<string>::const_iterator iter;
  for(iter = dirs.begin();iter!=dirs.end();++iter) {
    const string &nextdir( *iter );
    findSlaSpecs(res, nextdir,suffix);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rdx
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x13b88
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %r15, %rsi
xorl %edx, %edx
callq 0x13d56
movq (%rsp), %r15
cmpq 0x8(%rsp), %r15
je 0x2e629
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2e5cf
addq $0x20, %r15
jmp 0x2e60e
movq %rsp, %rdi
callq 0x12d80
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2e63d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x12d80
movq %rbx, %rdi
callq 0xf6e0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: initCompiler(SleighCompile&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, bool, bool, bool, bool, bool, bool)
static void initCompiler(SleighCompile &compiler, map<string,string> &defines, bool enableUnnecessaryPcodeWarning,
			 bool disableLenientConflict, bool enableAllCollisionWarning,
			 bool enableAllNopWarning,bool enableDeadTempWarning,bool enforceLocalKeyWord)

{
  map<string,string>::iterator iter = defines.begin();
  for (iter = defines.begin(); iter != defines.end(); iter++) {
    compiler.setPreprocValue((*iter).first, (*iter).second);
  }
  if (enableUnnecessaryPcodeWarning)
    compiler.setUnnecessaryPcodeWarning(true);
  if (disableLenientConflict)
    compiler.setLenientConflict(false);
  if (enableAllCollisionWarning)
    compiler.setLocalCollisionWarning( true );
  if (enableAllNopWarning)
    compiler.setAllNopWarning( true );
  if (enableDeadTempWarning)
    compiler.setDeadTempWarning(true);
  if (enforceLocalKeyWord)
    compiler.setEnforceLocalKeyWord(true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movq 0x18(%rsi), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0x2e699
leaq 0x20(%rbp), %rsi
leaq 0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x2b0aa
movq %rbp, %rdi
callq 0xf280
movq %rax, %rbp
jmp 0x2e677
testb %r12b, %r12b
je 0x2e6a5
movb $0x1, 0x334(%rbx)
testb %r15b, %r15b
je 0x2e6b1
movb $0x0, 0x336(%rbx)
testb %r14b, %r14b
je 0x2e6bd
movb $0x1, 0x337(%rbx)
cmpb $0x0, 0x4(%rsp)
je 0x2e6cb
movb $0x1, 0x338(%rbx)
cmpb $0x0, 0x40(%rsp)
je 0x2e6d9
movb $0x1, 0x335(%rbx)
cmpb $0x0, 0x48(%rsp)
je 0x2e6e7
movb $0x1, 0x204(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: find_size(ConstTpl const&, ConstructTpl const*)
static VarnodeTpl *find_size(const ConstTpl &offset,const ConstructTpl *ct)

{				// Find a defining instance of the local variable
				// with given -offset-
  const vector<OpTpl *> &ops(ct->getOpvec());
  VarnodeTpl *vn;
  OpTpl *op;
  
  for(int4 i=0;i<ops.size();++i) {
    op = ops[i];
    vn = op->getOut();
    if ((vn!=(VarnodeTpl *)0)&&(vn->isLocalTemp())) {
      if (vn->getOffset() == offset)
	return vn;
    }
    for(int4 j=0;j<op->numInput();++j) {
      vn = op->getIn(j);
      if (vn->isLocalTemp()&&(vn->getOffset()==offset))
	return vn;
    }
  }
  return (VarnodeTpl *)0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x2e9f2
movq (%rax,%r12,8), %r13
movq (%r13), %r15
testq %r15, %r15
je 0x2e9af
movq %r15, %rdi
callq 0x21b9a
testb %al, %al
je 0x2e9af
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x20e48
testb %al, %al
jne 0x2e9f5
xorl %ebp, %ebp
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jge 0x2e9ed
movq (%rax,%rbp,8), %r15
movq %r15, %rdi
callq 0x21b9a
testb %al, %al
je 0x2e9e8
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x20e48
testb %al, %al
jne 0x2e9f5
incq %rbp
jmp 0x2e9b1
incq %r12
jmp 0x2e972
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop