It is because JS uses double precision for the numbers, but if you want to perform operations with bits, the task is nontrivial, so a specific instruction to convert JS double into integer makes the thing easier.

This ARM link explains it very well: https://community.arm.com/processors/b/blog/posts/armv8-a-architecture-2016-additions

In order to add more information regarding fuz&#39;s comment, the differences between `FCVTZS` and `FJCVTZS` (both of them convert floating point to int) are that in case of overflow, `FJCVTZS` value will be 0x80000000 instead of overflowing. Furthermore, `FJCVTZS` can generate an exception in order to indicate how the conversion was (i.e. inexact).

`FJCVTZS` : http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0801g/hko1477562192868.html

`FCVTZS` : http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0802a/FCVTZS_float_int.html

There are two ways that make change value of `MutableLiveData`. But what is difference between **`setValue()`** &amp; **`postValue()`** in `MutableLiveData`.

I could not find documentation for same.

Here is class `MutableLiveData` of Android.

    package android.arch.lifecycle;
    
    /**
     * {@link LiveData} which publicly exposes {@link #setValue(T)} and {@link #postValue(T)} method.
     *
     * @param &lt;T&gt; The type of data hold by this instance
     */
    @SuppressWarnings(&quot;WeakerAccess&quot;)
    public class MutableLiveData&lt;T&gt; extends LiveData&lt;T&gt; {
        @Override
        public void postValue(T value) {
            super.postValue(value);
        }
    
        @Override
        public void setValue(T value) {
            super.setValue(value);
        }
    }




Difference of setValue() &amp; postValue() in MutableLiveData

I was trying to run a container with kvm, using the code I found here: https://github.com/jessfraz/dockerfiles/tree/master/kvm
I created a new directory, cd&#39;d into it and created the dockerfile and start.sh files.
When I gave order to build, it outputted the following error message:

```text
Sending build context to Docker daemon  3.584kB
Error response from daemon: No build stage in current context
```

I have no idea what this means and I couldn&#39;t Google an answer.
Any help?

Error response from daemon: No build stage in current context

[FJCVTZS][1] is &quot;Floating-point Javascript Convert to Signed fixed-point, rounding toward Zero&quot;.  It is supported in Arm v8.3-A chips and later.  Which is odd, because you don&#39;t expect to see JavaScript so close to the bare metal.

I can find explanations of what the instruction does, but not why it exists.  [This thread][2] says &quot;it exists as a single instruction is because JS&#39;s lack of an integer type means certain use cases need this operation obscenely often for no good algorithmic reason.&quot;.  That&#39;s plausible but I would like a more detailed understanding.



  [1]: https://developer.arm.com/documentation/dui0801/h/A64-Floating-point-Instructions/FJCVTZS
  [2]: https://twitter.com/marcan42/status/1009468989213327360

Why do ARM chips have an instruction with Javascript in the name (FJCVTZS)?

<p><a href="https://developer.arm.com/documentation/dui0801/h/A64-Floating-point-Instructions/FJCVTZS" target="_blank" rel="noopener noreferrer">FJCVTZS</a> is "Floating-point Javascript Convert to Signed fixed-point, rounding toward Zero".  It is supported in Arm v8.3-A chips and later.  Which is odd, because you don't expect to see JavaScript so close to the bare metal.</p>
<p>I can find explanations of what the instruction does, but not why it exists.  <a href="https://twitter.com/marcan42/status/1009468989213327360" target="_blank" rel="noopener noreferrer">This thread</a> says "it exists as a single instruction is because JS's lack of an integer type means certain use cases need this operation obscenely often for no good algorithmic reason.".  That's plausible but I would like a more detailed understanding.</p>


First, I want to say that I&#39;m new to Vue, and this is my first project ever using Vue.

I have a combobox and want to do something different based on the selected combobox. I use a separate `vue.html` and TypeScript file.
Here&#39;s my code:

```html
    &lt;select name=&quot;LeaveType&quot; @change=&quot;onChange()&quot; class=&quot;form-control&quot;&gt;
         &lt;option value=&quot;1&quot;&gt;Annual Leave/ Off-Day&lt;/option&gt;
         &lt;option value=&quot;2&quot;&gt;On Demand Leave&lt;/option&gt;
    &lt;/select&gt;
```

