Lines Matching defs:Load
319 if (N.getOpcode() != ISD::LOAD)
322 // If N is a load, do additional profitability checks.
361 // a load.
376 /// load's chain operand and move load below the call's chain operand.
377 static void MoveBelowOrigChain(SelectionDAG *CurDAG, SDValue Load,
381 if (Chain.getNode() == Load.getNode())
382 Ops.push_back(Load.getOperand(0));
387 if (Chain.getOperand(i).getNode() == Load.getNode())
388 Ops.push_back(Load.getOperand(0));
392 CurDAG->getNode(ISD::TokenFactor, SDLoc(Load), MVT::Other, Ops);
398 CurDAG->UpdateNodeOperands(Load.getNode(), Call.getOperand(0),
399 Load.getOperand(1), Load.getOperand(2));
402 Ops.push_back(SDValue(Load.getNode(), 1));
407 /// isCalleeLoad - Return true if call address is a load and it can be
411 /// chain and the load.
414 // the call. After MoveBelowOrigChain the load is moved between the call and
415 // the chain, this can create a cycle if the load is not folded. So it is
416 // *really* important that we are sure the load will be folded.
436 // writes to memory. It's not safe to move the callee (a load) across a store.
462 // Only does this if load can be folded into TC_RETURN.
465 /// Also try moving call address load from outside callseq_start to just
468 /// [Load chain]
471 /// [Load]
479 /// [LOAD/C2Reg] |
486 SDValue Load = N->getOperand(1);
487 if (!isCalleeLoad(Load, Chain, HasCallSeq))
489 MoveBelowOrigChain(CurDAG, Load, SDValue(N, 0), Chain);
495 // load to the stack. This is a gross hack. We would like to simply mark
535 MemVT = DstVT; // FP_ROUND must use DstVT, we can't do a 'trunc load'.
542 // FIXME: optimize the case where the src/dest is a load or store?
622 // load gs:0 -> GS segment register.
623 // load fs:0 -> FS segment register.
1029 case ISD::LOAD:
1324 /// is always a load, store, atomic node, or null. It is only null when
1364 /// SelectScalarSSELoad - Match a scalar SSE load. In particular, we want to
1365 /// match a load whose top elements are either undef or zeros. The load flavor
1399 // Okay, this is a zero extending load. Fold it.
1707 // Return the target constant operand for atomic-load-op and do simple
1708 // translations, such as from atomic-load-add to lock-sub. The return value is
1729 // For atomic-load-add, we could do some optimizations.
1748 // Translate (atomic-load-add ptr (sub 0 x)) back to (lock-sub x).
1755 // (atomic-load-add (truncate (sub 0 x))) to (lock-sub (EXTRACT_SUBREG x))
1937 /// is suitable for doing the {load; increment or decrement; store} to modify
1946 // is the stored value result 0 of the load?
1956 SDValue Load = StoredVal->getOperand(0);
1957 // Is the stored value a non-extending and non-indexed load?
1958 if (!ISD::isNormalLoad(Load.getNode())) return false;
1961 LoadNode = cast<LoadSDNode>(Load);
1969 if (!Load.hasOneUse())
1972 // Is the address of the store the same as the load?
1977 // Check if the chain is produced by the load or is a TokenFactor with
1978 // the load output chain as an operand. Return InputChain by reference.
1982 if (Chain == Load.getValue(1)) {
1989 if (Op == Load.getValue(1)) {
1996 // the load. But that can be very expensive. Instead visit the uses and
1997 // make sure they all have smaller node id than the load.
2012 // for the load.
2759 // Change a chain of {load; incr or dec; store} of the same value into
