+2019-11-26  Simon Marchi  <simon.marchi@efficios.com>
+
+        * arc-tdep.c (arc_insn_get_memory_base_reg): Make static.
+        (arc_insn_get_memory_offset): Likewise.
+        (arc_insn_dump): Likewise.
+        * cp-support.c (test_cp_symbol_name_matches): Likewise.
+        * csky-linux-tdep.c (csky_supply_fregset): Likewise.
+        * dictionary.c (dict_iterator_next): Likewise.
+        (dict_iter_match_first): Likewise.
+        (dict_iter_match_next): Likewise.
+        * f-lang.c (evaluate_subexp_f): Likewise.
+        * hppa-tdep.c (hppa_read_pc): Likewise.
+        * i386-tdep.c (i386_floatformat_for_type): Likewise.
+        * parse.c (write_exp_elt_msym): Likewise.
+        * ppc-linux-tdep.c (ppc_floatformat_for_type): Likewise.
+        * remote.c (remote_packet_size): Likewise.
+        (remote_notif_stop_parse): Likewise.
+        * rs6000-aix-tdep.c (aix_sighandle_frame_sniffer): Likewise.
+        * s12z-tdep.c (s12z_disassemble_info): Likewise.
+        * source.c (prepare_path_for_appending): Likewise.
+        * sparc64-linux-tdep.c
+        (sparc64_linux_handle_segmentation_fault); Likewise.
+        * stack.c (frame_selection_by_function_completer): Likewise.
+
 2019-11-26  Simon Marchi  <simon.marchi@efficios.com>
 
        * completer.c (set_gdb_completion_word_break_characters):
 
 
 /* Get register with base address of memory operation.  */
 
-int
+static int
 arc_insn_get_memory_base_reg (const struct arc_instruction &insn)
 {
   /* POP_S and PUSH_S have SP as an implicit argument in a disassembler.  */
 
 /* Get offset of a memory operation INSN.  */
 
-CORE_ADDR
+static CORE_ADDR
 arc_insn_get_memory_offset (const struct arc_instruction &insn)
 {
   /* POP_S and PUSH_S have offset as an implicit argument in a
 
 /* Dump INSN into gdb_stdlog.  */
 
-void
+static void
 arc_insn_dump (const struct arc_instruction &insn)
 {
   struct gdbarch *gdbarch = target_gdbarch ();
 
 
 namespace selftests {
 
-void
+static void
 test_cp_symbol_name_matches ()
 {
 #define CHECK_MATCH(SYMBOL, INPUT)                                     \
 
 
 /* Implement the supply_regset hook for FP registers in core files.  */
 
-void
+static void
 csky_supply_fregset (const struct regset *regset,
                     struct regcache *regcache, int regnum,
                     const void *regs, size_t len)
 
 /* Initialize ITERATOR to point at the first symbol in DICT, and
    return that first symbol, or NULL if DICT is empty.  */
 
-struct symbol *
+static struct symbol *
 dict_iterator_first (const struct dictionary *dict,
                     struct dict_iterator *iterator)
 {
 /* Advance ITERATOR, and return the next symbol, or NULL if there are
    no more symbols.  */
 
-struct symbol *
+static struct symbol *
 dict_iterator_next (struct dict_iterator *iterator)
 {
   return (DICT_VECTOR (DICT_ITERATOR_DICT (iterator)))
     ->iterator_next (iterator);
 }
 
-struct symbol *
+static struct symbol *
 dict_iter_match_first (const struct dictionary *dict,
                       const lookup_name_info &name,
                       struct dict_iterator *iterator)
   return (DICT_VECTOR (dict))->iter_match_first (dict, name, iterator);
 }
 
-struct symbol *
+static struct symbol *
 dict_iter_match_next (const lookup_name_info &name,
                      struct dict_iterator *iterator)
 {
 
 }
 
 /* Special expression evaluation cases for Fortran.  */
-struct value *
+
+static struct value *
 evaluate_subexp_f (struct type *expect_type, struct expression *exp,
                   int *pos, enum noside noside)
 {
 
   return align_up (addr, 16);
 }
 
-CORE_ADDR
+static CORE_ADDR
 hppa_read_pc (readable_regcache *regcache)
 {
   ULONGEST ipsw;
 
    length LEN in bits.  If non-NULL, NAME is the name of its type.
    If no suitable type is found, return NULL.  */
 
-const struct floatformat **
+static const struct floatformat **
 i386_floatformat_for_type (struct gdbarch *gdbarch,
                           const char *name, int len)
 {
 
   write_exp_elt (ps, &tmp);
 }
 
-void
+static void
 write_exp_elt_msym (struct expr_builder *ps, minimal_symbol *expelt)
 {
   union exp_element tmp;
 
    length LEN in bits.  If non-NULL, NAME is the name of its type.
    If no suitable type is found, return NULL.  */
 
-const struct floatformat **
+static const struct floatformat **
 ppc_floatformat_for_type (struct gdbarch *gdbarch,
                           const char *name, int len)
 {
 
   rs->explicit_packet_size = packet_size;
 }
 
-void
+static void
 remote_packet_size (remote_target *remote, const protocol_feature *feature,
                    enum packet_support support, const char *value)
 {
   return rs->stop_reply_queue.size ();
 }
 
-void
+static void
 remote_notif_stop_parse (remote_target *remote,
                         struct notif_client *self, const char *buf,
                         struct notif_event *event)
 
   return trad_frame_get_register (this_trad_cache, this_frame, regnum);
 }
 
-int
+static int
 aix_sighandle_frame_sniffer (const struct frame_unwind *self,
                             struct frame_info *this_frame,
                             void **this_prologue_cache)
 
   return 0;
 }
 
-struct disassemble_info
+static struct disassemble_info
 s12z_disassemble_info (struct gdbarch *gdbarch)
 {
   struct disassemble_info di;
 
    letters (for dos) as well as leading '/' characters and './'
    sequences.  */
 
-const char *
+static const char *
 prepare_path_for_appending (const char *path)
 {
   /* For dos paths, d:/foo -> /foo, and d:foo -> foo.  */
 
    gdbarch hook.
    Displays information related to ADI memory corruptions.  */
 
-void
+static void
 sparc64_linux_handle_segmentation_fault (struct gdbarch *gdbarch,
                                      struct ui_out *uiout)
 {
 
 /* Completion function for "frame function", "info frame function", and
    "select-frame function" commands.  */
 
-void
+static void
 frame_selection_by_function_completer (struct cmd_list_element *ignore,
                                       completion_tracker &tracker,
                                       const char *text, const char *word)