Lines Matching defs:Load
236 /// a load from the constant pool.
243 // target can do an extending load from float to double, we put it into
246 // an FP extending load is the same cost as a normal load (such as on the x87
340 // Load one integer register's worth from the stack slot.
341 SDValue Load = DAG.getLoad(RegVT, dl, Store, StackPtr,
345 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, Ptr,
357 // machines this requires an extending load from the stack slot to ensure
362 // Load from the stack slot.
363 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Store, StackPtr,
367 Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, Ptr,
412 /// Expands an unaligned load to 2 half-size loads.
427 // Expand to a (misaligned) integer load of the same size,
442 // loads and stores, then do a (aligned) load from the stack slot.
458 // Load one integer register's worth from the original location.
459 SDValue Load = DAG.getLoad(RegVT, dl, Chain, Ptr,
465 // Follow the load with a store to the stack slot. Remember the store.
466 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, StackPtr,
475 // The last copy may be partial. Do an extending load.
478 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Chain, Ptr,
485 // Follow the load with a store to the stack slot. Remember the store.
488 Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, StackPtr,
495 // Finally, perform the original load only redirected to the stack slot.
496 Load = DAG.getExtLoad(LD->getExtensionType(), dl, VT, TF, StackBase,
501 ValResult = Load;
506 "Unaligned load of unsupported type.");
519 // If the original load is NON_EXTLOAD, the hi part load must be ZEXTLOAD.
523 // Load the value in two parts
577 // badness. We could also load the value into a vector register (either
604 // Load the updated vector.
872 SDValue Value; // The value returned by the load op.
886 // If this is an unaligned load and the target doesn't support it,
918 assert(RVal.getNode() != Node && "Load must be completely replaced");
940 // load an i8. This trick is correct for ZEXTLOAD because the top 7
949 // Promote to a byte-sized load if not loading an integral number of
956 // way. A zext load from NVT thus automatically gives zext from SrcVT.
990 "Load size not an integral number of bytes!");
998 // Load the bottom RoundWidth bits.
1004 // Load the remaining ExtraWidth bits.
1013 // Build a factor node to remember that this load is independent of
1028 // Load the top RoundWidth bits.
1033 // Load the remaining ExtraWidth bits.
1043 // Build a factor node to remember that this load is independent of
1077 // If this is an unaligned load and the target doesn't support
1104 SDValue Load = DAG.getExtLoad(MidExtType, dl, LoadVT, Chain, Ptr,
1108 Value = DAG.getNode(ExtendOp, dl, Node->getValueType(0), Load);
1109 Load.getValue(1);
1123 // Turn the unsupported load into an EXTLOAD followed by an
1145 assert(Value.getNode() != Node && "Load must be completely replaced");
1228 case ISD::LOAD:
1230 // FIXME: Model these properly. LOAD and STORE are complicated, and
1389 case ISD::LOAD: {
1430 // Store the value to a temporary stack slot, then LOAD the returned part.
1455 // Replace the chain going out of the store, by the one out of the load.
1476 // Store the value to a temporary stack slot, then LOAD the returned part.
1503 // Finally, load the updated vector.
1510 // aligned object on the stack, store each element into it, then load
1553 // Result is a load from the stack slot.
1572 // Store the float to memory, then load the sign part out as an integer.
1574 // First create a temporary that is aligned for both the load and store.
1582 // Load out a legal integer with the same sign bit as the float.
1587 // The float may be wider than the integer we are going to load. Advance
1593 // Load a legal integer containing the sign bit.
1771 /// Emit a store/load combination to the stack. This stores
1773 /// a load from the stack slot to DestVT, extending it if needed.
1808 // Result is a load from the stack slot.
1821 // then load the whole vector back out.
1971 // If all elements are constants, create a load from the constant pool.
2448 // load the constructed double
2449 SDValue Load = DAG.getLoad(MVT::f64, dl, Store2, StackSlot,
2457 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Load, Bias);
2592 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT,
2596 HandleSDNode Handle(Load);
2597 LegalizeOp(Load.getNode());
2897 // There is no libcall for atomic load; fake it with ATOMIC_CMP_SWAP.
3007 // NOTE: we could fall back on load/store here too for targets without
3100 // Load the actual argument out of the pointer VAList
3805 // BRIND(load(Jumptable + index) + RelocBase)
