void UnicodeTest::TestBidiPairedBracketType() {
// BidiBrackets-6.3.0.txt says:
//
// The set of code points listed in this file was originally derived
// using the character properties General_Category (gc), Bidi_Class (bc),
// Bidi_Mirrored (Bidi_M), and Bidi_Mirroring_Glyph (bmg), as follows:
// two characters, A and B, form a pair if A has gc=Ps and B has gc=Pe,
// both have bc=ON and Bidi_M=Y, and bmg of A is B. Bidi_Paired_Bracket
// maps A to B and vice versa, and their Bidi_Paired_Bracket_Type
// property values are Open and Close, respectively.
IcuTestErrorCode errorCode(*this, "TestBidiPairedBracketType()");
UnicodeSet bpt("[:^bpt=n:]", errorCode);
assertTrue("bpt!=None is not empty", !bpt.isEmpty());
// The following should always be true.
UnicodeSet mirrored("[:Bidi_M:]", errorCode);
UnicodeSet other_neutral("[:bc=ON:]", errorCode);
assertTrue("bpt!=None is a subset of Bidi_M", mirrored.containsAll(bpt));
assertTrue("bpt!=None is a subset of bc=ON", other_neutral.containsAll(bpt));
// The following are true at least initially in Unicode 6.3.
UnicodeSet bpt_open("[:bpt=o:]", errorCode);
UnicodeSet bpt_close("[:bpt=c:]", errorCode);
UnicodeSet ps("[:Ps:]", errorCode);
UnicodeSet pe("[:Pe:]", errorCode);
assertTrue("bpt=Open is a subset of Ps", ps.containsAll(bpt_open));
assertTrue("bpt=Close is a subset of Pe", pe.containsAll(bpt_close));
}
/*
* prb_rtld_stalk() - setup for a breakpoint when rtld has opened or closed a
* shared object.
*/
prb_status_t
prb_rtld_stalk(prb_proc_ctl_t *proc_p)
{
prb_status_t prbstat = PRB_STATUS_OK;
DBG_TNF_PROBE_0(prb_rtld_stalk_1, "libtnfctl", "sunw%verbosity 2");
if (!proc_p->bptaddr) {
Elf3264_Dyn dentry;
struct r_debug r_dbg;
if (proc_p->dbgaddr == 0) {
DBG((void) fprintf(stderr,
"prb_rtld_stalk: dbgaddr not set\n"));
return (PRB_STATUS_BADARG);
}
prbstat = prb_proc_read(proc_p, proc_p->dbgaddr,
&dentry, sizeof (dentry));
if (prbstat || !dentry.d_un.d_ptr) {
DBG((void) fprintf(stderr,
"prb_rtld_stalk: error in d_un.d_ptr\n"));
return (prbstat);
}
/* read in the debug struct that it points to */
prbstat = prb_proc_read(proc_p, dentry.d_un.d_ptr,
&r_dbg, sizeof (r_dbg));
if (prbstat)
return (prbstat);
proc_p->bptaddr = r_dbg.r_brk;
}
/* plant a breakpoint trap in the pointed to function */
prbstat = bpt(proc_p, proc_p->bptaddr);
if (prbstat)
return (prbstat);
/* setup process to stop when breakpoint encountered */
prbstat = prb_proc_tracebpt(proc_p, B_TRUE);
return (prbstat);
}
/*
* prb_rtld_advance() - we've hit a breakpoint, replace the original
* instruction, istep, put the breakpoint back ...
*/
prb_status_t
prb_rtld_advance(prb_proc_ctl_t *proc_p)
{
prb_status_t prbstat;
DBG_TNF_PROBE_0(prb_rtld_advance_1, "libtnfctl", "sunw%verbosity 2");
prbstat = prb_proc_clrbptflt(proc_p);
if (prbstat)
return (prbstat);
prbstat = unbpt(proc_p, proc_p->bptaddr);
if (prbstat)
return (prbstat);
prbstat = prb_proc_istepbpt(proc_p);
if (prbstat)
return (prbstat);
prbstat = bpt(proc_p, proc_p->bptaddr);
if (prbstat)
return (prbstat);
return (PRB_STATUS_OK);
}
/* EFUN: "Hit Breakpoint" */
f_bkpt()
{ clean_exit();
bpt();
set_tty();
}
void nmethod::flush() {
BlockProfilerTicks bpt(exclude_nmethod_flush);
CSect cs(profilerSemaphore); // for profiler
# if GENERATE_DEBUGGING_AIDS
if (CheckAssertions) {
// for debugging
if (nmethodFlushCount && --nmethodFlushCount == 0)
warning("nmethodFlushCount");
if (this == (nmethod*)catchThisOne) warning("caught nmethod");
}
# endif
// EventMarker em("flushing nmethod %#lx %s", this, "");
if (PrintMethodFlushing) {
ResourceMark m;
char *compilerName = VMString[compiler()]->copy_null_terminated();
lprintf("*flushing %s%s%s-nmethod 0x%lx %d\t(",
isZombie() ? "zombie " : "",
isAccess() ? "access " : "",
compilerName, (void*)(long unsigned)this, (void*)useCount[id]);
printName(0, key.selector);
lprintf(")");
}
// always check the following - tests are really cheap
if (flags.flushed) fatal1("nmethod %#lx already flushed", this);
if (zone::frame_chain_nesting == 0) fatal("frames must be chained when flushing");
if (frame_chain != NoFrameChain) {
// Can't remove an nmethod from deps chains now, because later
// programming changes may need to invalidate it.
// That is, don't unlink() now.
// See comment for makeZombie routine. The comment above is the
// "original comment" referred to there.
// -- dmu 1/12/03
if (this == recompilee) {
// nmethod is being recompiled; cannot really flush yet
// em.event.args[1] = "(being recompiled)";
if (PrintMethodFlushing) {
lprintf(" (being recompiled)\n");
}
} else {
// nmethod is currently being executed; cannot flush yet
// em.event.args[1] = "(currently active)";
if (PrintMethodFlushing) {
lprintf(" (currently active)\n");
}
}
makeZombie(false);
} else {
unlink();
// nmethod is not being executed; completely throw away
// em.event.args[1] = "(not currently active)";
if (PrintMethodFlushing) {
lprintf("\n");
}
flatProfiler->flush((char*)this, instsEnd());
zoneLink.remove();
rememberLink.remove();
for (addrDesc* p = locs(), *pend = locsEnd(); p < pend; p++) {
if (p->isSendDesc()) {
p->asSendDesc(this)->unlink();
} else if (p->isDIDesc()) {
p->asDIDesc(this)->dependency()->flush();
}
}
flags.flushed = 1; // to detect flushing errors
# if GENERATE_DEBUGGING_AIDS
if (CheckAssertions) {
set_oops((oop*)insts(), instsLen()/oopSize, 0); // for quicker detection
}
# endif
Memory->code->free_nmethod(this);
}
MachineCache::flush_instruction_cache_for_debugging();
}
int
be_visitor_operation_ami_cs::visit_operation (be_operation *node)
{
// No sendc method for oneway operations.
if (node->flags () == AST_Operation::OP_oneway)
{
return 0;
}
be_visitor_context ctx;
TAO_OutStream *os = this->ctx_->stream ();
this->ctx_->node (node);
*os << be_nl_2 << "// TAO_IDL - Generated from" << be_nl
<< "// " << __FILE__ << ":" << __LINE__;
// Generate the return type mapping. Return type is simply void.
*os << be_nl_2
<< "void" << be_nl;
// Generate the operation name.
// Grab the scope name.
be_decl *parent =
be_scope::narrow_from_scope (node->defined_in ())->decl ();
if (parent == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%N:%l) be_visitor_operation_ami_cs::"
"visit_operation - "
"scope name is nil\n"),
-1);
}
// Generate the scope::operation name.
*os << parent->full_name ()
<< "::" << this->ctx_->port_prefix ().c_str ()
<< node->local_name ()->get_string ();
// Generate the argument list with the appropriate mapping (same as
// in the header file)
ctx = *this->ctx_;
be_visitor_operation_arglist oa_visitor (&ctx);
// Get the AMI version from the strategy class.
be_operation *ami_op = node;
if (ami_op->accept (&oa_visitor) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%N:%l) be_visitor_operation_ami_cs::"
"visit_operation - "
"codegen for argument list failed\n"),
-1);
}
// Generate the actual code for the stub. However, if any of the argument
// types is "native", we flag a MARSHAL exception.
// last argument
*os << be_nl << "{" << be_idt;
if (node->has_native ()) // native exists => no stub
{
be_predefined_type bpt (AST_PredefinedType::PT_void,
0);
int const status = this->gen_raise_exception ("::CORBA::MARSHAL",
"");
if (status == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%N:%l) be_visitor_operation_ami_cs::"
"visit_operation - "
"codegen for has-native exception failed\n"),
-1);
}
}
else
{
*os << be_nl
<< "if (!this->is_evaluated ())" << be_idt_nl
<< "{" << be_idt_nl
<< "::CORBA::Object::tao_object_initialize (this);"
<< be_uidt_nl
<< "}" << be_uidt_nl << be_nl;
}
// Includes the reply handler, but we have to add 1 for the retval anyway.
int nargs = ami_op->argument_count ();
if (nargs == 1)
{
// No arguments other than the reply handler, and the return
// type is void. No need to generate argument list.
*os << be_nl_2
<< "TAO::Argument ** _the_tao_operation_signature = 0;";
nargs = 0; // Don't count the reply handler.
}
else
{
*os << be_nl<< be_nl
<< "TAO::Arg_Traits<void>::"
<< (node->flags () == AST_Operation::OP_oneway &&
be_global->use_clonable_in_args() ? "clonable_" : "")
<< "ret_val _tao_retval;";
// Declare the argument helper classes.
this->gen_stub_body_arglist (ami_op, os, true);
// Assemble the arg helper class pointer array.
*os << be_nl_2
<< "TAO::Argument *_the_tao_operation_signature[] =" << be_idt_nl
<< "{" << be_idt_nl
<< "&_tao_retval";
AST_Argument *arg = 0;
UTL_ScopeActiveIterator arg_list_iter (ami_op,
UTL_Scope::IK_decls);
// For a sendc_* operation, skip the reply handler (first argument).
arg_list_iter.next ();
for (; ! arg_list_iter.is_done (); arg_list_iter.next ())
{
arg = AST_Argument::narrow_from_decl (arg_list_iter.item ());
*os << "," << be_nl
<< "&_tao_" << arg->local_name ();
}
*os << be_uidt_nl
<< "};" << be_uidt;
}
ACE_CString base (node->local_name ()->get_string ());
/// The sendc_* operation makes the invocation with the
/// original operation name.
ACE_CString lname_str (base.substr (ACE_OS::strlen ("sendc_")));
const char *lname = lname_str.c_str ();
ACE_CString opname (node->is_attr_op () ? "_" : "");
opname += lname;
/// Some compilers can't resolve the stream operator overload.
const char *op_name = opname.c_str ();
ACE_CDR::ULong len = opname.length ();
*os << be_nl_2
<< "TAO::Asynch_Invocation_Adapter _tao_call (" << be_idt << be_idt_nl
<< "this," << be_nl
<< "_the_tao_operation_signature," << be_nl
<< nargs << "," << be_nl
<< "\"" << op_name << "\"," << be_nl
<< len << "," << be_nl;
*os << "TAO::TAO_CO_NONE";
if (be_global->gen_direct_collocation())
{
*os << " | TAO::TAO_CO_DIRECT_STRATEGY";
}
if (be_global->gen_thru_poa_collocation())
{
*os << " | TAO::TAO_CO_THRU_POA_STRATEGY";
}
*os << be_uidt_nl
<< ");" << be_uidt;
*os << be_nl_2
<< "_tao_call.invoke (" << be_idt << be_idt_nl
<< "ami_handler," << be_nl
<< "&";
if (parent->is_nested ())
{
be_decl *gparent =
be_scope::narrow_from_scope (parent->defined_in ())->decl ();
*os << gparent->name () << "::";
}
*os << "AMI_" << parent->local_name () << "Handler::"
<< lname << "_reply_stub" << be_uidt_nl
<< ");" << be_uidt;
*os << be_uidt_nl
<< "}";
return 0;
}
//--------------------------------------------------------------------------
int idaapi rpc_debmod_t::dbg_is_ok_bpt(bpttype_t type, ea_t ea, int len)
{
return bpt(RPC_ISOK_BPT, type, ea, len);
}
//--------------------------------------------------------------------------
int rpc_debmod_t::dbg_add_bpt(bpttype_t type, ea_t ea, int len)
{
return bpt(RPC_ADD_BPT, type, ea, len);
}
