X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fstd-operator.def;h=925e2b6484e6509f980201e151c41036914a0109;hb=098caef485a4ece6096e6cdbb4cd9726e4a13386;hp=c33a287c2a6d2c63538d7431d51249c338353f71;hpb=ae8fddda32d161ea0d8606fdd71349230d5b0ad6;p=binutils-gdb.git diff --git a/gdb/std-operator.def b/gdb/std-operator.def index c33a287c2a6..925e2b6484e 100644 --- a/gdb/std-operator.def +++ b/gdb/std-operator.def @@ -1,6 +1,6 @@ /* Standard language operator definitions for GDB, the GNU debugger. - Copyright (C) 1986-2014 Free Software Foundation, Inc. + Copyright (C) 1986-2021 Free Software Foundation, Inc. This file is part of GDB. @@ -93,8 +93,8 @@ OP (BINOP_END) /* Operates on three values computed by following subexpressions. */ OP (TERNOP_COND) /* ?: */ -/* A sub-string/sub-array. (the deleted) Chill syntax: - OP1(OP2:OP3). Return elements OP2 through OP3 of OP1. */ +/* A sub-string/sub-array. Ada syntax: OP1(OP2..OP3). Return + elements OP2 through OP3 of OP1. */ OP (TERNOP_SLICE) /* Multidimensional subscript operator, such as Modula-2 x[a,b,...]. @@ -114,9 +114,9 @@ OP (MULTI_SUBSCRIPT) Thus, the operation occupies four exp_elements. */ OP (OP_LONG) -/* OP_DOUBLE is similar but takes a DOUBLEST constant instead of a - long. */ -OP (OP_DOUBLE) +/* OP_FLOAT is similar but takes a floating-point constant encoded in + the target format for the given type instead of a long. */ +OP (OP_FLOAT) /* OP_VAR_VALUE takes one struct block * in the following element, and one struct symbol * in the following exp_element, followed @@ -129,9 +129,15 @@ OP (OP_VAR_VALUE) /* OP_VAR_ENTRY_VALUE takes one struct symbol * in the following element, followed by another OP_VAR_ENTRY_VALUE, making three exp_elements. somename@entry may mean parameter value as present at the entry of the - current function. Implemented via DW_OP_GNU_entry_value. */ + current function. Implemented via DW_OP_entry_value. */ OP (OP_VAR_ENTRY_VALUE) +/* OP_VAR_MSYM_VALUE takes one struct objfile * in the following + element, and one struct minimal_symbol * in the following + exp_element, followed by another OP_VAR_MSYM_VALUE, making four + exp_elements. */ +OP (OP_VAR_MSYM_VALUE) + /* OP_LAST is followed by an integer in the next exp_element. The integer is zero for the last value printed, or it is the absolute number of a history element. @@ -162,14 +168,6 @@ OP (OP_FUNCALL) pointer. This is an Objective C message. */ OP (OP_OBJC_MSGCALL) -/* This is EXACTLY like OP_FUNCALL but is semantically different. - In F77, array subscript expressions, substring expressions and - function calls are all exactly the same syntactically. They - may only be disambiguated at runtime. Thus this operator, - which indicates that we have found something of the form - ( ). */ -OP (OP_F77_UNDETERMINED_ARGLIST) - /* OP_COMPLEX takes a type in the following element, followed by another OP_COMPLEX, making three exp_elements. It is followed by two double args, and converts them into a complex number of the given type. */ @@ -212,13 +210,6 @@ OP (UNOP_REINTERPRET_CAST) following subexpression. */ OP (UNOP_MEMVAL) -/* UNOP_MEMVAL_TLS is followed by a `struct objfile' pointer in the next - exp_element and a type pointer in the following exp_element. - With another UNOP_MEMVAL_TLS at the end, this makes four exp_elements. - It casts the contents of the word offsetted by the value of the - following subexpression from the TLS specified by `struct objfile'. */ -OP (UNOP_MEMVAL_TLS) - /* Like UNOP_MEMVAL, but the type is supplied as a subexpression. */ OP (UNOP_MEMVAL_TYPE) @@ -235,6 +226,7 @@ OP (UNOP_POSTINCREMENT) /* ++ after an expression */ OP (UNOP_PREDECREMENT) /* -- before an expression */ OP (UNOP_POSTDECREMENT) /* -- after an expression */ OP (UNOP_SIZEOF) /* Unary sizeof (followed by expression) */ +OP (UNOP_ALIGNOF) /* Unary alignof (followed by expression) */ OP (UNOP_PLUS) /* Unary plus */ @@ -266,6 +258,9 @@ OP (OP_M2_STRING) /* Modula-2 string constants */ OP (STRUCTOP_STRUCT) OP (STRUCTOP_PTR) +/* Anonymous field access, e.g. "foo.3". Used in Rust. */ +OP (STRUCTOP_ANONYMOUS) + /* C++: OP_THIS is just a placeholder for the class instance variable. It just comes in a tight (OP_THIS, OP_THIS) pair. */ OP (OP_THIS) @@ -278,6 +273,36 @@ OP (OP_OBJC_SELECTOR) a string, which, of course, is variable length. */ OP (OP_SCOPE) +/* OP_FUNC_STATIC_VAR refers to a function local static variable. The + function is taken from the following subexpression. The length of + the variable name as a string follows the opcode, followed by + BYTES_TO_EXP_ELEM(length) elements containing the data of the + string, followed by the length again and the opcode again. + + Note this is used by C++, but not C. The C parser handles local + static variables in the parser directly. Also, this is only used + in C++ if the function/method name is not quoted, like e.g.: + + p S:method()::var + p S:method() const::var + + If the function/method is quoted like instead: + + p 'S:method() const'::var + + then the C-specific handling directly in the parser takes over (see + block/variable productions). + + Also, if the whole function+var is quoted like this: + + p 'S:method() const::var' + + then the whole quoted expression is interpreted as a single symbol + name and we don't use OP_FUNC_STATIC_VAR either. In that case, the + C++-specific symbol lookup routines take care of the + function-local-static search. */ +OP (OP_FUNC_STATIC_VAR) + /* OP_TYPE is for parsing types, and used with the "ptype" command so we can look up types that are qualified by scope, either with the GDB "::" operator, or the Modula-2 '.' operator. */ @@ -289,13 +314,9 @@ OP (OP_NAME) /* An Objective C Foundation Class NSString constant. */ OP (OP_OBJC_NSSTRING) -/* A F90 array range operator (for "exp:exp", "exp:", ":exp" and ":"). */ -OP (OP_F90_RANGE) - -/* OP_DECFLOAT is followed by a type pointer in the next exp_element - and a dec long constant value in the following exp_element. - Then comes another OP_DECFLOAT. */ -OP (OP_DECFLOAT) +/* An array range operator (in Fortran 90, for "exp:exp", "exp:", + ":exp" and ":"). */ +OP (OP_RANGE) /* OP_ADL_FUNC specifies that the function is to be looked up in an Argument Dependent manner (Koenig lookup). */ @@ -312,3 +333,112 @@ OP (OP_DECLTYPE) /* The typeid operator. This has one expression argument. */ OP (OP_TYPEID) + +/* This is used for the Rust [expr; N] form of array construction. It + takes two expression arguments. */ +OP (OP_RUST_ARRAY) + +/* First extension operator. Some language modules define extra + operators below with numbers higher than OP_EXTENDED0. */ +OP (OP_EXTENDED0) + +/* ================ Ada operators ================ */ + +/* X IN A'RANGE(N). N is an immediate operand, surrounded by + BINOP_IN_BOUNDS before and after. A is an array, X an index + value. Evaluates to true iff X is within range of the Nth + dimension (1-based) of A. (A multi-dimensional array + type is represented as array of array of ...) */ +OP (BINOP_IN_BOUNDS) + +/* X IN L .. U. True iff L <= X <= U. */ +OP (TERNOP_IN_RANGE) + +/* Ada attributes ('Foo). */ +OP (OP_ATR_FIRST) +OP (OP_ATR_LAST) +OP (OP_ATR_LENGTH) +OP (OP_ATR_IMAGE) +OP (OP_ATR_MAX) +OP (OP_ATR_MIN) +OP (OP_ATR_MODULUS) +OP (OP_ATR_POS) +OP (OP_ATR_SIZE) +OP (OP_ATR_TAG) +OP (OP_ATR_VAL) + +/* Ada type qualification. It is encoded as for UNOP_CAST, above, + and denotes the TYPE'(EXPR) construct. */ +OP (UNOP_QUAL) + +/* X IN TYPE. The `TYPE' argument is immediate, with + UNOP_IN_RANGE before and after it. True iff X is a member of + type TYPE (typically a subrange). */ +OP (UNOP_IN_RANGE) + +/* An aggregate. A single immediate operand, N>0, gives + the number of component specifications that follow. The + immediate operand is followed by a second OP_AGGREGATE. + Next come N component specifications. A component + specification is either an OP_OTHERS (others=>...), an + OP_CHOICES (for named associations), or other expression (for + positional aggregates only). Aggregates currently + occur only as the right sides of assignments. */ +OP (OP_AGGREGATE) + +/* An others clause. Followed by a single expression. */ +OP (OP_OTHERS) + +/* An aggregate component association. A single immediate operand, N, + gives the number of choices that follow. This is followed by a second + OP_CHOICES operator. Next come N operands, each of which is an + expression, an OP_DISCRETE_RANGE, or an OP_NAME---the latter + for a simple name that must be a record component name and does + not correspond to a single existing symbol. After the N choice + indicators comes an expression giving the value. + + In an aggregate such as (X => E1, ...), where X is a simple + name, X could syntactically be either a component_selector_name + or an expression used as a discrete_choice, depending on the + aggregate's type context. Since this is not known at parsing + time, we don't attempt to disambiguate X if it has multiple + definitions, but instead supply an OP_NAME. If X has a single + definition, we represent it with an OP_VAR_VALUE, even though + it may turn out to be within a record aggregate. Aggregate + evaluation can use either OP_NAMEs or OP_VAR_VALUEs to get a + record field name, and can evaluate OP_VAR_VALUE normally to + get its value as an expression. Unfortunately, we lose out in + cases where X has multiple meanings and is part of an array + aggregate. I hope these are not common enough to annoy users, + who can work around the problem in any case by putting + parentheses around X. */ +OP (OP_CHOICES) + +/* A positional aggregate component association. The operator is + followed by a single integer indicating the position in the + aggregate (0-based), followed by a second OP_POSITIONAL. Next + follows a single expression giving the component value. */ +OP (OP_POSITIONAL) + +/* A range of values. Followed by two expressions giving the + upper and lower bounds of the range. */ +OP (OP_DISCRETE_RANGE) + +/* ================ Fortran operators ================ */ + +/* This is EXACTLY like OP_FUNCALL but is semantically different. + In F77, array subscript expressions, substring expressions and + function calls are all exactly the same syntactically. They + may only be disambiguated at runtime. Thus this operator, + which indicates that we have found something of the form + ( ). */ +OP (OP_F77_UNDETERMINED_ARGLIST) + +/* Single operand builtins. */ +OP (UNOP_FORTRAN_KIND) +OP (UNOP_FORTRAN_FLOOR) +OP (UNOP_FORTRAN_CEILING) + +/* Two operand builtins. */ +OP (BINOP_FORTRAN_CMPLX) +OP (BINOP_FORTRAN_MODULO)