/* Useful for printing annotations as comments.  Expects that
 * the annotation is a BrickAnnote. */
  void
Printer::print_annote(Annote *annote)
{
  start_comment();

  IdString name = annote->get_name();

  if (name != k_comment)
    fprintf(out, "[%s", name.chars());

  if (is_kind_of<BrickAnnote>(annote)) {
    BrickAnnote *an = (BrickAnnote *)(annote);
    char *separator = ": ";

    for (Iter<SuifBrick*> iter = an->get_brick_iterator();
        iter.is_valid(); iter.next())
    {
      fputs(separator, out);
      separator = ", ";

      SuifBrick *brick = iter.current();
      if (is_a<IntegerBrick>(brick)) {
        Integer i = ((IntegerBrick*)iter.current())->get_value();
        if (i.is_c_string_int())
          fputs(i.chars(), out);
        else
          fprintf(out, "%ld", i.c_long());
      }
      else if (is_a<StringBrick>(brick)) {
        putc('"', out);
        for (const char *p =
            ((StringBrick*)iter.current())->get_value().c_str();
            *p != '\0'; ++p)
        {
          if (*p == '"' || *p == '\\')
            putc('\\', out);
          putc(*p, out);
        }
        putc('"', out);
      }
      else {
        claim(is_a<SuifObjectBrick>(brick));
        SuifObject *so = ((SuifObjectBrick*)brick)->get_object();
        if (is_kind_of<Type>(so))
          fprint(out, (TypeId)so);
        else {
          const char *kind = so ? get_class_name(so) : "NULL";
          fprintf(out, "<<<%s object>>>", kind);
        }
      }
    }
  } else {
    claim(is_kind_of<GeneralAnnote>(annote), "Unexpected kind of Annote");
  }
  if (name != k_comment)
    fputs("]", out);
  fputs("\n", out);
}

void boot(int a1, int a2, void *prom)
{
    unsigned sa, len;
    void *dst;
    unsigned char *im;
    unsigned initrd_start, initrd_size;

    printf("coffboot starting: loaded at 0x%p\n", &_start);
    setup_bats(ram_start);

    initrd_size = (char *)(&__ramdisk_end) - (char *)(&__ramdisk_begin);
    if (initrd_size) {
	initrd_start = (ram_end - initrd_size) & ~0xFFF;
	a1 = initrd_start;
	a2 = initrd_size;
	claim(initrd_start, ram_end - initrd_start, 0);
	printf("initial ramdisk moving 0x%x <- 0x%p (%x bytes)\n\r",
	       initrd_start, (char *)(&__ramdisk_begin), initrd_size);
	memcpy((char *)initrd_start, (char *)(&__ramdisk_begin), initrd_size);
	prog_size = initrd_start - prog_start;
    } else
	a2 = 0xdeadbeef;

    im = (char *)(&__image_begin);
    len = (char *)(&__image_end) - (char *)(&__image_begin);
    /* claim 4MB starting at PROG_START */
    claim(prog_start, prog_size, 0);
    map(prog_start, prog_start, prog_size);
    dst = (void *) prog_start;
    if (im[0] == 0x1f && im[1] == 0x8b) {
	/* set up scratch space */
	begin_avail = avail_high = avail_ram = heap;
	end_avail = heap + sizeof(heap);
	printf("heap at 0x%p\n", avail_ram);
	printf("gunzipping (0x%p <- 0x%p:0x%p)...", dst, im, im+len);
	gunzip(dst, prog_size, im, &len);
	printf("done %u bytes\n", len);
	printf("%u bytes of heap consumed, max in use %u\n",
	       avail_high - begin_avail, heap_max);
    } else {
	memmove(dst, im, len);
    }

    flush_cache(dst, len);
    make_bi_recs(((unsigned long) dst + len), "coffboot", _MACH_Pmac,
		    (prog_start + prog_size));

    sa = (unsigned long)prog_start;
    printf("start address = 0x%x\n", sa);

    (*(kernel_start_t)sa)(a1, a2, prom);

    printf("returned?\n");

    pause();
}

