LCOV - code coverage report
Current view: top level - lib/Target/AArch64 - AArch64LegalizerInfo.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 208 224 92.9 %
Date: 2018-06-17 00:07:59 Functions: 12 16 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- AArch64LegalizerInfo.cpp ----------------------------------*- C++ -*-==//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : /// \file
      10             : /// This file implements the targeting of the Machinelegalizer class for
      11             : /// AArch64.
      12             : /// \todo This should be generated by TableGen.
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "AArch64LegalizerInfo.h"
      16             : #include "AArch64Subtarget.h"
      17             : #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
      18             : #include "llvm/CodeGen/MachineInstr.h"
      19             : #include "llvm/CodeGen/MachineRegisterInfo.h"
      20             : #include "llvm/CodeGen/TargetOpcodes.h"
      21             : #include "llvm/CodeGen/ValueTypes.h"
      22             : #include "llvm/IR/DerivedTypes.h"
      23             : #include "llvm/IR/Type.h"
      24             : 
      25             : using namespace llvm;
      26             : using namespace LegalizeActions;
      27             : using namespace LegalityPredicates;
      28             : 
      29        1435 : AArch64LegalizerInfo::AArch64LegalizerInfo(const AArch64Subtarget &ST) {
      30             :   using namespace TargetOpcode;
      31             :   const LLT p0 = LLT::pointer(0, 64);
      32        1435 :   const LLT s1 = LLT::scalar(1);
      33        1435 :   const LLT s8 = LLT::scalar(8);
      34        1435 :   const LLT s16 = LLT::scalar(16);
      35        1435 :   const LLT s32 = LLT::scalar(32);
      36        1435 :   const LLT s64 = LLT::scalar(64);
      37             :   const LLT s128 = LLT::scalar(128);
      38        1435 :   const LLT s256 = LLT::scalar(256);
      39        1435 :   const LLT s512 = LLT::scalar(512);
      40             :   const LLT v16s8 = LLT::vector(16, 8);
      41             :   const LLT v8s8 = LLT::vector(8, 8);
      42             :   const LLT v4s8 = LLT::vector(4, 8);
      43             :   const LLT v8s16 = LLT::vector(8, 16);
      44             :   const LLT v4s16 = LLT::vector(4, 16);
      45             :   const LLT v2s16 = LLT::vector(2, 16);
      46        1435 :   const LLT v2s32 = LLT::vector(2, 32);
      47        1435 :   const LLT v4s32 = LLT::vector(4, 32);
      48        1435 :   const LLT v2s64 = LLT::vector(2, 64);
      49             : 
      50        1435 :   getActionDefinitionsBuilder(G_IMPLICIT_DEF)
      51             :       .legalFor({p0, s1, s8, s16, s32, s64})
      52        2870 :       .clampScalar(0, s1, s64)
      53        1435 :       .widenScalarToNextPow2(0, 8);
      54             : 
      55        1435 :   getActionDefinitionsBuilder(G_PHI)
      56             :       .legalFor({p0, s16, s32, s64})
      57        2870 :       .clampScalar(0, s16, s64)
      58        1435 :       .widenScalarToNextPow2(0);
      59             : 
      60        1435 :   getActionDefinitionsBuilder(G_BSWAP)
      61             :       .legalFor({s32, s64})
      62        2870 :       .clampScalar(0, s16, s64)
      63        1435 :       .widenScalarToNextPow2(0);
      64             : 
      65        1435 :   getActionDefinitionsBuilder({G_ADD, G_SUB, G_MUL, G_AND, G_OR, G_XOR, G_SHL})
      66        1435 :       .legalFor({s32, s64, v2s32, v4s32, v2s64})
      67        2870 :       .clampScalar(0, s32, s64)
      68        1435 :       .widenScalarToNextPow2(0)
      69        1435 :       .clampNumElements(0, v2s32, v4s32)
      70        1435 :       .clampNumElements(0, v2s64, v2s64)
      71        1435 :       .moreElementsToNextPow2(0);
      72             : 
      73        1435 :   getActionDefinitionsBuilder(G_GEP)
      74             :       .legalFor({{p0, s64}})
      75        1435 :       .clampScalar(1, s64, s64);
      76             : 
      77        2870 :   getActionDefinitionsBuilder(G_PTR_MASK).legalFor({p0});
      78             : 
      79        1435 :   getActionDefinitionsBuilder({G_LSHR, G_ASHR, G_SDIV, G_UDIV})
      80        1435 :       .legalFor({s32, s64})
      81        2870 :       .clampScalar(0, s32, s64)
      82        1435 :       .widenScalarToNextPow2(0);
      83             : 
      84        1435 :   getActionDefinitionsBuilder({G_SREM, G_UREM})
      85        2870 :       .lowerFor({s1, s8, s16, s32, s64});
      86             : 
      87        1435 :   getActionDefinitionsBuilder({G_SMULO, G_UMULO})
      88        2870 :       .lowerFor({{s64, s1}});
      89             : 
      90        2870 :   getActionDefinitionsBuilder({G_SMULH, G_UMULH}).legalFor({s32, s64});
      91             : 
      92        1435 :   getActionDefinitionsBuilder({G_UADDE, G_USUBE, G_SADDO, G_SSUBO})
      93        2870 :       .legalFor({{s32, s1}, {s64, s1}});
      94             : 
      95        1435 :   getActionDefinitionsBuilder({G_FADD, G_FSUB, G_FMA, G_FMUL, G_FDIV})
      96        4305 :       .legalFor({s32, s64});
      97             : 
      98        2870 :   getActionDefinitionsBuilder({G_FREM, G_FPOW}).libcallFor({s32, s64});
      99             : 
     100        1435 :   getActionDefinitionsBuilder(G_INSERT)
     101          13 :       .unsupportedIf([=](const LegalityQuery &Query) {
     102          26 :         return Query.Types[0].getSizeInBits() <= Query.Types[1].getSizeInBits();
     103        2883 :       })
     104          13 :       .legalIf([=](const LegalityQuery &Query) {
     105          13 :         const LLT &Ty0 = Query.Types[0];
     106             :         const LLT &Ty1 = Query.Types[1];
     107             :         if (Ty0 != s32 && Ty0 != s64 && Ty0 != p0)
     108             :           return false;
     109          10 :         return isPowerOf2_32(Ty1.getSizeInBits()) &&
     110           4 :                (Ty1.getSizeInBits() == 1 || Ty1.getSizeInBits() >= 8);
     111        4305 :       })
     112             :       .clampScalar(0, s32, s64)
     113        1435 :       .widenScalarToNextPow2(0)
     114        2870 :       .maxScalarIf(typeInSet(0, {s32}), 1, s16)
     115        2870 :       .maxScalarIf(typeInSet(0, {s64}), 1, s32)
     116        1435 :       .widenScalarToNextPow2(1);
     117             : 
     118        1435 :   getActionDefinitionsBuilder(G_EXTRACT)
     119          13 :       .unsupportedIf([=](const LegalityQuery &Query) {
     120          26 :         return Query.Types[0].getSizeInBits() >= Query.Types[1].getSizeInBits();
     121        2883 :       })
     122          13 :       .legalIf([=](const LegalityQuery &Query) {
     123          13 :         const LLT &Ty0 = Query.Types[0];
     124             :         const LLT &Ty1 = Query.Types[1];
     125             :         if (Ty1 != s32 && Ty1 != s64)
     126             :           return false;
     127             :         if (Ty1 == p0)
     128             :           return true;
     129          14 :         return isPowerOf2_32(Ty0.getSizeInBits()) &&
     130           6 :                (Ty0.getSizeInBits() == 1 || Ty0.getSizeInBits() >= 8);
     131        4305 :       })
     132             :       .clampScalar(1, s32, s64)
     133        1435 :       .widenScalarToNextPow2(1)
     134        2870 :       .maxScalarIf(typeInSet(1, {s32}), 0, s16)
     135        2870 :       .maxScalarIf(typeInSet(1, {s64}), 0, s32)
     136        1435 :       .widenScalarToNextPow2(0);
     137             : 
     138        1435 :   getActionDefinitionsBuilder({G_SEXTLOAD, G_ZEXTLOAD})
     139             :       .legalForTypesWithMemSize({{s32, p0, 8},
     140             :                                  {s32, p0, 16},
     141             :                                  {s32, p0, 32},
     142             :                                  {s64, p0, 64},
     143             :                                  {p0, p0, 64},
     144        2870 :                                  {v2s32, p0, 64}})
     145        2870 :       .clampScalar(0, s32, s64)
     146        1435 :       .widenScalarToNextPow2(0)
     147             :       // TODO: We could support sum-of-pow2's but the lowering code doesn't know
     148             :       //       how to do that yet.
     149        1435 :       .unsupportedIfMemSizeNotPow2()
     150             :       // Lower anything left over into G_*EXT and G_LOAD
     151        1435 :       .lower();
     152             : 
     153        1435 :   getActionDefinitionsBuilder(G_LOAD)
     154             :       .legalForTypesWithMemSize({{s8, p0, 8},
     155             :                                  {s16, p0, 16},
     156             :                                  {s32, p0, 32},
     157             :                                  {s64, p0, 64},
     158             :                                  {p0, p0, 64},
     159        1435 :                                  {v2s32, p0, 64}})
     160             :       // These extends are also legal
     161             :       .legalForTypesWithMemSize({{s32, p0, 8},
     162        4305 :                                  {s32, p0, 16}})
     163        2870 :       .clampScalar(0, s8, s64)
     164        1435 :       .widenScalarToNextPow2(0)
     165             :       // TODO: We could support sum-of-pow2's but the lowering code doesn't know
     166             :       //       how to do that yet.
     167        1435 :       .unsupportedIfMemSizeNotPow2()
     168             :       // Lower any any-extending loads left into G_ANYEXT and G_LOAD
     169             :       .lowerIf([=](const LegalityQuery &Query) {
     170           1 :         return Query.Types[0].getSizeInBits() != Query.MMODescrs[0].Size * 8;
     171        2871 :       })
     172        1435 :       .clampNumElements(0, v2s32, v2s32);
     173             : 
     174        1435 :   getActionDefinitionsBuilder(G_STORE)
     175             :       .legalForTypesWithMemSize({{s8, p0, 8},
     176             :                                  {s16, p0, 16},
     177             :                                  {s32, p0, 32},
     178             :                                  {s64, p0, 64},
     179             :                                  {p0, p0, 64},
     180        1435 :                                  {v2s32, p0, 64}})
     181        2870 :       .clampScalar(0, s8, s64)
     182        1435 :       .widenScalarToNextPow2(0)
     183             :       // TODO: We could support sum-of-pow2's but the lowering code doesn't know
     184             :       //       how to do that yet.
     185        1435 :       .unsupportedIfMemSizeNotPow2()
     186           2 :       .lowerIf([=](const LegalityQuery &Query) {
     187           2 :         return Query.Types[0].isScalar() &&
     188           0 :                Query.Types[0].getSizeInBits() != Query.MMODescrs[0].Size * 8;
     189        2872 :       })
     190        1435 :       .clampNumElements(0, v2s32, v2s32);
     191             : 
     192             :   // Constants
     193        1435 :   getActionDefinitionsBuilder(G_CONSTANT)
     194             :       .legalFor({p0, s32, s64})
     195        2870 :       .clampScalar(0, s32, s64)
     196        1435 :       .widenScalarToNextPow2(0);
     197        1435 :   getActionDefinitionsBuilder(G_FCONSTANT)
     198             :       .legalFor({s32, s64})
     199        2870 :       .clampScalar(0, s32, s64);
     200             : 
     201        1435 :   getActionDefinitionsBuilder(G_ICMP)
     202             :       .legalFor({{s32, s32}, {s32, s64}, {s32, p0}})
     203        1435 :       .clampScalar(0, s32, s32)
     204             :       .clampScalar(1, s32, s64)
     205        1435 :       .widenScalarToNextPow2(1);
     206             : 
     207        1435 :   getActionDefinitionsBuilder(G_FCMP)
     208             :       .legalFor({{s32, s32}, {s32, s64}})
     209        1435 :       .clampScalar(0, s32, s32)
     210             :       .clampScalar(1, s32, s64)
     211        1435 :       .widenScalarToNextPow2(1);
     212             : 
     213             :   // Extensions
     214        1435 :   getActionDefinitionsBuilder({G_ZEXT, G_SEXT, G_ANYEXT})
     215        4305 :       .legalForCartesianProduct({s8, s16, s32, s64}, {s1, s8, s16, s32});
     216             : 
     217             :   // FP conversions
     218        2870 :   getActionDefinitionsBuilder(G_FPTRUNC).legalFor(
     219             :       {{s16, s32}, {s16, s64}, {s32, s64}});
     220        2870 :   getActionDefinitionsBuilder(G_FPEXT).legalFor(
     221             :       {{s32, s16}, {s64, s16}, {s64, s32}});
     222             : 
     223             :   // Conversions
     224        1435 :   getActionDefinitionsBuilder({G_FPTOSI, G_FPTOUI})
     225        1435 :       .legalForCartesianProduct({s32, s64})
     226        2870 :       .clampScalar(0, s32, s64)
     227        1435 :       .widenScalarToNextPow2(0)
     228             :       .clampScalar(1, s32, s64)
     229        1435 :       .widenScalarToNextPow2(1);
     230             : 
     231        1435 :   getActionDefinitionsBuilder({G_SITOFP, G_UITOFP})
     232        1435 :       .legalForCartesianProduct({s32, s64})
     233        2870 :       .clampScalar(1, s32, s64)
     234        1435 :       .widenScalarToNextPow2(1)
     235             :       .clampScalar(0, s32, s64)
     236        1435 :       .widenScalarToNextPow2(0);
     237             : 
     238             :   // Control-flow
     239        2870 :   getActionDefinitionsBuilder(G_BRCOND).legalFor({s1, s8, s16, s32});
     240        2870 :   getActionDefinitionsBuilder(G_BRINDIRECT).legalFor({p0});
     241             : 
     242             :   // Select
     243        1435 :   getActionDefinitionsBuilder(G_SELECT)
     244             :       .legalFor({{s32, s1}, {s64, s1}, {p0, s1}})
     245        1435 :       .clampScalar(0, s32, s64)
     246        1435 :       .widenScalarToNextPow2(0);
     247             : 
     248             :   // Pointer-handling
     249        2870 :   getActionDefinitionsBuilder(G_FRAME_INDEX).legalFor({p0});
     250        2870 :   getActionDefinitionsBuilder(G_GLOBAL_VALUE).legalFor({p0});
     251             : 
     252        1435 :   getActionDefinitionsBuilder(G_PTRTOINT)
     253             :       .legalForCartesianProduct({s1, s8, s16, s32, s64}, {p0})
     254        4305 :       .maxScalar(0, s64)
     255        1435 :       .widenScalarToNextPow2(0, /*Min*/ 8);
     256             : 
     257        1435 :   getActionDefinitionsBuilder(G_INTTOPTR)
     258           2 :       .unsupportedIf([&](const LegalityQuery &Query) {
     259           4 :         return Query.Types[0].getSizeInBits() != Query.Types[1].getSizeInBits();
     260        2872 :       })
     261        1435 :       .legalFor({{p0, s64}});
     262             : 
     263             :   // Casts for 32 and 64-bit width type are just copies.
     264             :   // Same for 128-bit width type, except they are on the FPR bank.
     265        1435 :   getActionDefinitionsBuilder(G_BITCAST)
     266             :       // FIXME: This is wrong since G_BITCAST is not allowed to change the
     267             :       // number of bits but it's what the previous code described and fixing
     268             :       // it breaks tests.
     269        2870 :       .legalForCartesianProduct({s1, s8, s16, s32, s64, s128, v16s8, v8s8, v4s8,
     270             :                                  v8s16, v4s16, v2s16, v4s32, v2s32, v2s64});
     271             : 
     272        2870 :   getActionDefinitionsBuilder(G_VASTART).legalFor({p0});
     273             : 
     274             :   // va_list must be a pointer, but most sized types are pretty easy to handle
     275             :   // as the destination.
     276        1435 :   getActionDefinitionsBuilder(G_VAARG)
     277             :       .customForCartesianProduct({s8, s16, s32, s64, p0}, {p0})
     278        2870 :       .clampScalar(0, s8, s64)
     279        1435 :       .widenScalarToNextPow2(0, /*Min*/ 8);
     280             : 
     281        1435 :   if (ST.hasLSE()) {
     282          31 :     getActionDefinitionsBuilder(G_ATOMIC_CMPXCHG_WITH_SUCCESS)
     283          62 :         .lowerForCartesianProduct({s8, s16, s32, s64}, {s1}, {p0});
     284             : 
     285             :     getActionDefinitionsBuilder(
     286             :         {G_ATOMICRMW_XCHG, G_ATOMICRMW_ADD, G_ATOMICRMW_SUB, G_ATOMICRMW_AND,
     287             :          G_ATOMICRMW_OR, G_ATOMICRMW_XOR, G_ATOMICRMW_MIN, G_ATOMICRMW_MAX,
     288          31 :          G_ATOMICRMW_UMIN, G_ATOMICRMW_UMAX, G_ATOMIC_CMPXCHG})
     289          93 :         .legalForCartesianProduct({s8, s16, s32, s64}, {p0});
     290             :   }
     291             : 
     292             :   // Merge/Unmerge
     293        7175 :   for (unsigned Op : {G_MERGE_VALUES, G_UNMERGE_VALUES}) {
     294        2870 :     unsigned BigTyIdx = Op == G_MERGE_VALUES ? 0 : 1;
     295        2870 :     unsigned LitTyIdx = Op == G_MERGE_VALUES ? 1 : 0;
     296             : 
     297          22 :     auto notValidElt = [](const LegalityQuery &Query, unsigned TypeIdx) {
     298          22 :       const LLT &Ty = Query.Types[TypeIdx];
     299             :       if (Ty.isVector()) {
     300           1 :         const LLT &EltTy = Ty.getElementType();
     301           1 :         if (EltTy.getSizeInBits() < 8 || EltTy.getSizeInBits() > 64)
     302             :           return true;
     303             :         if (!isPowerOf2_32(EltTy.getSizeInBits()))
     304             :           return true;
     305             :       }
     306             :       return false;
     307             :     };
     308             :     auto scalarize =
     309           0 :         [](const LegalityQuery &Query, unsigned TypeIdx) {
     310           0 :           const LLT &Ty = Query.Types[TypeIdx];
     311           0 :           return std::make_pair(TypeIdx, Ty.getElementType());
     312             :         };
     313             : 
     314             :     // FIXME: This rule is horrible, but specifies the same as what we had
     315             :     // before with the particularly strange definitions removed (e.g.
     316             :     // s8 = G_MERGE_VALUES s32, s32).
     317             :     // Part of the complexity comes from these ops being extremely flexible. For
     318             :     // example, you can build/decompose vectors with it, concatenate vectors,
     319             :     // etc. and in addition to this you can also bitcast with it at the same
     320             :     // time. We've been considering breaking it up into multiple ops to make it
     321             :     // more manageable throughout the backend.
     322        2870 :     getActionDefinitionsBuilder(Op)
     323             :         // Break up vectors with weird elements into scalars
     324             :         .fewerElementsIf(
     325          11 :             [=](const LegalityQuery &Query) { return notValidElt(Query, 0); },
     326        8610 :             [=](const LegalityQuery &Query) { return scalarize(Query, 0); })
     327             :         .fewerElementsIf(
     328          11 :             [=](const LegalityQuery &Query) { return notValidElt(Query, 1); },
     329        8610 :             [=](const LegalityQuery &Query) { return scalarize(Query, 1); })
     330             :         // Clamp the big scalar to s8-s512 and make it either a power of 2, 192,
     331             :         // or 384.
     332             :         .clampScalar(BigTyIdx, s8, s512)
     333             :         .widenScalarIf(
     334          11 :             [=](const LegalityQuery &Query) {
     335          11 :               const LLT &Ty = Query.Types[BigTyIdx];
     336          12 :               return !isPowerOf2_32(Ty.getSizeInBits()) &&
     337          12 :                      Ty.getSizeInBits() % 64 != 0;
     338             :             },
     339           0 :             [=](const LegalityQuery &Query) {
     340             :               // Pick the next power of 2, or a multiple of 64 over 128.
     341             :               // Whichever is smaller.
     342           0 :               const LLT &Ty = Query.Types[BigTyIdx];
     343             :               unsigned NewSizeInBits = 1
     344           0 :                                        << Log2_32_Ceil(Ty.getSizeInBits() + 1);
     345           0 :               if (NewSizeInBits >= 256) {
     346           0 :                 unsigned RoundedTo = alignTo<64>(Ty.getSizeInBits() + 1);
     347           0 :                 if (RoundedTo < NewSizeInBits)
     348             :                   NewSizeInBits = RoundedTo;
     349             :               }
     350           0 :               return std::make_pair(BigTyIdx, LLT::scalar(NewSizeInBits));
     351        8610 :             })
     352             :         // Clamp the little scalar to s8-s256 and make it a power of 2. It's not
     353             :         // worth considering the multiples of 64 since 2*192 and 2*384 are not
     354             :         // valid.
     355             :         .clampScalar(LitTyIdx, s8, s256)
     356        2870 :         .widenScalarToNextPow2(LitTyIdx, /*Min*/ 8)
     357             :         // So at this point, we have s8, s16, s32, s64, s128, s192, s256, s384,
     358             :         // s512, <X x s8>, <X x s16>, <X x s32>, or <X x s64>.
     359             :         // At this point it's simple enough to accept the legal types.
     360           9 :         .legalIf([=](const LegalityQuery &Query) {
     361           9 :           const LLT &BigTy = Query.Types[BigTyIdx];
     362           9 :           const LLT &LitTy = Query.Types[LitTyIdx];
     363           1 :           if (BigTy.isVector() && BigTy.getSizeInBits() < 32)
     364             :             return false;
     365           0 :           if (LitTy.isVector() && LitTy.getSizeInBits() < 32)
     366             :             return false;
     367           9 :           return BigTy.getSizeInBits() % LitTy.getSizeInBits() == 0;
     368        5740 :         })
     369             :         // Any vectors left are the wrong size. Scalarize them.
     370             :         .fewerElementsIf([](const LegalityQuery &Query) { return true; },
     371           0 :                          [](const LegalityQuery &Query) {
     372             :                            return std::make_pair(
     373           0 :                                0, Query.Types[0].getElementType());
     374        8610 :                          })
     375        2870 :         .fewerElementsIf([](const LegalityQuery &Query) { return true; },
     376           0 :                          [](const LegalityQuery &Query) {
     377             :                            return std::make_pair(
     378           0 :                                1, Query.Types[1].getElementType());
     379        5740 :                          });
     380             :   }
     381             : 
     382        1435 :   computeTables();
     383        1435 :   verify(*ST.getInstrInfo());
     384        1435 : }
     385             : 
     386           3 : bool AArch64LegalizerInfo::legalizeCustom(MachineInstr &MI,
     387             :                                           MachineRegisterInfo &MRI,
     388             :                                           MachineIRBuilder &MIRBuilder) const {
     389           6 :   switch (MI.getOpcode()) {
     390             :   default:
     391             :     // No idea what to do.
     392             :     return false;
     393           3 :   case TargetOpcode::G_VAARG:
     394           3 :     return legalizeVaArg(MI, MRI, MIRBuilder);
     395             :   }
     396             : 
     397             :   llvm_unreachable("expected switch to return");
     398             : }
     399             : 
     400           3 : bool AArch64LegalizerInfo::legalizeVaArg(MachineInstr &MI,
     401             :                                          MachineRegisterInfo &MRI,
     402             :                                          MachineIRBuilder &MIRBuilder) const {
     403           3 :   MIRBuilder.setInstr(MI);
     404           3 :   MachineFunction &MF = MIRBuilder.getMF();
     405           3 :   unsigned Align = MI.getOperand(2).getImm();
     406           3 :   unsigned Dst = MI.getOperand(0).getReg();
     407           3 :   unsigned ListPtr = MI.getOperand(1).getReg();
     408             : 
     409           3 :   LLT PtrTy = MRI.getType(ListPtr);
     410           6 :   LLT IntPtrTy = LLT::scalar(PtrTy.getSizeInBits());
     411             : 
     412           3 :   const unsigned PtrSize = PtrTy.getSizeInBits() / 8;
     413           3 :   unsigned List = MRI.createGenericVirtualRegister(PtrTy);
     414           3 :   MIRBuilder.buildLoad(
     415             :       List, ListPtr,
     416           9 :       *MF.getMachineMemOperand(MachinePointerInfo(), MachineMemOperand::MOLoad,
     417             :                                PtrSize, /* Align = */ PtrSize));
     418             : 
     419             :   unsigned DstPtr;
     420           3 :   if (Align > PtrSize) {
     421             :     // Realign the list to the actual required alignment.
     422           1 :     auto AlignMinus1 = MIRBuilder.buildConstant(IntPtrTy, Align - 1);
     423             : 
     424           1 :     unsigned ListTmp = MRI.createGenericVirtualRegister(PtrTy);
     425           1 :     MIRBuilder.buildGEP(ListTmp, List, AlignMinus1->getOperand(0).getReg());
     426             : 
     427           1 :     DstPtr = MRI.createGenericVirtualRegister(PtrTy);
     428           2 :     MIRBuilder.buildPtrMask(DstPtr, ListTmp, Log2_64(Align));
     429             :   } else
     430             :     DstPtr = List;
     431             : 
     432           3 :   uint64_t ValSize = MRI.getType(Dst).getSizeInBits() / 8;
     433           3 :   MIRBuilder.buildLoad(
     434             :       Dst, DstPtr,
     435           9 :       *MF.getMachineMemOperand(MachinePointerInfo(), MachineMemOperand::MOLoad,
     436             :                                ValSize, std::max(Align, PtrSize)));
     437             : 
     438           3 :   unsigned SizeReg = MRI.createGenericVirtualRegister(IntPtrTy);
     439           3 :   MIRBuilder.buildConstant(SizeReg, alignTo(ValSize, PtrSize));
     440             : 
     441           3 :   unsigned NewList = MRI.createGenericVirtualRegister(PtrTy);
     442           3 :   MIRBuilder.buildGEP(NewList, DstPtr, SizeReg);
     443             : 
     444           3 :   MIRBuilder.buildStore(
     445             :       NewList, ListPtr,
     446           6 :       *MF.getMachineMemOperand(MachinePointerInfo(), MachineMemOperand::MOStore,
     447             :                                PtrSize, /* Align = */ PtrSize));
     448             : 
     449           3 :   MI.eraseFromParent();
     450           3 :   return true;
     451             : }

Generated by: LCOV version 1.13