#include "gdbcmd.h"
#include "symfile.h" /* for overlay functions */
#include "inferior.h"
-#include "doublest.h"
+#include "target-float.h"
#include "block.h"
#include "source.h"
#include "objfiles.h"
}
-static void free_funcalls (void *ignore);
-
static int prefixify_subexp (struct expression *, struct expression *, int,
int);
const struct block *, int,
int, int *);
-void _initialize_parse (void);
-
/* Data structure for saving values of arglist_len for function calls whose
arguments contain other function calls. */
-struct funcall
- {
- struct funcall *next;
- int arglist_len;
- };
-
-static struct funcall *funcall_chain;
+static std::vector<int> *funcall_chain;
/* Begin counting arguments for a function call,
saving the data about any containing call. */
void
start_arglist (void)
{
- struct funcall *newobj;
-
- newobj = XNEW (struct funcall);
- newobj->next = funcall_chain;
- newobj->arglist_len = arglist_len;
+ funcall_chain->push_back (arglist_len);
arglist_len = 0;
- funcall_chain = newobj;
}
/* Return the number of arguments in a function call just terminated,
end_arglist (void)
{
int val = arglist_len;
- struct funcall *call = funcall_chain;
-
- funcall_chain = call->next;
- arglist_len = call->arglist_len;
- xfree (call);
+ arglist_len = funcall_chain->back ();
+ funcall_chain->pop_back ();
return val;
}
-/* Free everything in the funcall chain.
- Used when there is an error inside parsing. */
-
-static void
-free_funcalls (void *ignore)
-{
- struct funcall *call, *next;
-
- for (call = funcall_chain; call; call = next)
- {
- next = call->next;
- xfree (call);
- }
-}
\f
/* See definition in parser-defs.h. */
}
void
-write_exp_elt_dblcst (struct parser_state *ps, DOUBLEST expelt)
-{
- union exp_element tmp;
-
- memset (&tmp, 0, sizeof (union exp_element));
- tmp.doubleconst = expelt;
- write_exp_elt (ps, &tmp);
-}
-
-void
-write_exp_elt_decfloatcst (struct parser_state *ps, gdb_byte expelt[16])
+write_exp_elt_floatcst (struct parser_state *ps, const gdb_byte expelt[16])
{
union exp_element tmp;
int index;
for (index = 0; index < 16; index++)
- tmp.decfloatconst[index] = expelt[index];
+ tmp.floatconst[index] = expelt[index];
write_exp_elt (ps, &tmp);
}
{
bound_minimal_symbol bound_msym = {msymbol, objfile};
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
CORE_ADDR pc;
+ bool is_tls = (section != NULL
+ && section->the_bfd_section->flags & SEC_THREAD_LOCAL);
+
+ /* Addresses of TLS symbols are really offsets into a
+ per-objfile/per-thread storage block. */
+ CORE_ADDR addr = (is_tls
+ ? MSYMBOL_VALUE_RAW_ADDRESS (bound_msym.minsym)
+ : BMSYMBOL_VALUE_ADDRESS (bound_msym));
+
/* The minimal symbol might point to a function descriptor;
resolve it to the actual code address instead. */
pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target);
if (overlay_debugging)
addr = symbol_overlayed_address (addr, section);
- if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
+ if (is_tls)
{
/* Skip translation if caller does not need the address. */
if (address_p != NULL)
break;
case OP_LONG:
- case OP_DOUBLE:
- case OP_DECFLOAT:
+ case OP_FLOAT:
case OP_VAR_VALUE:
case OP_VAR_MSYM_VALUE:
oplen = 4;
break;
case TYPE_INSTANCE:
- oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
+ oplen = 5 + longest_to_int (expr->elts[endpos - 2].longconst);
args = 1;
break;
const struct block *block,
int comma, int void_context_p, int *out_subexp)
{
- struct cleanup *old_chain;
const struct language_defn *lang = NULL;
struct parser_state ps;
int subexp;
if (lexptr == 0 || *lexptr == 0)
error_no_arg (_("expression to compute"));
- old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
- funcall_chain = 0;
+ std::vector<int> funcalls;
+ scoped_restore save_funcall_chain = make_scoped_restore (&funcall_chain,
+ &funcalls);
expression_context_block = block;
if (expressiondebug)
dump_prefix_expression (ps.expout, gdb_stdlog);
- discard_cleanups (old_chain);
-
*stringptr = lexptr;
return expression_up (ps.expout);
}
}
/* Parse floating point value P of length LEN.
- Return 0 (false) if invalid, 1 (true) if valid.
- The successfully parsed number is stored in D.
- *SUFFIX points to the suffix of the number in P.
+ Return false if invalid, true if valid.
+ The successfully parsed number is stored in DATA in
+ target format for floating-point type TYPE.
NOTE: This accepts the floating point syntax that sscanf accepts. */
-int
-parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
-{
- char *copy;
- int n, num;
-
- copy = (char *) xmalloc (len + 1);
- memcpy (copy, p, len);
- copy[len] = 0;
-
- num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
- xfree (copy);
-
- /* The sscanf man page suggests not making any assumptions on the effect
- of %n on the result, so we don't.
- That is why we simply test num == 0. */
- if (num == 0)
- return 0;
-
- *suffix = p + n;
- return 1;
-}
-
-/* Parse floating point value P of length LEN, using the C syntax for floats.
- Return 0 (false) if invalid, 1 (true) if valid.
- The successfully parsed number is stored in *D.
- Its type is taken from builtin_type (gdbarch) and is stored in *T. */
-
-int
-parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
- DOUBLEST *d, struct type **t)
+bool
+parse_float (const char *p, int len,
+ const struct type *type, gdb_byte *data)
{
- const char *suffix;
- int suffix_len;
- const struct builtin_type *builtin_types = builtin_type (gdbarch);
-
- if (! parse_float (p, len, d, &suffix))
- return 0;
-
- suffix_len = p + len - suffix;
-
- if (suffix_len == 0)
- *t = builtin_types->builtin_double;
- else if (suffix_len == 1)
- {
- /* Handle suffixes: 'f' for float, 'l' for long double. */
- if (tolower (*suffix) == 'f')
- *t = builtin_types->builtin_float;
- else if (tolower (*suffix) == 'l')
- *t = builtin_types->builtin_long_double;
- else
- return 0;
- }
- else
- return 0;
-
- return 1;
+ return target_float_from_string (data, type, std::string (p, len));
}
\f
/* Stuff for maintaining a stack of types. Currently just used by C, but
push_type (tp_function_with_arguments);
}
+/* Pop the type stack and return a type_instance_flags that
+ corresponds the const/volatile qualifiers on the stack. This is
+ called by the C++ parser when parsing methods types, and as such no
+ other kind of type in the type stack is expected. */
+
+type_instance_flags
+follow_type_instance_flags ()
+{
+ type_instance_flags flags = 0;
+
+ for (;;)
+ switch (pop_type ())
+ {
+ case tp_end:
+ return flags;
+ case tp_const:
+ flags |= TYPE_INSTANCE_FLAG_CONST;
+ break;
+ case tp_volatile:
+ flags |= TYPE_INSTANCE_FLAG_VOLATILE;
+ break;
+ default:
+ gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
+ }
+}
+
+
/* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
as modified by all the stuff on the stack. */
struct type *
{
case BINOP_VAL:
case OP_COMPLEX:
- case OP_DECFLOAT:
- case OP_DOUBLE:
+ case OP_FLOAT:
case OP_LONG:
case OP_SCOPE:
case OP_TYPE:
case TYPE_INSTANCE:
{
- LONGEST arg, nargs = elts[pos + 1].longconst;
+ LONGEST arg, nargs = elts[pos + 2].longconst;
for (arg = 0; arg < nargs; arg++)
{
- struct type *type = elts[pos + 2 + arg].type;
+ struct type *type = elts[pos + 3 + arg].type;
struct objfile *objfile = TYPE_OBJFILE (type);
if (objfile && (*objfile_func) (objfile, data))
projects / deliverable / binutils-gdb.git / blobdiff