void
chrpboot(int a1, int a2, void *prom)
{
    unsigned sa, len;
    void *dst;
    unsigned char *im;
    unsigned int initrd_size, initrd_start;
    
    printf("chrpboot starting: loaded at 0x%p\n\r", &_start);

    initrd_size = (char *)(&__ramdisk_end) - (char *)(&__ramdisk_begin);
    if (initrd_size) {
	initrd_start = (RAM_END - initrd_size) & ~0xFFF;
	a1 = initrd_start;
	a2 = initrd_size;
	claim(initrd_start, RAM_END - initrd_start, 0);
	printf("initial ramdisk moving 0x%x <- 0x%p (%x bytes)\n\r",
	       initrd_start, (char *)(&__ramdisk_begin), initrd_size);
	memcpy((char *)initrd_start, (char *)(&__ramdisk_begin), initrd_size);
    } else {
	initrd_start = 0;
	initrd_size = 0;
	a2 = 0xdeadbeef;
    }

    im = (char *)(&__image_begin);
    len = (char *)(&__image_end) - (char *)(&__image_begin);
    /* claim 4MB starting at PROG_START */
    claim(PROG_START, PROG_SIZE - PROG_START, 0);
    dst = (void *) PROG_START;
    if (im[0] == 0x1f && im[1] == 0x8b) {
	avail_ram = scratch;
	begin_avail = avail_high = avail_ram;
	end_avail = scratch + sizeof(scratch);
	printf("gunzipping (0x%p <- 0x%p:0x%p)...", dst, im, im+len);
	gunzip(dst, 0x400000, im, &len);
	printf("done %u bytes\n\r", len);
	printf("%u bytes of heap consumed, max in use %u\n\r",
	       avail_high - begin_avail, heap_max);
    } else {
	memmove(dst, im, len);
    }

    flush_cache(dst, len);
    make_bi_recs(((unsigned long) dst + len), "chrpboot", _MACH_chrp,
		    (PROG_START + PROG_SIZE));
    
    sa = (unsigned long)PROG_START;
    printf("start address = 0x%x\n\r", sa);

    (*(void (*)())sa)(a1, a2, prom, initrd_start, initrd_size);

    printf("returned?\n\r");

    pause();
}

CfgNode*
get_parent_node(PhiNode *phi)
{
    SuifObject *annote = phi->get_parent();
    claim(is_kind_of<SsaPhiAnnote>(annote), "Bad phi-node parent");

    SuifObject *block = static_cast<SsaPhiAnnote*>(annote)->get_parent();
    claim(is_kind_of<CfgNode>(block), "Bad phi-node annote parent");

    return static_cast<CfgNode*>(block);
}

bool
M2aSuifPass::parse_command_line(TokenStream* command_line_stream)
{
    // set defaults for optional command-line flags
    debuglvl = 0;
    m2a.print_all_notes = false;
    m2a.Gnum = 512;		// in bytes
    m2a.want_stabs = false;    

    bool result = PipelinablePass::parse_command_line(command_line_stream);

    debug(1, "Debug level is %d", debuglvl);
    debug(1, "Gnum = %d", m2a.Gnum);
    if (m2a.print_all_notes)
	debug(1, "Printing all notes");
    if (m2a.want_stabs)
	debug(1, "Printing with stabs information");

    int n = nonprinting_notes_option->get_number_of_values();
    claim((n == 0) || !m2a.print_all_notes, 
	  "cannot specify -noprint with -all_notes");

    // process non-printing notes, if any
    for (int i = 0; i < n; i++) {
	IdString s = nonprinting_notes_option->get_string(i)->get_string();
	nonprinting_notes.insert(s);
	debug(1, "Suppressing `%s' annotations", s.chars());
    }

    int file_count = file_names_option->get_number_of_values();
    int i = 0;

    // Process the input file name, if any.
    if (the_suif_env->get_file_set_block()) {		// expect no input file
	claim(file_count <= 1, "Too many file names: already have input");
    } else {
	claim(file_count > 0, "No input file");
	IdString s = file_names_option->get_string(i++)->get_string();
	the_suif_env->read(s.chars());
    }

    // Process the output file name, if any.
    if (i < file_count) {
	IdString s = file_names_option->get_string(i++)->get_string();
	m2a.out = fopen(s.chars(), "w");
	claim(m2a.out, "Couldn't open %s for writing", s.chars());
    } else {
	m2a.out = stdout;
    }
    claim(i == file_count,
	  "Too many file names: expected %d, got %d", i, file_count);
    return result;
}

