1 files changed, 32 insertions, 32 deletions

diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 3fe66772ae9..a5270fdcf11 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -353,7 +353,7 @@ gen_sign_extend (struct agent_expr *ax, struct type *type)
 {
   /* Do we need to sign-extend this?  */
   if (!TYPE_UNSIGNED (type))
-    ax_ext (ax, type->length * TARGET_CHAR_BIT);
+    ax_ext (ax, TYPE_LENGTH(type) * TARGET_CHAR_BIT);
 }
 
 
@@ -363,7 +363,7 @@ gen_sign_extend (struct agent_expr *ax, struct type *type)
 static void
 gen_extend (struct agent_expr *ax, struct type *type)
 {
-  int bits = type->length * TARGET_CHAR_BIT;
+  int bits = TYPE_LENGTH(type) * TARGET_CHAR_BIT;
   /* I just had to.  */
   ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
 }
@@ -381,7 +381,7 @@ gen_fetch (struct agent_expr *ax, struct type *type)
       ax_trace_quick (ax, TYPE_LENGTH (type));
     }
 
-  switch (type->code)
+  switch (TYPE_CODE(type))
     {
     case TYPE_CODE_PTR:
     case TYPE_CODE_ENUM:
@@ -389,7 +389,7 @@ gen_fetch (struct agent_expr *ax, struct type *type)
     case TYPE_CODE_CHAR:
       /* It's a scalar value, so we know how to dereference it.  How
          many bytes long is it?  */
-      switch (type->length)
+      switch (TYPE_LENGTH(type))
 	{
 	case 8 / TARGET_CHAR_BIT:
 	  ax_simple (ax, aop_ref8);
@@ -697,7 +697,7 @@ gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
      the stack.  Should we tweak the type?  */
 
   /* Some types require special handling.  */
-  switch (value->type->code)
+  switch (TYPE_CODE(value->type))
     {
       /* Functions get converted to a pointer to the function.  */
     case TYPE_CODE_FUNC:
@@ -709,7 +709,7 @@ gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
          are no longer an lvalue.  */
     case TYPE_CODE_ARRAY:
       {
-	struct type *elements = TYPE_TARGET_TYPE (value->type);
+	struct type *elements = ARRAY_ELEMENT_TYPE (value->type);
 	value->type = lookup_pointer_type (elements);
 	value->kind = axs_rvalue;
 	/* We don't need to generate any code; the address of the array
@@ -872,7 +872,7 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
   /* Dereference typedefs. */
   type = check_typedef (type);
 
-  switch (type->code)
+  switch (TYPE_CODE(type))
     {
     case TYPE_CODE_PTR:
       /* It's implementation-defined, and I'll bet this is what GCC
@@ -923,9 +923,9 @@ gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
 {
   struct type *element = TYPE_TARGET_TYPE (type);
 
-  if (element->length != 1)
+  if (TYPE_LENGTH(element) != 1)
     {
-      ax_const_l (ax, element->length);
+      ax_const_l (ax, TYPE_LENGTH(element));
       ax_simple (ax, op);
     }
 }
@@ -941,8 +941,8 @@ gen_add (struct agent_expr *ax, struct axs_value *value,
 	 struct axs_value *value1, struct axs_value *value2, char *name)
 {
   /* Is it INT+PTR?  */
-  if (value1->type->code == TYPE_CODE_INT
-      && value2->type->code == TYPE_CODE_PTR)
+  if (TYPE_CODE(value1->type) == TYPE_CODE_INT
+      && TYPE_CODE(value2->type) == TYPE_CODE_PTR)
     {
       /* Swap the values and proceed normally.  */
       ax_simple (ax, aop_swap);
@@ -953,8 +953,8 @@ gen_add (struct agent_expr *ax, struct axs_value *value,
     }
 
   /* Is it PTR+INT?  */
-  else if (value1->type->code == TYPE_CODE_PTR
-	   && value2->type->code == TYPE_CODE_INT)
+  else if (TYPE_CODE(value1->type) == TYPE_CODE_PTR
+	   && TYPE_CODE(value2->type) == TYPE_CODE_INT)
     {
       gen_scale (ax, aop_mul, value1->type);
       ax_simple (ax, aop_add);
@@ -964,8 +964,8 @@ gen_add (struct agent_expr *ax, struct axs_value *value,
 
   /* Must be number + number; the usual binary conversions will have
      brought them both to the same width.  */
-  else if (value1->type->code == TYPE_CODE_INT
-	   && value2->type->code == TYPE_CODE_INT)
+  else if (TYPE_CODE(value1->type) == TYPE_CODE_INT
+	   && TYPE_CODE(value2->type) == TYPE_CODE_INT)
     {
       ax_simple (ax, aop_add);
       gen_extend (ax, value1->type);	/* Catch overflow.  */
@@ -987,10 +987,10 @@ static void
 gen_sub (struct agent_expr *ax, struct axs_value *value,
 	 struct axs_value *value1, struct axs_value *value2)
 {
-  if (value1->type->code == TYPE_CODE_PTR)
+  if (TYPE_CODE(value1->type) == TYPE_CODE_PTR)
     {
       /* Is it PTR - INT?  */
-      if (value2->type->code == TYPE_CODE_INT)
+      if (TYPE_CODE(value2->type) == TYPE_CODE_INT)
 	{
 	  gen_scale (ax, aop_mul, value1->type);
 	  ax_simple (ax, aop_sub);
@@ -1001,7 +1001,7 @@ gen_sub (struct agent_expr *ax, struct axs_value *value,
       /* Is it PTR - PTR?  Strictly speaking, the types ought to
          match, but this is what the normal GDB expression evaluator
          tests for.  */
-      else if (value2->type->code == TYPE_CODE_PTR
+      else if (TYPE_CODE(value2->type) == TYPE_CODE_PTR
 	       && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
 		   == TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))))
 	{
@@ -1016,8 +1016,8 @@ an integer nor a pointer of the same type.");
     }
 
   /* Must be number + number.  */
-  else if (value1->type->code == TYPE_CODE_INT
-	   && value2->type->code == TYPE_CODE_INT)
+  else if (TYPE_CODE(value1->type) == TYPE_CODE_INT
+	   && TYPE_CODE(value2->type) == TYPE_CODE_INT)
     {
       ax_simple (ax, aop_sub);
       gen_extend (ax, value1->type);	/* Catch overflow.  */
@@ -1042,8 +1042,8 @@ gen_binop (struct agent_expr *ax, struct axs_value *value,
 	   enum agent_op op_unsigned, int may_carry, char *name)
 {
   /* We only handle INT op INT.  */
-  if ((value1->type->code != TYPE_CODE_INT)
-      || (value2->type->code != TYPE_CODE_INT))
+  if ((TYPE_CODE(value1->type) != TYPE_CODE_INT)
+      || (TYPE_CODE(value2->type) != TYPE_CODE_INT))
     error ("Illegal combination of types in %s.", name);
 
   ax_simple (ax,
@@ -1090,7 +1090,7 @@ gen_deref (struct agent_expr *ax, struct axs_value *value)
 {
   /* The caller should check the type, because several operators use
      this, and we don't know what error message to generate.  */
-  if (value->type->code != TYPE_CODE_PTR)
+  if (TYPE_CODE(value->type) != TYPE_CODE_PTR)
     internal_error (__FILE__, __LINE__,
 		    "gen_deref: expected a pointer");
 
@@ -1100,7 +1100,7 @@ gen_deref (struct agent_expr *ax, struct axs_value *value)
      T" to "T", and mark the value as an lvalue in memory.  Leave it
      to the consumer to actually dereference it.  */
   value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
-  value->kind = ((value->type->code == TYPE_CODE_FUNC)
+  value->kind = ((TYPE_CODE(value->type) == TYPE_CODE_FUNC)
 		 ? axs_rvalue : axs_lvalue_memory);
 }
 
@@ -1112,7 +1112,7 @@ gen_address_of (struct agent_expr *ax, struct axs_value *value)
   /* Special case for taking the address of a function.  The ANSI
      standard describes this as a special case, too, so this
      arrangement is not without motivation.  */
-  if (value->type->code == TYPE_CODE_FUNC)
+  if (TYPE_CODE(value->type) == TYPE_CODE_FUNC)
     /* The value's already an rvalue on the stack, so we just need to
        change the type.  */
     value->type = lookup_pointer_type (value->type);
@@ -1163,7 +1163,7 @@ find_field (struct type *type, char *name)
     }
 
   error ("Couldn't find member named `%s' in struct/union `%s'",
-	 name, type->tag_name);
+	 name, TYPE_TAG_NAME(type));
 
   return 0;
 }
@@ -1344,7 +1344,7 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
   /* Follow pointers until we reach a non-pointer.  These aren't the C
      semantics, but they're what the normal GDB evaluator does, so we
      should at least be consistent.  */
-  while (value->type->code == TYPE_CODE_PTR)
+  while (TYPE_CODE(value->type) == TYPE_CODE_PTR)
     {
       gen_usual_unary (ax, value);
       gen_deref (ax, value);
@@ -1408,7 +1408,7 @@ gen_repeat (union exp_element **pc, struct agent_expr *ax,
 
     if (!v)
       error ("Right operand of `@' must be a constant, in agent expressions.");
-    if (v->type->code != TYPE_CODE_INT)
+    if (TYPE_CODE(v->type) != TYPE_CODE_INT)
       error ("Right operand of `@' must be an integer.");
     length = value_as_long (v);
     if (length <= 0)
@@ -1417,11 +1417,11 @@ gen_repeat (union exp_element **pc, struct agent_expr *ax,
     /* The top of the stack is already the address of the object, so
        all we need to do is frob the type of the lvalue.  */
     {
-      /* FIXME-type-allocation: need a way to free this type when we are
+      /* TYPEFIX-type-allocation: need a way to free this type when we are
          done with it.  */
-      struct type *range
-      = create_range_type (0, builtin_type_int, 0, length - 1);
-      struct type *array = create_array_type (0, value1.type, range);
+      struct range_type *range
+      = make_range_type (NULL, builtin_type_int, 0, length - 1);
+      struct type *array = (struct type *)make_array_type (NULL, value1.type, range);
 
       value->kind = axs_lvalue_memory;
       value->type = array;