diff mbox

[v2] gdb: CTF support

Message ID 5377c457-52b0-583d-15b5-47024eae1f48@simark.ca
State New
Headers show

Commit Message

Simon Marchi Sept. 30, 2019, 3:06 a.m. UTC
Hi Weimin,

I am done reading ctfread.c, I noted a few comments below.

There are a few issues with styling as well, most importantly:

- The indentation
- Use "= NULL" / "!= NULL" when testing a pointer

Instead of pointing them out individually, I've fixed what I saw as I read
the patch, see the attached patch.  If you use it, please read through it
carefully and don't assume I haven't made mistakes :).

> +struct field_info
> +  {
> +    /* List of data member fields.  */
> +    std::vector<struct nextfield> fields;
> +
> +    /* Number of fields.  */
> +    int nfields = 0;

This field seems unnecessary, as it represents the size of the vector above (which you can get with fields.size()).

> +/* Callback to add member NAME to a struct/union type. TID is the type
> +   of struct/union member, OFFSET is the offset of member in bits
> +   (gdbarch_bits_big_endian(), and ARG contains the field_info.  */

This comment (the gdbarch_bits_big_endian part) seems incomplete).

> +/* Callback to add member NAME of EVAL to an enumeration type.
> +   ARG contains the field_info.  */
> +
> +static int
> +ctf_add_enum_member_cb (const char *name, int eval, void *arg)

I had to search why that variable was called EVAL.  It means "enum value", but I
automatically associate "eval" to "evaluate".  I'd suggest renaming it to "enum_value"
or "value" for clarity.

> +/* Add a new symbol entry, with its name from TP, its access index and
> +   domain from TP's kind, and its type from TPYE.  */

This comment refers to TP, which doesn't exist, so it seems outdated.  Also,
watch the typo "TPYE".