boot(int a1, int a2, void *prom)
{
    int ns, oh, i;
    unsigned sa, len;
    void *dst;
    unsigned char *im;
    unsigned initrd_start, initrd_size;
    
    printf("coffboot starting: loaded at 0x%x\n", _start);
    setup_bats(RAM_START);
    if (initrd_len) {
	initrd_size = initrd_len;
	initrd_start = (RAM_END - initrd_size) & ~0xFFF;
	a1 = initrd_start;
	a2 = initrd_size;
	claim(initrd_start - RAM_START, RAM_END - initrd_start, 0);
	printf("initial ramdisk moving 0x%x <- 0x%x (%x bytes)\n",
	       initrd_start, initrd_data, initrd_size);
	memcpy((char *)initrd_start, initrd_data, initrd_size);
    }
    im = image_data;
    len = image_len;
    /* claim 3MB starting at 0 */
    claim(0, 3 << 20, 0);
    dst = (void *) RAM_START;
    if (im[0] == 0x1f && im[1] == 0x8b) {
	/* claim 512kB for scratch space */
	avail_ram = claim(0, 512 << 10, 0x10) + RAM_START;
	end_avail = avail_ram + (512 << 10);
	printf("avail_ram = %x\n", avail_ram);
	printf("gunzipping (0x%x <- 0x%x:0x%0x)...", dst, im, im+len);
	gunzip(dst, 3 << 20, im, &len);
	printf("done %u bytes\n", len);
    } else {
	memmove(dst, im, len);
    }

    flush_cache(dst, len);
    make_bi_recs((unsigned long)dst + len);
    
    sa = (unsigned long)PROG_START;
    printf("start address = 0x%x\n", sa);

#if 0
    pause();
#endif
    (*(void (*)())sa)(a1, a2, prom);

    printf("returned?\n");

    pause();
}

boot(int a1, int a2, void *prom)
{
    int ns, oh, i;
    unsigned sa, len;
    void *dst;
    unsigned char *im;
    unsigned initrd_start, initrd_size;
    extern char _start;
    
    printf("chrpboot starting: loaded at 0x%x\n", &_start);
    if (initrd_len) {
	initrd_size = initrd_len;
	initrd_start = (RAM_END - initrd_size) & ~0xFFF;
	a1 = initrd_start;
	a2 = initrd_size;
	claim(initrd_start, RAM_END - initrd_start, 0);
	printf("initial ramdisk moving 0x%x <- 0x%x (%x bytes)\n", initrd_start,
	       initrd_data,initrd_size);
	memcpy((char *)initrd_start, initrd_data, initrd_size);
    }
    im = image_data;
    len = image_len;
    /* claim 3MB starting at PROG_START */
    claim(PROG_START, PROG_SIZE, 0);
    dst = (void *) PROG_START;
    if (im[0] == 0x1f && im[1] == 0x8b) {
	/* claim some memory for scratch space */
	avail_ram = (char *) claim(0, SCRATCH_SIZE, 0x10);
	begin_avail = avail_high = avail_ram;
	end_avail = avail_ram + SCRATCH_SIZE;
	printf("heap at 0x%x\n", avail_ram);
	printf("gunzipping (0x%x <- 0x%x:0x%0x)...", dst, im, im+len);
	gunzip(dst, PROG_SIZE, im, &len);
	printf("done %u bytes\n", len);
	printf("%u bytes of heap consumed, max in use %u\n",
	       avail_high - begin_avail, heap_max);
    } else {
	memmove(dst, im, len);
    }

    flush_cache(dst, len);
    make_bi_recs((unsigned long) dst + len);

    sa = (unsigned long)PROG_START;
    printf("start address = 0x%x\n", sa);

    (*(void (*)())sa)(a1, a2, prom);

    printf("returned?\n");

    pause();
}