Here&#39;s my TypeScript file:

```javascript
    onChange(value) {
        console.log(value);
    }
```

How do I get the selected option value in my TypeScript function? Thanks.

Vue.js get selected option on @change

The following code

    function steamrollArray(arr) {
      // I&#39;m a steamroller, baby
      return arr.flat();
    }
    
    steamrollArray([1, [2], [3, [[4]]]]);

returns

&gt; `arr.flat` is not a function

I tried it in **Firefox** and **Chrome v67** and the same result has happened.

What&#39;s wrong?

.flat() is not a function, what&#39;s wrong?

Bower install fails with 502 - Bad Gateway when downloading bower packages.

For example bower install for ember library gives following response in command line.

&gt; EINVRES Request to https://bower.herokuapp.com/packages/ember failed
&gt; with 502

When http://bower.herokuapp.com/ is accessed directly from URL it gives the following message.

&gt; This Bower version is deprecated. Please update it: npm install -g
&gt; bower. The new registry address is https://registry.bower.io

EINVRES Request to https://bower.herokuapp.com/packages/ failed with 502

Going through the docs, I encountered:

&gt; ...you can call functions directly with an HTTP request or a [call from the client][1].
&gt;  
&gt; ~ [source][2]

there _(link in the quote)_ is a mention about `functions.https.onCall`.


But in the tutorial [here][3], another function `functions.https.onRequest` is used, so which one should I use and why? What is the difference/similarity between them?

Documentation for `functions.https` is [here][4].


  [1]: https://firebase.google.com/docs/functions/callable
  [2]: https://firebase.google.com/docs/functions/#lifecycle_of_a_background_function
  [3]: https://firebase.google.com/docs/functions/get-started
  [4]: https://firebase.google.com/docs/reference/functions/functions.https#.onCall

Firebase Cloud Functions: Difference between onRequest and onCall

I get these TypeScript errors VS Code while I&#39;m working in JS files. Is there anything I can do to disable this? I have put this in my settings and did not solve the issue:  

    &quot;typescript.validate.enable&quot;: false

The error can been seen here

