Lines Matching +defs:lo +defs:size
47 // networks, each half in size in terms of the number of nodes. In those
136 Node Num = Order.size();
168 for (unsigned P = 0; P != Order.size(); ++P) {
178 for (unsigned I = 0; I != Order.size(); ++I) {
196 for (unsigned I = 0; I != Q.size(); ++I) {
264 for (unsigned I = 0; I != Order.size(); ++I)
334 Order.assign(Ord.data(), Ord.data()+Ord.size());
337 unsigned S = Order.size();
341 Table.resize(Order.size());
347 unsigned Size = Order.size();
366 unsigned size() const {
367 return Order.size();
384 if (!route(Order.data(), Table.data(), size(), 0))
398 if (!route(Order.data(), Table.data(), size(), 0))
412 if (!route(Order.data(), Table.data(), size(), 0))
626 static OpRef lo(const OpRef &R) {
679 return List.size()-1;
689 unsigned size() const { return List.size(); }
690 unsigned top() const { return size()-1; }
727 OS << "lo ";
754 for (unsigned I = 0, E = List.size(); I != E; ++I) {
776 ShuffleMask lo() const {
777 size_t H = Mask.size()/2;
781 size_t H = Mask.size()/2;
809 ArrayRef<int> lo(ArrayRef<int> Vuu) { return Vuu.take_front(Vuu.size() / 2); }
810 ArrayRef<int> hi(ArrayRef<int> Vuu) { return Vuu.take_back(Vuu.size() / 2); }
813 int Len = Vu.size();
833 int Len = Vu.size();
853 int Len = Vu.size();
868 int Len = Vu.size();
881 int Len = Vu.size();
883 return vpack(hi(T), lo(T), Size, TakeOdd);
887 int Len = Vu.size();
999 unsigned VecLen = Mask.size();
1000 assert(MaskL.size() == VecLen && MaskR.size() == VecLen);
1017 assert(A.size() > 0 && A.size() >= MaxLen);
1036 for (int I = 0, E = Mask.size(); I != E; ++I) {
1045 int L = Mask.size();
1082 unsigned MaskLen = SM.Mask.size();
1086 for (int S = 0, E = Map.size(); S != E; ++S) {
1109 for (int I = OutSegMap.size() - 1; I >= 0; --I) {
1113 if (InvMap.size() <= S)
1119 for (int I = 0, E = Mask.size(); I != E; ++I) {
1140 for (unsigned i = 0; i != WorkQ.size(); ++i) {
1164 for (unsigned I = 0, E = Results.size(); I != E; ++I) {
1183 assert(Idx >= 0 && unsigned(Idx) < Output.size());
1286 unsigned VecLen = SM.Mask.size();
1313 unsigned SegCount = SegList.size();
1404 Va = (Seg0 == 0 || Seg0 == 2) ? OpRef::lo(P) : OpRef::hi(P);
1431 assert(SMH.Mask.size() == VecLen);
1445 assert(SMA.Mask.size() == VecLen);
1508 unsigned SegCount = SegList.size();
1520 for (int I = 0, E = SegList.size(); I != E; ++I) {
1523 Out[I] = (S & 1) ? OpRef::hi(Op) : OpRef::lo(Op);
1552 size_t S = Bytes.size() / 2;
1553 OpRef L = vmuxs(Bytes.take_front(S), OpRef::lo(Va), OpRef::lo(Vb), Results);
1560 unsigned VecLen = SM.Mask.size();
1591 return (Strip1.first == 0) ? OpRef::lo(S) : OpRef::hi(S);
1611 int VecLen = SM.Mask.size();
1638 int VecLen = SM.Mask.size();
1646 OpRef P = packs(SM, OpRef::lo(Va), OpRef::hi(Va), Results, PackedMask);
1653 OpRef L = shuffs1(PM.lo(), P, Results);
1671 OpRef L = shuffs2(SM.lo(), OpRef::lo(Va), OpRef::hi(Va), Results);
1672 OpRef H = shuffs2(SM.hi(), OpRef::lo(Va), OpRef::hi(Va), Results);
1685 int VecLen = SM.Mask.size();
1721 for (unsigned i = 0, e = T::size(); i != e; ++i) {
1793 for (unsigned I = 0; I != SubNodes.size(); ++I) {
1815 for (unsigned I = 0; I != TmpQ.size(); ++I) {
1830 assert(SubNodes.size() == TmpQ.size());
1848 unsigned VecLen = Mask.size();
1924 for (unsigned I = 0, E = Bs.size(); I != E; ++I) {
1944 SmallVector<uint8_t> BitValues(SM.Mask.size());
1945 for (int i = 0, e = SM.Mask.size(); i != e; ++i) {
1994 for (unsigned I = 0, E = Sorted.size(); I != E;) {
2045 for (int I = 0, E = SM.Mask.size(); I != E; ++I) {
2079 int VecLen = SM.Mask.size();
2110 for (int i = 0, e = std::size(Opcodes); i != e; ++i) {
2126 for (int i = 0, e = std::size(Opcodes); i != e; ++i) {
2147 for (int i = 0, e = std::size(Opcodes); i != e; ++i) {
2154 {OpRef::hi(vdeal), OpRef::lo(vdeal)});
2181 int VecLen = SM.Mask.size();
2231 int VecLen = SM.Mask.size();
2266 // matrices (or "sub-matrices"), given a specific group size. For example,
2267 // if the group size is 1 (i.e. each element is its own group), there
2272 // Now, this result can be transposed again, but with the group size of 2:
2275 // If we then transpose that result, but with the group size of 4, we get:
2283 // with changing group size. HVX has two instructions:
2288 // transpose with a group size of 2^n will take place. If multiple bits are
2290 // with the largest group size, vshuffvdd will do them in the reverse order.
2297 // The transpose with the group size 2^n corresponds to swapping columns
2326 for (int i = 0, e = SM.Mask.size(); i != e; ++i) {
2377 unsigned LogPos, N = C.size();
2392 if (Cs.size() != 1)
2397 int D = Len - C.size();
2424 if (C.size() <= 1)
2472 Arg = concats(OpRef::hi(Arg), OpRef::lo(Arg), Results);
2474 for (unsigned I = 0, E = SwapElems.size(); I != E;) {
2490 Res.Ops = {OpRef::hi(Arg), OpRef::lo(Arg), OpRef::res(-1)};
2495 return HavePairs ? Arg : OpRef::lo(Arg);
2513 int VecLen = SM.Mask.size();
2559 MVT VecTy = MVT::getVectorVT(MVT::i8, Data.size());
2599 unsigned VecLen = Mask.size();
2776 assert(TopMask.size() == S0->getMask().size() &&
2777 TopMask.size() == S1->getMask().size());
2778 assert(TopMask.size() == HwLen);