> +
> +static struct symbol *
> +new_symbol (ctf_context_t *ccp, struct type *type, ctf_id_t tid)
> +{
> +  struct objfile *objfile = ccp->of;
> +  ctf_file_t *fp = ccp->fp;
> +  struct symbol *sym = NULL;
> +
> +  const char *name = ctf_type_aname_raw (fp, tid);
> +  if (name)
> +    {
> +      sym = allocate_symbol (objfile);
> +      OBJSTAT (objfile, n_syms++);
> +
> +      SYMBOL_SET_LANGUAGE (sym, language_c, &objfile->objfile_obstack);
> +      SYMBOL_SET_NAMES (sym, xstrdup (name), strlen (name), 0, objfile);

Looking at the code of ctf_type_aname_raw, it seems to return an allocated copy,
which needs to be freed eventually.

Also, instead of calling xstrdup, you can just pass true to the COPY_NAME parameter.

> +/* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
> +   and create the symbol for it.  */
> +
> +static struct type *
> +read_base_type (ctf_context_t *ccp, ctf_id_t tid)
> +{
> +  struct objfile *of = ccp->of;
> +  ctf_file_t *fp = ccp->fp;
> +  ctf_encoding_t cet;
> +  struct type *type = NULL;
> +  const char *name;
> +  uint32_t kind;
> +
> +  if (ctf_type_encoding (fp, tid, &cet))
> +    {
> +      complaint (_("ctf_type_encoding read_base_type failed - %s"),
> +                 ctf_errmsg (ctf_errno (fp)));
> +      return NULL;
> +    }
> +
> +  name = ctf_type_aname_raw (fp, tid);
> +  if (!name || (name && !strlen (name)))

I think that can be written more simply (and in GNU style) as

  if (name == NULL || strlen (name) == 0)

> +/* Start a structure or union scope (definition) with TID and TP to create
> +   a type for the structure or union.

TP seems to refer to something that doesn't exist (anymore?).  This occurs a few times
in the file.

> +
> +   Fill in the type's name and general properties. The members will not be
> +   processed, nor a symbol table entry be done until process_structure_type
> +   (assuming the type has a name).  */
> +
> +static struct type *
> +read_structure_type (ctf_context_t *ccp, ctf_id_t tid)
> +{
> +  struct objfile *of = ccp->of;
> +  ctf_file_t *fp = ccp->fp;
> +  struct type *type;
> +  const char *name;
> +  uint32_t kind;

I'd suggest adding a gdb_assert to make sure that tid represents a struct or union
(and actually I'd suggest doing the same for all read_foo functions, make sure the
kind of the TID is what we expect).

> +  type = alloc_type (of);
> +  name = ctf_type_aname_raw (fp, tid);

ctf_type_aname_raw returns an allocated string.  Is it ever free'd?

This applies to other uses of ctf_type_aname_raw.

> +  if (name && strlen (name))
> +    TYPE_NAME (type) = name;
> +  kind = ctf_type_kind (fp, tid);
> +  if (kind == CTF_K_UNION)
> +    {
> +      TYPE_CODE (type) = TYPE_CODE_UNION;
> +    }
> +  else
> +    {
> +      TYPE_CODE (type) = TYPE_CODE_STRUCT;
> +    }
> +  TYPE_LENGTH (type) = ctf_type_size (fp, tid);
> +  set_type_align (type, ctf_type_align (fp, tid));
> +
> +  return set_tid_type (ccp->of, tid, type);
> +}
> +
> +/* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
> +   and create the symbol for it.  */
> +
> +static void
> +process_struct_members (ctf_context_t *ccp,
> +                        ctf_id_t tid,
> +                        struct type *type)
> +{
> +  ctf_file_t *fp = ccp->fp;
> +  struct field_info fi;> +
> +  fi.cur_context.fp = fp;
> +  fi.cur_context.of = ccp->of;
> +  fi.cur_context.builder = ccp->builder;

I might be missing something, but I find it odd to copy the whole ctf_context_t structure,
couldn't you just make field_info::cur_context a pointer, and just assign CCP to it?

> +/* Read TID of kind CTF_K_VOLATILE with base type BTID.  */
> +
> +static struct type *
> +read_volatile_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid)
> +{
> +  struct objfile *objfile = ccp->of;
> +  ctf_file_t *fp = ccp->fp;
> +  struct type *base_type, *cv_type;
> +
> +  base_type = get_tid_type (objfile, btid);
> +  if (!base_type)
> +    {

In read_const_type and read_restrict_type, you call read_type_record to read
in the type if it hasn't been read yet.  Is there a reason you don't do it here?

> +/* Add an ELF STT_FUNC symbol with index IDX to the symbol table.  */
> +
> +struct symbol *
> +add_stt_func (ctf_context_t *ccp, unsigned long idx)

static

> +/* Get text segment base for OBJFILE, TSIZE contains the segment size.  */
> +
> +static CORE_ADDR
> +get_of_text_range (struct objfile *of, int *tsize)

I'd suggest renaming this to get_objfile_text_range.  A few characters more,
but a lot clearer IMO.

> +/* Read in full symbols for PST, and anything it depends on.  */
> +
> +static void
> +psymtab_to_symtab (struct partial_symtab *pst)
> +{
> +  struct symbol *sym;
> +  ctf_context_t *ccp;
> +
> +  if (pst->readin == 1)
> +    return;

This should never happen (it's checked in ctf_read_symtab), so I would use:

  gdb_assert (!pst->readin);

> +/* Allocate a new partial_symtab NAME.  */
> +/* Each source file that has not been fully read in is represented by
> +   a partial_symtab.  This contains the information on where in the
> +   executable the debugging symbols for a specific file are, and a
> +   list of names of global symbols which are located in this file.
> +   They are all chained on partial symtab lists.
> +
> +   Even after the source file has been read into a symtab, the
> +   partial_symtab remains around.  They are allocated on an obstack,
> +   objfile_obstack.  */
> +
> +static struct partial_symtab *
> +create_partial_symtab (const char *name,
> +                       ctf_file_t *cfp,
> +                       struct objfile *objfile)
> +{
> +  struct partial_symtab *pst;
> +  static ctf_context_t ccx;
> +
> +  pst = start_psymtab_common (objfile, name, 0);
> +
> +  ccx.fp = cfp;
> +  ccx.of = objfile;
> +  pst->read_symtab_private = (void *)&ccx;

Hmm that looks fishy.  It looks like this is taking the address of a
local variable for something that will be used after the current function
will have returned.

> +/* Setup partial_symtab's describing each source file for which
> +   debugging information is available.  */
> +
> +static void
> +scan_partial_symbols (ctf_file_t *cfp, struct objfile *of)
> +{
> +  ctf_context_t ccx;
> +  bfd *abfd = of->obfd;
> +  char *name = bfd_get_filename (abfd);
> +  struct partial_symtab *pst = create_partial_symtab (name, cfp, of);
> +
> +  ccx.fp = cfp;
> +  ccx.of = of;
> +  if (ctf_type_iter (cfp, ctf_psymtab_type_cb, &ccx) == CTF_ERR)
> +    {
> +      complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
> +                 ctf_errmsg (ctf_errno (cfp)));
> +    }
> +
> +  if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, &ccx) == CTF_ERR)
> +    {
> +      complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
> +                 ctf_errmsg (ctf_errno (cfp)));
> +    }
> +
> +  /* Scan CTF object and function sections which correspond to each
> +     STT_FUNC or STT_OBJECT entry in the symbol table,
> +     pick up what init_symtab has done.  */
> +  for (unsigned long idx = 0; ; idx++)
> +    {
> +      ctf_id_t tid;
> +      if ((tid = ctf_lookup_by_symbol (cfp, idx)) == CTF_ERR)
> +        {
> +	if (ctf_errno (cfp) == EINVAL
> +           || ctf_errno (cfp) == ECTF_NOSYMTAB)
> +	    // case ECTF_SYMRANGE:
> +	  break;

Is this comment (the "case ECTF_SYMRANGE:" comment) a leftover?

Also, if these cases happen, it means the debug information is not valid/corrupted?
Should there be an error printed to the user, should we maybe call error()?

Simon
diff mbox

Patch

From 51ee2314deec65e928228d15c1aa7d856020b333 Mon Sep 17 00:00:00 2001
From: Simon Marchi <simon.marchi@polymtl.ca>
Date: Sat, 28 Sep 2019 14:43:36 -0400
Subject: [PATCH] fixups

---
 gdb/ctfread.c | 564 ++++++++++++++++++++++++--------------------------
 1 file changed, 274 insertions(+), 290 deletions(-)

diff --git a/gdb/ctfread.c b/gdb/ctfread.c
index 9b6c70ee4d34..59d76c500fca 100644
--- a/gdb/ctfread.c
+++ b/gdb/ctfread.c
@@ -106,29 +106,28 @@  struct nextfield
 };
 
 struct field_info
-  {
-    /* List of data member fields.  */
-    std::vector<struct nextfield> fields;
+{
+  /* List of data member fields.  */
+  std::vector<struct nextfield> fields;
 
-    /* Number of fields.  */
-    int nfields = 0;
+  /* Number of fields.  */
+  int nfields = 0;
 
-    /* Context.  */
-    ctf_context_t cur_context;
+  /* Context.  */
+  ctf_context_t cur_context;
 
-    /* Parent type.  */
-    struct type *ptype;
+  /* Parent type.  */
+  struct type *ptype;
 
-    /* typedefs defined inside this class.  TYPEDEF_FIELD_LIST contains head
-       of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements.  */
-    std::vector<struct decl_field> typedef_field_list;
+  /* typedefs defined inside this class.  TYPEDEF_FIELD_LIST contains head
+     of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements.  */
+  std::vector<struct decl_field> typedef_field_list;
 
-    /* Nested types defined by this struct and the number of elements in
-       this list.  */
-    std::vector<struct decl_field> nested_types_list;
-  };
+  /* Nested types defined by this struct and the number of elements in
+     this list.  */
+  std::vector<struct decl_field> nested_types_list;
+};
 
-
 /* Local function prototypes */
 
 static void psymtab_to_symtab (struct partial_symtab *);
@@ -138,24 +137,24 @@  static int ctf_add_type_cb (ctf_id_t tid, void *arg);
 static struct type *read_array_type (ctf_context_t *ccp, ctf_id_t tid);
 
 static struct type *read_pointer_type (ctf_context_t *ccp, ctf_id_t tid,
-                                       ctf_id_t btid);
+				       ctf_id_t btid);
 
 static struct type *read_structure_type (ctf_context_t *ccp, ctf_id_t tid);
 
 static struct type *read_enum_type (ctf_context_t *ccp, ctf_id_t tid);
 
 static struct type *read_typedef_type (ctf_context_t *ccp, ctf_id_t tid,
-                                       ctf_id_t btid, const char *name);
+				       ctf_id_t btid, const char *name);
 
 static struct type *read_type_record (ctf_context_t *ccp, ctf_id_t tid);
 
 static void process_structure_type (ctf_context_t *ccp, ctf_id_t tid);
 
 static void process_struct_members (ctf_context_t *ccp, ctf_id_t tid,
-                        struct type *type);
+				    struct type *type);
 
-static struct symbol * new_symbol (ctf_context_t *ccp, struct type *type,
-                                   ctf_id_t tid);
+static struct symbol *new_symbol (ctf_context_t *ccp, struct type *type,
+				  ctf_id_t tid);
 
 struct ctf_tid_and_type
 {
@@ -198,8 +197,8 @@  set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ)
   if (htab == NULL)
     {
       htab = htab_create_alloc (1, tid_and_type_hash,
-                                tid_and_type_eq,
-                                NULL, xcalloc, xfree);
+				tid_and_type_eq,
+				NULL, xcalloc, xfree);
       ctf_tid_key.set (of, htab);
     }
 
@@ -209,7 +208,7 @@  set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ)
   slot = (struct ctf_tid_and_type **) htab_find_slot (htab, &ids, INSERT);
   if (*slot)
     complaint (_("An internal GDB problem: ctf_ id_t %ld type already set"),
-               (tid));
+	       (tid));
   *slot = XOBNEW (&of->objfile_obstack, struct ctf_tid_and_type);
   **slot = ids;
   return typ;
