Esempio n. 1
0
/*-----------------------------------------------------------------*/
const char *
format_opcode (const char *inst, const char *fmt, va_list ap)
{
  struct dbuf_s dbuf;

  dbuf_init (&dbuf, INITIAL_INLINEASM);

  if (inst && *inst)
    {
      dbuf_append_str (&dbuf, inst);

      if (fmt && *fmt)
        {
          dbuf_append_char (&dbuf, '\t');
          dbuf_tvprintf (&dbuf, fmt, ap);
        }
    }
  else
    {
      if (fmt && *fmt)
        {
          dbuf_tvprintf (&dbuf, fmt, ap);
        }
    }

  return dbuf_detach_c_str (&dbuf);
}
Esempio n. 2
0
int
enum_symbols (FILE * fp, long size, int (*func) (const char *sym, void *param), void *param)
{
  long end;
  struct dbuf_s buf;
  struct dbuf_s symname;

  assert (func != NULL);

  dbuf_init (&buf, 512);
  dbuf_init (&symname, 32);

  end = (size >= 0) ? ftell (fp) + size : -1;

  /*
   * Read in the object file.  Look for lines that
   * begin with "S" and end with "D".  These are
   * symbol table definitions.  If we find one, see
   * if it is our symbol.  Make sure we only read in
   * our object file and don't go into the next one.
   */

  while (end < 0 || ftell (fp) < end)
    {
      const char *p;

      dbuf_set_length (&buf, 0);
      if (dbuf_getline (&buf, fp) == 0)
        break;

      p = dbuf_c_str (&buf);

      if ('T' == p[0])
        break;

      /*
       * Skip everything that's not a symbol record.
       */
      if ('S' == p[0] && ' ' == p[1])
        {
          dbuf_set_length (&symname, 0);

          for (p += 2; *p && ' ' != *p; ++p)
            dbuf_append_char (&symname, *p);

          /* If it's an actual symbol, record it */
          if (' ' == p[0] && 'D' == p[1])
            if (func != NULL)
              if ((*func) (dbuf_c_str (&symname), NULL))
                return 1;
        }
    }

  dbuf_destroy (&buf);
  dbuf_destroy (&symname);

  return 0;
}
Esempio n. 3
0
/*-----------------------------------------------------------------*/
static void
printAllocInfoSeg (memmap * map, symbol * func, struct dbuf_s *oBuf)
{
  symbol *sym;

  if (!map)
    return;
  if (!map->syms)
    return;

  for (sym = setFirstItem (map->syms); sym;
       sym = setNextItem (map->syms))
    {

      if (sym->level == 0)
        continue;
      if (sym->localof != func)
        continue;

      dbuf_printf (oBuf, ";%-25s Allocated ", sym->name);

      /* if assigned to registers */
      if (!sym->allocreq && sym->reqv)
        {
          int i;

          sym = OP_SYMBOL (sym->reqv);
          if (!sym->isspilt || sym->remat)
            {
              dbuf_append_str (oBuf, "to registers ");
              for (i = 0; i < 4 && sym->regs[i]; i++)
                dbuf_printf (oBuf, "%s ", port->getRegName (sym->regs[i]));
              dbuf_append_char (oBuf, '\n');
              continue;
            }
          else
            {
              sym = sym->usl.spillLoc;
            }
        }

      /* if on stack */
      if (sym->onStack)
        {
          dbuf_printf (oBuf, "to stack - offset %d\n", sym->stack);
          continue;
        }

      /* otherwise give rname */
      dbuf_printf (oBuf, "with name '%s'\n", sym->rname);
    }
}
Esempio n. 4
0
/*-----------------------------------------------------------------*/
void
printLine (lineNode * head, struct dbuf_s *oBuf)
{
  iCode *last_ic = NULL;
  bool debug_iCode_tracking = (getenv ("DEBUG_ICODE_TRACKING") != NULL);

  while (head)
    {
      if (head->ic != last_ic)
        {
          last_ic = head->ic;
          if (debug_iCode_tracking)
            {
              if (head->ic)
                dbuf_printf (oBuf, "; block = %d, seq = %d\n", head->ic->block, head->ic->seq);
              else
                dbuf_append_str (oBuf, "; iCode lost\n");
            }
        }

      /* don't indent comments & labels */
      if (head->line && (head->isComment || head->isLabel))
        {
          dbuf_printf (oBuf, "%s\n", head->line);
        }
      else
        {
          if (head->isInline && *head->line == '#')
            {
              /* comment out preprocessor directives in inline asm */
              dbuf_append_char (oBuf, ';');
            }
          dbuf_printf (oBuf, "\t%s\n", head->line);
        }
      head = head->next;
    }
}
Esempio n. 5
0
/*-----------------------------------------------------------------*/
static int
printAllocInfoSeg (memmap * map, symbol * func, struct dbuf_s *oBuf)
{
  symbol *sym;
  int flg = FALSE;

  if (!map || !map->syms)
    return 0;

  for (sym = setFirstItem (map->syms); sym;
       sym = setNextItem (map->syms))
    {
      if (sym->level == 0)
        continue;
      if (sym->localof != func)
        continue;

      dbuf_printf (oBuf, ";%-25s Allocated ", sym->name);
      flg = TRUE;

      /* if assigned to registers */
      if (!sym->allocreq && sym->reqv)
        {
          int i;

          sym = OP_SYMBOL (sym->reqv);
          if (!sym->isspilt || sym->remat)
            {
              dbuf_append_str (oBuf, "to registers ");
              for (i = 0; i < 4 && sym->regs[i]; i++)
                dbuf_printf (oBuf, "%s ", port->getRegName (sym->regs[i]));
              dbuf_append_char (oBuf, '\n');
              continue;
            }
          else
            {
              sym = sym->usl.spillLoc;
            }
        }

      /* if on stack */
      if (sym->onStack)
        {
          int stack_offset = 0;

          if (options.omitFramePtr)
            {
              if (SPEC_OCLS (sym->etype)->paged)
                stack_offset = func->xstack;
              else
                stack_offset = func->stack;
            }

          dbuf_printf (oBuf, "to stack - %s %+d\n", SYM_BP (sym), sym->stack - stack_offset);
          continue;
        }

      /* otherwise give rname */
      dbuf_printf (oBuf, "with name '%s'\n", sym->rname);
    }

  return flg;
}
Esempio n. 6
0
int
enum_symbols (FILE * fp, long size, int (*func) (const char *sym, void *param), void *param)
{
  long end;
  struct dbuf_s buf;
  struct dbuf_s symname;

  assert (func != NULL);

  dbuf_init (&buf, 512);
  dbuf_init (&symname, 32);

  end = (size >= 0) ? ftell (fp) + size : -1;

  /*
   * Read in the object file.  Look for lines that
   * begin with "S" and end with "D".  These are
   * symbol table definitions.  If we find one, see
   * if it is our symbol.  Make sure we only read in
   * our object file and don't go into the next one.
   */

  while (end < 0 || ftell (fp) < end)
    {
      const char *p;

      dbuf_set_length (&buf, 0);
      if (dbuf_getline (&buf, fp) == 0)
        break;

      p = dbuf_c_str (&buf);

      /* Skip whitespace */
      while (isspace (*p))
        p++;

      /* Skip local symbols or directives */
      if ('.' == p[0])
        continue;

      /*
       * Skip everything that's not a symbol.
       */
      if (isalpha (*p) || '_' == *p)
        {
          bool found = false;

          dbuf_set_length (&symname, 0);

          while (isalnum (*p) || '_' == *p)
            dbuf_append_char (&symname, *p++);

          if (':' == *p) /* a label */
            {
              if (':' == *++p) /* a global label */
                found = true;
            }
          else /* no label */
            {
              size_t i;

              /* Skip whitespace */
              while (isspace (*p))
                p++;

              for (found = false, i = 0; !found && i < sizeof(directives) / sizeof(symbol_t); i++)
                {
                  if (0 == strncmp(p, directives[i].text, strlen(directives[i].text)))
                    {
                      switch (directives[i].subtype)
                        {
                        case stEQU:
                        case stBYTE:
                        case stWORD_BE:
                        case stWORD_LE:
                        case stLONG_BE:
                        case stLONG_LE:
                        case stBUFFER:
                        case stTEXT:
                        case stDS:
                        case stDSIN:
                        case stDSOUT:
                        case stDSIO:
                        case stDSROM:
                        case stDSRAM:
                          /* It's a symbol */
                          found = true;
                          break;
                        default:
						  break;
                        }
                    }
                }
            }

          /* If it's an actual symbol, record it */
          if (found)
            if (func != NULL)
              if ((*func) (dbuf_c_str (&symname), NULL))
                return 1;
        }
    }

  dbuf_destroy (&buf);
  dbuf_destroy (&symname);

  return 0;
}