void
M2c::do_proc_def(ProcDef *pd)
{
    const char *cur_pname = (get_name(pd)).chars();
    debug(3, "Processing procedure %s", cur_pname);

    // create a list to hold any .file op's found in the middle
    // of the text segment -- cannot print them there
    List<IdString> file_strings;

    claim(is_kind_of<InstrList>(get_body(pd)), "Body is not an InstrList");
    cur_body = static_cast<InstrList*>(get_body(pd));

    printer->print_proc_begin(pd);

    // print the procedure symbol table
    process_sym_table(pd->get_symbol_table());

    // walk the instruction list once to record all vr defs
    cur_handle = start(cur_body);
    process_vr_decls(pd);
    cur_handle = start(cur_body);

    Instr *mi = *cur_handle;
    if (mi->peek_annote(k_proc_entry) == NULL) {
	// Entry point to procedure is not the first instruction,
	// generate goto to instruction with k_proc_entry note.
	fprintf(out, "\n\tgoto %s_entry_pt;\n", cur_pname);
    } else {
	// simple entry point
	claim(is_null(mi));
	++cur_handle;	
    }

    // output procedure body
    while (cur_handle != end(cur_body)) {
	mi = *cur_handle;

	// do some work on a non-simple procedure entry point
	if (mi->peek_annote(k_proc_entry) != NULL) {
	    // generate label for earlier goto
	    claim(is_null(mi));
	    fprintf(out, "\n%s_entry_pt:\n", cur_pname);
	}
	printer->print_instr(mi);
	++cur_handle;
    }
    // procedure body must not end with a label
    if (is_label(mi))
	fputs("\t/* empty statement */;\n", out);
    fprintf(out, "}\t/* end of %s */\n\n", cur_pname);
}

const NatSet*
DominanceInfo::reverse_dom_frontier(int n) const
{
    claim(_rdf, "DominanceInfo::reverse_dom_frontier() -- "
	  "run find_reverse_dom_frontier() first");
    return &_rdf[n];
}

  VarSym*
get_var(Opnd opnd)
{
  IrOpnd *o = opnd;
  claim(is_kind_of<OpndVar>(o), "get_var: not a variable operand");
  return static_cast<OpndVar*>(o)->get_var();
}

  Context*
find_context(IdString libname)
{
  ContextCacheHandle h = the_context_cache.find(libname);

  if (h != the_context_cache.end())
    return (*h).second;

  ContextCreatorHandle c = the_context_creator_registry.find(libname);

  if (c == the_context_creator_registry.end()) {	// library needs loading
#ifdef NCI_1999
    the_suif_env->get_dll_subsystem()->loadAndInitializeDLL(libname);
#else
    the_suif_env->require_module(libname);
#endif

    c = the_context_creator_registry.find(libname);
    claim(c != the_context_creator_registry.end(),
        "Library `%s' didn't register a context creator", libname.chars());
  }

  Context *result = ((*c).second)();			// create target context
  the_context_cache[libname] = result;
  return result;
}

 EnhancedMetafile::EnhancedMetafile
     ( const Size& size, const string& path, const string& description )
     : myHandle(claim(::create(
           size.data(), path.data(), description.data(), 0
           )))
 {
 }

void goto_symext::symex_free(const expr2tc &expr)
{
  const code_free2t &code = to_code_free2t(expr);

  // Trigger 'free'-mode dereference of this pointer. Should generate various
  // dereference failure callbacks.
  expr2tc tmp = code.operand;
  dereference(tmp, false, true);

  address_of2tc addrof(code.operand->type, tmp);
  pointer_offset2tc ptr_offs(pointer_type2(), addrof);
  equality2tc eq(ptr_offs, zero_ulong);
  claim(eq, "Operand of free must have zero pointer offset");

  // Clear the alloc bit, and set the deallocated bit.
  guardt guard;
  type2tc sym_type = type2tc(new array_type2t(get_bool_type(),
                                              expr2tc(), true));
  pointer_object2tc ptr_obj(pointer_type2(), code.operand);

  symbol2tc dealloc_sym(sym_type, deallocd_arr_name);
  index2tc dealloc_index_expr(get_bool_type(), dealloc_sym, ptr_obj);
  expr2tc truth = true_expr;
  symex_assign_rec(dealloc_index_expr, truth, guard);

  symbol2tc valid_sym(sym_type, valid_ptr_arr_name);
  index2tc valid_index_expr(get_bool_type(), valid_sym, ptr_obj);
  expr2tc falsity = false_expr;
  symex_assign_rec(valid_index_expr, falsity, guard);
}

  OpndHandle
