Lines Matching refs:Lo
1875 /// Post merger cleanup, reduces a malformed Hi and Lo pair to
1881 /// \param Lo - The classification for the parts of the type
1887 void postMerge(unsigned AggregateSize, Class &Lo, Class &Hi) const;
1892 /// \param Lo - The classification for the parts of the type
1906 /// be passed in Memory then at least the classification of \arg Lo
1909 /// The \arg Lo class will be NoClass iff the argument is ignored.
1911 /// If the \arg Lo class is ComplexX87, then the \arg Hi class will
1913 void classify(QualType T, uint64_t OffsetBase, Class &Lo, Class &Hi,
2244 void X86_64ABIInfo::postMerge(unsigned AggregateSize, Class &Lo,
2268 Lo = Memory;
2269 if (Hi == X87Up && Lo != X87 && honorsRevision0_98())
2270 Lo = Memory;
2271 if (AggregateSize > 128 && (Lo != SSE || Hi != SSEUp))
2272 Lo = Memory;
2273 if (Hi == SSEUp && Lo != SSE)
2318 Class &Lo, Class &Hi, bool isNamedArg) const {
2327 Lo = Hi = NoClass;
2329 Class &Current = OffsetBase < 64 ? Lo : Hi;
2338 Lo = Integer;
2347 Lo = SSE;
2350 Lo = X87;
2364 classify(ET->getDecl()->getIntegerType(), OffsetBase, Lo, Hi, isNamedArg);
2377 // Lo and Hi now.
2378 Lo = Hi = Integer;
2385 Lo = Hi = Integer;
2410 Hi = Lo;
2433 Hi = Lo;
2438 // SSEUP. The original Lo and Hi design considers that types can't be
2439 // greater than 128-bits, so a 64-bit split in Hi and Lo makes sense.
2450 Lo = SSE;
2464 Lo = Hi = Integer;
2468 Lo = Hi = SSE;
2476 Lo = Hi = SSE;
2486 Hi = Lo;
2515 // contains a single 256-bit element. Since Lo and Hi logic isn't extended
2523 Lo = merge(Lo, FieldLo);
2525 if (Lo == Memory || Hi == Memory)
2529 postMerge(Size, Lo, Hi);
2530 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp array classification.");
2556 // Reset Lo class, this will be recomputed.
2576 Lo = merge(Lo, FieldLo);
2578 if (Lo == Memory || Hi == Memory) {
2579 postMerge(Size, Lo, Hi);
2596 // contains a single 256-bit element. Since Lo and Hi logic isn't extended
2600 Lo = Memory;
2601 postMerge(Size, Lo, Hi);
2606 Lo = Memory;
2607 postMerge(Size, Lo, Hi);
2643 Lo = merge(Lo, FieldLo);
2645 if (Lo == Memory || Hi == Memory)
2649 postMerge(Size, Lo, Hi);
2981 GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi,
2987 unsigned LoSize = (unsigned)TD.getTypeAllocSize(Lo);
3002 if (Lo->isFloatTy())
3003 Lo = llvm::Type::getDoubleTy(Lo->getContext());
3005 assert((Lo->isIntegerTy() || Lo->isPointerTy())
3006 && "Invalid/unknown lo type");
3007 Lo = llvm::Type::getInt64Ty(Lo->getContext());
3011 llvm::StructType *Result = llvm::StructType::get(Lo, Hi, nullptr);
3024 X86_64ABIInfo::Class Lo, Hi;
3025 classify(RetTy, 0, Lo, Hi, /*isNamedArg*/ true);
3028 assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
3029 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
3032 switch (Lo) {
3039 "Unknown missing lo part");
3044 llvm_unreachable("Invalid classification for lo word.");
3106 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
3111 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
3121 assert(Lo == SSE && "Unexpected SSEUp classification.");
3132 if (Lo != X87) {
3134 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
3156 X86_64ABIInfo::Class Lo, Hi;
3157 classify(Ty, 0, Lo, Hi, isNamedArg);
3161 assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
3162 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
3167 switch (Lo) {
3174 "Unknown missing lo part");
3191 llvm_unreachable("Invalid classification for lo word.");
3244 if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
3254 if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
3264 assert(Lo == SSE && "Unexpected SSEUp classification");
6548 // 64 and 65 are the multiply/divide registers, $hi and $lo.
