i386: Also check R12-R15 registers when optimizing testq to testb

[deliverable/binutils-gdb.git] / gdb / ada-exp.y

diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y
index efad85b19ad358c3acbf5001be5add7bb20cde0f..00020cd0677b1aa241b9dd2feb474508cb1f8ad1 100644 (file)
--- a/gdb/ada-exp.y
+++ b/gdb/ada-exp.y
@@ -717,7 +717,6 @@ primary     :       '*' primary             %prec '.'
 #define yy_switch_to_buffer ada_yy_switch_to_buffer
 #define yyrestart ada_yyrestart
 #define yytext ada_yytext
-#define yywrap ada_yywrap
 
 static struct obstack temp_parse_space;
 
@@ -813,11 +812,11 @@ write_object_renaming (struct parser_state *par_state,
   if (orig_left_context == NULL)
     orig_left_context = get_selected_block (NULL);
 
-  name = (char *) obstack_copy0 (&temp_parse_space, renamed_entity,
-                                renamed_entity_len);
+  name = obstack_strndup (&temp_parse_space, renamed_entity,
+                         renamed_entity_len);
   ada_lookup_encoded_symbol (name, orig_left_context, VAR_DOMAIN, &sym_info);
   if (sym_info.symbol == NULL)
-    error (_("Could not find renamed variable: %s"), ada_decode (name));
+    error (_("Could not find renamed variable: %s"), ada_decode (name).c_str ());
   else if (SYMBOL_CLASS (sym_info.symbol) == LOC_TYPEDEF)
     /* We have a renaming of an old-style renaming symbol.  Don't
        trust the block information.  */
@@ -882,9 +881,8 @@ write_object_renaming (struct parser_state *par_state,
            if (end == NULL)
              end = renaming_expr + strlen (renaming_expr);
 
-           index_name
-             = (char *) obstack_copy0 (&temp_parse_space, renaming_expr,
-                                       end - renaming_expr);
+           index_name = obstack_strndup (&temp_parse_space, renaming_expr,
+                                         end - renaming_expr);
            renaming_expr = end;
 
            ada_lookup_encoded_symbol (index_name, orig_left_context,
@@ -1042,7 +1040,7 @@ find_primitive_type (struct parser_state *par_state, char *name)
        (char *) alloca (strlen (name) + sizeof ("standard__"));
       strcpy (expanded_name, "standard__");
       strcat (expanded_name, name);
-      sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN, NULL).symbol;
+      sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN).symbol;
       if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
        type = SYMBOL_TYPE (sym);
     }
@@ -1104,12 +1102,10 @@ static void
 write_ambiguous_var (struct parser_state *par_state,
                     const struct block *block, char *name, int len)
 {
-  struct symbol *sym = XOBNEW (&temp_parse_space, struct symbol);
+  struct symbol *sym = new (&temp_parse_space) symbol ();
 
-  memset (sym, 0, sizeof (struct symbol));
   SYMBOL_DOMAIN (sym) = UNDEF_DOMAIN;
-  SYMBOL_LINKAGE_NAME (sym)
-    = (const char *) obstack_copy0 (&temp_parse_space, name, len);
+  sym->set_linkage_name (obstack_strndup (&temp_parse_space, name, len));
   SYMBOL_LANGUAGE (sym) = language_ada;
 
   write_exp_elt_opcode (par_state, OP_VAR_VALUE);
@@ -1207,8 +1203,7 @@ write_var_or_type (struct parser_state *par_state,
 
   encoded_name = ada_encode (name0.ptr);
   name_len = strlen (encoded_name);
-  encoded_name
-    = (char *) obstack_copy0 (&temp_parse_space, encoded_name, name_len);
+  encoded_name = obstack_strndup (&temp_parse_space, encoded_name, name_len);
   for (depth = 0; depth < MAX_RENAMING_CHAIN_LENGTH; depth += 1)
     {
       int tail_index;
@@ -1230,19 +1225,6 @@ write_var_or_type (struct parser_state *par_state,
                                          VAR_DOMAIN, &syms);
          encoded_name[tail_index] = terminator;
 
-         /* A single symbol may rename a package or object. */
-
-         /* This should go away when we move entirely to new version.
-            FIXME pnh 7/20/2007. */
-         if (nsyms == 1)
-           {
-             struct symbol *ren_sym =
-               ada_find_renaming_symbol (syms[0].symbol, syms[0].block);
-
-             if (ren_sym != NULL)
-               syms[0].symbol = ren_sym;
-           }
-
          type_sym = select_possible_type_sym (syms);
 
          if (type_sym != NULL)
@@ -1407,10 +1389,21 @@ convert_char_literal (struct type *type, LONGEST val)
   if (TYPE_CODE (type) != TYPE_CODE_ENUM)
     return val;
 
-  xsnprintf (name, sizeof (name), "QU%02x", (int) val);
+  if ((val >= 'a' && val <= 'z') || (val >= '0' && val <= '9'))
+    xsnprintf (name, sizeof (name), "Q%c", (int) val);
+  else
+    xsnprintf (name, sizeof (name), "QU%02x", (int) val);
+  size_t len = strlen (name);
   for (f = 0; f < TYPE_NFIELDS (type); f += 1)
     {
-      if (strcmp (name, TYPE_FIELD_NAME (type, f)) == 0)
+      /* Check the suffix because an enum constant in a package will
+        have a name like "pkg__QUxx".  This is safe enough because we
+        already have the correct type, and because mangling means
+        there can't be clashes.  */
+      const char *ename = TYPE_FIELD_NAME (type, f);
+      size_t elen = strlen (ename);
+
+      if (elen >= len && strcmp (name, ename + elen - len) == 0)
        return TYPE_FIELD_ENUMVAL (type, f);
     }
   return val;