Lines Matching defs:Lo
876 /// Post merger cleanup, reduces a malformed Hi and Lo pair to
882 /// \param Lo - The classification for the parts of the type
888 void postMerge(unsigned AggregateSize, Class &Lo, Class &Hi) const;
893 /// \param Lo - The classification for the parts of the type
904 /// be passed in Memory then at least the classification of \arg Lo
907 /// The \arg Lo class will be NoClass iff the argument is ignored.
909 /// If the \arg Lo class is ComplexX87, then the \arg Hi class will
911 void classify(QualType T, uint64_t OffsetBase, Class &Lo, Class &Hi) const;
1066 void X86_64ABIInfo::postMerge(unsigned AggregateSize, Class &Lo,
1090 Lo = Memory;
1091 if (Hi == X87Up && Lo != X87 && honorsRevision0_98())
1092 Lo = Memory;
1093 if (AggregateSize > 128 && (Lo != SSE || Hi != SSEUp))
1094 Lo = Memory;
1095 if (Hi == SSEUp && Lo != SSE)
1140 Class &Lo, Class &Hi) const {
1149 Lo = Hi = NoClass;
1151 Class &Current = OffsetBase < 64 ? Lo : Hi;
1160 Lo = Integer;
1167 Lo = X87;
1177 classify(ET->getDecl()->getIntegerType(), OffsetBase, Lo, Hi);
1188 Lo = Hi = Integer;
1206 Hi = Lo;
1224 Hi = Lo;
1228 // SSEUP. The original Lo and Hi design considers that types can't be
1229 // greater than 128-bits, so a 64-bit split in Hi and Lo makes sense.
1233 Lo = SSE;
1247 Lo = Hi = Integer;
1251 Lo = Hi = SSE;
1260 Hi = Lo;
1289 // contains a single 256-bit element. Since Lo and Hi logic isn't extended
1297 Lo = merge(Lo, FieldLo);
1299 if (Lo == Memory || Hi == Memory)
1303 postMerge(Size, Lo, Hi);
1304 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp array classification.");
1330 // Reset Lo class, this will be recomputed.
1350 Lo = merge(Lo, FieldLo);
1352 if (Lo == Memory || Hi == Memory)
1368 // contains a single 256-bit element. Since Lo and Hi logic isn't extended
1372 Lo = Memory;
1377 Lo = Memory;
1413 Lo = merge(Lo, FieldLo);
1415 if (Lo == Memory || Hi == Memory)
1419 postMerge(Size, Lo, Hi);
1756 GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi,
1762 unsigned LoSize = (unsigned)TD.getTypeAllocSize(Lo);
1775 if (Lo->isFloatTy())
1776 Lo = llvm::Type::getDoubleTy(Lo->getContext());
1778 assert(Lo->isIntegerTy() && "Invalid/unknown lo type");
1779 Lo = llvm::Type::getInt64Ty(Lo->getContext());
1783 llvm::StructType *Result = llvm::StructType::get(Lo, Hi, NULL);
1796 X86_64ABIInfo::Class Lo, Hi;
1797 classify(RetTy, 0, Lo, Hi);
1800 assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
1801 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
1804 switch (Lo) {
1878 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
1883 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
1893 assert(Lo == SSE && "Unexpected SSEUp classification.");
1904 if (Lo != X87) {
1906 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
1925 X86_64ABIInfo::Class Lo, Hi;
1926 classify(Ty, 0, Lo, Hi);
1930 assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
1931 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
1936 switch (Lo) {
2013 if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
2023 if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
2033 assert(Lo == SSE && "Unexpected SSEUp classification");