static void emit_ident(struct q *q, const struct node *node)
{
    emit_byte(q, OP_PUSH);
    emit_byte(q, TYPE_STR);
    emit(q, &node->vec.len, sizeof(node->vec.len));
    emit(q, node->vec.ptr, node->vec.len);
}

void MacroAssembler::get_thread(Register thread) {

  int segment = NOT_LP64(Assembler::GS_segment) LP64_ONLY(Assembler::FS_segment);
  // Try to emit a Solaris-specific fast TSD/TLS accessor.
  ThreadLocalStorage::pd_tlsAccessMode tlsMode = ThreadLocalStorage::pd_getTlsAccessMode ();
  if (tlsMode == ThreadLocalStorage::pd_tlsAccessIndirect) {            // T1
     // Use thread as a temporary: mov r, gs:[0]; mov r, [r+tlsOffset]
     emit_byte (segment);
     // ExternalAddress doesn't work because it can't take NULL
     AddressLiteral null(0, relocInfo::none);
     movptr (thread, null);
     movptr(thread, Address(thread, ThreadLocalStorage::pd_getTlsOffset())) ;
     return ;
  } else
  if (tlsMode == ThreadLocalStorage::pd_tlsAccessDirect) {              // T2
     // mov r, gs:[tlsOffset]
     emit_byte (segment);
     AddressLiteral tls_off((address)ThreadLocalStorage::pd_getTlsOffset(), relocInfo::none);
     movptr (thread, tls_off);
     return ;
  }

  slow_call_thr_specific(this, thread);

}

static void emit_string_constant(struct q *q, const struct node *node)
{
    char			*dst, *src;
    str_size_t		n = 0;

    /* XXX Must go first, cause expand_code may change q->code pointer */
    if (q->code + q->cc + 2 + sizeof(n) + node->vec.len > q->code + q->cs)
        expand_code(q, node->vec.len + 2 + sizeof(n) + 1);

    dst = q->code + q->cc + 2 + sizeof(n);
    src = node->vec.ptr + 1;

    assert(node->vec.ptr[0] == '"');
    assert(node->vec.ptr[node->vec.len - 1] == '"');
    assert(dst + node->vec.len < q->code + q->cs);

    for (; src < node->vec.ptr + node->vec.len - 1; src++, n++)
        if (*src == '%') {
            dst[n] = hex_ascii_to_int(q,src[1],node->line_no) << 4;
            dst[n] |= hex_ascii_to_int(q, src[2], node->line_no);
            src += 2;
        } else {
            dst[n] = *src;
        }

    emit_byte(q, OP_PUSH);
    emit_byte(q, TYPE_STR);
    emit(q, &n, sizeof(n));
    q->cc += n;
}

static void parse_type_assignment()
{
	int local_id = compiler.num_locals++;
	Local *local = &(compiler.locals[local_id]);
	local->name = parser.previous.start;
	local->length = parser.previous.length;

	// Consume the :
	advance();
	consume(TOKEN_IDENTIFIER, "Expected type");

    // Get the identifier
    Type *type = find_type(&parser.previous);
    if (!type)
    {
        error_at(&parser.previous, "Unknown type");
        return;

    }
	// Ignore type for now, otherwise it's not stored in prev

	// Consume the assignment
	consume(TOKEN_ASSIGN, "Expected =");

	advance();
	if (parser.current.type == TOKEN_NO_INIT)
	{
		// No init!
		return;
	}
	expression_after_advance();
    // Conversion here!
	emit_byte(OP_ASSIGN);
	emit_byte((uint8_t)local_id);
}

LOCAL void
emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark)
/* Emit a marker code */
{
  emit_byte(cinfo, 0xFF);
  emit_byte(cinfo, (int) mark);
}

void sbitmap_bitmap_show(struct sbitmap *sb, struct seq_file *m)
{
	u8 byte = 0;
	unsigned int byte_bits = 0;
	unsigned int offset = 0;
	int i;

	for (i = 0; i < sb->map_nr; i++) {
		unsigned long word = READ_ONCE(sb->map[i].word);
		unsigned int word_bits = READ_ONCE(sb->map[i].depth);

		while (word_bits > 0) {
			unsigned int bits = min(8 - byte_bits, word_bits);

			byte |= (word & (BIT(bits) - 1)) << byte_bits;
			byte_bits += bits;
			if (byte_bits == 8) {
				emit_byte(m, offset, byte);
				byte = 0;
				byte_bits = 0;
				offset++;
			}
			word >>= bits;
			word_bits -= bits;
		}
	}
	if (byte_bits) {
		emit_byte(m, offset, byte);
		offset++;
	}
	if (offset)
		seq_putc(m, '\n');
}

static void and()
{
	// Skip the right argument if the left is true.
	emit_byte(OP_AND);
	int jump = current_chunk()->size;
	emit_byte(0xFF);
	parse_precedence(PREC_AND);
	current_chunk()->code[jump] = (uint8_t)(current_chunk()->size - jump - 1);
}

