#include "config.h"
#ifdef HALF_PIC_INIT
#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "obstack.h"
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
extern rtx eliminate_constant_term ();
extern void assemble_name ();
extern void output_addr_const ();
int flag_half_pic = 0;
int half_pic_number_ptrs = 0;
int half_pic_number_refs = 0;
int (*ptr_half_pic_address_p)() = half_pic_address_p;
static struct obstack half_pic_obstack;
struct all_refs {
struct all_refs *hash_next;
struct all_refs *next;
int external_p;
int pointer_p;
char *ref_name;
int ref_len;
char *real_name;
int real_len;
};
static struct all_refs *half_pic_names;
static char *half_pic_prefix;
static int half_pic_prefix_len;
#ifndef MAX_HASH_TABLE
#define MAX_HASH_TABLE 1009
#endif
#define HASHBITS 30
static struct all_refs *
half_pic_hash (name, len, create_p)
char *name;
int len;
int create_p;
{
static struct all_refs *hash_table[MAX_HASH_TABLE];
static struct all_refs zero_all_refs;
unsigned char *uname;
int hash;
int i;
int ch;
struct all_refs *first;
struct all_refs *ptr;
if (len == 0)
len = strlen (name);
uname = (unsigned char *)name;
ch = uname[0];
hash = len * 613 + ch;
for (i = 1; i < len; i += 2)
hash = (hash * 613) + uname[i];
hash &= (1 << HASHBITS) - 1;
hash %= MAX_HASH_TABLE;
ptr = first = hash_table[hash];
if (ptr)
{
do
{
if (len == ptr->real_len
&& ch == *(ptr->real_name)
&& !strcmp (name, ptr->real_name))
{
hash_table[hash] = ptr;
return ptr;
}
ptr = ptr->hash_next;
}
while (ptr != first);
}
if (!create_p)
return (struct all_refs *) 0;
ptr = (struct all_refs *) obstack_alloc (&half_pic_obstack, sizeof (struct all_refs));
*ptr = zero_all_refs;
ptr->real_name = name;
ptr->real_len = len;
if (first == (struct all_refs *) 0)
ptr->hash_next = ptr;
else
{
ptr->hash_next = first->hash_next;
first->hash_next = ptr;
}
hash_table[hash] = ptr;
return ptr;
}
void
half_pic_init ()
{
flag_half_pic = TRUE;
half_pic_prefix = HALF_PIC_PREFIX;
half_pic_prefix_len = strlen (half_pic_prefix);
obstack_init (&half_pic_obstack);
}
void
half_pic_finish (stream)
FILE *stream;
{
struct all_refs *p = half_pic_names;
if (!p)
return;
data_section ();
for (; p != 0; p = p->next)
{
if (p->pointer_p)
{
ASM_OUTPUT_LABEL (stream, p->ref_name);
ASM_OUTPUT_INT (stream, gen_rtx_SYMBOL_REF (Pmode, p->real_name));
}
}
}
void
half_pic_encode (decl)
tree decl;
{
enum tree_code code = TREE_CODE (decl);
tree asm_name;
struct all_refs *ptr;
if (!flag_half_pic)
return;
if (code != VAR_DECL && code != FUNCTION_DECL)
return;
asm_name = DECL_ASSEMBLER_NAME (decl);
if (!asm_name)
return;
#ifdef HALF_PIC_DEBUG
if (HALF_PIC_DEBUG)
{
fprintf (stderr, "\n========== Half_pic_encode %.*s\n",
IDENTIFIER_LENGTH (asm_name),
IDENTIFIER_POINTER (asm_name));
debug_tree (decl);
}
#endif
if (!DECL_EXTERNAL (decl) && (code != VAR_DECL || !TREE_PUBLIC (decl)))
return;
ptr = half_pic_hash (IDENTIFIER_POINTER (asm_name),
IDENTIFIER_LENGTH (asm_name),
TRUE);
ptr->external_p = TRUE;
#ifdef HALF_PIC_DEBUG
if (HALF_PIC_DEBUG)
fprintf (stderr, "\n%.*s is half-pic\n",
IDENTIFIER_LENGTH (asm_name),
IDENTIFIER_POINTER (asm_name));
#endif
}
void
half_pic_declare (name)
char *name;
{
struct all_refs *ptr;
if (!flag_half_pic)
return;
ptr = half_pic_hash (name, 0, FALSE);
if (!ptr)
return;
ptr->external_p = FALSE;
#ifdef HALF_PIC_DEBUG
if (HALF_PIC_DEBUG)
fprintf (stderr, "\n========== Half_pic_declare %s\n", name);
#endif
}
void
half_pic_external (name)
char *name;
{
struct all_refs *ptr;
if (!flag_half_pic)
return;
ptr = half_pic_hash (name, 0, TRUE);
if (!ptr)
return;
ptr->external_p = TRUE;
#ifdef HALF_PIC_DEBUG
if (HALF_PIC_DEBUG)
fprintf (stderr, "\n========== Half_pic_external %s\n", name);
#endif
}
int
half_pic_address_p (addr)
rtx addr;
{
char *name;
int len;
struct all_refs *ptr;
if (!flag_half_pic)
return FALSE;
switch (GET_CODE (addr))
{
default:
break;
case CONST:
{
rtx offset = const0_rtx;
addr = eliminate_constant_term (XEXP (addr, 0), &offset);
if (GET_CODE (addr) != SYMBOL_REF)
return FALSE;
}
case SYMBOL_REF:
name = XSTR (addr, 0);
#ifdef HALF_PIC_DEBUG
if (HALF_PIC_DEBUG)
fprintf (stderr, "\n========== Half_pic_address_p %s\n", name);
#endif
if (name[0] == '*')
return FALSE;
len = strlen (name);
if (len > half_pic_prefix_len
&& half_pic_prefix[0] == name[0]
&& !strncmp (name, half_pic_prefix, half_pic_prefix_len))
return FALSE;
ptr = half_pic_hash (name, len, FALSE);
if (ptr == (struct all_refs *) 0)
return FALSE;
if (ptr->external_p)
{
#ifdef HALF_PIC_DEBUG
if (HALF_PIC_DEBUG)
fprintf (stderr, "%s is half-pic\n", name);
#endif
return TRUE;
}
}
return FALSE;
}
struct rtx_def *
half_pic_ptr (operand)
rtx operand;
{
char *name;
struct all_refs *p;
int len;
if (GET_CODE (operand) != SYMBOL_REF)
return operand;
name = XSTR (operand, 0);
len = strlen (name);
p = half_pic_hash (name, len, FALSE);
if (p == (struct all_refs *) 0 || !p->external_p)
return operand;
if (!p->pointer_p)
{
obstack_grow (&half_pic_obstack, half_pic_prefix, half_pic_prefix_len);
obstack_grow (&half_pic_obstack, name, len+1);
p->next = half_pic_names;
p->ref_name = (char *) obstack_finish (&half_pic_obstack);
p->ref_len = len + half_pic_prefix_len;
p->pointer_p = TRUE;
half_pic_names = p;
half_pic_number_ptrs++;
}
half_pic_number_refs++;
return gen_rtx_SYMBOL_REF (Pmode, p->ref_name);
}
#endif