@@ -248,9 +247,7 @@  get_bitsize (ctf_file_t *fp, ctf_id_t tid, uint32_t kind)
       || kind == CTF_K_FLOAT)
       && ctf_type_reference (fp, tid) != CTF_ERR
       && ctf_type_encoding (fp, tid, &cet) != CTF_ERR)
-    {
-      return cet.cte_bits;
-    }
+    return cet.cte_bits;
 
   return 0;
 }
@@ -278,13 +275,13 @@  attach_fields_to_type (struct field_info *fip, struct type *type)
 {
   int nfields = fip->nfields;
 
-  if (!nfields)
+  if (nfields == 0)
     return;
 
   /* Record the field count, allocate space for the array of fields.  */
   TYPE_NFIELDS (type) = nfields;
-  TYPE_FIELDS (type) = (struct field *)
-    TYPE_ZALLOC (type, sizeof (struct field) * nfields);
+  TYPE_FIELDS (type)
+    = (struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields);
 
   /* Copy the saved-up fields into the field vector.  */
   for (int i = 0; i < nfields; ++i)
@@ -300,16 +297,16 @@  attach_fields_to_type (struct field_info *fip, struct type *type)
 
 static struct type *
 ctf_init_float_type (struct objfile *objfile,
-                     int bits,
-                     const char *name,
-                     const char *name_hint)
+		     int bits,
+		     const char *name,
+		     const char *name_hint)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   const struct floatformat **format;
   struct type *type;
 
   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
-  if (format)
+  if (format != NULL)
     type = init_float_type (objfile, bits, name, format);
   else
     type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
@@ -323,11 +320,11 @@  ctf_init_float_type (struct objfile *objfile,
 
 static int
 ctf_add_member_cb (const char *name,
-                   ctf_id_t tid,
-                   unsigned long offset,
-                   void *arg)
+		   ctf_id_t tid,
+		   unsigned long offset,
+		   void *arg)
 {
-  struct field_info *fip = (struct field_info *)arg;
+  struct field_info *fip = (struct field_info *) arg;
   ctf_context_t *ccp = &fip->cur_context;
   struct nextfield new_field;
   struct field *fp;
@@ -339,21 +336,19 @@  ctf_add_member_cb (const char *name,
 
   kind = ctf_type_kind (ccp->fp, tid);
   t = get_tid_type (ccp->of, tid);
-  if (!t)
+  if (t == NULL)
     {
       t = read_type_record (ccp, tid);
-      if (!t)
-        {
-          complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name, tid);
-          t = objfile_type (ccp->of)->builtin_error;
-          set_tid_type (ccp->of, tid, t);
-        }
+      if (t == NULL)
+	{
+	  complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name, tid);
+	  t = objfile_type (ccp->of)->builtin_error;
+	  set_tid_type (ccp->of, tid, t);
+	}
     }
 
   if (kind == CTF_K_STRUCT || kind == CTF_K_UNION)
-    {
-      process_struct_members (ccp, tid, t);
-    }
+    process_struct_members (ccp, tid, t);
 
   FIELD_TYPE (*fp) = t;
   SET_FIELD_BITPOS (*fp, offset / TARGET_CHAR_BIT);
@@ -371,7 +366,7 @@  ctf_add_member_cb (const char *name,
 static int
 ctf_add_enum_member_cb (const char *name, int eval, void *arg)
 {
-  struct field_info *fip = (struct field_info *)arg;
+  struct field_info *fip = (struct field_info *) arg;
   struct nextfield new_field;
   struct field *fp;
   ctf_context_t *ccp = &fip->cur_context;
@@ -382,7 +377,7 @@  ctf_add_enum_member_cb (const char *name, int eval, void *arg)
   SET_FIELD_ENUMVAL (*fp, eval);
   FIELD_BITSIZE (*fp) = 0;
 
-  if (name)
+  if (name != NULL)
     {
       struct symbol *sym = allocate_symbol (ccp->of);
       OBJSTAT (ccp->of, n_syms++);
@@ -412,7 +407,7 @@  new_symbol (ctf_context_t *ccp, struct type *type, ctf_id_t tid)
   struct symbol *sym = NULL;
 
   const char *name = ctf_type_aname_raw (fp, tid);
-  if (name)
+  if (name != NULL)
     {
       sym = allocate_symbol (objfile);
       OBJSTAT (objfile, n_syms++);
@@ -428,33 +423,33 @@  new_symbol (ctf_context_t *ccp, struct type *type, ctf_id_t tid)
       uint32_t kind = ctf_type_kind (fp, tid);
       switch (kind)
 	{
-      	  case CTF_K_STRUCT:
-      	  case CTF_K_UNION:
-      	  case CTF_K_ENUM:
+	  case CTF_K_STRUCT:
+	  case CTF_K_UNION:
+	  case CTF_K_ENUM:
 	    SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
 	    SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
 	    break;
-      	  case CTF_K_FUNCTION:
+	  case CTF_K_FUNCTION:
 	    SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
 	    break;
-      	  case CTF_K_CONST:
+	  case CTF_K_CONST:
 	    if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
 	      SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
 	    break;
-      	  case CTF_K_TYPEDEF:
-      	  case CTF_K_INTEGER:
-      	  case CTF_K_FLOAT:
+	  case CTF_K_TYPEDEF:
+	  case CTF_K_INTEGER:
+	  case CTF_K_FLOAT:
 	    SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
 	    SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 	    break;
-      	  case CTF_K_POINTER:
+	  case CTF_K_POINTER:
 	    break;
-      	  case CTF_K_VOLATILE:
-      	  case CTF_K_RESTRICT:
+	  case CTF_K_VOLATILE:
+	  case CTF_K_RESTRICT:
 	    break;
-      	  case CTF_K_SLICE:
-      	  case CTF_K_ARRAY:
-      	  case CTF_K_UNKNOWN:
+	  case CTF_K_SLICE:
+	  case CTF_K_ARRAY:
+	  case CTF_K_UNKNOWN:
 	    break;
 	}
 
@@ -480,17 +475,17 @@  read_base_type (ctf_context_t *ccp, ctf_id_t tid)
   if (ctf_type_encoding (fp, tid, &cet))
     {
       complaint (_("ctf_type_encoding read_base_type failed - %s"),
-                 ctf_errmsg (ctf_errno (fp)));
+		 ctf_errmsg (ctf_errno (fp)));
       return NULL;
     }
 
   name = ctf_type_aname_raw (fp, tid);
-  if (!name || (name && !strlen (name)))
+  if (name == NULL || strlen (name) == 0)
     {
       name = ctf_type_aname (fp, tid);
-      if (!name)
-        complaint (_("ctf_type_aname read_base_type failed - %s"),
-                   ctf_errmsg (ctf_errno (fp)));
+      if (name == NULL)
+	complaint (_("ctf_type_aname read_base_type failed - %s"),
+		   ctf_errmsg (ctf_errno (fp)));
     }
 
   kind = ctf_type_kind (fp, tid);
@@ -503,10 +498,10 @@  read_base_type (ctf_context_t *ccp, ctf_id_t tid)
       ischar = cet.cte_format & CTF_INT_CHAR;
       isbool = cet.cte_format & CTF_INT_BOOL;
       if (ischar)
-      	type = init_character_type (of, TARGET_CHAR_BIT, !issigned, name);
+	type = init_character_type (of, TARGET_CHAR_BIT, !issigned, name);
       else if (isbool)
-      	type = init_boolean_type (of, gdbarch_int_bit (gdbarch),
-                                  !issigned, name);
+	type = init_boolean_type (of, gdbarch_int_bit (gdbarch),
+				  !issigned, name);
       else
 	{
 	  int bits;
@@ -514,25 +509,23 @@  read_base_type (ctf_context_t *ccp, ctf_id_t tid)
 	    bits = cet.cte_bits;
 	  else
 	    bits = gdbarch_int_bit (gdbarch);
-      	  type = init_integer_type (of, bits, !issigned, name);
+	  type = init_integer_type (of, bits, !issigned, name);
 	}
     }
   else if (kind == CTF_K_FLOAT)
     {
       uint32_t isflt;
       isflt = !((cet.cte_format & CTF_FP_IMAGRY) == CTF_FP_IMAGRY
-                 || (cet.cte_format & CTF_FP_DIMAGRY) == CTF_FP_DIMAGRY
-                 || (cet.cte_format & CTF_FP_LDIMAGRY) == CTF_FP_LDIMAGRY);
+		 || (cet.cte_format & CTF_FP_DIMAGRY) == CTF_FP_DIMAGRY
+		 || (cet.cte_format & CTF_FP_LDIMAGRY) == CTF_FP_LDIMAGRY);
       if (isflt)
-        {
-	  type = ctf_init_float_type (of, cet.cte_bits, name, name);
-        }
+	type = ctf_init_float_type (of, cet.cte_bits, name, name);
       else
-        {
-	  struct type *t;
-	  t = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name);
-      	  type = init_complex_type (of, name, t);
-        }
+	{
+	  struct type *t
+	    = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name);
+	  type = init_complex_type (of, name, t);
+	}
     }
   else
     {
@@ -540,7 +533,7 @@  read_base_type (ctf_context_t *ccp, ctf_id_t tid)
       type = init_type (of, TYPE_CODE_ERROR, cet.cte_bits, name);
     }
 