static void emit_modrm_base_offset(int r, int basex86reg, int offset) {
    if (offset == 0) {
        emit_byte(basex86reg | r << 3);
    } else if (offset >= -0x80 && offset < 0x80) {
        emit_byte(0x40 | basex86reg | r << 3);
        emit_byte(offset);
    } else {
        emit_byte(0x80 | basex86reg | r << 3);
        emit_dword(offset);
    }
}

LOCAL void
emit_marker (compress_info_ptr cinfo, JPEG_MARKER mark)
#endif	/* XIE_SUPPORTED */
/* Emit a marker code */
{
  emit_byte(cinfo, 0xFF);
  emit_byte(cinfo, mark);
#ifdef XIE_SUPPORTED
  return(0);
#endif	/* XIE_SUPPORTED */
}

static void emit_alu_armreg_immediate(int aluop, int armreg, int imm) {
    if (imm >= -0x80 && imm < 0x80) {
        emit_byte(0x83);
        emit_modrm_armreg(aluop, armreg);
        emit_byte(imm);
    } else {
        emit_byte(0x81);
        emit_modrm_armreg(aluop, armreg);
        emit_dword(imm);
    }
}

static void emit_alu_x86reg_immediate(int aluop, int x86reg, int imm) {
    if (imm >= -0x80 && imm < 0x80) {
        emit_byte(0x83);
        emit_modrm_x86reg(aluop, x86reg);
        emit_byte(imm);
    } else if (x86reg == EAX) {
        emit_byte(0x05 | aluop << 3);
        emit_dword(imm);
    } else {
        emit_byte(0x81);
        emit_modrm_x86reg(aluop, x86reg);
        emit_dword(imm);
    }
}

static void emit_shift_armreg(int shiftop, int armreg, int count) {
    if (count == SHIFT_BY_CL) {
        emit_byte(0xD3);
        emit_modrm_armreg(shiftop, armreg);
    } else if (count == 0) {
        /* no-op */
    } else if (count == 1) {
        emit_byte(0xD1);
        emit_modrm_armreg(shiftop, armreg);
    } else {
        emit_byte(0xC1);
        emit_modrm_armreg(shiftop, armreg);
        emit_byte(count);
    }
}

int Plotter::filltype(int level)
{
	emit_byte((int) O_FILLTYPE);
	emit_integer(level);
	emit_terminator();
	return 0;
}

void emit_dword(int i)
{
	emit_byte(i&0xff);
	emit_byte((i>>8)&0xff);
	emit_byte((i>>16)&0xff);
	emit_byte((i>>24)&0xff);
}

static void parse_auto_assignment()
{
	int local_id = compiler.num_locals++;
	Local *local = &(compiler.locals[local_id]);
	local->name = parser.previous.start;
	local->length = parser.previous.length;

	// Consume the :=
	advance();

	// Handle the expression
	expression();
	// Type needed to be deducted here...
	emit_byte(OP_ASSIGN);
	emit_byte((uint8_t)local_id);
}

static inline void emit_jump(uintptr_t target) {
    emit_byte(0xE9);
    int64_t diff = target - ((uintptr_t) out + 4);
    if(diff > INT32_MAX || diff < INT32_MIN)
        assert(false);

    emit_dword(diff);
}

/*This is a hack:
 * -regs not saved
 * -stack not aligned */
static inline void emit_call_nosave(uintptr_t target) {
    emit_byte(0xE8);
    int64_t diff = target - ((uintptr_t) out + 4);
    if(diff > INT32_MAX || diff < INT32_MIN)
        assert(false); //Distance doesn't fit into immediate

    emit_dword(diff);
}

static void emit_hash_definition(struct q *q, const struct node *node, int idx)
{
    if (node == NULL) {
        die(q, "%s: line %d: bad hash def", serr, node->line_no);
    } else if (node->tok == ',') {
        emit_hash_definition(q, node->left, idx);
        emit_byte(q, OP_POP);
        emit_hash_definition(q, node->right, idx + 1);
    } else if (node->tok == '=') {
        if (node->left->tok == TOK_IDENT) {
            emit_expr(q, node->right);
            emit_byte(q, OP_DUP);
            emit_byte(q, 1);
            emit_ident(q, node->left);
            emit_byte(q, OP_SET);
        } else {
            die(q, "%s: line %d: bad hash def", serr,node->line_no);
        }
    } else {
        /* Key is the index of the entry in the definition */
        emit_expr(q, node);
        emit_byte(q, OP_DUP);
        emit_byte(q, 1);
        emit_num(q, idx);
        emit_byte(q, OP_SET);
    }
}

static void literal()
{
	switch (parser.previous.type)
	{
		case TOKEN_TRUE:
			emit_byte(OP_TRUE);
			break;
		case TOKEN_FALSE:
			emit_byte(OP_FALSE);
			break;
		case TOKEN_NIL:
			emit_byte(OP_NIL);
			break;
		default:
			assert(false && "Can't reach this!");
			return;
	}
}

static void emit_function_call(struct q *q, const struct node *node)
{
    int	num_params;

    num_params = emit_params(q, node->right, 0);
    emit_num(q, num_params);
    emit_expr(q, node->left);
    emit_byte(q, OP_CALL);
}