X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fsb.c;h=76d555e34024d2fe40ba2db28535479ff135fa4a;hb=06fe285fd293e999481ec8f5c619658aa5e3b48b;hp=0195c9226b9d4e15812c19e0f2637ca0bed0877e;hpb=4b4da1607aeed19ac399963a3aa12b0417e477ae;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/sb.c b/gas/sb.c index 0195c9226b..76d555e340 100644 --- a/gas/sb.c +++ b/gas/sb.c @@ -1,5 +1,5 @@ /* sb.c - string buffer manipulation routines - Copyright 1994, 1995, 2000, 2003 Free Software Foundation, Inc. + Copyright (C) 1994-2016 Free Software Foundation, Inc. Written by Steve and Judy Chamberlain of Cygnus Support, sac@cygnus.com @@ -8,7 +8,7 @@ GAS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) + the Free Software Foundation; either version 3, or (at your option) any later version. GAS is distributed in the hope that it will be useful, @@ -21,18 +21,15 @@ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ -#include "config.h" -#include -#ifdef HAVE_STDLIB_H -#include +#include "as.h" +#include "sb.h" + +#ifdef HAVE_LIMITS_H +#include #endif -#ifdef HAVE_STRING_H -#include -#else -#include +#ifndef CHAR_BIT +#define CHAR_BIT 8 #endif -#include "libiberty.h" -#include "sb.h" /* These routines are about manipulating strings. @@ -46,69 +43,42 @@ sb_new (&foo); sb_grow... (&foo,...); use foo->ptr[*]; - sb_kill (&foo); - -*/ + sb_kill (&foo); */ -static int dsize = 5; -static void sb_check (sb *, int); +/* Buffers start at INIT_ALLOC size, and roughly double each time we + go over the current allocation. MALLOC_OVERHEAD is a guess at the + system malloc overhead. We aim to not waste any memory in the + underlying page/chunk allocated by the system malloc. */ +#define MALLOC_OVERHEAD (2 * sizeof (size_t)) +#define INIT_ALLOC (64 - MALLOC_OVERHEAD - 1) -/* Statistics of sb structures. */ -static int string_count[sb_max_power_two]; +static void sb_check (sb *, size_t); -/* Free list of sb structures. */ -static sb_list_vector free_list; +/* Initializes an sb. */ -/* initializes an sb. */ - -static void -sb_build (sb *ptr, int size) +void +sb_build (sb *ptr, size_t size) { - /* see if we can find one to allocate */ - sb_element *e; - - if (size > sb_max_power_two) - abort (); - - e = free_list.size[size]; - if (!e) - { - /* nothing there, allocate one and stick into the free list */ - e = (sb_element *) xmalloc (sizeof (sb_element) + (1 << size)); - e->next = free_list.size[size]; - e->size = 1 << size; - free_list.size[size] = e; - string_count[size]++; - } - - /* remove from free list */ - - free_list.size[size] = e->next; - - /* copy into callers world */ - ptr->ptr = e->data; - ptr->pot = size; + ptr->ptr = XNEWVEC (char, size + 1); + ptr->max = size; ptr->len = 0; - ptr->item = e; } void sb_new (sb *ptr) { - sb_build (ptr, dsize); + sb_build (ptr, INIT_ALLOC); } -/* deallocate the sb at ptr */ +/* Deallocate the sb at ptr. */ void sb_kill (sb *ptr) { - /* return item to free list */ - ptr->item->next = free_list.size[ptr->pot]; - free_list.size[ptr->pot] = ptr->item; + free (ptr->ptr); } -/* add the sb at s to the end of the sb at ptr */ +/* Add the sb at s to the end of the sb at ptr. */ void sb_add_sb (sb *ptr, sb *s) @@ -118,26 +88,70 @@ sb_add_sb (sb *ptr, sb *s) ptr->len += s->len; } -/* make sure that the sb at ptr has room for another len characters, +/* Helper for sb_scrub_and_add_sb. */ + +static sb *sb_to_scrub; +static char *scrub_position; +static size_t +scrub_from_sb (char *buf, size_t buflen) +{ + size_t copy; + copy = sb_to_scrub->len - (scrub_position - sb_to_scrub->ptr); + if (copy > buflen) + copy = buflen; + memcpy (buf, scrub_position, copy); + scrub_position += copy; + return copy; +} + +/* Run the sb at s through do_scrub_chars and add the result to the sb + at ptr. */ + +void +sb_scrub_and_add_sb (sb *ptr, sb *s) +{ + sb_to_scrub = s; + scrub_position = s->ptr; + + sb_check (ptr, s->len); + ptr->len += do_scrub_chars (scrub_from_sb, ptr->ptr + ptr->len, s->len); + + sb_to_scrub = 0; + scrub_position = 0; +} + +/* Make sure that the sb at ptr has room for another len characters, and grow it if it doesn't. */ static void -sb_check (sb *ptr, int len) +sb_check (sb *ptr, size_t len) { - if (ptr->len + len >= 1 << ptr->pot) + size_t want = ptr->len + len; + + if (want > ptr->max) { - sb tmp; - int pot = ptr->pot; - while (ptr->len + len >= 1 << pot) - pot++; - sb_build (&tmp, pot); - sb_add_sb (&tmp, ptr); - sb_kill (ptr); - *ptr = tmp; + size_t max; + + want += MALLOC_OVERHEAD + 1; + if ((ssize_t) want < 0) + as_fatal ("string buffer overflow"); +#if GCC_VERSION >= 3004 + max = (size_t) 1 << (CHAR_BIT * sizeof (want) + - (sizeof (want) <= sizeof (long) + ? __builtin_clzl ((long) want) + : __builtin_clzll ((long long) want))); +#else + max = 128; + while (want > max) + max <<= 1; +#endif + max -= MALLOC_OVERHEAD + 1; + ptr->max = max; + ptr->ptr = XRESIZEVEC (char, ptr->ptr, max + 1); } } -/* make the sb at ptr point back to the beginning. */ +/* Make the sb at ptr point back to the beginning. */ void sb_reset (sb *ptr) @@ -145,41 +159,50 @@ sb_reset (sb *ptr) ptr->len = 0; } -/* add character c to the end of the sb at ptr. */ +/* Add character c to the end of the sb at ptr. */ void -sb_add_char (sb *ptr, int c) +sb_add_char (sb *ptr, size_t c) { sb_check (ptr, 1); ptr->ptr[ptr->len++] = c; } -/* add null terminated string s to the end of sb at ptr. */ +/* Add null terminated string s to the end of sb at ptr. */ void sb_add_string (sb *ptr, const char *s) { - int len = strlen (s); + size_t len = strlen (s); + sb_check (ptr, len); + memcpy (ptr->ptr + ptr->len, s, len); + ptr->len += len; +} + +/* Add string at s of length len to sb at ptr */ + +void +sb_add_buffer (sb *ptr, const char *s, size_t len) +{ sb_check (ptr, len); memcpy (ptr->ptr + ptr->len, s, len); ptr->len += len; } -/* like sb_name, but don't include the null byte in the string. */ +/* Write terminating NUL and return string. */ char * sb_terminate (sb *in) { - sb_add_char (in, 0); - --in->len; + in->ptr[in->len] = 0; return in->ptr; } -/* start at the index idx into the string in sb at ptr and skip - whitespace. return the index of the first non whitespace character */ +/* Start at the index idx into the string in sb at ptr and skip + whitespace. return the index of the first non whitespace character. */ -int -sb_skip_white (int idx, sb *ptr) +size_t +sb_skip_white (size_t idx, sb *ptr) { while (idx < ptr->len && (ptr->ptr[idx] == ' ' @@ -188,12 +211,12 @@ sb_skip_white (int idx, sb *ptr) return idx; } -/* start at the index idx into the sb at ptr. skips whitespace, +/* Start at the index idx into the sb at ptr. skips whitespace, a comma and any following whitespace. returns the index of the next character. */ -int -sb_skip_comma (int idx, sb *ptr) +size_t +sb_skip_comma (size_t idx, sb *ptr) { while (idx < ptr->len && (ptr->ptr[idx] == ' '