-  if (name && strcmp (name, "char") == 0)
+  if (name != NULL && strcmp (name, "char") == 0)
     TYPE_NOSIGN (type) = 1;
 
   return set_tid_type (of, tid, type);
@@ -572,18 +565,17 @@  read_structure_type (ctf_context_t *ccp, ctf_id_t tid)
   uint32_t kind;
 
   type = alloc_type (of);
+
   name = ctf_type_aname_raw (fp, tid);
-  if (name && strlen (name))
+  if (name != NULL && strlen (name) != 0)
     TYPE_NAME (type) = name;
+
   kind = ctf_type_kind (fp, tid);
   if (kind == CTF_K_UNION)
-    {
-      TYPE_CODE (type) = TYPE_CODE_UNION;
-    }
+    TYPE_CODE (type) = TYPE_CODE_UNION;
   else
-    {
-      TYPE_CODE (type) = TYPE_CODE_STRUCT;
-    }
+    TYPE_CODE (type) = TYPE_CODE_STRUCT;
+
   TYPE_LENGTH (type) = ctf_type_size (fp, tid);
   set_type_align (type, ctf_type_align (fp, tid));
 
@@ -595,8 +587,8 @@  read_structure_type (ctf_context_t *ccp, ctf_id_t tid)
 
 static void
 process_struct_members (ctf_context_t *ccp,
-                        ctf_id_t tid,
-                        struct type *type)
+			ctf_id_t tid,
+			struct type *type)
 {
   ctf_file_t *fp = ccp->fp;
   struct field_info fi;
@@ -605,10 +597,8 @@  process_struct_members (ctf_context_t *ccp,
   fi.cur_context.of = ccp->of;
   fi.cur_context.builder = ccp->builder;
   if (ctf_member_iter (fp, tid, ctf_add_member_cb, &fi) == CTF_ERR)
-    {
-      complaint (_("ctf_member_iter process_struct_members failed - %s"),
-                 ctf_errmsg (ctf_errno (fp)));
-    }
+    complaint (_("ctf_member_iter process_struct_members failed - %s"),
+	       ctf_errmsg (ctf_errno (fp)));
 
   /* Attach fields to the type.  */
   attach_fields_to_type (&fi, type);
@@ -617,8 +607,7 @@  process_struct_members (ctf_context_t *ccp,
 }
 
 static void
-process_structure_type (ctf_context_t *ccp,
-                        ctf_id_t tid)
+process_structure_type (ctf_context_t *ccp, ctf_id_t tid)
 {
   struct type *type;
 
@@ -638,9 +627,11 @@  read_func_kind_type (ctf_context_t *ccp, ctf_id_t tid)
   const char *name;
 
   type = alloc_type (objfile);
+
   name = ctf_type_aname_raw (fp, tid);
-  if (name && strlen (name))
+  if (name != NULL && strlen (name) != 0)
     TYPE_NAME (type) = name;
+
   TYPE_CODE (type) = TYPE_CODE_FUNC;
   ctf_func_type_info (fp, tid, &cfi);
   rettype = get_tid_type (objfile, cfi.ctc_return);
@@ -654,8 +645,7 @@  read_func_kind_type (ctf_context_t *ccp, ctf_id_t tid)
    the enumeration, and create the symbol for the enumeration type.  */
 
 static struct type *
-read_enum_type (ctf_context_t *ccp,
-                       ctf_id_t tid)
+read_enum_type (ctf_context_t *ccp, ctf_id_t tid)
 {
   struct objfile *of = ccp->of;
   ctf_file_t *fp = ccp->fp;
@@ -664,9 +654,11 @@  read_enum_type (ctf_context_t *ccp,
   const char *name;
 
   type = alloc_type (of);
+
   name = ctf_type_aname_raw (fp, tid);
   if (name && strlen (name))
     TYPE_NAME (type) = name;
+
   TYPE_CODE (type) = TYPE_CODE_ENUM;
   TYPE_LENGTH (type) = ctf_type_size (fp, tid);
   ctf_func_type_info (fp, tid, &fi);
@@ -679,7 +671,7 @@  read_enum_type (ctf_context_t *ccp,
 
 static void
 process_enum_type (ctf_context_t *ccp,
-                   ctf_id_t tid)
+		   ctf_id_t tid)
 {
   ctf_file_t *fp = ccp->fp;
   struct type *type;
@@ -692,10 +684,8 @@  process_enum_type (ctf_context_t *ccp,
   fi.cur_context.builder = ccp->builder;
   fi.ptype = type;
   if (ctf_enum_iter (fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR)
-    {
-      complaint (_("ctf_enum_iter process_enum_type failed - %s"),
-                 ctf_errmsg (ctf_errno (fp)));
-    }
+    complaint (_("ctf_enum_iter process_enum_type failed - %s"),
+	       ctf_errmsg (ctf_errno (fp)));
 
   /* Attach fields to the type.  */
   attach_fields_to_type (&fi, type);
@@ -707,10 +697,10 @@  process_enum_type (ctf_context_t *ccp,
 
 static struct type *
 add_array_cv_type (ctf_context_t *ccp,
-                   ctf_id_t tid,
-                   struct type *base_type,
-                   int cnst,
-                   int voltl)
+		   ctf_id_t tid,
+		   struct type *base_type,
+		   int cnst,
+		   int voltl)
 {
   struct type *el_type, *inner_array;
 
@@ -719,8 +709,8 @@  add_array_cv_type (ctf_context_t *ccp,
 
   while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
     {
-      TYPE_TARGET_TYPE (inner_array) =
-	copy_type (TYPE_TARGET_TYPE (inner_array));
+      TYPE_TARGET_TYPE (inner_array)
+	= copy_type (TYPE_TARGET_TYPE (inner_array));
       inner_array = TYPE_TARGET_TYPE (inner_array);
     }
 
@@ -746,17 +736,19 @@  read_array_type (ctf_context_t *ccp, ctf_id_t tid)
   if (ctf_array_info (fp, tid, &ar) == CTF_ERR)
     {
       complaint (_("ctf_array_info read_array_type failed - %s"),
-                 ctf_errmsg (ctf_errno (fp)));
+		 ctf_errmsg (ctf_errno (fp)));
       return NULL;
     }
+
   element_type = get_tid_type (objfile, ar.ctr_contents);
-  if (!element_type)
+  if (element_type == NULL)
     return NULL;
+
   idx_type = get_tid_type (objfile, ar.ctr_index);
-  if (!idx_type)
+  if (idx_type == NULL)
     idx_type = objfile_type (objfile)->builtin_int;
 
-  range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems-1);
+  range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems - 1);
   type = create_array_type (NULL, element_type, range_type);
   if (ar.ctr_nelems <= 1)	/* Check if undefined upper bound.  */
     {
@@ -765,9 +757,8 @@  read_array_type (ctf_context_t *ccp, ctf_id_t tid)
       TYPE_TARGET_STUB (type) = 1;
     }
   else
-    {
-      TYPE_LENGTH (type) = ctf_type_size (fp, tid);
-    }
+    TYPE_LENGTH (type) = ctf_type_size (fp, tid);
+
   set_type_align (type, ctf_type_align (fp, tid));
 
   return set_tid_type (objfile, tid, type);
@@ -785,11 +776,11 @@  read_const_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid)
   if (base_type == NULL)
     {
       base_type = read_type_record (ccp, btid);
-      if (!base_type)
-        {
-          complaint (_("read_const_type: NULL base type (%ld)"), btid);
+      if (base_type == NULL)
+	{
+	  complaint (_("read_const_type: NULL base type (%ld)"), btid);
 	  base_type = objfile_type (objfile)->builtin_error;
-        }
+	}
     }
   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
 
@@ -806,7 +797,7 @@  read_volatile_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid)
   struct type *base_type, *cv_type;
 
   base_type = get_tid_type (objfile, btid);
-  if (!base_type)
+  if (base_type == NULL)
     {
       complaint (_("read_volatile_type: NULL base type (%ld)"), btid);
       base_type = objfile_type (objfile)->builtin_error;
@@ -831,11 +822,11 @@  read_restrict_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid)
   if (base_type == NULL)
     {
       base_type = read_type_record (ccp, btid);
-      if (!base_type)
-        {
-          complaint (_("read_restrict_type: NULL base type (%ld)"), btid);
+      if (base_type == NULL)
+	{
+	  complaint (_("read_restrict_type: NULL base type (%ld)"), btid);
 	  base_type = objfile_type (objfile)->builtin_error;
-        }
+	}
     }
   cv_type = make_restrict_type (base_type);
 
@@ -846,7 +837,7 @@  read_restrict_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid)
 
 static struct type *
 read_typedef_type (ctf_context_t *ccp, ctf_id_t tid,
-                   ctf_id_t btid, const char *name)
+		   ctf_id_t btid, const char *name)
 {
   struct objfile *objfile = ccp->of;
   struct type *this_type, *target_type;
@@ -858,7 +849,7 @@  read_typedef_type (ctf_context_t *ccp, ctf_id_t tid,
     TYPE_TARGET_TYPE (this_type) = target_type;
   else
     TYPE_TARGET_TYPE (this_type) = NULL;
-  TYPE_TARGET_STUB (this_type) = TYPE_TARGET_TYPE (this_type)? 1 : 0;
+  TYPE_TARGET_STUB (this_type) = TYPE_TARGET_TYPE (this_type) ? 1 : 0;
 
   return set_tid_type (objfile, tid, this_type);
 }
@@ -872,14 +863,14 @@  read_pointer_type (ctf_context_t *ccp, ctf_id_t tid, ctf_id_t btid)
   struct type *target_type, *type;
 
   target_type = get_tid_type (of, btid);
-  if (!target_type)
+  if (target_type == NULL)
     {
       target_type = read_type_record (ccp, btid);
-      if (!target_type)
-        {
-          complaint (_("read_pointer_type: NULL target type (%ld)"), btid);
+      if (target_type == NULL)
+	{
+	  complaint (_("read_pointer_type: NULL target type (%ld)"), btid);
 	  target_type = objfile_type (ccp->of)->builtin_error;
-        }
+	}
     }
 
   type = lookup_pointer_type (target_type);
@@ -908,42 +899,42 @@  read_type_record (ctf_context_t *ccp, ctf_id_t tid)
 	break;
       case CTF_K_ENUM:
 	type = read_enum_type (ccp, tid);
-        break;
+	break;
       case CTF_K_FUNCTION:
 	type = read_func_kind_type (ccp, tid);
-        break;
+	break;
       case CTF_K_CONST:
-        btid = ctf_type_reference (fp, tid);
+	btid = ctf_type_reference (fp, tid);
 	type = read_const_type (ccp, tid, btid);
-        break;
+	break;
       case CTF_K_TYPEDEF:
-        name = ctf_type_aname_raw (fp, tid);
-        btid = ctf_type_reference (fp, tid);
+	name = ctf_type_aname_raw (fp, tid);
+	btid = ctf_type_reference (fp, tid);
 	type = read_typedef_type (ccp, tid, btid, name);
-        break;
+	break;
       case CTF_K_VOLATILE:
-        btid = ctf_type_reference (fp, tid);
+	btid = ctf_type_reference (fp, tid);
 	type = read_volatile_type (ccp, tid, btid);
-        break;
+	break;
       case CTF_K_RESTRICT:
-        btid = ctf_type_reference (fp, tid);
+	btid = ctf_type_reference (fp, tid);
 	type = read_restrict_type (ccp, tid, btid);
-        break;
+	break;
       case CTF_K_POINTER:
-        btid = ctf_type_reference (fp, tid);
+	btid = ctf_type_reference (fp, tid);
 	type = read_pointer_type (ccp, tid, btid);
-        break;
+	break;
       case CTF_K_INTEGER:
       case CTF_K_FLOAT:
 	type = read_base_type (ccp, tid);
-        break;
+	break;
       case CTF_K_ARRAY:
 	type = read_array_type (ccp, tid);
-        break;
+	break;
       case CTF_K_UNKNOWN:
-        break;
+	break;
       default:
-        break;
+	break;
     }
 
   return type;
@@ -960,7 +951,7 @@  ctf_add_type_cb (ctf_id_t tid, void *arg)
 
   /* Check if tid's type has already been defined.  */
   type = get_tid_type (ccp->of, tid);
-  if (type)
+  if (type != NULL)
     return 0;
 
   ctf_id_t btid = ctf_type_reference (ccp->fp, tid);
@@ -973,42 +964,42 @@  ctf_add_type_cb (ctf_id_t tid, void *arg)
 	break;
       case CTF_K_ENUM:
 	process_enum_type (ccp, tid);
-        break;
+	break;
       case CTF_K_FUNCTION:
 	type = read_func_kind_type (ccp, tid);
 	new_symbol (ccp, type, tid);
-        break;
+	break;
       case CTF_K_INTEGER:
       case CTF_K_FLOAT:
 	process_base_type (ccp, tid);
-        break;
+	break;
       case CTF_K_TYPEDEF:
 	new_symbol (ccp, read_type_record (ccp, tid), tid);
-        break;
+	break;
       case CTF_K_CONST:
 	type = read_const_type (ccp, tid, btid);
 	new_symbol (ccp, type, tid);
-        break;
+	break;
       case CTF_K_VOLATILE:
 	type = read_volatile_type (ccp, tid, btid);
 	new_symbol (ccp, type, tid);
-        break;
+	break;
       case CTF_K_RESTRICT:
 	type = read_restrict_type (ccp, tid, btid);
 	new_symbol (ccp, type, tid);
-        break;
+	break;
       case CTF_K_POINTER:
 	type = read_pointer_type (ccp, tid, btid);
 	new_symbol (ccp, type, tid);
-        break;
+	break;
       case CTF_K_ARRAY:
 	type = read_array_type (ccp, tid);
 	new_symbol (ccp, type, tid);
-        break;
+	break;
       case CTF_K_UNKNOWN:
-        break;
+	break;
       default:
-        break;
+	break;
     }
 
   return 0;
@@ -1031,8 +1022,8 @@  ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
     {
       case CTF_K_FUNCTION:
 	if (name && !strcmp(name, "main"))
-          set_objfile_main_name (ccp->of, name, language_c);
-        break;
+	  set_objfile_main_name (ccp->of, name, language_c);
+	break;
       case CTF_K_INTEGER:
       case CTF_K_FLOAT:
       case CTF_K_VOLATILE:
@@ -1041,44 +1032,42 @@  ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
       case CTF_K_CONST:
       case CTF_K_POINTER:
       case CTF_K_ARRAY:
-        if (type)
-    	  {
+	if (type)
+	  {
 	    sym = new_symbol (ccp, type, id);
-            SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of);
-          }
-        break;
+	    SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of);
+	  }
+	break;
       case CTF_K_STRUCT:
       case CTF_K_UNION:
       case CTF_K_ENUM:
-        if (!type)
-        {
-          complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
-          type = objfile_type (ccp->of)->builtin_error;
-        }
-        sym = allocate_symbol (ccp->of);
-        OBJSTAT (ccp->of, n_syms++);
+	if (!type)
+	{
+	  complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
+	  type = objfile_type (ccp->of)->builtin_error;
+	}
+	sym = allocate_symbol (ccp->of);
+	OBJSTAT (ccp->of, n_syms++);
 	SYMBOL_TYPE (sym) = type;
 	SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-        SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
-        SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of);
-        add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
-        break;
+	SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
+	SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of);
+	add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
+	break;
       default:
-        complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind);
-        break;
+	complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind);
+	break;
     }
 
   if (sym)
-    {
-      set_symbol_address (ccp->of, sym, name);
-    }
+    set_symbol_address (ccp->of, sym, name);
 
   return 0;
 }
 
 /* Add an ELF STT_OBJ symbol with index IDX to the symbol table.  */
 
-struct symbol *
+static struct symbol *
 add_stt_obj (ctf_context_t *ccp, unsigned long idx)
 {
   const char *name;
@@ -1096,6 +1085,7 @@  add_stt_obj (ctf_context_t *ccp, unsigned long idx)
   name = ctf_type_aname_raw (ccp->fp, idx);
   if (name == NULL)
     return NULL;
+
   sym = new_symbol (ccp, type, tid);
   SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of);
 
@@ -1104,7 +1094,7 @@  add_stt_obj (ctf_context_t *ccp, unsigned long idx)
 
 /* Add an ELF STT_FUNC symbol with index IDX to the symbol table.  */
 
-struct symbol *
+static struct symbol *
 add_stt_func (ctf_context_t *ccp, unsigned long idx)
 {
   struct type *ftype, *atyp, *rettyp;
@@ -1126,15 +1116,17 @@  add_stt_func (ctf_context_t *ccp, unsigned long idx)
   name = ctf_type_aname_raw (ccp->fp, idx);
   if (name == NULL)
     return NULL;
+
   tid = ctf_lookup_by_symbol (ccp->fp, idx);
   ftype = get_tid_type (ccp->of, tid);
   if (finfo.ctc_flags & CTF_FUNC_VARARG)
     TYPE_VARARGS (ftype) = 1;
   TYPE_NFIELDS (ftype) = argc;
+
   /* If argc is 0, it has a "void" type.  */
-  if (argc)
-    TYPE_FIELDS (ftype) = (struct field *)
-      TYPE_ZALLOC (ftype, argc * sizeof (struct field));
+  if (argc != 0)
+    TYPE_FIELDS (ftype)
+      = (struct field *) TYPE_ZALLOC (ftype, argc * sizeof (struct field));
 
   /* TYPE_FIELD_TYPE must never be NULL.  Fill it with void_type, if failed
      to find the argument type.  */
@@ -1142,9 +1134,9 @@  add_stt_func (ctf_context_t *ccp, unsigned long idx)
     {
       atyp = get_tid_type (ccp->of, argv[iparam]);
       if (atyp)
-    	TYPE_FIELD_TYPE (ftype, iparam) = atyp;
+	TYPE_FIELD_TYPE (ftype, iparam) = atyp;
       else
-    	TYPE_FIELD_TYPE (ftype, iparam) = void_type;
+	TYPE_FIELD_TYPE (ftype, iparam) = void_type;
     }
 
   sym = new_symbol (ccp, ftype, tid);
@@ -1153,6 +1145,7 @@  add_stt_func (ctf_context_t *ccp, unsigned long idx)
     SYMBOL_TYPE (sym) = rettyp;
   else
     SYMBOL_TYPE (sym) = void_type;
+
   SYMBOL_SET_NAMES (sym, name, strlen (name), 0, ccp->of);
 
   return sym;
@@ -1168,7 +1161,7 @@  get_of_text_range (struct objfile *of, int *tsize)
   const asection *codes;
 
   codes = bfd_get_section_by_name (abfd, ".text");
-  if (!codes)
+  if (codes == NULL)
     {
       text_base = 0;
       *tsize = 0;
@@ -1186,14 +1179,14 @@  get_of_text_range (struct objfile *of, int *tsize)
 
 static void
 ctf_start_symtab (struct partial_symtab *pst,
-                  struct objfile *of, CORE_ADDR text_offset)
+		  struct objfile *of, CORE_ADDR text_offset)
 {
   ctf_context_t *ccp;
 
   ccp = (ctf_context_t *) pst->read_symtab_private;
-  ccp->builder = new struct buildsym_compunit
+  ccp->builder = new buildsym_compunit
 		       (of, of->original_name, NULL,
-	               language_c, text_offset);
+		       language_c, text_offset);
   ccp->builder->record_debugformat ("ctf");
 }
 