[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/9OMHm.png

Removing [ts] errors from JS files In VS Code

I&#39;ve been trying to understand assembly language code generated by GCC and frequently encounter this instruction at the start of many functions including `_start()`, but couldn&#39;t find any guide explaining its purpose:
```
31-0000000000001040 &lt;_start&gt;:
32:    1040:	f3 0f 1e fa          	endbr64 
33-    1044:	31 ed                	xor    ebp,ebp

What does the endbr64 instruction actually do?

There are cases where you know that a certain floating-point expression will always be non-negative. For example, when computing the length of a vector, one does `sqrt(a[0]*a[0] + ... + a[N-1]*a[N-1])` (NB: I *am* aware of `std::hypot`, this is not relevant to the question), and the expression under the square root is clearly non-negative. However, GCC [outputs][1] the following assembly for `sqrt(x*x)`:
```
        mulss   xmm0, xmm0
        pxor    xmm1, xmm1
        ucomiss xmm1, xmm0
        ja      .L10
        sqrtss  xmm0, xmm0
        ret
.L10:
        jmp     sqrtf
```

That is, it compares the result of `x*x` to zero, and if the result is non-negative, it does the `sqrtss` instruction, otherwise it calls `sqrtf`.

So, my question is: **how can I force GCC into assuming that `x*x` is always non-negative so that it skips the comparison and the `sqrtf` call, without writing inline assembly?**

I wish to emphasize that I am interested in a local solution, and not doing things like `-ffast-math`, `-fno-math-errno`, or `-ffinite-math-only` (though these do indeed solve the issue, thanks to ks1322, harold, and Eric Postpischil in the comments).

Furthemore, &quot;force GCC into assuming `x*x` is non-negative&quot; should be interpreted as `assert(x*x &gt;= 0.f)`, so this also excludes the case of `x*x` being NaN.

I am OK with compiler-specific, platform-specific, CPU-specific, etc. solutions.

  [1]: https://godbolt.org/z/SsrYUu

How to force GCC to assume that a floating-point expression is non-negative?

I am banging my head into the wall with this.

In my project, when I&#39;m allocating memory with ```mmap``` the mapping (```/proc/self/maps```) shows that it is an readable and executable region **despite** I requested only readable memory.

After looking into strace (which was looking good) and other debugging, I was able to identify the only thing that seems to avoid this strange problem: removing assembly files from the project and leaving only pure C. (what?!)

So here is my strange example, I am working on Ubunbtu 19.04 and default gcc.

If you compile the target executable with the ASM file (which is empty) then ```mmap``` returns a readable and executable region, if you build without then it behave correctly. See the output of ```/proc/self/maps``` which I have embedded in my example.

**example.c**
```
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/mman.h&gt;

int main()
{
    void* p;
    p = mmap(NULL, 8192,PROT_READ,MAP_ANONYMOUS|MAP_PRIVATE,-1,0);
    
    {
        FILE *f;
        char line[512], s_search[17];
        snprintf(s_search,16,&quot;%lx&quot;,(long)p);
        f = fopen(&quot;/proc/self/maps&quot;,&quot;r&quot;);
        while (fgets(line,512,f))
        {
            if (strstr(line,s_search)) fputs(line,stderr);
        }
        
        fclose(f);
    }

    return 0;
}
```
**example.s**: Is an empty file!

**Outputs**

With the ASM included version
```
VirtualBox:~/mechanics/build$ gcc example.c example.s -o example &amp;&amp; ./example
7f78d6e08000-7f78d6e0a000 r-xp 00000000 00:00 0 
```
Without the ASM included version
```
VirtualBox:~/mechanics/build$ gcc example.c -o example &amp;&amp; ./example
7f1569296000-7f1569298000 r--p 00000000 00:00 0 
```




Unexpected exec permission from mmap when assembly files included in the project

I&#39;m watching Chandler Carruth&#39;s talk in CppCon 2019:

[There are no Zero-Cost Abstractions][1]

in it, he gives the example of how he was surprised by just how much overhead you incur by using an `std::unique_ptr&lt;int&gt;` over an `int*`; that segment starts about at time point 17:25.

You can have a look at the [compilation results][2] of his example pair-of-snippets (godbolt.org) - to witness that, indeed, it seems the compiler is not willing to pass the unique_ptr value - which in fact in the bottom line is just an address - inside a register, only in straight memory.

One of the points Mr. Carruth makes at around 27:00 is that the C++ ABI requires by-value parameters (some but not all; perhaps - non-primitive types? non-trivially-constructible types?) to be passed in-memory rather than within a register.

My questions:

1. Is this actually an ABI requirement on some platforms? (which?) Or maybe it&#39;s just some pessimization in certain scenarios?
2. Why is the ABI like that? That is, if the fields of a struct/class fit within registers, or even a single register - why should we not be able to pass it within that register?
3. Has the C++ standards committee discussed this point in recent years, or ever?

------------

PS - So as not to leave this question with no code:

Plain pointer:
```
void bar(int* ptr) noexcept;
void baz(int* ptr) noexcept;

void foo(int* ptr) noexcept {
    if (*ptr &gt; 42) {
        bar(ptr); 
        *ptr = 42; 
    }
    baz(ptr);
}
```

Unique pointer:
```
using std::unique_ptr;
void bar(int* ptr) noexcept;
void baz(unique_ptr&lt;int&gt; ptr) noexcept;

void foo(unique_ptr&lt;int&gt; ptr) noexcept {
    if (*ptr &gt; 42) { 
        bar(ptr.get());
        *ptr = 42; 
    }
    baz(std::move(ptr));
}
```



  [1]: https://www.youtube.com/watch?v=rHIkrotSwcc
  [2]: https://godbolt.org/z/5yv_41

Why can a T* be passed in register, but a unique_ptr&lt;T&gt; cannot?

I believe I found a bug in GCC while implementing O&#39;Neill&#39;s PCG PRNG. ([Initial code on Godbolt&#39;s Compiler Explorer](https://c.godbolt.org/z/jzKUgG))

After multiplying ```oldstate``` by ```MULTIPLIER```, (result stored in rdi), GCC doesn&#39;t add that result to ```INCREMENT```, movabs&#39;ing ```INCREMENT``` to rdx instead, which then gets used as the return value of rand32_ret.state

A minimum reproducible example ([Compiler Explorer](https://gcc.godbolt.org/z/FCuEsg)):
```c
#include &lt;stdint.h&gt;

struct retstruct {
    uint32_t a;
    uint64_t b;
};

struct retstruct fn(uint64_t input)
{
    struct retstruct ret;

    ret.a = 0;
    ret.b = input * 11111111111 + 111111111111;

    return ret;
}
```
Generated assembly (GCC 9.2, x86_64, -O3):
```x86
fn:
  movabs rdx, 11111111111     # multiplier constant (doesn&#39;t fit in imm32)
  xor eax, eax                # ret.a = 0
  imul rdi, rdx
  movabs rdx, 111111111111    # add constant; one more 1 than multiplier
     # missing   add rdx, rdi   # ret.b=... that we get with clang or older gcc
  ret
# returns RDX:RAX = constant 111111111111 : 0
# independent of input RDI, and not using the imul result it just computed
```

Interestingly, modifying the struct to have the uint64_t as the first member [produces correct code](https://gcc.godbolt.org/z/dZsF4v), as does [changing both members to be uint64_t](https://gcc.godbolt.org/z/w6zxZU)

x86-64 System V does return structs smaller than 16 bytes in RDX:RAX, when they&#39;re trivially copyable.  In this case the 2nd member is in RDX because the high half of RAX is the padding for alignment or `.b` when `.a` is a narrower type.  (`sizeof(retstruct)` is 16 either way; we&#39;re not using `__attribute__((packed))` so it respects alignof(uint64_t) = 8.)

**Does this code contain any undefined behaviour that would allow GCC to emit the &quot;incorrect&quot; assembly?**

If not, this should get reported on https://gcc.gnu.org/bugzilla/

Possible GCC bug when returning struct from a function

I am constantly getting this warning while building my android studio code using terminal command `gradle clean assembleRelease`:

`Unable to strip library &#39;lib.so&#39; due to missing strip tool for ABI &#39;ARMEABI&#39;. Packaging it as is.`

Please help me on how to get this warning resolved.

Note: I know this won&#39;t affect the behaviour of my app, but my APK is too bulky and this will surely help me reduce APK size. So I need this resolved.

Android Studio : Missing Strip Tool

I use the latest `Apple M1` chip processor. And I keep getting errors while application installation.

say.,
```
brew install openjdk@11
```

```
Error: Cannot install in Homebrew on ARM processor in Intel default prefix (/usr/local)!
Please create a new installation in /opt/homebrew using one of the
&quot;Alternative Installs&quot; from:
  https://docs.brew.sh/Installation
You can migrate your previously installed formula list with:
  brew bundle dump
```

Need help with exact steps to follow. 

Error: Cannot install in Homebrew on ARM processor in Intel default prefix (/usr/local)

I have successfully installed python 3.9.1 with Numpy and Matplotlib on a new Mac mini with Apple Silicon. However, I cannot install SciPy : I get compilation errors when using 

```
python3 -m pip install scipy
```

I also tried installing everything from brew, and `import scipy` works, but using it gives a seg fault. I have installed ARM versions of lapack and openblas, but this does not fix the problem.

Has anyone succeeded? (I am interested in running it natively, not through Rosetta).

Content Type	Original Author	Original Content on Stackoverflow
Question	Tim Smith	View Question on Stackoverflow
Solution 1 - Javascript	Jose	View Answer on Stackoverflow

Why do ARM chips have an instruction with Javascript in the name (FJCVTZS)?

Javascript Problem Overview

Javascript Solutions

Solution 1 - Javascript

Error response from daemon: No build stage in current context

Difference of setValue() & postValue() in MutableLiveData

Attributions