srcs_end(Opnd addr_exp)
{
  claim(is_addr_exp(addr_exp), "srcs_end: not an address expression");
  IrOpnd *o = addr_exp;
  return static_cast<OpndAddrExp*>(o)->srcs().end();
}

  int
srcs_size(Opnd addr_exp)
{
  claim(is_addr_exp(addr_exp), "srcs_size: not an address expression");
  IrOpnd *o = addr_exp;
  return static_cast<OpndAddrExp*>(o)->get_src_count();
}

  Sym*
get_sym(Opnd opnd)
{
  IrOpnd *o = opnd;
  claim(is_kind_of<OpndAddrSym>(o), "get_sym: not an address-symbol operand");
  return static_cast<OpndAddrSym*>(o)->get_sym();
}

  void
set_deref_type(Opnd opnd, TypeId type)
{
  claim(is_addr_exp(opnd));
  IrOpnd *o = opnd;
  static_cast<OpndAddrExp*>(o)->set_deref_type(type);
}

int
Expire_splay(
	  const Expire_splay_in * in
	, Expire_splay_out * out
	, Expire_splay_atoms * atoms)
{
	State * & state = atoms->state();
	State::ClaimThreadIdRAII claim(*state);
	std::vector<EventBase *> expired;
	std::vector<EventBase *> cancelled;
	time_t present_time = time(NULL);
	if(state->until_time > present_time) {
		sleep(state->until_time - present_time); // not terribly accurate
	}
	state->synch_update_internals(
		  present_time
		, expired
		, cancelled);
	oflux::PushTool<Expire_splay_out> ptool(out);
	std::vector<EventBase *>::iterator itr;
	int push_count = 0;
	for(itr = expired.begin(); itr != expired.end(); ++itr) {
		ptool->timer.reset(*itr);
		ptool->is_cancelled = false;
		ptool.next();
		++push_count;
	}
	for(itr = cancelled.begin(); itr != cancelled.end(); ++itr) {
		ptool->timer.reset(*itr);
		ptool->is_cancelled = true;
		ptool.next();
		++push_count;
	}
	return (push_count > 0 ? 0 : -1);
}

  void
Printer::print_sym(Sym *s)
{
  if (s == NULL) {
    fputs("<<null>>", out);
  } else {
    SymTable *st = to<SymTable>(s->get_parent());
    IrObject *par = to<IrObject>(st->get_parent());
    if (is_kind_of<ProcDef>(par)) {
      // We make the local symbol name unique by appending
      // the procedure name as a prefix.
      ProcDef *pd = to<ProcDef>(par);
      fprintf(out, "%s.", get_name(pd).chars());
    } else {
      // We assume that we aren't given nested symbol tables, and
      // thus st must be a global symbol table.  The symbol
      // therefore is global and doesn't need a prefix.
      claim(is_global(st));
#ifndef CFE_NUMERIC_SYMS_FIXED
      // Symbols for literals are coming out of CFE with purely numeric names.
      const char *name = get_name(s).chars();
      if (isdigit(name[0]))
        fprintf(out, "__anon.");
#endif
    }
    fprintf(out, "%s", get_name(s).chars());
  }
}

  int
get_reg(Opnd opnd)
{
  IrOpnd *o = opnd;
  claim(is_kind_of<OpndReg>(o), "get_reg: not a register operand");
  int reg = static_cast<OpndReg*>(o)->get_reg();
  return reg < 0 ? -(reg + 1) : reg;
}