@@ -1203,7 +1196,7 @@  ctf_start_symtab (struct partial_symtab *pst,
 
 static struct compunit_symtab *
 ctf_end_symtab (struct partial_symtab *pst,
-                CORE_ADDR end_addr, int section)
+		CORE_ADDR end_addr, int section)
 {
   ctf_context_t *ccp;
 
@@ -1223,38 +1216,33 @@  psymtab_to_symtab (struct partial_symtab *pst)
   struct symbol *sym;
   ctf_context_t *ccp;
 
-  if (pst->readin == 1)
+  if (pst->readin)
     return;
 
   ccp = (ctf_context_t *) pst->read_symtab_private;
 
   /* Iterate over entries in data types section.  */
   if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
-    {
-      complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
-                 ctf_errmsg (ctf_errno (ccp->fp)));
-    }
-
+    complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
+	       ctf_errmsg (ctf_errno (ccp->fp)));
 
   /* Iterate over entries in variable info section.  */
   if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR)
-    {
-      complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
-                 ctf_errmsg (ctf_errno (ccp->fp)));
-    }
+    complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
+	       ctf_errmsg (ctf_errno (ccp->fp)));
 
   /* Add entries in data objects and function info sections.  */
   for (unsigned long i = 0; ; i++)
     {
       sym = add_stt_obj (ccp, i);
-      if (!sym)
-        {
+      if (sym == NULL)
+	{
 	  if (ctf_errno (ccp->fp) == EINVAL
-             || ctf_errno (ccp->fp) == ECTF_NOSYMTAB)
+	      || ctf_errno (ccp->fp) == ECTF_NOSYMTAB)
 	    break;
-          sym = add_stt_func (ccp, i);
-        }
-      if (!sym)
+	  sym = add_stt_func (ccp, i);
+	}
+      if (sym == NULL)
 	continue;
 
       set_symbol_address (ccp->of, sym, SYMBOL_LINKAGE_NAME (sym));
@@ -1267,14 +1255,11 @@  psymtab_to_symtab (struct partial_symtab *pst)
    PST is not NULL.  */
 
 static void
-ctf_read_symtab (struct partial_symtab *pst,
-                 struct objfile *objfile)
+ctf_read_symtab (struct partial_symtab *pst, struct objfile *objfile)
 {
   if (pst->readin)
-    {
-      warning (_("bug: psymtab for %s is already read in."),
+    warning (_("bug: psymtab for %s is already read in."),
 	       pst->filename);
-    }
   else
     {
       if (info_verbose)
@@ -1293,9 +1278,9 @@  ctf_read_symtab (struct partial_symtab *pst,
       psymtab_to_symtab (pst);
 
       pst->set_text_low (text_offset);
-      pst->set_text_high (text_offset+tsize);
+      pst->set_text_high (text_offset + tsize);
       pst->compunit_symtab = ctf_end_symtab (pst, text_offset + tsize,
-                                         SECT_OFF_TEXT (objfile));
+					 SECT_OFF_TEXT (objfile));
 
       /* Finish up the debug error message.  */
       if (info_verbose)
@@ -1314,8 +1299,9 @@  ctf_close_objfile (struct objfile *of, void *datum)
   ctf_close (arc);
 }
 
-/* Allocate a new partial_symtab NAME.  */
-/* Each source file that has not been fully read in is represented by
+/* Allocate a new partial_symtab NAME.
+
+   Each source file that has not been fully read in is represented by
    a partial_symtab.  This contains the information on where in the
    executable the debugging symbols for a specific file are, and a
    list of names of global symbols which are located in this file.
@@ -1327,8 +1313,8 @@  ctf_close_objfile (struct objfile *of, void *datum)
 
 static struct partial_symtab *
 create_partial_symtab (const char *name,
-                       ctf_file_t *cfp,
-                       struct objfile *objfile)
+		       ctf_file_t *cfp,
+		       struct objfile *objfile)
 {
   struct partial_symtab *pst;
   static ctf_context_t ccx;
@@ -1337,7 +1323,7 @@  create_partial_symtab (const char *name,
 
   ccx.fp = cfp;
   ccx.of = objfile;
-  pst->read_symtab_private = (void *)&ccx;
+  pst->read_symtab_private = (void *) &ccx;
   pst->read_symtab = ctf_read_symtab;
 
   return pst;
@@ -1353,9 +1339,9 @@  ctf_psymtab_type_cb (ctf_id_t tid, void *arg)
   uint32_t kind;
   short section = -1;
 
-  ccp = (ctf_context_t *)arg;
+  ccp = (ctf_context_t *) arg;
   name = ctf_type_aname_raw (ccp->fp, tid);
-  if (!name || (name && !strlen (name)))
+  if (name == NULL || strlen (name) == 0)
     return 0;
 
   domain_enum domain = UNDEF_DOMAIN;
@@ -1366,40 +1352,40 @@  ctf_psymtab_type_cb (ctf_id_t tid, void *arg)
       case CTF_K_STRUCT:
       case CTF_K_UNION:
       case CTF_K_ENUM:
-      	domain = STRUCT_DOMAIN;
-      	aclass = LOC_TYPEDEF;
-        break;
+	domain = STRUCT_DOMAIN;
+	aclass = LOC_TYPEDEF;
+	break;
       case CTF_K_FUNCTION:
       case CTF_K_FORWARD:
-      	domain = VAR_DOMAIN;
-      	aclass = LOC_STATIC;
-        section = SECT_OFF_TEXT (ccp->of);
-        break;
+	domain = VAR_DOMAIN;
+	aclass = LOC_STATIC;
+	section = SECT_OFF_TEXT (ccp->of);
+	break;
       case CTF_K_CONST:
-      	domain = VAR_DOMAIN;
-      	aclass = LOC_STATIC;
-        break;
+	domain = VAR_DOMAIN;
+	aclass = LOC_STATIC;
+	break;
       case CTF_K_TYPEDEF:
       case CTF_K_POINTER:
       case CTF_K_VOLATILE:
       case CTF_K_RESTRICT:
-      	domain = VAR_DOMAIN;
-      	aclass = LOC_TYPEDEF;
-        break;
+	domain = VAR_DOMAIN;
+	aclass = LOC_TYPEDEF;
+	break;
       case CTF_K_INTEGER:
       case CTF_K_FLOAT:
-      	domain = VAR_DOMAIN;
-      	aclass = LOC_TYPEDEF;
-        break;
+	domain = VAR_DOMAIN;
+	aclass = LOC_TYPEDEF;
+	break;
       case CTF_K_ARRAY:
       case CTF_K_UNKNOWN:
-        return 0;
+	return 0;
     }
 
-    add_psymbol_to_list (name, strlen (name), 1,
-                         domain, aclass, section,
-                         psymbol_placement::GLOBAL,
-                         0, language_c, ccp->of);
+    add_psymbol_to_list (name, strlen (name), true,
+			 domain, aclass, section,
+			 psymbol_placement::GLOBAL,
+			 0, language_c, ccp->of);
 
   return 0;
 }
@@ -1411,10 +1397,10 @@  ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg)
 {
   ctf_context_t *ccp = (ctf_context_t *) arg;
 
-  add_psymbol_to_list (name, strlen (name), 1,
-                       VAR_DOMAIN, LOC_STATIC, -1,
-                       psymbol_placement::GLOBAL,
-                       0, language_c, ccp->of);
+  add_psymbol_to_list (name, strlen (name), true,
+		       VAR_DOMAIN, LOC_STATIC, -1,
+		       psymbol_placement::GLOBAL,
+		       0, language_c, ccp->of);
   return 0;
 }
 
@@ -1431,17 +1417,14 @@  scan_partial_symbols (ctf_file_t *cfp, struct objfile *of)
 
   ccx.fp = cfp;
   ccx.of = of;
+
   if (ctf_type_iter (cfp, ctf_psymtab_type_cb, &ccx) == CTF_ERR)
-    {
-      complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
-                 ctf_errmsg (ctf_errno (cfp)));
-    }
+    complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
+	       ctf_errmsg (ctf_errno (cfp)));
 
   if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, &ccx) == CTF_ERR)
-    {
-      complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
-                 ctf_errmsg (ctf_errno (cfp)));
-    }
+    complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
+	       ctf_errmsg (ctf_errno (cfp)));
 
   /* Scan CTF object and function sections which correspond to each
      STT_FUNC or STT_OBJECT entry in the symbol table,
@@ -1450,41 +1433,42 @@  scan_partial_symbols (ctf_file_t *cfp, struct objfile *of)
     {
       ctf_id_t tid;
       if ((tid = ctf_lookup_by_symbol (cfp, idx)) == CTF_ERR)
-        {
-	if (ctf_errno (cfp) == EINVAL
-           || ctf_errno (cfp) == ECTF_NOSYMTAB)
-	    // case ECTF_SYMRANGE:
-	  break;
-	else
-	  continue;
-        }
+	{
+	  if (ctf_errno (cfp) == EINVAL || ctf_errno (cfp) == ECTF_NOSYMTAB)
+	    {
+	      // case ECTF_SYMRANGE:
+	      break;
+	    }
+	  else
+	    continue;
+	}
       const char *tname = ctf_type_aname_raw (cfp, tid);
       uint32_t kind = ctf_type_kind (cfp, tid);
       address_class aclass;
       domain_enum tdomain;
       switch (kind)
-        {
-          case CTF_K_STRUCT:
-          case CTF_K_UNION:
-          case CTF_K_ENUM:
+	{
+	  case CTF_K_STRUCT:
+	  case CTF_K_UNION:
+	  case CTF_K_ENUM:
 	    tdomain = STRUCT_DOMAIN;
 	    break;
-          default:
+	  default:
 	    tdomain = VAR_DOMAIN;
 	    break;
-        }
+	}
 
       if (kind == CTF_K_FUNCTION)
-        aclass = LOC_STATIC;
+	aclass = LOC_STATIC;
       else if (kind == CTF_K_CONST)
-        aclass = LOC_CONST;
+	aclass = LOC_CONST;
       else
-        aclass = LOC_TYPEDEF;
+	aclass = LOC_TYPEDEF;
 
-      add_psymbol_to_list (tname, strlen (name), 1,
-                           tdomain, aclass, -1,
-                           psymbol_placement::STATIC,
-                           0, language_c, of);
+      add_psymbol_to_list (tname, strlen (name), true,
+			   tdomain, aclass, -1,
+			   psymbol_placement::STATIC,
+			   0, language_c, of);
     }
 
   end_psymtab_common (of, pst);
@@ -1501,14 +1485,14 @@  elfctf_build_psymtabs (struct objfile *of)
   int err;
 
   ctf_archive_t *arc = ctf_bfdopen (abfd, &err);
-  if (!arc)
+  if (arc == NULL)
     error (_("ctf_bfdopen failed on %s - %s"),
-           bfd_get_filename (abfd), ctf_errmsg (err));
+	   bfd_get_filename (abfd), ctf_errmsg (err));
 
   ctf_file_t *fp = ctf_arc_open_by_name (arc, NULL, &err);
-  if (!fp)
+  if (fp == NULL)
     error (_("ctf_arc_open_by_name failed on %s - %s"),
-           bfd_get_filename (abfd), ctf_errmsg (err));
+	   bfd_get_filename (abfd), ctf_errmsg (err));
   set_objfile_data (of, ctf_file_key, fp);
 
   scan_partial_symbols (fp, of);
-- 
2.23.0