Lines Matching refs:Lo
1042 /// Post merger cleanup, reduces a malformed Hi and Lo pair to
1048 /// \param Lo - The classification for the parts of the type
1054 void postMerge(unsigned AggregateSize, Class &Lo, Class &Hi) const;
1059 /// \param Lo - The classification for the parts of the type
1070 /// be passed in Memory then at least the classification of \arg Lo
1073 /// The \arg Lo class will be NoClass iff the argument is ignored.
1075 /// If the \arg Lo class is ComplexX87, then the \arg Hi class will
1077 void classify(QualType T, uint64_t OffsetBase, Class &Lo, Class &Hi) const;
1232 void X86_64ABIInfo::postMerge(unsigned AggregateSize, Class &Lo,
1256 Lo = Memory;
1257 if (Hi == X87Up && Lo != X87 && honorsRevision0_98())
1258 Lo = Memory;
1259 if (AggregateSize > 128 && (Lo != SSE || Hi != SSEUp))
1260 Lo = Memory;
1261 if (Hi == SSEUp && Lo != SSE)
1306 Class &Lo, Class &Hi) const {
1315 Lo = Hi = NoClass;
1317 Class &Current = OffsetBase < 64 ? Lo : Hi;
1326 Lo = Integer;
1333 Lo = X87;
1343 classify(ET->getDecl()->getIntegerType(), OffsetBase, Lo, Hi);
1354 Lo = Hi = Integer;
1372 Hi = Lo;
1390 Hi = Lo;
1394 // SSEUP. The original Lo and Hi design considers that types can't be
1395 // greater than 128-bits, so a 64-bit split in Hi and Lo makes sense.
1399 Lo = SSE;
1413 Lo = Hi = Integer;
1417 Lo = Hi = SSE;
1426 Hi = Lo;
1455 // contains a single 256-bit element. Since Lo and Hi logic isn't extended
1463 Lo = merge(Lo, FieldLo);
1465 if (Lo == Memory || Hi == Memory)
1469 postMerge(Size, Lo, Hi);
1470 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp array classification.");
1496 // Reset Lo class, this will be recomputed.
1517 Lo = merge(Lo, FieldLo);
1519 if (Lo == Memory || Hi == Memory)
1535 // contains a single 256-bit element. Since Lo and Hi logic isn't extended
1539 Lo = Memory;
1544 Lo = Memory;
1580 Lo = merge(Lo, FieldLo);
1582 if (Lo == Memory || Hi == Memory)
1586 postMerge(Size, Lo, Hi);
1923 GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi,
1929 unsigned LoSize = (unsigned)TD.getTypeAllocSize(Lo);
1942 if (Lo->isFloatTy())
1943 Lo = llvm::Type::getDoubleTy(Lo->getContext());
1945 assert(Lo->isIntegerTy() && "Invalid/unknown lo type");
1946 Lo = llvm::Type::getInt64Ty(Lo->getContext());
1950 llvm::StructType *Result = llvm::StructType::get(Lo, Hi, NULL);
1963 X86_64ABIInfo::Class Lo, Hi;
1964 classify(RetTy, 0, Lo, Hi);
1967 assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
1968 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
1971 switch (Lo) {
2045 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
2050 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
2060 assert(Lo == SSE && "Unexpected SSEUp classification.");
2071 if (Lo != X87) {
2073 if (Lo == NoClass) // Return HighPart at offset 8 in memory.
2092 X86_64ABIInfo::Class Lo, Hi;
2093 classify(Ty, 0, Lo, Hi);
2097 assert((Hi != Memory || Lo == Memory) && "Invalid memory classification.");
2098 assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp classification.");
2103 switch (Lo) {
2180 if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
2190 if (Lo == NoClass) // Pass HighPart at offset 8 in memory.
2200 assert(Lo == SSE && "Unexpected SSEUp classification");