Searched defs:ctl (Results 1 - 17 of 17) sorted by relevance

/openjdk7/jdk/src/share/classes/com/sun/jndi/ldap/
H A DDefaultResponseControlFactory.java66 * @param ctl A non-null control.
73 public Control getControlInstance(Control ctl) argument
76 String id = ctl.getID();
81 return new SortResponseControl(id, ctl.isCritical(),
82 ctl.getEncodedValue());
85 return new PagedResultsResponseControl(id, ctl.isCritical(),
86 ctl.getEncodedValue());
89 return new EntryChangeResponseControl(id, ctl.isCritical(),
90 ctl.getEncodedValue());
/openjdk7/jdk/src/share/classes/javax/naming/ldap/
H A DControlFactory.java68 * Typically, <tt>ctl</tt> is a "basic" control containing
87 * @param ctl A non-null control.
90 * @exception NamingException If <tt>ctl</tt> contains invalid data that prevents it
95 public abstract Control getControlInstance(Control ctl) throws NamingException; argument
110 * return <code>ctl</code>.
118 * @param ctl The non-null control object containing the OID and BER data.
123 * @return A control object created using <code>ctl</code>; or
124 * <code>ctl</code> if a control object cannot be created using
134 public static Control getControlInstance(Control ctl, Context ctx, argument
144 return ctl;
[all...]
/openjdk7/hotspot/src/share/vm/opto/
H A Dvectornode.cpp405 LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, argument
408 return new (C) LoadVectorNode(ctl, mem, adr, atyp, vt);
412 StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, argument
415 return new (C) StoreVectorNode(ctl, mem, adr, atyp, val);
H A DidealKit.hpp211 Node* CastPX(Node* ctl, Node* p) { return transform(new (C) CastP2XNode(ctl, p)); } argument
216 Node* load(Node* ctl,
224 Node* store(Node* ctl,
232 Node* storeCM(Node* ctl,
H A DidealKit.cpp349 Node* IdealKit::load(Node* ctl, argument
362 ld = LoadLNode::make_atomic(C, ctl, mem, adr, adr_type, t);
364 ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt);
369 Node* IdealKit::store(Node* ctl, Node* adr, Node *val, BasicType bt, argument
378 st = StoreLNode::make_atomic(C, ctl, mem, adr, adr_type, val);
380 st = StoreNode::make(_gvn, ctl, mem, adr, adr_type, val, bt);
390 Node* IdealKit::storeCM(Node* ctl, Node* adr, Node *val, Node* oop_store, int oop_adr_idx, argument
400 Node* st = new (C) StoreCMNode(ctl, mem, adr, adr_type, val, oop_store, oop_adr_idx);
H A DgraphKit.hpp318 Node* DivI(Node* ctl, Node* l, Node* r) { return _gvn.transform(new (C) DivINode(ctl, l, r)); } argument
488 Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, argument
491 return make_load(ctl, adr, t, bt, adr->bottom_type()->is_ptr(),
494 Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, const TypePtr* adr_type, bool require_atomic_access = false) { argument
497 return make_load(ctl, adr, t, bt, C->get_alias_index(adr_type),
501 Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, int adr_idx, bool require_atomic_access = false);
505 Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt, argument
510 return store_to_memory(ctl, adr, val, bt,
516 Node* store_to_memory(Node* ctl, Nod
542 store_oop_to_object(Node* ctl, Node* obj, Node* adr, const TypePtr* adr_type, Node* val, const TypeOopPtr* val_type, BasicType bt) argument
552 store_oop_to_array(Node* ctl, Node* obj, Node* adr, const TypePtr* adr_type, Node* val, const TypeOopPtr* val_type, BasicType bt) argument
[all...]
H A Dparse1.cpp104 Node *ctl = control(); local
110 case T_INT: l = new (C) LoadINode( ctl, mem, adr, TypeRawPtr::BOTTOM ); break;
111 case T_FLOAT: l = new (C) LoadFNode( ctl, mem, adr, TypeRawPtr::BOTTOM ); break;
112 case T_ADDRESS: l = new (C) LoadPNode( ctl, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM ); break;
113 case T_OBJECT: l = new (C) LoadPNode( ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInstPtr::BOTTOM ); break;
121 ? (Node*)new (C) LoadDNode( ctl, mem, adr, TypeRawPtr::BOTTOM )
122 : (Node*)new (C) LoadLNode( ctl, mem, adr, TypeRawPtr::BOTTOM );
125 ? (Node*)new (C) LoadD_unalignedNode( ctl, mem, adr, TypeRawPtr::BOTTOM )
126 : (Node*)new (C) LoadL_unalignedNode( ctl, mem, adr, TypeRawPtr::BOTTOM );
H A Dloopnode.cpp149 Node* ctl = n->in(0); local
150 assert(ctl->is_CFG(), "expensive input 0 must be cfg");
153 if (!is_dominator(ctl, earliest) && !is_dominator(earliest, ctl)) {
154 dump_bad_graph("Bad graph detected in get_early_ctrl_for_expensive", n, earliest, ctl);
158 if (dom_depth(ctl) < min_dom_depth) {
163 Node *next = ctl;
169 if (ctl->is_CountedLoop() && ctl->in(1) != NULL && ctl
1275 Node *ctl = _head->in(LoopNode::EntryControl); local
[all...]
H A Dmacro.cpp1012 Node* PhaseMacroExpand::make_load(Node* ctl, Node* mem, Node* base, int offset, const Type* value_type, BasicType bt) { argument
1015 Node* value = LoadNode::make(_igvn, ctl, mem, adr, adr_type, value_type, bt);
1021 Node* PhaseMacroExpand::make_store(Node* ctl, Node* mem, Node* base, int offset, Node* value, BasicType bt) { argument
1023 mem = StoreNode::make(_igvn, ctl, mem, adr, NULL, value, bt);
H A Dsuperword.cpp1374 Node* ctl = n->in(MemNode::Control); local
1378 vn = LoadVectorNode::make(C, opc, ctl, mem, adr, atyp, vlen, velt_basic_type(n));
1383 Node* ctl = n->in(MemNode::Control); local
1387 vn = StoreVectorNode::make(C, opc, ctl, mem, adr, atyp, val, vlen);
H A Dcompile.hpp687 void set_recent_alloc(Node* ctl, Node* obj) { argument
688 _recent_alloc_ctl = ctl;
H A Dmemnode.cpp236 Node *ctl = in(MemNode::Control); local
237 if (ctl && remove_dead_region(phase, can_reshape))
239 ctl = in(MemNode::Control);
241 if (ctl && ctl->is_top()) return NodeSentinel;
245 if (ctl && can_reshape && igvn != NULL) {
248 if (ctl->in(0)->is_If()) {
249 assert(ctl->is_IfTrue() || ctl->is_IfFalse(), "sanity");
250 bol = ctl
893 make( PhaseGVN& gvn, Node *ctl, Node *mem, Node *adr, const TypePtr* adr_type, const Type *rt, BasicType bt ) argument
934 make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt) argument
1915 Node *ctl = NULL; local
2235 make( PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, BasicType bt ) argument
2267 make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val) argument
2699 clear_memory(Node* ctl, Node* mem, Node* dest, intptr_t start_offset, Node* end_offset, PhaseGVN* phase) argument
2721 clear_memory(Node* ctl, Node* mem, Node* dest, Node* start_offset, Node* end_offset, PhaseGVN* phase) argument
2749 clear_memory(Node* ctl, Node* mem, Node* dest, intptr_t start_offset, intptr_t end_offset, PhaseGVN* phase) argument
3602 Node* ctl = old->in(MemNode::Control); local
[all...]
H A DgraphKit.cpp887 // Call [state:] ctl io mem fptr retadr
1428 Node* GraphKit::make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, argument
1437 ld = LoadLNode::make_atomic(C, ctl, mem, adr, adr_type, t);
1439 ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt);
1444 Node* GraphKit::store_to_memory(Node* ctl, Node* adr, Node *val, BasicType bt, argument
1453 st = StoreLNode::make_atomic(C, ctl, mem, adr, adr_type, val);
1455 st = StoreNode::make(_gvn, ctl, mem, adr, adr_type, val, bt);
1469 Node* ctl,
1479 set_control(ctl);
1498 void GraphKit::post_barrier(Node* ctl, argument
1468 pre_barrier(bool do_load, Node* ctl, Node* obj, Node* adr, uint adr_idx, Node* val, const TypeOopPtr* val_type, Node* pre_val, BasicType bt) argument
1529 store_oop(Node* ctl, Node* obj, Node* adr, const TypePtr* adr_type, Node* val, const TypeOopPtr* val_type, BasicType bt, bool use_precise) argument
1562 store_oop_to_unknown(Node* ctl, Node* obj, Node* adr, const TypePtr* adr_type, Node* val, BasicType bt) argument
1626 load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype) argument
[all...]
H A Dlibrary_call.cpp3381 Node* ctl = region->in(i); local
3382 if (ctl == NULL || ctl == top()) {
5005 Node* ctl = control(); local
5006 while (ctl != alloc_ctl) {
5010 if ((ctl->is_IfFalse() || ctl->is_IfTrue()) && ctl->in(0)->is_If()) {
5011 IfNode* iff = ctl->in(0)->as_If();
5012 Node* not_ctl = iff->proj_out(1 - ctl
[all...]
/openjdk7/jdk/src/solaris/native/sun/awt/splashscreen/
H A Dsplashscreen_sys.c559 int ctl = splash->controlpipe[0]; local
566 pfd[1].fd = ctl;
595 if (read(ctl, &buf, sizeof(buf)) > 0) {
/openjdk7/jdk/src/share/classes/java/util/concurrent/
H A DForkJoinPool.java174 * variable ("ctl"). This variable is read on the order of 10-100
213 * the wait queue field of ctl stores worker indices, not worker
233 * a simple Treiber stack, headed by the "id" field of ctl, plus a
317 * contention on blockedCount alleviates some contention on ctl).
320 * the ctl stop bit and then (non-atomically) sets each workers
438 * as reads memory-acquire by first reading ctl. All readers must
505 * the lower 32 bits of queue state, u = (int)(ctl >>> 32) and e =
506 * (int)ctl. The ec field is never accessed alone, but always
517 volatile long ctl; field in class:ForkJoinPool
540 // masks and units for dealing with u = (int)(ctl >>> 3
[all...]
H A DThreadPoolExecutor.java319 * The main pool control state, ctl, is an atomic integer packing
375 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); field in class:ThreadPoolExecutor
386 // Packing and unpacking ctl
392 * Bit field accessors that don't require unpacking ctl.
409 * Attempt to CAS-increment the workerCount field of ctl.
412 return ctl.compareAndSet(expect, expect + 1);
416 * Attempt to CAS-decrement the workerCount field of ctl.
419 return ctl.compareAndSet(expect, expect - 1);
423 * Decrements the workerCount field of ctl. This is called only on
428 do {} while (! compareAndDecrementWorkerCount(ctl
[all...]

Completed in 114 milliseconds