mirror of
https://github.com/tobast/libunwind-eh_elf.git
synced 2024-11-05 01:09:27 +01:00
Rename ia64_cursor -> cursor.
2002/12/18 15:52:24-08:00 mostang.com!davidm Rename: src/ia64/Gscript.c -> src/ia64/Gscript-ia64.c (Logical change 1.32)
This commit is contained in:
mostang.com!davidm
parent
997f02561e
commit
469215c497
1 changed files with 532 additions and 0 deletions
|
|
@ -0,0 +1,532 @@
|
||||||
|
/* libunwind - a platform-independent unwind library
|
||||||
|
Copyright (C) 2001-2002 Hewlett-Packard Co
|
||||||
|
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
|
||||||
|
|
||||||
|
This file is part of libunwind.
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining
|
||||||
|
a copy of this software and associated documentation files (the
|
||||||
|
"Software"), to deal in the Software without restriction, including
|
||||||
|
without limitation the rights to use, copy, modify, merge, publish,
|
||||||
|
distribute, sublicense, and/or sell copies of the Software, and to
|
||||||
|
permit persons to whom the Software is furnished to do so, subject to
|
||||||
|
the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be
|
||||||
|
included in all copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||||
|
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||||
|
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||||
|
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||||
|
|
||||||
|
#include "offsets.h"
|
||||||
|
#include "rse.h"
|
||||||
|
#include "unwind_i.h"
|
||||||
|
|
||||||
|
#ifdef HAVE___THREAD
|
||||||
|
static __thread struct ia64_script_cache ia64_per_thread_cache;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
static inline unw_hash_index_t
|
||||||
|
hash (unw_word_t ip)
|
||||||
|
{
|
||||||
|
# define magic 0x9e3779b97f4a7c16 /* based on (sqrt(5)/2-1)*2^64 */
|
||||||
|
|
||||||
|
return (ip >> 4) * magic >> (64 - IA64_LOG_UNW_HASH_SIZE);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline long
|
||||||
|
cache_match (struct ia64_script *script, unw_word_t ip, unw_word_t pr)
|
||||||
|
{
|
||||||
|
/* XXX lock script cache */
|
||||||
|
if (ip == script->ip && ((pr ^ script->pr_val) & script->pr_mask) == 0)
|
||||||
|
/* keep the lock... */
|
||||||
|
return 1;
|
||||||
|
/* XXX unlock script cache */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void
|
||||||
|
flush_script_cache (unw_addr_space_t as, struct ia64_script_cache *cache)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 0; i < IA64_UNW_CACHE_SIZE; ++i)
|
||||||
|
cache->buckets[i].ip = 0;
|
||||||
|
|
||||||
|
cache->generation = as->cache_generation;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline struct ia64_script_cache *
|
||||||
|
get_script_cache (unw_addr_space_t as)
|
||||||
|
{
|
||||||
|
struct ia64_script_cache *cache = &as->global_cache;
|
||||||
|
|
||||||
|
#ifdef HAVE___THREAD
|
||||||
|
if (as->caching_policy == UNW_CACHE_PER_THREAD)
|
||||||
|
cache = &ia64_per_thread_cache;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (as->cache_generation != cache->generation)
|
||||||
|
flush_script_cache (as, cache);
|
||||||
|
|
||||||
|
return cache;
|
||||||
|
}
|
||||||
|
|
||||||
|
static struct ia64_script *
|
||||||
|
script_lookup (struct ia64_script_cache *cache, struct cursor *c)
|
||||||
|
{
|
||||||
|
struct ia64_script *script = cache->buckets + c->hint;
|
||||||
|
unsigned short index;
|
||||||
|
unw_word_t ip, pr;
|
||||||
|
|
||||||
|
ip = c->ip;
|
||||||
|
pr = c->pr;
|
||||||
|
|
||||||
|
if (cache_match (script, ip, pr))
|
||||||
|
return script;
|
||||||
|
|
||||||
|
index = cache->hash[hash (ip)];
|
||||||
|
if (index >= IA64_UNW_CACHE_SIZE)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
script = cache->buckets + index;
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
if (cache_match (script, ip, pr))
|
||||||
|
{
|
||||||
|
/* update hint; no locking needed: single-word writes are atomic */
|
||||||
|
c->hint = cache->buckets[c->prev_script].hint =
|
||||||
|
(script - cache->buckets);
|
||||||
|
return script;
|
||||||
|
}
|
||||||
|
if (script->coll_chain >= IA64_UNW_HASH_SIZE)
|
||||||
|
return 0;
|
||||||
|
script = cache->buckets + script->coll_chain;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
HIDDEN struct ia64_script *
|
||||||
|
ia64_script_lookup (struct cursor *c)
|
||||||
|
{
|
||||||
|
return script_lookup (get_script_cache (c->as), c);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* On returning, the lock for the SCRIPT is still being held. */
|
||||||
|
|
||||||
|
static inline struct ia64_script *
|
||||||
|
script_new (struct ia64_script_cache *cache, unw_word_t ip)
|
||||||
|
{
|
||||||
|
struct ia64_script *script, *prev, *tmp;
|
||||||
|
unw_hash_index_t index;
|
||||||
|
unsigned short head;
|
||||||
|
|
||||||
|
/* XXX lock hash table */
|
||||||
|
{
|
||||||
|
head = cache->lru_head;
|
||||||
|
script = cache->buckets + head;
|
||||||
|
cache->lru_head = script->lru_chain;
|
||||||
|
}
|
||||||
|
/* XXX unlock hash table */
|
||||||
|
|
||||||
|
/* XXX We'll deadlock here if we interrupt a thread that is holding
|
||||||
|
the script->lock. */
|
||||||
|
/* XXX lock script */
|
||||||
|
|
||||||
|
/* XXX lock unwind data lock */
|
||||||
|
{
|
||||||
|
/* re-insert script at the tail of the LRU chain: */
|
||||||
|
cache->buckets[cache->lru_tail].lru_chain = head;
|
||||||
|
cache->lru_tail = head;
|
||||||
|
|
||||||
|
/* remove the old script from the hash table (if it's there): */
|
||||||
|
if (script->ip)
|
||||||
|
{
|
||||||
|
index = hash (script->ip);
|
||||||
|
tmp = cache->buckets + cache->hash[index];
|
||||||
|
prev = 0;
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
if (tmp == script)
|
||||||
|
{
|
||||||
|
if (prev)
|
||||||
|
prev->coll_chain = tmp->coll_chain;
|
||||||
|
else
|
||||||
|
cache->hash[index] = tmp->coll_chain;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
prev = tmp;
|
||||||
|
if (tmp->coll_chain >= IA64_UNW_CACHE_SIZE)
|
||||||
|
/* old script wasn't in the hash-table */
|
||||||
|
break;
|
||||||
|
tmp = cache->buckets + tmp->coll_chain;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* enter new script in the hash table */
|
||||||
|
index = hash (ip);
|
||||||
|
script->coll_chain = cache->hash[index];
|
||||||
|
cache->hash[index] = script - cache->buckets;
|
||||||
|
|
||||||
|
script->ip = ip; /* set new IP while we're holding the locks */
|
||||||
|
}
|
||||||
|
/* XXX unlock unwind data lock */
|
||||||
|
|
||||||
|
script->hint = 0;
|
||||||
|
script->count = 0;
|
||||||
|
return script;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void
|
||||||
|
script_finalize (struct ia64_script *script, struct cursor *c,
|
||||||
|
struct ia64_state_record *sr)
|
||||||
|
{
|
||||||
|
script->pr_mask = sr->pr_mask;
|
||||||
|
script->pr_val = sr->pr_val;
|
||||||
|
script->pi = c->pi;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void
|
||||||
|
script_emit (struct ia64_script *script, struct ia64_script_insn insn)
|
||||||
|
{
|
||||||
|
if (script->count >= IA64_MAX_SCRIPT_LEN)
|
||||||
|
{
|
||||||
|
dprintf ("%s: script exceeds maximum size of %u instructions!\n",
|
||||||
|
__FUNCTION__, IA64_MAX_SCRIPT_LEN);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
script->insn[script->count++] = insn;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void
|
||||||
|
emit_nat_info (struct ia64_state_record *sr, int i, struct ia64_script *script)
|
||||||
|
{
|
||||||
|
struct ia64_reg_info *r = sr->curr.reg + i;
|
||||||
|
struct ia64_script_insn insn;
|
||||||
|
enum ia64_script_insn_opcode opc = IA64_INSN_SET;
|
||||||
|
unsigned long val = 0;
|
||||||
|
|
||||||
|
switch (r->where)
|
||||||
|
{
|
||||||
|
case IA64_WHERE_GR:
|
||||||
|
val = IA64_LOC (r->val, 0);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_WHERE_FR:
|
||||||
|
val = 0; /* value doesn't matter... */
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_WHERE_BR:
|
||||||
|
val = IA64_LOC (0, 0); /* no NaT bit */
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_WHERE_PSPREL:
|
||||||
|
case IA64_WHERE_SPREL:
|
||||||
|
opc = IA64_INSN_SETNAT_MEMSTK;
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
dprintf ("%s: don't know how to emit nat info for where = %u\n",
|
||||||
|
__FUNCTION__, r->where);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
insn.opc = opc;
|
||||||
|
insn.dst = unw.preg_index[i];
|
||||||
|
insn.val = val;
|
||||||
|
script_emit (script, insn);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
compile_reg (struct ia64_state_record *sr, int i, struct ia64_script *script)
|
||||||
|
{
|
||||||
|
struct ia64_reg_info *r = sr->curr.reg + i;
|
||||||
|
enum ia64_script_insn_opcode opc;
|
||||||
|
unsigned long val, rval;
|
||||||
|
struct ia64_script_insn insn;
|
||||||
|
long is_preserved_gr;
|
||||||
|
|
||||||
|
if (r->where == IA64_WHERE_NONE || r->when >= sr->when_target)
|
||||||
|
return;
|
||||||
|
|
||||||
|
opc = IA64_INSN_MOVE;
|
||||||
|
val = rval = r->val;
|
||||||
|
is_preserved_gr = (i >= IA64_REG_R4 && i <= IA64_REG_R7);
|
||||||
|
|
||||||
|
switch (r->where)
|
||||||
|
{
|
||||||
|
case IA64_WHERE_GR:
|
||||||
|
if (rval >= 32)
|
||||||
|
{
|
||||||
|
/* register got spilled to a stacked register */
|
||||||
|
opc = IA64_INSN_MOVE_STACKED;
|
||||||
|
val = rval - 32;
|
||||||
|
}
|
||||||
|
else if (rval >= 4 && rval <= 7)
|
||||||
|
/* register got spilled to a preserved register */
|
||||||
|
val = unw.preg_index[IA64_REG_R4 + (rval - 4)];
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* register got spilled to a scratch register */
|
||||||
|
opc = IA64_INSN_MOVE_SCRATCH;
|
||||||
|
val = UNW_IA64_GR + rval;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_WHERE_FR:
|
||||||
|
if (rval <= 5)
|
||||||
|
val = unw.preg_index[IA64_REG_F2 + (rval - 1)];
|
||||||
|
else if (rval >= 16 && rval <= 31)
|
||||||
|
val = unw.preg_index[IA64_REG_F16 + (rval - 16)];
|
||||||
|
else
|
||||||
|
{
|
||||||
|
opc = IA64_INSN_MOVE_SCRATCH;
|
||||||
|
val = UNW_IA64_FR + rval;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_WHERE_BR:
|
||||||
|
if (rval >= 1 && rval <= 5)
|
||||||
|
val = unw.preg_index[IA64_REG_B1 + (rval - 1)];
|
||||||
|
else
|
||||||
|
{
|
||||||
|
opc = IA64_INSN_MOVE_SCRATCH;
|
||||||
|
val = UNW_IA64_BR + rval;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_WHERE_SPREL:
|
||||||
|
opc = IA64_INSN_ADD_SP;
|
||||||
|
if (i >= IA64_REG_F2 && i <= IA64_REG_F31)
|
||||||
|
val |= IA64_LOC_TYPE_FP;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_WHERE_PSPREL:
|
||||||
|
opc = IA64_INSN_ADD_PSP;
|
||||||
|
if (i >= IA64_REG_F2 && i <= IA64_REG_F31)
|
||||||
|
val |= IA64_LOC_TYPE_FP;
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
dprintf ("%s: register %u has unexpected `where' value of %u\n",
|
||||||
|
__FUNCTION__, i, r->where);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
insn.opc = opc;
|
||||||
|
insn.dst = unw.preg_index[i];
|
||||||
|
insn.val = val;
|
||||||
|
script_emit (script, insn);
|
||||||
|
if (is_preserved_gr)
|
||||||
|
emit_nat_info (sr, i, script);
|
||||||
|
|
||||||
|
if (i == IA64_REG_PSP)
|
||||||
|
{
|
||||||
|
/* info->psp must contain the _value_ of the previous sp, not
|
||||||
|
it's save location. We get this by dereferencing the value
|
||||||
|
we just stored in info->psp: */
|
||||||
|
insn.opc = IA64_INSN_LOAD;
|
||||||
|
insn.dst = insn.val = unw.preg_index[IA64_REG_PSP];
|
||||||
|
script_emit (script, insn);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Build an unwind script that unwinds from state OLD_STATE to the
|
||||||
|
entrypoint of the function that called OLD_STATE. */
|
||||||
|
|
||||||
|
static inline int
|
||||||
|
build_script (struct cursor *c, struct ia64_script *script)
|
||||||
|
{
|
||||||
|
struct ia64_state_record sr;
|
||||||
|
struct ia64_script_insn insn;
|
||||||
|
int i, ret;
|
||||||
|
|
||||||
|
ret = ia64_create_state_record (c, &sr);
|
||||||
|
if (ret < 0)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
/* First, set psp if we're dealing with a fixed-size frame;
|
||||||
|
subsequent instructions may depend on this value. */
|
||||||
|
if (sr.when_target > sr.curr.reg[IA64_REG_PSP].when
|
||||||
|
&& (sr.curr.reg[IA64_REG_PSP].where == IA64_WHERE_NONE)
|
||||||
|
&& sr.curr.reg[IA64_REG_PSP].val != 0)
|
||||||
|
{
|
||||||
|
/* new psp is psp plus frame size */
|
||||||
|
insn.opc = IA64_INSN_ADD;
|
||||||
|
insn.dst = struct_offset (struct cursor, psp) / 8;
|
||||||
|
insn.val = sr.curr.reg[IA64_REG_PSP].val; /* frame size */
|
||||||
|
script_emit (script, insn);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* determine where the primary UNaT is: */
|
||||||
|
if (sr.when_target < sr.curr.reg[IA64_REG_PRI_UNAT_GR].when)
|
||||||
|
i = IA64_REG_PRI_UNAT_MEM;
|
||||||
|
else if (sr.when_target < sr.curr.reg[IA64_REG_PRI_UNAT_MEM].when)
|
||||||
|
i = IA64_REG_PRI_UNAT_GR;
|
||||||
|
else if (sr.curr.reg[IA64_REG_PRI_UNAT_MEM].when >
|
||||||
|
sr.curr.reg[IA64_REG_PRI_UNAT_GR].when)
|
||||||
|
i = IA64_REG_PRI_UNAT_MEM;
|
||||||
|
else
|
||||||
|
i = IA64_REG_PRI_UNAT_GR;
|
||||||
|
|
||||||
|
compile_reg (&sr, i, script);
|
||||||
|
|
||||||
|
for (i = IA64_REG_BSP; i < IA64_NUM_PREGS; ++i)
|
||||||
|
compile_reg (&sr, i, script);
|
||||||
|
|
||||||
|
if (sr.is_signal_frame)
|
||||||
|
{
|
||||||
|
insn.opc = IA64_INSN_SET;
|
||||||
|
insn.dst = struct_offset (struct cursor, is_signal_frame) / 8;
|
||||||
|
insn.val = 1;
|
||||||
|
script_emit (script, insn);
|
||||||
|
}
|
||||||
|
|
||||||
|
script_finalize (script, c, &sr);
|
||||||
|
|
||||||
|
ia64_free_state_record (&sr);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply the unwinding actions represented by OPS and update SR to
|
||||||
|
reflect the state that existed upon entry to the function that this
|
||||||
|
unwinder represents. */
|
||||||
|
|
||||||
|
static inline int
|
||||||
|
run_script (struct ia64_script *script, struct cursor *c)
|
||||||
|
{
|
||||||
|
struct ia64_script_insn *ip, *limit, next_insn;
|
||||||
|
unw_word_t val, unat_addr, *s = (unw_word_t *) c;
|
||||||
|
unsigned long opc, dst;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
c->pi = script->pi;
|
||||||
|
ip = script->insn;
|
||||||
|
limit = script->insn + script->count;
|
||||||
|
next_insn = *ip;
|
||||||
|
|
||||||
|
while (ip++ < limit)
|
||||||
|
{
|
||||||
|
opc = next_insn.opc;
|
||||||
|
dst = next_insn.dst;
|
||||||
|
val = next_insn.val;
|
||||||
|
next_insn = *ip;
|
||||||
|
|
||||||
|
switch (opc)
|
||||||
|
{
|
||||||
|
case IA64_INSN_SET:
|
||||||
|
s[dst] = val;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_INSN_ADD:
|
||||||
|
s[dst] += val;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_INSN_ADD_PSP:
|
||||||
|
s[dst] = c->psp + val;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_INSN_ADD_SP:
|
||||||
|
s[dst] = c->sp + val;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_INSN_MOVE:
|
||||||
|
s[dst] = s[val];
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_INSN_MOVE_SCRATCH:
|
||||||
|
s[dst] = ia64_scratch_loc (c, val);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_INSN_MOVE_STACKED:
|
||||||
|
s[dst] = ia64_rse_skip_regs (c->bsp, val);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_INSN_SETNAT_MEMSTK:
|
||||||
|
ret = ia64_get (c, c->pri_unat_loc, &unat_addr);
|
||||||
|
if (ret < 0)
|
||||||
|
return ret;
|
||||||
|
s[dst] = IA64_LOC (unat_addr >> 3, IA64_LOC_TYPE_MEMSTK_NAT);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case IA64_INSN_LOAD:
|
||||||
|
ret = ia64_get (c, s[val], &s[dst]);
|
||||||
|
if (ret < 0)
|
||||||
|
return ret;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
HIDDEN int
|
||||||
|
ia64_find_save_locs (struct cursor *c)
|
||||||
|
{
|
||||||
|
struct ia64_script *script = NULL;
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
if (c->as->caching_policy == UNW_CACHE_NONE)
|
||||||
|
{
|
||||||
|
struct ia64_script tmp_script;
|
||||||
|
|
||||||
|
script = &tmp_script;
|
||||||
|
script->ip = c->ip;
|
||||||
|
script->hint = 0;
|
||||||
|
script->count = 0;
|
||||||
|
ret = build_script (c, script);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
struct ia64_script_cache *cache = get_script_cache (c->as);
|
||||||
|
|
||||||
|
script = script_lookup (cache, c);
|
||||||
|
if (!script)
|
||||||
|
{
|
||||||
|
script = script_new (cache, c->ip);
|
||||||
|
if (!script)
|
||||||
|
{
|
||||||
|
dprintf ("%s: failed to create unwind script\n", __FUNCTION__);
|
||||||
|
return -UNW_EUNSPEC;
|
||||||
|
}
|
||||||
|
cache->buckets[c->prev_script].hint = script - cache->buckets;
|
||||||
|
|
||||||
|
ret = build_script (c, script);
|
||||||
|
}
|
||||||
|
c->hint = script->hint;
|
||||||
|
c->prev_script = script - cache->buckets;
|
||||||
|
}
|
||||||
|
if (ret < 0)
|
||||||
|
{
|
||||||
|
if (ret != UNW_ESTOPUNWIND)
|
||||||
|
dprintf ("%s: failed to locate/build unwind script for ip %lx\n",
|
||||||
|
__FUNCTION__, (long) c->ip);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
run_script (script, c);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
HIDDEN void
|
||||||
|
ia64_script_cache_init (struct ia64_script_cache *cache)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
cache->lru_head = IA64_UNW_CACHE_SIZE - 1;
|
||||||
|
cache->lru_tail = 0;
|
||||||
|
|
||||||
|
for (i = 0; i < IA64_UNW_CACHE_SIZE; ++i)
|
||||||
|
{
|
||||||
|
if (i > 0)
|
||||||
|
cache->buckets[i].lru_chain = (i - 1);
|
||||||
|
cache->buckets[i].coll_chain = -1;
|
||||||
|
#if 0
|
||||||
|
/* must be lock-free! */
|
||||||
|
unw.cache[i].lock = RW_LOCK_UNLOCKED;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
for (i = 0; i<IA64_UNW_HASH_SIZE; ++i)
|
||||||
|
cache->hash[i] = -1;
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue