<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/54339>54339</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            llc crash with `-fp-armv8` and `global-isel=1` when attempting to lower non-scalable function
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            new issue
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          nasherm
      </td>
    </tr>
</table>

<pre>
    Hi, I've come across the following crash when attempting to debug an [issue in rustc](https://github.com/rust-lang/rust/issues/80268). 

platform: x86_64-apple-darwin

fail.ll
```
define float @foo(double %x) {
start:
  %0 = fptrunc double %x to float
  ret float %0
}
```

crash stack trace

```
$ llc -march=aarch64 -mattr=-fp-armv8 -global-isel=1 fail.ll
LLVM ERROR: unable to lower function: float (double)* (in function: foo)
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace.
Stack dump:
0.      Program arguments: llc -march=aarch64 -mattr=-fp-armv8 -global-isel=1 test.ll
1.      Running pass 'Function Pass Manager' on module 'test.ll'.
2.      Running pass 'IRTranslator' on function '@foo'
Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it):
0  llc                      0x000000010e4b87f7 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) + 39
1  llc                      0x000000010e4b75b8 llvm::sys::RunSignalHandlers() + 248
2  llc                      0x000000010e4b8e40 SignalHandler(int) + 272
3  libsystem_platform.dylib 0x00007ff801f85e2d _sigtramp + 29
4  libsystem_platform.dylib 0x0000000800000000 _sigtramp + 18446603404907618800
5  libsystem_c.dylib        0x00007ff801ebcd10 abort + 123
6  llc                      0x000000010e3f23c5 llvm::report_fatal_error(llvm::Twine const&, bool) + 469
7  llc                      0x000000010e96d833 reportTranslationError(llvm::MachineFunction&, llvm::TargetPassConfig const&, llvm::OptimizationRemarkEmitter&, llvm::OptimizationRemarkMissed&) + 323
8  llc                      0x000000010e981891 llvm::IRTranslator::runOnMachineFunction(llvm::MachineFunction&) + 3265
9  llc                      0x000000010d88da7d llvm::MachineFunctionPass::runOnFunction(llvm::Function&) + 397
10 llc                      0x000000010dcd5241 llvm::FPPassManager::runOnFunction(llvm::Function&) + 1073
11 llc                      0x000000010dcdb8c8 llvm::FPPassManager::runOnModule(llvm::Module&) + 72
12 llc                      0x000000010dcd58ce llvm::legacy::PassManagerImpl::run(llvm::Module&) + 1102
13 llc                      0x000000010c2ab8a3 main + 9731
14 dyld                     0x000000011720a4fe start + 462

```

I've been able to trace the issue down to a check made in `llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp`
```cpp
...
  if (CLI->fallBackToDAGISel(*MF)) {
    OptimizationRemarkMissed R("gisel-irtranslator", "GISelFailure",
                               F.getSubprogram(), &F.getEntryBlock());
    R << "unable to lower function: " << ore::NV("Prototype", F.getType());
    reportTranslationError(*MF, *TPC, *ORE, R);
    return false;
  }
...
```

Inspecting `fallBackToDAGISel` further it appears that the function itself is being recognised as a `ScalableVectorType` within `llvm/lib/Target/AArch64/AArch64ISelLowering.cpp`

```cpp
...
bool AArch64TargetLowering::fallBackToDAGISel(const Instruction &Inst) const {
   if (isa<ScalableVectorType>(Inst.getType()))
     return true;
  
   for (unsigned i = 0; i < Inst.getNumOperands(); ++i)
     if (isa<ScalableVectorType>(Inst.getOperand(i)->getType()))
       return true;
  
   if (const AllocaInst *AI = dyn_cast<AllocaInst>(&Inst)) {
     if (isa<ScalableVectorType>(AI->getAllocatedType()))
       return true;
   }
  
   return false;
 }
...
```

I'm relatively new to contributing to LLVM, but I'd like to fix this bug. Would anybody be able to give guidance on the scope of this problem and whether it wouldn't too large in scope? Is my intuition correct in thinking that `fallBackToDAGISel` shouldn't recognise our function as a scalable-vector type? Any help is appreciated
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJydWFtv4roW_jXpiwXKDZI88EAvzCC1uxWt5uicl8pJHPCpY0eOU4b96_dadsJlyrTsQYgktvOtb129TK7K3ew798IbsvTC5J2RQtWM0EKrtiVmw0ilhFBbLtek0LTdkO2GSUKNYXVjcNQoUrK8WxMqiTe55m3bMcIl0V1rCm9y64Xpxpim9aK5Fy7gu-Zm0-VjkAMPuGokqFz393CxCC3cpH44Tb0wGxPPv_X8ufttBDWV0jXgkZ_p9HUaj2jTCDYqqQaax0srysVYiH5o6vdf-1iyikvQTihqiBf7lVLAtFRdLhjxwslPEEy85Nqtbg3VBjWwTwQX-MSLbknVGN3Jghy9iBaxsMNizcwgB17r2SS3Z2m5X2dpEFq8EaNpwY4nf30jjIkQBRnVVBcb4ETxOo1xwBgNA6OqGVFdv6dktBYqp2LEWyZgIiAnFrq___FA7larxxXatpMUNQJlwP1MkwrUNFxJnBu06e0FpvLCOT6D30_WoVEzh_50fzd_viNtl9fcEEowZDRrlDYo45MQEeJ9uIwarf7PipMogbgrId4K0ZXMBqwzXg62s6YbO_HP1phlVzd7N_owlT1ptda0JlSvu5pJgyT-3J6GtWZvzwDxV52UmCYNhXyCDFv05iFPOPBAJV0zDeMEhmpVdjaIkgEnTHr64Tms5epFU9lCQqgBYrA-Tg9RnfxqAbIF-6rOkHZX50oQSWuGgCmTbacZ2amObCjUAmtzt4j_DTEA7oU5TZ7mL9-J0qSFyEaTM_nOtZJoP_JONYHgxGB6ff7vw_Xj_fJ_d6tXfAWG0deN4tI6nRuMjr07iLX72Y__03efwGdxniZVYrnhu9G83bXu5kkDsFXzxSZNmB4Wabp9Va3RjEIwTbHewVqb4-E1ifoYDS6mkEzy9BwFcNEzX0sqvkNYCqYhQtNBShinvTMv15TFPjkBtEm2Jx4moYOMAJLnQAPq8utQIsflDgZ7yKSqUj-o0gkLS_La8jVkB4SCRenVj78EgU_aX_1fQII0jqdTP4r9OPOTaZDCQgc7OYYterwTdR03lhdl4BOaY02wkGHkEKYXGiyqwqiYHPnFFZjXihoqXpnWmCdHQfGyxT2gUBI3HhsUuVJiMG487e2SXCg-m5ZpFPVVbUhNSMa7D4IfaLEB0UMx6IUfEYNyxAyWiBslK74-4XhY9ghbcM3_tkJWDArW2x0UV4NR8uXKB6igrLQL-yQYrJ1eqm4apFlwJOSkHjn7d_JRflD2C0MMdKYTxye7jE-ZpiVNSvJbcDTnEa2zfM4RyfoCCrF5EY-inITxsV0WTyh6qPX_nkHgJ71rguBSCnlapBdQeLBbzqlL-qG9-KHGBOHF-qcFOxIu2JoWu75GH2gs60bsqXxOIQj8gUR0EYkipHlKI1JTLi1ClkRBjxATKEHlFwhBEvo0rhixrV9fD8LP-jD72zfROcMmue-fbBti90nXHJdqK3GckmLDYEuuaWk7ZoAaeh2ew--NKtk3BpZZfLNtxvIZuoxwcZxl46JpDgwGQjhoR8bj8dCE8go3-Jv75ciL7ioqxDVuk-p2_s3Bwi41f1jYTu6o70Wb_K50kJV9K1xj9zPi2hz1IiFWH7hY8AU0mdBWuNED7iefxRiq33OXN645c3uog5zauTtp9O5aqOJtmIM-4ojzCprzG_gih88aWZgeVipgaIPvrx9OL-gMjTK7pifuSL3Y53Mif1v1e8Mil_nL001_97i6w7vVRxjTaejjqGjZ0cT-vLB36fnwk20D_TE2iTDz0c3QgFWdhlCEXg6a8KZhVOMxj7o-bt89cgM-rSBeIZIRTLNCrSVHr9MWAheAngsq0LA_QJ7S1i6Ajp3lmVB2-xnczOe2mT7cIa179AuIOY3mr2Iat2rSozj8Acf58VyQ222UgJXg1Db0ydOl3Vozt8eexL5LGt5SCJAz-kbgwhTf_hgZQ0tFjnwKMk9cOiyALgvFdBL6KQkW5vZk6cNSe3tDBhF_dfVjwyDCyr6txCVQmeDLTyX-G-I9JK4HECwPn2vzpT5OuLPmXECS0qU1bDifL61q5U6-FhSMHt0c5h2pgzs-1KGLlJovewUcsGHlH2hyyLYjrc4n5qV5CdtCDRBYGd6Z2BHJtliRwEhG87wb_knBU5NtQ-Fwhu9AN8PfbO2q-E9IUUzIbj0m_1Ed7GBU7nJV7iBH93vNGuDJuuMllbDnQHxjWreFauChcgBQVGFxbc_N2w0bisEWISWePQEHaiVmFO5K9mUvWpBlS-odnpo6bjOnUBrKgsE1mPNvVgWsJL-rPO3mIGJfUAieJ_d1xxaXtvft6N06l9gaDATmckc2TDRYlqB0AQRHB1-Vs6jMooxeGW4Em2F70P9VBcUI2ewP7MgC1YbrLyd3W7s-_rPldgyp5Gggted61Wkx-_O_LSZxFGVXm1lRxEkWp5MgqcJpkWcJKyZh6acxy3w4R1VXIJWJduZNIM1DDBsLgXvS5PaKz0I_DP0oCIJ0koTROIO-3M-yMKpgvCiZF_uwZds_ed7rsdLrKz2zlCCMWpgUvDXtYRKaM6xBzIoDfNqZjdIzCdZkur6yomeW-j_x6fd2">