Lines Matching defs:Load
79 // Do not limit the scalar integer load size if no threshold is given.
119 /// intrinsics or load/store that only access the entire alloca at once.
143 /// ScalarLoadThreshold - The maximum size in bits of scalars to load when
368 // scalar load threshold.
568 // can handle it like a load or store of the scalar type.
635 // The load is a bit extract from NewAI shifted right by Offset bits.
653 // If the load we just inserted is now dead, then the inserted store
684 // If the load we just inserted is now dead, then the memset overwrote
694 // can handle it like a load or store of the scalar type.
700 // a noop copy-to-self, just delete it. Otherwise, emit a load and store
705 // Dest must be OrigAI, change this to be a load from the original
721 // Src must be OrigAI, change this to be a load from NewAI then a store
772 // If the load is of the whole new alloca, no conversion is needed.
842 // If this is a big-endian system and the load is narrower than the
1129 /// subsequently loaded can be rewritten to load both input pointers and then
1130 /// select between the result, allowing the load of the alloca to be promoted.
1133 /// %V = load i32* %P2
1135 /// %V1 = load i32* %Alloca -> will be mem2reg'd
1136 /// %V2 = load i32* %Other
1166 /// subsequently loaded can be rewritten to load both input pointers in the pred
1167 /// blocks and then PHI the results, allowing the load of the alloca to be
1171 /// %V = load i32* %P2
1173 /// %V1 = load i32* %Alloca -> will be mem2reg'd
1175 /// %V2 = load i32* %Other
1182 // For now, we can only do this promotion if the load is in the same block as
1183 // the PHI, and if there are no stores between the phi and load.
1196 // Ensure that there are no instructions between the PHI and the load that
1210 // trapping load
1216 // there is no safe place to put a load in the predecessor.
1221 // (an invoke), there is no valid place to put a load in the predecessor.
1229 // If this pointer is always safe to load, or if we can prove that there is
1230 // already a load in the block, then we can move the load to the pred block.
1275 // If it is safe to turn "load (select c, AI, ptr)" into a select of two
1290 // If it is safe to turn "load (phi [AI, ptr, ...])" into a PHI of loads
1309 // If there are no instructions to rewrite, then all uses are load/stores and
1327 // Selects in InstsToRewrite only have load uses. Rewrite each as two
1393 LoadInst *&Load = InsertedLoads[Pred];
1394 if (!Load) {
1395 Load = new LoadInst(PN->getIncomingValue(i),
1398 Load->setAlignment(Align);
1399 if (AATags) Load->setAAMetadata(AATags);
1402 NewPN->addIncoming(Load, Pred);
1668 /// the alloca. The most important use case for this is single load and stores
1797 /// isSafeMemAccess - Check if a load/store/memcpy operates on the entire AI
1809 // Check if this is a load/store of the entire alloca.
1921 // %res = load { i32, i32 }* %alloc
1923 // %load.0 = load i32* %alloc.0
1924 // %insert.0 insertvalue { i32, i32 } zeroinitializer, i32 %load.0, 0
1925 // %load.1 = load i32* %alloc.1
1926 // %insert = insertvalue { i32, i32 } %insert.0, i32 %load.1, 1
1931 Value *Load = Builder.CreateLoad(NewElts[i], "load");
1932 Insert = Builder.CreateInsertValue(Insert, Load, i, "insert");
1939 // If this is a load of the entire alloca to an integer, rewrite it.
2266 // If we got down to a scalar, insert a load or store as appropriate.
2464 load of the entire allocation to
2465 /// an integer. Load the individual pieces to form the aggregate value.
2475 DEBUG(dbgs() << "PROMOTING LOAD OF WHOLE ALLOCA: " << *AI << '\n' << *LI
2493 // Load the value from the alloca. If the NewElt is an aggregate, cast
2494 // the pointer to an integer of the same size before doing the load.
2510 SrcField = new LoadInst(SrcField, "sroa.load.elt", LI);
